[15]接口

当抽象类中的方法全是抽象时，可用接口interface来表示

接口中的成员：
1.定义变量，但是变量必须由固定的修饰符修饰，public static final所以接口中的变量也称常量
2.定义方法，public abstract（如果缺少编译器会自动加上）
接口中的成员全是public

接口的特点：
1.接口不可以创建对象
2.子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化
继承表示Sub...
接口表示...Imps

类与类之间的关系是继承（is a），类与接口之间的关系是实现（like a）。实现接口通过implements

那么从以上我们可以看出，用接口来完成的，抽象类也可以完成。那为什么还要用接口呢？

【接口中最重要的体现】

解决多继承的弊端：多继承时，当多个父类有相同功能时，子类调用会产生不确定性
多继承时父类中功能有主体，调用时不确定运行哪个主体内容
接口中的方法没有方法体，由子类来明确

 

class A{
    public void show(){}
}

class B extends A{
    public void show(){}
}

class C extends B{
    public static void main(String[] args){
        C c=new C();
        c.show();//此时产生了不确定因素。一般调用近的那个    
    }
}

而接口

interface A{
    public abstract void show();
}

interface B{
    public abstract void show();
}

class C implements A,B{
    public void show(){}
    public static void main(String[] args){
        C c=new C();
        c.show();//此时方法体内容子类来确定
    }
}

接口避免了单继承的局限性。

继承定义了事物的基本功能。（父类有的功能，子类继承后，就会有父类的功能）

接口定义了事物的扩展功能。

class Phone{
    public void call(){
        System.out.println("打电话");
    }
}

interface PlayGameImpl{
    public abstract void play();
}

interface 

class SmartPhone extends Phone implements PlayGameImpl{
    public void call(){
        super.call();
    }
    public void play(){
        System.out.println("玩游戏");
    }
}

接口支持多继承

interface A{
    public abstract void show1();
}

interface B{
    pubic abstract void show2();
}

/*
    接口也可继承多个接口
*/

interface C extends B,A{
    public abstract void show3();
}

class Inter implements C{
    public void show1(){}
    public void show2(){}
    public void show3(){}
    public static void main(String[] args){
        Inter i=new Inter();
        i.show1();
        i.show2();
        i.show3();
    }
}

抽象类中能否拥有抽象方法？是可以有的。

仅不让实例化。 

interface AImpl{
    public abstract void show1();
    public abstract void show2();
    public abstract void show3();
    public abstract void show4();
}

/*
    如果这里直接实现此接口，那么如果Inter类只需要一个show1()，就要也把所有的方法重写一遍，复用性差
    所以需要一个类先实现接口。
*/

/*
    这个类可以被实例化，但是这个类没有实例化的意义，虽说有方法体，但是方法体是空的。和抽象方法类
    似，所以为了不被实例化，用abstract来表示。private这个类虽然也可以，不被实例化，但是无法继
    承从而重写方法。                    
*/
abstract class SubA{
    public void show1(){}
    public void show2(){}
    public void show3(){}
    public void show4(){}
}

class Inter extends SubA /*implements Aimpl*/{
    
    public static void main(Srting[] args){
/*
        public void show1(){
            System.out.println("show1 run");
}
        public void show1(){}
        public void show1(){}
        public void show1(){}
    }
*/

//接下来我们只要继承这个没有抽象方法的类
    public void show1(){
        System.out.println("show1 run");
}

}

接口和抽象类的区别：

机器狗是狗的一种。是is a关系，狗抽象，但是机器狗可以具体。所以机器狗继承于抽象类狗

而发光，是机器狗特有的功能。狗并不具备。很多东西都可以发光，比如机器猫（不是动漫的那种，动漫的那种貌似也可以好像，emmmmm偏题了）。

比如机器猫和机器狗都会发光，但和发光并不是is a关系。当然你可以这么写，编译器会通过。但是还要继承充电功能？和设计思路上不符合。

发光和充电是机器狗的扩展功能。用接口实现

interface ShineImpl{
    public abstract void shine();
}

interface ChargeImpl{
    public abstract void charge();
}

abstract class Dog{
    public abstract void shout();
    public abstract void eat();
}

class EDog extends Dog implements ShineImpl{
    public void shout(){
        System.out.println("汪汪");
    }
    public void eat(){
        System.out.println("用嘴吃");
    }
    public void shine(){
        System.out.println("闪光");
    }
    public void charge(){
        System.out.println("充电");
    }
}

class Demo{
    EDog edog=new EDog();
    edog.shout();
    edog.eat();
    edog.shine();
}

再举个例子：

//需求：会多门语言
public abstract class Person{
    private String name;
    public Person(String name){
        this.name=name;
}
    public abstract void speak();
}
/*
public interface LanguageImpl{
    public abstract void speakCN();
    public abstract void speakEN();
    public abstract void speakJE();
}

public abstract class SubLanguage implements LanguageImpl{
    public void speakCN(){
        System.out.println("说中文");
    }
    public void speakEN(){
        System.out.println("说英文");
    }
    public void speakJE(){
        System.out.println("说日语");
    }
}
*/

interface EnglishImpl{
    public abstract void speakEN(){
        System.out.println("说英文");
    }
}

interface ChineImpl{
    public abstract void speakCN(){
        System.out.println("说中文");
    }

interface JapanaseImpl{
    public abstract void speakJE(){
        System.out.println("说日语");
    }
}


//中国人只会说中文吗？我们还可以学英语，日语，韩语等等。继承？办不到抽象类？可以
//但是你每次会说英文，就必须会所有其他的语言。每个人都是神童？所以用接口实现
//可以通过接口引变抽象类或是写三个接口
public class Chinese extends Person implements EnglishImpl,ChineImpl{
    public Chinese(String name){
        super(name);
    }
    public void speak(){
        System.out.println("说话");
    }
    public void speakEN(){
        System.out.println("说英文");
    }
    public void speakCN(){
        System.out.println("说中文");
    }
}

public Demo{
    public static void main(String[] args){
        Chinese c=new Chinese("lgb");
        c.speakCN();
        c.speakEN();
    }
}