目录

什么是抽象类

抽象类再实现多态中的意义 

接口是什么

---

 各位铁汁们大家好呀😊！

😎今天让我们继续学习java，看看java中的抽象类和接口到底是什么🤔？ 

什么是抽象类

🍑我们之前学过什么是类，那么抽象类是不是也是类的一种呢？

听名字就感觉好抽象呀！说对了，他就是抽象的，不是具体的。在类中没有包含足够的信息来描绘一个具体的对象，这样的类称为抽象类。

🌰来看一个抽象类的例子

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

大家觉得这个抽象类是不是什么也没干，他唯一的方法draw()还是空的。

像这样的类是不是就没有包含足够的信息来描绘一个具体的对象，自然也就不能实例化对象了。不信你看：

🍑那既然一个类不能实例化，那这种抽象类存在的意义是什么呀🤔？别急，存在即合理，听我慢慢道来。

---

抽象类在实现多态中的意义 

🍑抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态。

来看一段代码

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重写抽象类中的draw方法
        System.out.println("画一个圆圈");
    }
}

public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象类虽然不能直接实例化
        // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
        Shape shape = new Cycle(); // 这称作：向上转型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

运行之后你就会发现神奇的一幕：

 

大家在看完了代码可能会有很多疑问，别急咱们一个一个的说，

📝什么是向上转型：一句话总结就是“父类引用指向子类对象”

向上转型后的变化

1. 🏀关于方法：父类引用可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），但子类特有的方法无法调用。
2. 🏀关于属性: 父类引用可以调用父类的属性，不可以调用子类的属性

向上转型的作用

1. 🐟减少一些重复性的代码
2. 🐟对象实例化的时候可以根据不同需求实例化不同的对象

🌰这样的话就我们上面的代码就可以理解了

​ 

📝看来，我们可以通过子类对抽象类的继承和重写，抽象类还真有点用呀！

🍑但这和多态有什么关系呢，抽象类用起来这么麻烦，我还不如直接用普通类，也能达到这样的效果，还不用再写一个子类呢😫？

🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

🌰那行，你再看看下面的代码，你就知道抽象类在实现多态时的好处了。 

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}

public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子类引用cycle
        Flower flower = new Flower(); // 子类引用flower
        Square square = new Square();
        
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象

            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }

    }
}

🍑调用同一个方法竟然打印出了不同的结果😮，这难道就是所谓的多态🤔 

 是不是有点懵😂，下面我们来解释一下😉

// 对上面的代码补充一下
// 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
// 但上面的代码就相当于 

 Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀！数组大小为3

// (将指向->子类对象)的子类引用赋值给父类对象，不就相当于该夫类引用指向->所对应的子类对象吗
//这是向上转型的另一种写法，应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
 shapes1[0] = cycle;  // 如果前面没实例化子类对象，就要写成shape1[0] = new Cycle
 shapes1[1] = flower;
 shapes1[2] = square;

对于多态来说，他有这三个要素

1. 继承（我们刚才的Cycle类继承Shape抽象类）
2. 重写（我们子类对draw方法的重写）
3. 父类指向子类对象（就是shape1[0] = cycle -->也可以称作向上转型) 

🍑回头再看一下我们的代码，是不是就刚好符合了多态的三要素😉。

📝当我们的父类引用指向不同的子类对象时，当我们调用同一个draw方法时却输出了不同的结果。（其实就是该方法再子类中被重写成了不同形式）这就叫做多态 。

嘻嘻😂，其实只要只要结合着例子来看，多态也没那么难理解呀😎

  

🍑那为啥一定要用抽象类呢😂？我一个普通类继承普通类来实现多态不可以吗🤔

🌰当然可以，但不太安全有风险；

     

但如果是抽象类的话，就不一样了😉 

  

🍑从这我们也可以看出，当用抽象类的时候，编译器自动就对我们是否重写进行了校验，而充分利用编译器的校验, 在实际开发中是非常有意义的 。所以说抽象类还是有用的，嘻嘻😉

