javaoop--接口(day09)

---

接口只是定义一些功能，没有具体的实现，所以是抽象的，满足抽象的一些特性。
比如说：
1.不能直接被实例化，只能采用多态的方式
2.子类要重写所有接口里的抽象方法（跟子类必须强制重写父类的抽象方法一个道理）
建议：接口的子类为实现类，并重写所有接口方法**

/*
    接口的特点：
        A:接口用关键字interface表示 
            interface 接口名 {}
接口没有class，只是功能的扩展
        B:类实现接口用implements表示
            class 类名 implements 接口名 {}
        C:接口不能实例化
            那么，接口如何实例化呢?
            按照多态的方式来实例化。
        D:接口的子类
            a:可以是抽象类。但是意义不大。
            b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

    由此可见：
        A:具体类多态(几乎没有)
        B:抽象类多态(常用)
        C:接口多态(最常用)
*/
//定义动物培训接口
interface AnimalTrain {
    public abstract void jump();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain {
}

//具体类实现接口
class Cat implements AnimalTrain {
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

class InterfaceDemo {
    public static void main(String[] args) {
        //AnimalTrain是抽象的; 无法实例化
        //AnimalTrain at = new AnimalTrain();
        //at.jump();

        AnimalTrain at = new Cat();
        at.jump();
    }
}

*接口中的成员变量*默认为常量，等同于用final关键字修饰的变量
可以通过接口名字访问变量，因为接口默认为static的
默认修饰符：public static final****
所有的类都默认继承自一个类：Object。因为object只提供了无参构造方法Object()，因此子类继承的父类默认都继承父类的无参构造方法
接口方法不能带有主体，因此所有接口方法都必须是抽象的
子类重写接口方法必须带public
接口方法默认为public abstract

/*
    接口成员特点
        **成员变量**；只能是常量，并且是静态的。
                默认修饰符：public static final
                建议：自己手动给出。
        **构造方法**：接口没有构造方法。
        **成员方法**：只能是抽象方法。
                默认修饰符：public abstract
                建议：自己手动给出。

    所有的类都默认继承自一个类：Object。
    类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
*/
interface Inter {
    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;

    //错误: 需要<标识符>
    //public Inter() {}

    //接口方法不能带有主体，因此所有接口方法都必须是抽象的
    //public void show() {}

    //abstract void show(); //默认public
    public void show(); //默认abstract
}

//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
}
*/

class InterImpl extends Object implements Inter {
    public InterImpl() {
        super();
    }
    //子类重写接口方法必须带public
    public void show() {}
}

//测试类
class InterfaceDemo2 {
    public static void main(String[] args) {
        //创建对象
        Inter i = new InterImpl();
        System.out.println(i.num);//10
        System.out.println(i.num2);//20
        //i.num = 100;
        //i.num2 = 200;
        //System.out.println(i.num); //无法为最终变量num分配值，接口中的变量默认为常量
        //System.out.println(i.num2);//无法为最终变量num2分配值
        System.out.println(Inter.num);//可以通过接口名字访问变量，因为接口默认为static的
        System.out.println(Inter.num2);
        System.out.println("--------------");
    }
}

接口总结：
类与接口是实现关系，类继承类只能单根继承，但是类实现接口可以多个接口，中间用逗号隔开。
类也可以既继承一个类，又实现一个接口
注意：如果继承多个接口，对应的接口实现对应的方法，不要搞错了。
接口与接口继承关系,可以单继承,也可以多继承。
interface Sister extends Father,Mother

/*
    类与类：
        继承关系,只能单继承,可以多层继承。
    类与接口：
        实现关系,可以单实现,也可以多实现。
        并且还可以在继承一个类的同时实现多个接口。
    接口与接口：
        继承关系,可以单继承,也可以多继承。
*/
interface Father {
    public abstract void show();
}

interface Mother {
    public abstract void show2();
}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
    public void show() {
        System.out.println("show son");
    }

    public void show2() {
        System.out.println("show2 son");
    }
}

class InterfaceDemo3 {
    public static void main(String[] args) {
        //创建对象
        Father f = new Son();
        f.show();
        //f.show2(); //报错

        Mother m = new Son();
        //m.show(); //报错
        m.show2();
    }
}