java核心（十一）：抽象类、接口

1. 抽象类不能使用“final”关键字修饰，因为抽象类必须要由子类进行继承，然后通过子类向上转型进行实例化；
2. 抽象类里面会存在一些属性，所以抽象类一定也会存在构造方法。抽象类通过子类进行实例化时，同样满足：先实例化父类，再实例化子类的原则。
3. 外部抽象类不允许使用static修饰，而内部抽象类可以使用static修饰。使用static修饰的内部类，相当于一个外部抽象类，子类进行继承时使用“外部类.内部类”。

4. class Biology{
       /**
        * 内部抽象类：使用static修饰
        */
       abstract static class Animal{
           public abstract String doing();
       }
   }
   
   /**
    * 子类：继承抽象类Animal
    */
   class Dog extends Biology.Animal{
       @Override
       public String doing() {
           return "狗咬吕洞宾";
       }
   }
   
   public class TestAbstract{
       public static void main(String[] args) {
           Biology.Animal dog = new Dog();
           System.out.println(dog.doing());       //狗咬吕洞宾
       }
   }

5. 抽象类可以有static方法，直接通过抽象类名称”.”方法名称()，进行调用。

/**
 * 有时候，由于抽象类只需要一个特定的系统子类，此时可以通过内部类来实现（避免了不必要的外部子类）
 */
abstract class Animal{
    public abstract String doing();
    /**
     * 通过内部子类，实例化抽象类
     */
    public static Animal getInstance(){
        return new Dog();   //通过内部子类，实例化抽象类
    }
    /**
     * 子类：继承抽象类Animal
     * 私有内部类，在外部不可见
     */
    private static class Dog extends Animal{
        @Override
        public String doing() {
            return "狗咬吕洞宾";
        }
    }
}

public class TestAbstract{
    public static void main(String[] args) {
        Animal dog = Animal.getInstance();
        System.out.println(dog.doing());       //狗咬吕洞宾
    }
}

二、接口

1. 接口中，只能有抽象方法和全局常量。
2. 接口中，访问权限只能是public。如果类定义时，属性未显示用“public final static“修饰，则系统自动为属性添加以上修饰。如果方法为显示用“public”修饰，则系统自动添加“public”修饰。
3. 子类只能继承一个父类（普通类或抽象类），但是，接口可以使用extends关键字，继承多个接口。

4. interface IAaa{
       void fa();
   }
   interface IBbb{
       void fb();
   }
   interface ICcc extends IAaa,IBbb{
       void fc();
   }
   /**
    * 子类：
    */
   class Child implements ICcc {
       @Override
       public void fa() {
       }
   
       @Override
       public void fb() {
       }
   
       @Override
       public void fc() {
       }
   }

5. 接口中可以包含内部类、内部抽象类、内部接口。

6. interface Biology{
       String printType();
       /**
        * 内部接口：
        */
       interface Animal{
           String eat();
           String work();
       }
       /**
        * 内部抽象类
        */
       abstract class Plant{
           public abstract String grow();
       }
   
   }
   
   /**
    * 子类：实现外部接口
    *  只需要重写外部接口的抽象方法，和其中的内部类或内部接口无关
    */
   class Robot implements Biology{
       @Override
       public String printType() {
           return "自能机器人";
       }
   }
   
   /**
    * 子类：实现内部接口
    */
   class Dog implements Biology.Animal {
       @Override
       public String eat() {
           return "狗啃骨头";
       }
   
       @Override
       public String work() {
           return "狗咬吕洞宾";
       }
   }
   
   /**
    * 子类：实现内部抽象类
    */
   class Bamboo extends Biology.Plant{
       @Override
       public String grow() {
           return "芝麻开花节节高";
       }
   }
   
   public class Test {
       public static void main(String[] args) {
           Biology robot = new Robot();
           System.out.println(robot.printType());  //自能机器人
           
           Biology.Animal dog = new Dog();
           System.out.println(dog.eat());          //狗啃骨头
           System.out.println(dog.work());         //狗咬吕洞宾
   
           Biology.Plant bamboo = new Bamboo();
           System.out.println(bamboo.grow());      //芝麻开花节节高
       }
   }

三、接口在实际开发之中有三大核心作用

1. 定义不同层之间的操作标准
2. 表示一种操作的能力
3. 表示将服务器端的远程方法试图暴露给客服端

四、抽象类和接口的比较

五、其他说明

　　语法要求：定义类时，先写继承extends，再写接口实现implements，否则，编辑时就会报错。

class Dog extends AbstractFather implements IAnimal {
    …..
}

java核心（十一）：抽象类、接口

原文：https://www.cnblogs.com/newbie27/p/10500691.html