📝好了，相信到这里你对抽象类也有了一个大概的认识😊，下面我们来简单做一下总结

1. 使用abstract修饰的类或方法，就抽象类或者抽象方法
2. 抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
3. 抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
4. 当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法🤔（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）

   ---

5. 但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
6. final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌😂）
7. 抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写😫）
8. 抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。

🌰哈哈，上面的8条总结是不是臭长臭长的，大家也不用专门去记（用的多了，自然就记住了😉）

🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

---

接口是什么

🍑抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）🤔。

📝接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成😎。

如何定义一个接口呢？下面我们来看一个栗子🌰

//接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口

public interface 接口名称{
// 定义变量
int a = 10;      // 接口当中的成员变量默认都是public static final

// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
}

可以看到接口和类其实还是有很多相似点：

📝接口中也包含抽象方法，所以也不能直接实例化接口🤔，那么我们怎么用接口呢？

🍑哈哈，很简单😉，我们再用一个普通类实现这个接口不就行了吗😂，不同的是抽象类是被子类来继承而实现的，而接口与类之间则是用关键字implements来实现。

📝就像普通类实现实现抽象类一样，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类🤔。

---

 通过接口实现多态

🍑铁汁们！刚才我们是用抽象类来实现多态，那么现在我们可以尝试用接口来实现多态，嘻嘻😎

接口可以看成是一种特殊的类，只能用 interface 关键字修饰
interface IShape {
    int a = 10;   接口当中的成员变量默认都是public static final
    int b = 23;
    void draw();  接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前）
  
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰
    }
    public static void test() {
        System.out.println("这是接口当中的一个静态的方法");
    }
}

// 一个普通的类要想实现接口，可以用implement, 
//因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法
class Cycle implements IShape {

    @Override
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
class Flower implements IShape {

    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接实例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 这里的IShape接口就相当与抽象类中父类，接口类型也是一种引用类型

        IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型

        for (IShape iShape : iShapes) { // 增强型的for—each循环，也可以写成普通的for循环形式
            iShape.draw();              // 通过重写实现了多态
        }
    }
}
引用变量cycle和square都赋值给了Shape类型的引用变量shape,
但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，
就看此时接口引用的是那个对象的，是shape的、还是cycle的

 😎看一下运行结果😎

 看完代码你可能有点晕😫，但没关系。一般接口咱也不这么用，直接使用抽象类不就好了😉（我只是演示一下用接口也能实现多态😂）

🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑

📝下面我们来总结一下Java中接口的几个主要特点

1. 🌰接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 d一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
2. 🌰接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。

🍑那么接口一般用在什么地方呢？

• 一般情况下，实现类和它的抽象类之前具有 "is-a" 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
• 由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。

🌰下面就让我们来看看接口的正确用法：帮助java实现“ 多继承 ”😎

由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。
class Animal {
    String name;        // 不能使用private,后面的子类也要用

    public Animal(String name) { // 父类的自定义的构造方法
        this.name = name;
    }
}
interface IFlying {   // 自定义多种接口
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swimming();
}
// 小鸭子，不仅会跑，还会游泳、飞行
一个类继承父类，并实现多个接口，间接的解决java中不能多继承的问题
class Duck extends Animal implements IRunning, ISwimming, IFlying {

    public Duck(String name) {  // 子类构造方法
        super(name);            // 必须在子类构造方法的第一行
        // 在给实现子类的构造方法前，先要用super()调用实现父类的构造方法，比较先有父后有子呀！
        // 因为父类自己定义了构造方法，编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法，需要我们自己实现
    }
    // 对接口中的抽象方法进行重写
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在用两条腿跑");
    }

    @Override
    public void swimming() {
        System.out.println(this.name + "正在漂在水上");
    }

}

