接口的定义与使用

接口的定义与使用

​ 抽象类与普通类相比最大的特点是约定了子类的实现要求，即抽象类的产生原因是：普通类无法限制子类覆写哪些方法。但抽象类的局限性在于，很多事物不满足is-a原则，且抽象类只能实现单继承，若想多继承必须使用多层继承。而接口就可以实现多继承。接口是更纯粹的抽象类–融合。

接口优先原则：9在一个操作既可以使用抽象类和接口的时候，优先考虑使用接口。

1.接口的基本概念

1.1 接口定义：

​ 接口是抽象方法和全局常量的集合（JDK8以前），接口是更加纯粹的抽象方法。在java中接口使用interface关键字定义；

定义一个简单接口(为了区分接口，在定义时在接口名前加 I )；

interface IMessage{
    //全局常量  在声明时赋值
    public static final String MSG="I am a bitter";
    public abstract void print();
}

1.2 子类实现接口：

接口无法直接实例化，通过子类向上转型完成

子类实现接口使用implements关键字，子类可以同时实现多个接口（接口多继承）,但同时要覆写所有方法。同时子类实例化对象可以赋值给其中任意一个接口

子类必须覆写所有抽象方法。子类命名一般使用impl结尾（表示这是一个实现了接口的子类），两个接口以上选择主要接口 。

**父接口的相互转换：**多个接口若有共同子类，可以通过子类进行相互转换（new在哪，）

interface  IMessage{//定义一个接口
    public static final String MSG ="hello java";//全局常量
    public abstract void print();//抽象方法
}
interface  INews{//接口
    public abstract String getNews();//抽象方法
}
class MessageImpl implements IMessage,INews{//子类实现多个接口
    public void print(){//子类覆写接口中的抽象方法
        System.out.println(IMessage.MSG);
    }
    public String getNews(){//子类覆写接口中的抽象方法
        return IMessage.MSG;
    }
}
public class Test1{
    public static void main(String[] args) {
        IMessage message =  new MessageImpl();//向上转型
        //只能使用接口中的方法
        message.print();//调用被覆写后的方法
        INews news = (INews) message;//父接口之间的相互转化
        System.out.println(news.getNews());
    }
}

1.3 接口使用原则

1）接口中只允许 public权限（无论属性方法，其权限都是public）

​ 在接口中 public static final abstract 均可以省略不屑，抽象类中一个也不能省略

interface IMessage{//定义一个接口
    static final String MSG = "hello  java";//全局常量
    abstract void print();//不写权限默认为public
}
class MessageImpl implements IMessage{
    void print(){//没写权限为default
       System.out.println("接口的抽象方法！");
    }    
} 
public class Test29{
    public static void main(String[] args){
        IMessage m = new MessageImpl();
        m.print();
    }
}

99%的接口只提供抽象方法，很少在接口中提供全局常量；

阿里编码规约：接口中的方法和属性不加任何修饰符，public 也不加，保持代码的简洁性

interface IMassage {
    String MSG = "hello java";
    void print;
}

2） 当子类既需要实现接口又需要继承抽象类时，先使用extends 继承一个抽象类，而后使用 implements 实现多个接口（因为继承是单继承，实现是多实现）

当父类与父接口也有共同子类时，父类与父接口也可以通过子类相互转换

interface IMessage{//定义一个接口
    static final String MSG = "hello  java";//全局常量
    abstract void print();
}
abstract class News{
    public abstract void getMsg();
}
class MessageImpl extends News implements IMessage{//先继承抽象类再实现接口
    public void print(){
       System.out.println("接口的抽象方法！");
    }
    public void getMsg(){
        System.out.println("抽象类的抽象方法！");
    }
    
} 
public class Test29{
    public static void main(String[] args){
        IMessage m = new MessageImpl();
        m.print();
        //父接口与父类的相互转换
        News news = (News) m;
        news.getMsg();
        
    }
}

