抽象类，接口_05

抽象类，接口

抽象类

概述：

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类。

抽象方法

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

修饰符 abstract 返回值类型 方法名 (参数列表);
例：
    public abstract void run()；

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

定义：

abstract class 类名字 {
}

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设 计。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象 类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有 意义。

接口

概述：接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做 是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象 类。

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

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。

如果是Java 7，那么接口中可以包含的内容有：

1. 常量
2. 抽象方法

如果是Java 8，还可以额外包含有：
3. 默认方法
4. 静态方法

如果是Java 9，还可以额外包含有：

5. 私有方法

接口中的抽象方法

必须全部实现，

代码如下： 定义接口：

public interface LiveAble {
    // 定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
    @Override
    public void sleep() {
        System.out.println("晚上睡");
    }
}

接口中的默认方法：

概述：

接口投入使用后，如果想为接口添加新的方法，那么接口的所用实现类都会报错（因为实现类必须实现，接口的所有抽象方法。）。这个时候就不能为接口添加抽象方法了，这时就可以添加默认方法。

定义接口:

public interface LiveAble { 
    public default void fly(){ 
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
    // 继承，什么都不用写，直接调用,也可以重写默认方法
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}
输出结果：
天上飞

接口中静态方法的使用

概述：静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，

定义接口：

public interface LiveAble {
    public static void run(){
    System.out.println("跑起来~~~");
    }
}

定义实现类：

public class Animal implements LiveAble {
    // 无法重写静态方法
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // Animal.run(); // 【错误】无法继承方法,也无法调用
        LiveAble.run(); //
    }
}
输出结果：
跑起来~~~

接口中私有方法：

私有方法：只有默认方法可以调用。
私有静态方法：默认方法和静态方法可以调用。

概述：

​ 使用私有方法，主要是因为接口中默认方法，私有方法，可能需要将一些重复代码 抽出为函数，但是这些函数不应该被实现类直接使用，为了防止接口之外的实现类使用这个方法，将他设置为私有的

定义接口：

public interface LiveAble {
    default void func(){
        func1();
        func2();
    }
    private void func1(){
        System.out.println("跑起来~~~");
    }
    private void func2(){
        System.out.println("跑起来~~~");
    }
}

接口的多实现

概述：

一个类是可以实现多个接口的，这叫做接 口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

注意：

一个类是可以实现多个接口，这样就可以出现：抽象方法有重名的情况，因为这两个重名的方法都是抽象方法，没有方法体。所以可以看做是一个函数，只需要重写一个

抽象方法重名： 看做是一个函数，只需要重写一个

默认方法:重名： 如果默认方法有重名的，必须重写一次。

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

优先级的问题： 当一个类，既继承一个父类，又实现若干个接口时，extends的优先级高于interface
父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

接口的多继承: 如果父接口中的默认方法有重名的，那么子接口需要重写一次。

定义多个接口：

interface A {
    public abstract void showA();
    public abstract void show();
}
interface B {
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    @Override
    public void showA() {
    	System.out.println("showA");
    }
    @Override
    public void showB() {
    	System.out.println("showB");
    }
    @Override
    public void show() {
    	System.out.println("show");
    }
}