public class 接口的使用 {  // 不用学我用中文名作为类名，我只是为演示方便
    public static void main(String[] args) {
        Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
        duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
        duck.run();
        duck.swimming();
    }
}
有人可能会说干嘛用接口，我直接在父类Animal中实现fly、run、swimming这些属性，
然后不同的动物子类再继承父类这些方法不行吗？

但问题是，鸭子会fly、swimming，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了
而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了，

只要一个子类有这种行为，他就可以实现相对应的接口，接口是更加灵活的

 📝上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

 📝继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ，能实现接口的类和该接口并不一定有is_a的关系，只要该类有这个接口的特性就行

猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

 🍑这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型，只要这个类有有这个特性就好。

举个栗子🌰

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    // 对run方法进行重写
    @Override
    public void run() {
        System.out.println("机器人" + this.name + "正在跑");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Robot robot1 = new Robot("图图");
        robot1.run();
    }
}
// 执行结果
机器人图图正在跑

😎只要能跑就行，管他是机器人还是动物呢😂，接口是不是很灵活呀！

同时在实际的开发过程中，一般来说，一个类是一个Java文件，一个接口也是一个Java文件。大家也要在平时就养成这个好习惯呀！

哈哈，不知道现在你对抽象类和接口的认识是不是又上升了一个高度呢？嘻嘻，我们下篇博客再见了，下篇让我们瞅瞅Java中常用的接口有哪些😉

 每天进步一点点，铁汁们，一起加油😎😎😎

抽象类

​ 概述

​ 父类当中的方法，被他的子类们重写，子类的各自实现又不一样。那么父类的方法声明和方法体，只有声明还有意义，而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。Java语言规定，如果一个类包含了抽象的方法。那么该类就是一个抽象类

定义：

​ 抽象方法：没有方法体的方法

​ 抽象类：包含抽象方法的类

abstract关键字的使用格式

​ 抽象方法

​ 使用abstract关键字修饰成员方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

​ 定义格式：

修饰符   abstract 返回值类型  方法名(参数列表);

示例代码：

public abstract void run();
// 吃饭的抽象方法
public abstract void eat();
// 跳跃的抽象方法
public abstract void jump(); 

抽象类

​ 如果一个类包含了抽象方法，那么该类就是一个抽象类。

定义格式：

修饰符 abstract class ClassName {}

示例代码：

public abstract class Animal {
    // 奔跑的抽象方法
    public abstract void run();
}

抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为一个抽象类。

注意事项

关于抽象类的使用，需要注意的事项:

1. 抽象类不能创建对象，如果创建对象，编译无法通过。只能创建其非抽象子类的对象。
2. 抽象类中,可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4. 抽象类的子类，必须重写父类中的所有的抽象方法，否则编译无法通过，除非该子类也是抽象类。

接口

概述

​ 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是【封装了方法】，包含了抽象方法（JDK1.7及以前），默认方法和静态的方法(JDK1.8)，私有方法(JDK1.9)

​ 接口的定义，它与类的定义很相似，但是使用interface关键字，他也会被编译生成class文件，但一定要明确他并不是类，而是另外一种引用数据类型。

引用数据类型：类、数组、接口。

接口的使用，不能直接创建对象，但是可以被实现(implements关键字，类似于被继承)，一个实现接口的类（可以看做是接口的子类），需要重写接口中的所有的抽象方法，创建该类对象，就可以调用方法了。

接口的定义格式:

public interface 接口名称{
    // 抽象方法为主
    // 默认方法
    // 常量
    // 静态方法
    // 私有方法(JDK1.9)
}

含有抽象方法

抽象方法:使用abstract关键字修饰，没有方法体内容，该方法主要是供子类使用的

public interface InterfaceName{
    public abstract
}

含有默认方法和静态方法

默认方法:使用default关键字修饰的方法，不可省略，供子类调用或者子类重写。

静态方法:使用static关键字修饰的方法，供接口直接使用。

含有私有方法和私有静态的方法

私有方法:使用private关键字,供接口中的默认方法或者静态方法调用。

