抽象&接口_day7

1、抽象类

使用abstract修饰的类（可以修饰类、方法）
可以理解成一张不完整的设计图，一般作为父类，让子类来继承（去细化）

1.1使用场景

当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，
于是父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。
这个父类就是抽象类。

抽象类的特征、注意事项

1. 类有的成员（成员变量、方法、构造器）抽象类都具备
2. 抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类
3. 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类（但这没什么意义）
4. 不能用abstract修饰变量、代码块、构造器
5. 抽象类得到了抽象方法，失去了创建对象的能力（有得必有失）。反证：假如他能创建对象，如果有对象.抽象方法，能执行？显然不合理，因为他方法体都没有

1.2使用抽象类举例

就拿小学生和中学生写作文来说，两种学生写的作文的开头和结尾都差不多（我们认为一样），主要区别在于作文的主体

关键字：学生、小学生、中学生、写主体不同、头尾同

package abstracttest;

public abstract class Student {
    public final void write(){//final修饰，防止子类重写，重写就没意义了
        System.out.println("作文第一段");
        writeMain();
        System.out.println("作文最后一段");
    }

    public abstract void writeMain();
}
class StudentMiddle extends Student{

    @Override
    public void writeMain() {
        System.out.println("...................");
        System.out.println("这是中学生的作文主体内容");
        System.out.println("...................");
    }
}
class StudentChild extends Student{

    @Override
    public void writeMain() {
        System.out.println("...................");
        System.out.println("这是小学生的作文主体内容");
        System.out.println("...................");
    }
}

package abstracttest;

public class StudentMain {
    public static void main(String[] args) {
        StudentChild studentChild = new StudentChild();
        StudentMiddle studentMiddle = new StudentMiddle();
        studentChild.write();
        studentMiddle.write();
    }
}

运行结果

作文第一段
...................
这是小学生的作文主体内容
...................
作文最后一段
作文第一段
...................
这是中学生的作文主体内容
...................
作文最后一段

1.3注意

1. final和abstract是互斥关系
2. final修饰类，类不能被继承；而abstract修饰类，类一定要被继承，否则没有意义

互斥是指不能 public abstract final……
像上面代码中，抽象类中可以出现final,只要它不和abstract在一起

1. 应用：模板方法模式
2. 场景：当系统中出现同一个功能在多出开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候

设计步骤：

1. 把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码，模板方法最好用final修饰，防止子类重写

public final void write(){//final修饰，防止子类重写，重写就没意义了
        System.out.println("作文第一段");
        writeMain();
        System.out.println("作文最后一段");
    }

2. 模板方法中不能决定的功能定义成抽象方法让具体子类实现

public abstract void writeMain();

2、接口

书写格式

public interface 接口名{
//常量
//抽象方法
}

接口体现的是一种规范，规范一定是公开的（成员用public修饰，不写也默认，抽象默认，常量默认）
就像

public interface InterfaceDemo {
	int num = 0;//常量public final int num = 0;
    void run();//只需要声明返回值类型和方法名，默认public abstract...
    void competition();
   	void rest();
}

2.1接口用法

接口是用来被类实现（implements）的，实现接口的类叫实现类。实现类可以理解成所谓的子类，可多实现，即实现多个接口
实现格式

修饰符 class 实现类 implements 接口1，接口2，接口3，……{
	
}

2.2注意事项

1. 类和类：单继承（只能有一个爸爸）
2. 类和接口：多实现（可以有多个干爹）
3. 接口和接口：多继承，一个接口可以同时继承多个接口。规范合并，整合多个接口为同一个接口，便于子类实现

2.3JDK8开始接口新增的方法

允许接口中直接定义带有方法体的方法==（为了增加对象的共同功能）
第一种：默认方法

1. 类似之前写的普通实例方法：必须用default修饰
2. 默认会public修饰。需要用接口的实现类的对象来调用

第二中：静态方法

1. 默认会public修饰，必须static修饰
2. 注意：接口的静态方法必须用本身的接口名来调用

第三中：私有方法

1. 就是私有的实例方法，必须使用private修饰，从JDK1.9才开始（我用的1.8），不便在下面举例
2. 只能在本类（即本接口）中被其他默认方法或者私有方法访问
   举例代码

package interfacelearning;

public interface InterfaceDemo {
    void run();
    void competition();
    default void rest(){//第一种
        System.out.println("我累了，要休息");
    }
    static void get(){//第二种
        System.out.println("苏炳添第一名！！！");
    }
}

package interfacelearning;

public class Runner implements InterfaceDemo {
    private String name;
    public Runner(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(name + "必须进行跑步训练！！！");
    }
    @Override
    public void competition() {
        System.out.println(name + "参加100米大赛！！！");
    }
}

package interfacelearning;

public class TestMain {
    public static void main(String[] args) {
        Runner runner1 = new Runner("苏炳添");
        runner1.run();//自己本身
        runner1.competition();
        runner1.rest();//实现类对象都可以调用
        InterfaceDemo.get();//接口名调用
    }
}

运行结果

苏炳添必须进行跑步训练！！！
苏炳添参加100米大赛！！！
我累了，要休息
苏炳添第一名！！！

注意事项总结

1. 接口不能创建对象（以下几种较偏，不必太在意）
2. 一个类实现多个接口，多个接口中有同名的静态方法不冲突（接口的静态方法只能接口自己来调，对象不能，所以不冲突）
3. 一个类继承了父类，同时由实现了接口，父类中和接口中有同名方法，默认用父类的（亲爸，干爹）“继承extends在前，实现implements在后”
4. 一个类实现多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写方法即可
5. 一个接口继承多个接口是没有问题的，如果多个接口中存在规范冲突（一个int run();另一个void run();）则不能多继承

待续~~~~