JAVA 接口 详解

接口（interface)：. 接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。

---

为什么存在接口？

/**这里的Usb接口相当于笔记本电脑的接口，因为笔记的Usb接口可以
连接不同设备实现功能，由此可见，类接口就是去连接不同实现类*/
public interface Usb{//接口
    //接口的规定
public void start();
public void stop();
}

//用相机去连接接口Usb
public class Camera implements UsbInterface{//实现接口
  @Override
   public void start() {
        System.out.println("相机开始工作.....");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作...");
    }
}

//用手机去连接接口Usb
public class Phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("手机开始了工作....");
    }

    @Override
    public void stop() {
        System.out.println("手机停止了工作.....");
    }
}
//用电脑去实现接口的连接
public class Compater {
    //编写一个方法
    public void work(UsbInterface usbInterface){
        //通过接口调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}
//对连接的接口实例化对象
class Test{
  public static void main(String[] args) {
        //创建一个手机和一个相机
        Camera camera = new Camera();
        Phone phone = new Phone();
        //创建一个计算机
        Compater compater = new Compater();
        compater.work(phone); //把手机接入到计算机
        System.out.println("---------------");
        compater.work(camera);//把相机接入到计算机
    }
}

---

接口的注意事项：

public interface Usb {
    //1、写属性
    public int n1=10;
    //2、写方法
    //在接口中，抽象方法可以省略abstract关键字
    public abstract void hi();
    //在JDK8后，可以有默认实现方法;如果要默认实现方法，需要使用default关键字修饰
  default public void ok(){
        System.out.println("Ok......");
    }
    //JDK8后，可以有静态方法
    public static void cry(){
        System.out.println("cry.....");
    }
}

//1、如果一个类implements实现接口
//2、需要将该接口的所有抽象方法都实现
public class A implements Usb {
    @Override
    public void hi() {

    }
}

public class Interface {
    public static void main(String[] args) {
    //1、接口不能被实例化
       AI a=new AI();//错误
    }
}
interface IA{
//2、接口中的所有的方法public方法，接口中抽象方法，可以不用abstract 修饰(接口中所有的方法都是public)
    public void say();
    void hi();
}
class Cat implements IA{ 
//3、一个普通类实现接口，必须将该接口的所有方法都实现，可以使用Alt+enter
    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}
//4、抽象类实现接口，可以不用实现接口方法
abstract class Tiger implements IA{

}

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //证明接口中的属性是public static void
        System.out.println(IB.n1);//静态属于的根本用法
        // IB.n1=20;  说明n1是final
    }
}

/**
 * 1、一个类同时可以实现多个接口
 * 2、接口中的属性只能是final的，而且是public static final修饰
 * 3、接口中的属性访问形式是：接口名.属性名
 * 4、一个接口不能继承其他的类，但是可以继承多个别的接口
 * 5、接口的修饰符只能是public和默认 ，这点和类的修饰也是一样的
 */
interface IB {
    //接口中的属性只能是final的，而且是public static final修饰
    int n1 = 10;//等价于public static final int n1=10;

    void say();
}

interface IC {
    void hi();
}
//一个接口不能继承其他的类，但是可以继承多个别的接口
interface ID extends IB,IC{

}
//一个类同时可以实现多个接口
class Pig implements IB, IC {
    @Override
    public void say() {
    }

    @Override
    public void hi() {
    }
}

---

案例说明：

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey littleMonkey = new LittleMonkey("悟空");
        littleMonkey.climbing();
        littleMonkey.swimming();
        littleMonkey.flying();
    }
}

//猴子
class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void climbing(){
        System.out.println(name+"猴子会爬树");
    }
}
//接口实现的关系
interface FishAble{
    void swimming();
}
interface BirdAble{
    void flying();
}
//继承的关系
//小猴子继承猴子
class LittleMonkey extends Monkey implements FishAble,BirdAble{
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName()+"通过学习，可以像鱼儿一样游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName()+"通过学习可以像鸟儿一样飞翔....");
    }
}
/**题目来源：韩顺平老师 零基础30天学Java*/

 小结：
    1、当子类继承了父类，就自动的拥有了父类的一些功能
    2、如果子类需要扩展功能，可以通过实现接口的方式来扩展
         实现接口 是 对Java 单继承机制的一种补充