代码如下:

public interface InterfaceName{
    private void method(){
        // 方法体内容。
    }
}

基本的实现

实现的概述

类与接口的关系，为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为

接口的子类，(实现的动作类似于继承，格式相仿，只是关键字不同，实现使用implements关键字)

非抽象类实现接口:

1.必须重写接口当中的所有的抽象方法

2.继承了接口的当中的默认方法，既可以直接调用，也可以重写

实现格式:

public class 实现类 implements 接口名称{
    // 重写接口当中的所有的抽象方法
    // 重写接口当中的默认方法
}

抽象方法的使用:

必须全部实现:

代码如下: 定义一个接口:

public interface Biological{// 生物
    // 定义一个吃东西的功能
    public abstract void eat();
    // 定义一个休息的功能
    public abstract void sleep();
}
// 定义一个实现类
public class Animal implements Biological{
    @Override
    public void eat(){
        System.out.println("吃东西");
    }
    @Override
    public void sleep(){
        System.out.println("睡觉");
    }
}

// 定义测试类
public class InterfaceDemo01{
    public static void main(String[] args){
        // 创建子类对象
        Animal ani = new Animal();
        // 调用重写之后的方法
        ani.eat();
        ani.sleep();
    }
}
// 输出结果:
// 吃东西
// 睡觉

默认方法的使用

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用

1.继承默认方法，代码如下

public interface Biological{
  public default void fly(){
    System.out.println("天上飞");
}
}
// 定义实现类
public class Animal implements Biological{
    // 继承 什么也不写，直接调用
}
// 定义测试类
public class InterfaceDemo02{
    
  public static void main(String[] args){
      // 创建子类对象
      Animal ani = new Animal();
      // 调用默认方法
      ani.fly();
  }
}
// 输出结果:天上飞

2.重写默认方法，代码如下:

public interface Biological{
  public default void fly(){
    System.out.println("天上飞");
}
}
// 定义实现类
public class Animal implements Biological{
 //重写
 @Override
    public void fly(){
        System.out.println("自由自在的飞");
    }
}

public class InterfaceDemo03{
    
  public static void main(String[] args){
      // 创建子类对象
      Animal ani = new Animal();
      // 调用默认方法
      ani.fly();
  }
}
// 输出结果:自由自在的飞

静态方法的使用

静态的一般都是和类.class文件相关，只能使用【接口名】来调用，不可以通过实现类的类名或者是实现类的对象来调用。代码如下:

public interface Biological{
  public static void run(){
    System.out.println("跑起来。。");
}
}
// 定义实现类
public class Animal implements Biological{
 // 无法重写静态方法
}

// 定义测试类
public class InterfaceDemo04{
  public static void main(String[] args){
      // 调用静态方法
     Biological.fly();
  }
}
// 输出结果:跑起来

私有方法的使用

私有方法: 只有默认方法可以调用

私有静态方法: 默认方法和静态方法都可以调用

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，

供默认方法去调用。从设计的角度考虑，私有的方法是对默认的方法和静态的方法的一种辅助。

// 定义一个接口
public interface Biological{
    private void run1(){
        System.out.println("跑起来。。");
    }
    private default void funMethod01(){
        //System.out.println("跑起来。。");
        run1();
    }
    private default void funMethod02(){
        //System.out.println("跑起来。。");
        run1();
    }
}

接口的多实现

在继承体系中，一个类只能直接继承一个父类，而对于接口来说，一个类可以实现多个接口，这叫做接

口的【多实现】。并且，一个类能直接继承一个父类的同时还可以实现多个接口。

实现格式:

public class ClassName extends 父类 implements 接口名1,接口名2,...{
    //重写接口中的所有的抽象方法
    //重写接口中的默认方法(可选)
    //抽象方法重名
}

抽象方法

接口中，有多个抽象方法，实现类必须重写所有的抽象方法，如果抽象方法名有重名的，只需要重写一

