Java中的接口

在Java中有一个接口优先原则（在一个操作即可以使用抽象类又可以使用接口的时候，优先考虑使用接口）

为什么会有接口优先原则呢？
主要是因为抽象类局限于单继承原则，而接口可以实现多继承，子类实现接口使用implements关键字，子类可以同时实现多个父接口。

什么是接口呢？
接口就是一个抽象方法与全局常量的集合（JDK8之前）

接口使用interface关键字定义
例：定义一个简单的接口

interface IMyInterface{
    public static final String str = "hello";//全局常量
    public abstract void print();;//抽象方法
}

package www.java.test;

interface IMyInterface{
    public static final String str = "hello";//全局常量
    public abstract void print();;//抽象方法
}
class MyInterfaceImpl implements IMyInterface{
    public void print(){
        System.out.println(str);
    }
}
public class Test{
    public static void main(String[] args) {
        IMyInterface myInterface = new MyInterfaceImpl();
        myInterface.print();
    }
}

来证明以下接口可以多继承：

package www.java.test;

interface IMyInterface{
    public static final String str = "hello";//全局常量
    public abstract void print();;//抽象方法
}
interface INews{
    public abstract void getNews();
}
class MyInterfaceImpl implements IMyInterface,INews{
    public void print(){
        System.out.println(str);
    }
    public void getNews(){
        System.out.println(str);
    }
}
public class Test{
    public static void main(String[] args) {
        IMyInterface myInterface = new MyInterfaceImpl();
        myInterface.print();
        INews news = new MyInterfaceImpl();
        news.getNews();
    }
}

• 接口中只有public（不管是属性还是方法，其权限均为public）
  例：
  
• 接口中public、static、final、abstract均可以省略（为保证代码简洁）
  例：

interface IMyInterface{
   String str = "hello";//全局常量
   void print();;//抽象方法
}

• 当一个子类即需要实现接口又需要继承抽象类时，要先使用extends继承一个抽象类，然后使用implements实现多个接口。
  例：

package www.java.test;

interface IMyInterface{
    String str = "hello";//全局常量
    void print();;//抽象方法
}
abstract class News{
    public abstract void getNews();
}
class MyInterfaceImpl extends News implements IMyInterface{
    public void print(){
        System.out.println(str);
    }
    public void getNews(){
        System.out.println(str);
    }
}
public class Test{
    public static void main(String[] args) {
        News news = new MyInterfaceImpl();
        IMyInterface myInterface = (IMyInterface) news;
        myInterface.print();
    }
}

我们看主方法里的对象和函数调用，是不是很懵逼呢？
父类和父接口可以相互转换的本质原因就是拥有共同的子类，所以以后我们看只需要看等号后边，真正new的子类才有意义，别被前面的类名称搞晕。

• 抽象类可以使用implements实现接口（普通类都可以实现接口，抽象类是普通类的超类，更可以实现了），但接口不能extends抽象类（接口中只有抽象方法和全局变量，而抽象类中还有普通方法、构造方法，如果接口要继承抽象类就必须继承它的所有）
• 接口可以使用extends继承多个父接口

interface A{
    void test1();
}
interface B{
    void test2();
}
interface C extends A,B{
    void test3();
}
class D implements C{

    @Override
    public void test1() {
        System.out.println("test1");
    }

    @Override
    public void test2() {
        System.out.println("test2");
    }

    @Override
    public void test3() {
        System.out.println("test3");
    }
}

我们可以先来看一个简单的接口应用。最常见的接口就是我们电脑的USB接口了，这是一个标准，我们买电脑时根本就不知道我们将来要往电脑上插什么东西，但只要知道它的USB接口的大小就行，以后不管是鼠标还是键盘，只要它的USB接口和电脑的一样大，就可以插上去。

package www.java.test;

interface USB{
    void plugIn();
    void setup();
    void work();
}
class Mouse implements USB{

    @Override
    public void plugIn() {
        System.out.println("鼠标插入电脑");
    }

    @Override
    public void setup() {
        System.out.println("安装鼠标驱动");
    }

    @Override
    public void work() {
        System.out.println("鼠标正常使用");
    }
}
class Keyboard implements USB{
    @Override
    public void plugIn() {
        System.out.println("键盘插入电脑");
    }

    @Override
    public void setup() {
        System.out.println("键盘鼠标驱动");
    }

    @Override
    public void work() {
        System.out.println("键盘正常使用");
    }
}
class Computer{
    public void fun(USB usb){
        usb.plugIn();
        usb.setup();
        usb.work();
    }
}
public class Test{
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.fun(new Mouse());
        computer.fun(new Keyboard());
    }
}

如果我们连接一个打印机，Computer（客户端）这个类是不需要任何改动的