第四章：抽象类、接口、面向接口编程

一：抽象类

（1）什么是抽象类

1. 抽象类就是将多个具有共性实例向上抽取相同点，然后将其封装起来，用abstract修饰的类
2. 因为这个类是抽象的，所以我们无法直接实例化这个类
3. 这个类的抽象方法也是抽取出来的一个行为规范，具体是什么无法确定，所以也是抽象的

（2）抽象类的总结

1. 抽象类是由abstract修饰，在抽象类中可以有抽象方法，也可以有具体实现的方法
2. 抽象类中有构造方法，但是不能实例化
3. 一个抽象方法必须存在于抽象类中，但是抽象类中不一定有抽象方法
4. 如果一个类继承了抽象类，那么必须重写所有抽象类中的抽象方法，否则这个子类也是抽象的
5. 抽象类一般是对子类的行为约束，也就是说子类必须完成抽象类中未完成的功能
6. 抽象类的抽象方法不能用private修饰，其他方法可以使用任何权限修饰符修饰

/public class Animal {
//    public abstract eat();            //1.当一个类中有抽象方法时，这个类就必须是抽象的
//}
public abstract class Animal{
//    private abstract void  eat();    //2.抽象方法不能使用私有修饰符，因为这个抽象方法需要被子类所重写才有意义
    public abstract void eat();      //3.抽象类中可以没有抽象方法，抽象方法一定存在抽象类中
    public Animal(){
        System.out.println("动物在吃什么？？");
    };                //4.抽象方法可以有构造方法，但是这个抽象类不能实例化
    public void run(){};             //5.抽象类中可以有非抽象方法，
}
//public class Dot extends Animal {   //6.子类继承抽象类需要重写父类的抽象方法，否则这个子类也必须是抽象的
//}

//public class Dot extends Animal{   //7.子类继承抽象类如果抽象类中没有抽象方法，那么不需要重写或者子类标记成抽象类也可以
//
//}
public class Dot extends Animal{

    @Override
    public void eat() {
        System.out.println("狗在啃骨头");  //8.抽象类一般是对子类的约束，也就是子类必须完成抽象类中指定的所有的未完成定义的功能
    }
}

二：接口

（1）接口的定义

1. 接口是有interface修饰的
2. 接口比抽象类更抽象，所以里面的方法都是抽象的方法，即都是abstract修饰的
3. 接口是功能的集合，它只定于了行为规范，具体实现细节由实现这个接口的类来完善

（2）接口的总结

1. 接口是有interface关键字修饰的
2. 接口中所有属性都是public abstract static final修饰的常量值，必须赋初始值且大写，不可以被改变
3. 接口中的方法都是public abstract修饰的，都是对外公开的抽象方法
4. 接口中没有构造方法，所以我们也不能实例化接口对象
5. 接口可以继承多个接口，接口的继承使用extends关键字
6. 一个类可以实现多个接口，如果这个类没有全部实现接口中的所有抽象方法，那么这个类也是抽象的
7. 当一个类继承另一个类实现了多个接口，那么继承要写在接口的实现前面
8. jdk1,7后，接口中还可以定义default默认接口方法，接口实现类的对象去访问此方法
9. jdk1.7后，接口还可以定义static静态方法，此静态方法必须用接口名直接访问。
10. 接口主要作用是提供规范的

/**
 * 定义了一个usb接口，接口里面的所有成员都是public权限
 */
public interface USB {                                          //1.接口的修饰符是：interface
    int a =1;
    public static final int A = 2;                            //2.接口中的属性都是常量的，都是被public static final修饰的常量，可以省略不写，不可以被修改

//   public USB(){}                                             //3.接口没有构造方法，所以接口也不能实例化

    void read();
    public abstract void write();                             //4.接口中的方法都是public abstract抽象方法，不能有方法体,可以省略不写，这是定义了一个run的规则

    public default void run2(){                             //5.jdk1.7后出现的default接口默认方法，必须是public权限
        System.out.println("我是一个defalut新特性");
    }
    public static void run3(){                              //6.jdk1.7后出现的static静态方法，必须使用接口名来调用此方法，不冷使用接口实现类取访问，因为实现类没有重写此方法
        System.out.println("我是一个static新特性");
    }



}

public class Mouse implements USB {     //7.实现接口implements，必须重写接口中所有的抽象方法
    @Override
    public void read() {
        System.out.println("鼠标正在连接。。。。");
    }

    @Override
    public void write() {
        System.out.println("鼠标正在操作。。。。");
    }




}

**
 * 定义具体实现的类，功能类
 */
public class Computer {
    public void run(USB usb){
        usb.read();
        usb.write();
    }
}

package com.zelin.test;
import com.zelin.inter.*;

public class TestComputer {
    public static void main(String[] args){
        Computer compluter = new Computer();
        USB u1 = new Mouse();
        compluter.run(u1);
        System.out.println("===========================");
        USB u2 = new KeyBoard();
        compluter.run(u2);
        System.out.println("===========================");
        USB u3 = new Printer();
        compluter.run(u3);
        System.out.println("===========================");

        u3.run2();                                              //实例化对象调用接口default方法
        USB.run3();                                            //接口中的静态方法只能由类名.方法名调用

    }
}

三： 抽象类与接口的比较

1. 接口是由interface修饰的，而抽象类是abstract修饰的
2. 接口的所有方法都是public abstract ，而抽象类的方法可以是抽象方法，也可以是非抽象方法
3. 接口没有构造方法，而抽象类可以有构造方法，但是二者都不能实例化对象
4. 一个抽象类可以被其子类继承，一个子类只能继承一个抽象类，但是可以实现多个接口
5. 接口之间可以多继承，抽象类不能实现多继承
6. 在使用时，抽象类的使用场景是在其中定义一些公有的方法，还有一些无法实现的抽象的方法以此来约束子类的行为。而接口的使用场景是所有功能都需要子类自己去完成，接口只是定义了规范
7. jdk1.7之后可以在接口中定义default默认方法，此方法一定是public的，而抽象类中的方法则可以使private protected default public ，可以使任意修饰符。（抽象方法不能private），默认方法使用实现这个接口的实例去访问
8. jdk1.8之后接口还可以定义static静态方法，此方法必须使用接口名直接访问，不能使用接口实现类的对象访问