次即可，代码如下：

// 定义多个接口
public interface Animal{
    public abstract void eat();
    public abstract void run();
}
public interface Human{
    public abstract void eat();
    public abstract void run();
}
// 继承实现类
public class People implements Animal,Human{
    @Override
    public void eat(){
        System.out.println("吃东西!");
    }
    @Override
    public void run(){
        System.out.println("健身。。");
    }
}

默认方法

接口中,有多个默认方法时，实现类都可继承使用，如果默认方法有重名的，【必须重写一次】代码如下:

public interface A{
    public default void methodA(){}
    public default void method(){}
}
public interface B{
    public default void methodB(){}
    public default void method(){}
}
// 定义实现类
public class C implements A,B{
    @Override
    public void method(){
        System.out.println("method方法被重写。。。");
    }
}

静态方法

接口中，如果存在同名的静态方法并不会冲突，原因是只能通过各自的接口名访问静态方法。

优先级的问题

当一个类，既继承了一个父类，又同时实现类多个接口，父类中的成员方法与接口当中的默认方法

重名，子类就近选择父类的成员方法。

代码如下:

public interface A{
    public default void methodA(){
        System.out.println("AAAAAAAA");
    }
}
// 定义父类
public class D{
    public void methodA(){
        System.out.println("DDDDDDDD");
    }
}
// 定义子类
public class E extends D implements A{
    // 未重写methodA()
}
// 定义测试类
public class TestInterfaceDemo06{
    public static void main(String[] args){
        // 创建子类对象E
        E e = new E();
        e.methodA();
    }
}
//输出结果:DDDDDDDD

接口的多继承【了解】

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父接口的方法，如果父接口中的默认方法有重名方法，那么子接口需要重写一次。代码如下:

public interface A{
public default void method(){
    System.out.println("AAAAAAAAAA");
}
}
public interface B{
    public default void method(){
         System.out.println("BBBBBBBBBB");
    }
}
// 定义子接口
public interface C extends A,B{
    @Override
    public default void method(){
        System.out.println("CCCCCCCCCC");
    }
}

备注:子接口重写默认方法，default保留。

其他成员特点:

接口中，无法定义成员变量，但是可以定义常量，因为值不可变，默认使用public static final 修饰的

接口中，没有构造方法，不能创建对象

接口当中，没有静态代码块

接口的好处:

设定了规则

降低耦合性【高内聚，低耦合】

扩展原有类的功能

接口与抽象类的区别:

相同点:

• 都包含抽象方法，其子类都必须重写这些抽象方法
• 都不能直接实例化对象
• 都位于继承的顶端,用于被其他类实现或者继承

区别 :

• 抽象类里面可以包含普通成员方法，接口不能包含普通成员方法
• 一个类只能直接继承一个父类(可以是抽象类)，一个类也可以实现多个接口
• 类与类之间只能时单继承关系，接口与接口之间可以多继承
• 抽象类可以定义普通的成员变量和常量，接口只能定义常量 public static final 修饰的

在 Java 中，针对 抽象有两种实现方式 一种是接口，一种是抽象类。很多读者对这两种实现方式比较困惑，到底是使用接口，还是使用抽象类呢？对于它们的选择甚至反映出对问题领域本质的理解，对设计意图的理解是否正确、合理？

在面向对象的设计思想中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有描绘一个具体的对象，那么这样的类就是抽象类，抽象类是对那些看上去不同，但是本质上相同的具体概念的抽象，正是因为抽象的概念在问题领域没有对应的具体概念，所以抽象类是不能够实例化的。
基本语法区别
在 Java 中，接口和抽象类的定义语法是不一样的。这里以动物类为例来说明，其中定义接口的示意代码如下：

public interface Animal
{
    //所有动物都会吃
    public void eat();
    //所有动物都会飞
    public void fly();
}

定义抽象类的示意代码如下：
public abstract class Animal
{
    //所有动物都会吃
    public abstract void eat();
    //所有动物都会飞
    public void fly(){};
}