3）抽象类可以使用 implements实现若干个接口，但是接口无法继承抽象类

interface IMessage{
    void print();
}
abstract class News implements IMessage{//抽象类实现接口
    //News 为抽象类，可以覆写 IMessage 中的抽象方法
    //抽象类中的方法前面abstract 不能省略，否则就是普通方法
    public abstract void getNews();//抽象类中的抽象方法
}
class MessageImpl extends News{//子类实现接口
    //覆写接口中所有的抽象方法
    public void print(){
        System.out.println("子类覆写接口中的抽象方法！");
    }
    public void getNews(){
        System.out.println("子类覆写抽象类中的抽象方法！");
    }

}
public class Test32{
    public static void main(String[] args){
        MessageImpl messageImpl = new MessageImpl();
        messageImpl.print();
        messageImpl.getNews();
    }
}

//接口不能继承重选ing类
interface IMessage{
    void print();
}
abstract class News implements IMessage{//抽象类实现接口
    //News 为抽象类，可以覆写 IMessage 中的抽象方法
    //抽象类中的方法前面abstract 不能省略，否则就是普通方法
    public abstract void getNews();//抽象类中的抽象方法
}
class MessageImpl extends News{//子类实现接口
    //覆写接口中所有的抽象方法
    public void print(){
        System.out.println("子类覆写接口中的抽象方法！");
    }
    public void getNews(){
        System.out.println("子类覆写抽象类中的抽象方法！");
    }
}
interface QQmessage extends News{//此处报错 
    void print2();
}

此处的implements IMessage 只是为了强调 MessageImpl 是 IMessge 的实现类

class MessageImpl extends News implements IMessage{//
      public void print(){
        System.out.println("子类覆写接口中的抽象方法！");
    }
    public void getNews(){
        System.out.println("子类覆写抽象类中的抽象方法！");
    }
}

4）接口之间可以使用extends继承多个父接口

interface A{//接口A
    void PlayA();
}
interface B{//接口B
    void PlayB();
}
interface C extends A,B{//接口C继承接口A，B  接口可以实现多继承
    void PlayC();
}
class CImpl implements C{//子类实现接口
    public void PlayA(){//覆写接口抽象方法
        System.out.println("接口A的抽象方法");
    }
    public void PlayB(){//覆写接口抽象方法
        System.out.println("接口B的抽象方法");
    }
    public void PlayC(){//覆写接口抽象方法
        System.out.println("接口C的抽象方法");
    }
}
public class Test30{
    public static void main(String[] args){
        C c = new  CImpl();
        c.PlayA();
        c.PlayB();
        c.PlayC();
    }
}

5)接口可以定义一系列的内部结构，包括 ：内部普通类，内部接口，

2.接口的应用

2.1 定义标准

interface USB{
    void setup();
    void work();
}
class Compture{//定义一个电脑类使用usb
    public void plugin(USB usb){
        usb.setup();
        usb.work();
    }
}
class UDisk implements USB{//子类实现接口
    public void setup(){
        System.out.println("U盘安装驱动");
    }
    public void work(){
        System.out.println("U盘正常工作");
    }
}
class PrintDisk implements USB{
    public void setup(){
        System.out.println("键盘按装驱动");
    }
    public void work(){
        System.out.println("键盘正常工作");
    }
}
public class Teat31{
   public static void main(String[] args){
      Compture compture = new Compture();
      compture.plugin(new UDisk());
      compture.plugin(new PrintDisk());
   }
}

2.2 表示能力

2.3抽象类与接口的区别

区别	抽象类（abstract）	接口（interface）
组成结构	普通方法，抽象方法	全局常量 抽象方法
权限	所有权限	只有public
子类使用	使用extends继承（单继承）	使用implement实现（多实现）
关系	一个子类可以实现多个接口	接口不能继承抽象类；接口可以使用extends继承多个父接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口