011Java基础之抽象类、接口

1、抽象类

当父类的某些方法，需要声明，但又不确定怎么实现时，可以将其声明为抽象方法，那么这个类便是一个抽象类，也需要用abstract来修（即，有抽象方法的类一定是抽象类）

/**
 * @author Francis
 * @create 2021-07-03 9:09
 */
public class Abstract01 {
    
        public static void main(String[] args) {
        }
    }
abstract class Animal {
        private String name;
        public Animal(String name) {
            this.name = name;
        }
        //思考：这里 eat 这里你实现了，其实没有什么意义
//即： 父类方法不确定性的问题
//===> 考虑将该方法设计为抽象(abstract)方法
//===> 所谓抽象方法就是没有实现的方法
//===> 所谓没有实现就是指，没有方法体
//===> 当一个类中存在抽象方法时，需要将该类声明为 abstract 类
//===> 一般来说，抽象类会被继承，有其子类来实现抽象方法. // public void eat() {
// System.out.println("这是一个动物，但是不知道吃什么..");
// }
        
        public abstract void eat() ;
    }

注意事项和细节
（1）抽象类不能被实例化
（2）抽象类不一定要有抽象方法
（3）一个类一旦包含了abstract的方法，这个类就必须声明为abstract类
（4）abstract只能修饰类和方法，不能修饰属性和其他
（5）抽象类的价值更多的在于设计，是设计中设计好后，让子类继承并实现抽象类
（6）抽象类可以有任意成员，（抽象类的本质还是类，如非抽象方法，构造器，静态属性等）
（7）抽象方法不能有方法体，即在声明的时候不能实现
（8）如果一个类继承了抽象类，则必须实现被实现类的抽象方法，除非它自己也声明为abstract类
（9）抽象方法不能使用static（目前原因不详）、private（子类不能继承父类的私有方法）、final来修饰（共存就是又要被继承，又不能被继承），因为这些关键字与abstract的特性是矛盾的
抽象类的实践：模板设计模式

2、接口

接口就是给出一些没有实现的方法，封装到一起，规定要实现的规范，到某个类要使用的时候，再根据具体情况把这些方法逐一实现
基本语法

interface 接口名{
//属性
//方法（可以省略abstract关键字）
}

class 类名 implements 接口{
//自己的属性
//自己的方法
必须实现接口的抽象方法
}

小结
在JDK7.0以前，接口里所有方法都没有方法体，即都是抽象方法，在JDK8.0以后，接口可以有静态方法（static关键字修饰）、默认方法（default关键字修饰），也就是说接口中可以有方法的具体实现。

注意事项和细节
（1）接口不能被实例化（这里也佐证了可以有方法实现，但其中一种要求是方法是static的）
（2）接口中的所有方法都是public的（不写也是public的），接口中的抽象方法可以不用abstract修饰，当然加上也不会报错。
（3）一个普通类实现接口，就必须将该接口中的所有抽象方法实现
（4）抽象类实现接口，可以不实现接口的方法
（5）一个类可以实现多个接口（java中只能单继承）
（6）接口中的属性，只能是final的，而且是public static final修饰符（同样，没有任何修饰符，默认就是public static final），比如：int i=1;实际上是public static final int i = 1;
（7）接口中属性的访问形式：接口名.属性名
（8）一个接口不可以继承其他的类，但可以继承多个接口
（9）接口的修饰符只能是public和默认，这一点和类的修饰符是一样的
（10）类实现接口，就会继承接口里的所有属性及方法，并且使用方式和继承于类一样

/**
 * @author Francis
 * @create 2021-07-03 16:10
 */
public class InterfaceDetail01 {

        public static void main(String[] args) {
//接口中的属性,是 public static final
            System.out.println(IB.n1);//说明 n1 就是 static
//IB.n1 = 30; 说明 n1 是 final
        }
    }
    interface IB {
        //接口中的属性,只能是 final 的，而且是 public static final 修饰符
        int n1 = 10; //等价 public static final int n1 = 10;
        void hi();
    }
    interface IC {
        void say();
    }
    interface IA{
    public void hello();
    }
    //接口不能继承其它的类,但是可以继承多个别的接口,而且方法不用实现
    interface ID extends IB,IA {
    }
    //接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
    interface IE{}
    //一个类同时可以实现多个接口
    class Pig implements IB,IC {
        @Override
        public void hi() {
        }
        @Override
        public void say() {
        }
    }

实现接口VS继承类
继承与接口解决的问题不同
（1）继承的主要价值在于：解决代码的复用性和可维护性
（2）接口的价值主要在于：设计，设计好各种规范（方法），让其他类去实现这些方法，更加灵活
接口比继承更加灵活
继承时满足is-a的关系，而接口只需满足like-a 的关系
接口在一定程度上实现代码解耦

1、接口的多态特性

（1）多态参数
（2）动态数组
（3）多态传递
有一个例子来说明继承与接口同时存在属性的问题

/**
 * @author Francis
 * @create 2021-07-03 17:44
 */
public class InterfaceExercise01 {
        public static void main(String[] args) {
            new C().pX();
        }
    }
    interface A { //
        int x = 0;
    } //想到 等价 public static final int x = 0;
    class B {
        int x = 1;
    } //普通属性
    class C extends B implements A {
        public void pX() {
//System.out.println(x); //错误，原因不明确 x

//可以明确的指定 x
//访问接口的 x 就使用 A.x
//访问父类的 x 就使用 super.x
            System.out.println(A.x + " " + super.x);
        }
    }