可以看到，在接口内只能是功能的定义，而抽象类中则可以包括功能的定义和功能的实现。在接口中，所有的属性肯定是 public、static 和 final，所有的方法都是 abstract，所以可以默认不写上述标识符；在抽象类中，既可以包含抽象的定义，也可以包含具体的实现方法。

在具体的实现类上，接口和抽象类的实 现类定义方式也是不一样的，其中接口实现类的示意代码如下：

public class concreteAnimal implements Animal
{
    //所有动物都会吃
    public void eat(){}
    //所有动物都会飞
    public void fly(){}
}

抽象类的实现类示意代码如下：

public class concreteAnimal extends Animal
{
    //所有动物都会吃
    public void eat(){}
    //所有动物都会飞
    public void fly(){}
}

可以看到，在接口的实现类中使用 implements 关键字；而在抽象类的实现类中，则使用 extends 关键字。一个接口的实现类可以实现多个接口，而一个抽象类的实现类则只能实现一个抽象类。
设计思想区别
从前面抽象类的具体实现类的实现方式可以看出，其实在 Java 中，抽象类和具体实现类之间是一种继承关系，也就是说如果釆用抽象类的方式，则父类和子类在概念上应该是相同的。接口却不一样，如果采用接口的方式，则父类和子类在概念上不要求相同。接口只是抽取相互之间没有关系的类的共同特征，而不用关注类之间的关系，它可以使没有层次关系的类具有相同的行为。因此，可以这样说：抽象类是对一组具有相同属性和方法的逻辑上有关系的事物的一种抽象，而接口则是对一组具有相同属性和方法的逻辑上不相关的事物的一种抽象。

仍然以前面动物类的设计为例来说明接口和抽象类关于设计思想的区别，该动物类默认所有的动物都具有吃的功能，其中定义接口的示意代码如下：

public interface Animal
{
    //所有动物都会吃
    public void eat();
}

定义抽象类的示意代码如下：

public abstract class Animal
{
    //所有动物都会吃
    public abstract void eat();
}

不管是实现接口，还是继承抽象类的具体动物，都具有吃的功能，具体的动物类的示意代码如下。

接口实现类的示意代码如下：

public class concreteAnimal implements Animal
{
    //所有动物都会吃
    public void eat(){}
}

抽象类的实现类示意代码如下：

public class concreteAnimal extends Animal
{
    //所有动物都会吃
    public void eat(){}
}

当然，具体的动物类不光具有吃的功能，比如有些动物还会飞，而有些动物却会游泳，那么该如何设计这个抽象的动物类呢？可以别在接口和抽象类中增加飞的功能，其中定义接口的示意代码如下：

public interface Animal
{
    //所有动物都会吃
    public void eat();
    //所有动物都会飞
    public void fly();
}

定义抽象类的示意代码如下：

public abstract class Animal
{
    //所有动物都会吃
    public abstract void eat();

    //所有动物都会飞
    public void fly(){};
}

这样一来，不管是接口还是抽象类的实现类，都具有飞的功能，这显然不能满足要求，因为只有一部分动物会飞，而会飞的却不一定是动物，比如飞机也会飞。那该如何设计呢？有很多种方案，比如再设计一个动物的接口类，该接口具有飞的功能，示意代码如下：

public interface AnimaiFly
{
    //所有动物都会飞
    public void fly();
}

那些具体的动物类，如果有飞的功能的话，除了实现吃的接口外，再实现飞的接口，示意代码如下：

public class concreteAnimal implements Animal,AnimaiFly
{
    //所有动物都会吃
    public void eat(){}
    //动物会飞
    public void fly();
}

那些不需要飞的功能的具体动物类只实现具体吃的功能的接口即可。另外一种解决方案是再设计一个动物的抽象类，该抽象类具有飞的功能，示意代码如下：

public abstract class AnimaiFly
{
    //动物会飞
    public void fly();
}

但此时没有办法实现那些既有吃的功能，又有飞的功能的具体动物类。因为在 Java 中具体的实现类只能实现一个抽象类。一个折中的解决办法是，让这个具有飞的功能的抽象类，继承具有吃的功能的抽象类，示意代码如下：

public abstract class AnimaiFly extends Animal
{
    //动物会飞
    public void fly();
}

此时，对那些只需要吃的功能的具体动物类来说，继承 Animal 抽象类即可。对那些既有吃的功能又有飞的功能的具体动物类来说，则需要继承 AnimalFly 抽象类。

但此时对客户端有一个问题，那就是不能针对所有的动物类都使用 Animal 抽象类来进行编程，因为 Animal 抽象类不具有飞的功能，这不符合面向对象的设计原则，因此这种解决方案其实是行不通的。

还有另外一种解决方案，即具有吃的功能的抽象动物类用抽象类来实现，而具有飞的功能的类用接口实现；或者具有吃的功能的抽象动物类用接口来实现，而具有飞的功能的类用抽象类实现。

具有吃的功能的抽象动物类用抽象类来实现，示意代码如下：

public abstract class Animal
{
    //所有动物都会吃
    public abstract void eat();
}

具有飞的功能的类用接口实现，示意代码如下：

public interface AnimaiFly
{
    //动物会飞
    public void fly();
}

既具有吃的功能又具有飞的功能的具体的动物类，则继承 Animal 动物抽象类，实现 AnimalFly 接口，示意代码如下：

public class concreteAnimal extends Animal implements AnimaiFly
{
    //所有动物都会吃
    public void eat(){}
    //动物会飞
    public void fly();
}

或者具有吃的功能的抽象动物类用接口来实现，示意代码如下：

public interface Animal
{
    //所有动物都会吃
    public abstract void eat();
}

具有飞的功能的类用抽象类实现，示意代码如下：

public abstract class AnimaiFly
{
    //动物会飞
    public void fly(){};
}

既具有吃的功能又具有飞的功能的具体的动物类，则实现 Animal 动物类接口，继承 AnimaiFly 抽象类，示意代码如下：

public class concreteAnimal extends AnimaiFly implements Animal
{
    //所有动物都会吃
    public void eat(){}
    //动物会飞
    public void fly();
}

这些解决方案有什么不同呢？再回过头来看接口和抽象类的区别：抽象类是对一组具有相同属性和方法的逻辑上有关系的事物的一种抽象，而接口则是对一组具有相同属性和方法的逻辑上不相关的事物的一种抽象，因此抽象类表示的是“is a”关系，接口表示的是“like a”关系。

假设现在要研究的系统只是动物系统，如果设计人员认为对既具有吃的功能又具有飞的功能的具体的动物类来说，它和只具有吃的功能的动物一样，都是动物，是一组逻辑上有关系的事物，因此这里应该使用抽象类来抽象具有吃的功能的动物类，即继承 Animal 动物抽象类，实现 AnimalFly 接口。

如果设计人员认为对既具有吃的功能，又具有飞的功能的具体的动物类来说，它和只具有飞的功能的动物一样，都是动物，是一组逻辑上有关系的事物，因此这里应该使用抽象类来抽象具有飞的功能的动物类，即实现 Animal 动物类接口，继承 AnimaiFly 抽象类。

假设现在要研究的系统不只是动物系统，如果设计人员认为不管是吃的功能，还是飞的功能和动物类没有什么关系，因为飞机也会飞，人也会吃，则这里应该实现两个接口来分别抽象吃的功能和飞的功能，即除实现吃的 Animal 接口外，再实现飞的 AnimalFly 接口。

从上面的分析可以看出，对于接口和抽象类的选择，反映出设计人员看待问题的不同角度，即抽象类用于一组相关的事物，表示的是“isa”的关系，而接口用于一组不相关的事物，表示的是“like a”的关系。