Java中的接口

狭义定义：

interface（关键词） 接口名 {
}

---

广义定义：

接口相当于定义一个规则 使用接口时 必须遵守这个规则

---

implements：

实现接口的关键字

注意：接口的实现类后缀一般为 Impl

---

注意（JDK1.8以前的规则）：

1.接口只能声明抽象方法
2.声明方法时，没有abstract 系统会默认添加
3.接口没有构造方法 不能直接实例化对象
4.接口定义的成员变量 是常量 修饰符为public static final
  可以用接口名调用

---

举例：

//  声明一个接口A
interface InterA {
    public static final int num = 10;
    public abstract void fun();
}

//  实现接口A
class InterAImpl implements InterA {
    //  重写接口中的方法
    public void fun() {
        System.out.println(num);
        System.out.println("我是实现类的 fun方法");
    }
}

//  测试
public static void main(String[] args) {
    //  使用实现类（多态方法使用）
    InterA a = new InterAImpl();
    a.fun();
    //  直接调用num
    System.out.println(InterA.num);
}

---

类与类 类与接口 接口与接口的关系：

类与类：
  继承关系 只能单继承 或多层继承
类与接口
  实现关系 可单实现 也可多实现
接口与接口
  继承关系 可单继承 也可多继承

---

举例：

需求：

动物 吃 叫
猫 吃鱼 喵喵喵
训练动物：训练跳高
会跳高的猫

---

//  动物类
abstract class Animal {
    //  抽象方法
    public abstract void eat();
    public abstract void speak();   
}
//  接口训练猫
interface CatJumpInter {
    //  训练猫
    public abstract void jump();
}
//  猫
class Cat extends Animal {
    //  重写抽象类的方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void speak() {
        System.out.println("猫叫 喵喵喵");
    }
}
//  跳高猫
class JumpCat extends Cat implements CatJumpInter {
    //  实现接口中的方法
    @Override
    public void jump() {
        System.out.println("拿棍子怼屁股 训练跳高的最好方法");
    }
}

---

//  测试接口的多实现
interface InterB {
    public abstract void fun1();
}
interface InterC {
    public abstract void fun2();
}

---

//  测试接口和接口的关系
interface InterD extends InterB , InterC {

}

class InterImpl implements InterD {
    @Override
    public void fun1() {

    }

    @Override
    public void fun2() {

    }
}

---

接口（JDK.1.8后）的新特性：

可以声明：
1.抽象方法
2.静态方法
3.默认方法

---

抽象类 接口的区别：

---

1.成员变量
   抽象类：可以是变量 也可以是常量
   接口：只能是常量
2.成员方法
   抽象类：可以是抽象方法 也可以是普通成员方法
   接口：只能是抽象方法 静态方法和默认方法
3.构造方法（抽象类和接口 都不能实例化对象）
   抽象类：有构造方法 可以被继承
   接口：没有构造方法 只能被实现

---

举例：

interface InterX {
    //  抽象方法
    public abstract void print();
    //  静态方法
    public static void staticFun() {
        System.out.println("我是接口中的静态方法staticFun()");
    }
    //  默认方法（使用default关键词）
    public default void defaultFun() {
        System.out.println("我是接口中的默认方法defaultFun()");
    }
}
//  接口的实现类
//  实现类中可以不去重写（实现）接口中静态方法和默认方法
class InterXImpl implements InterX {
    //  抽象方法
    @Override
    public void print() {   
        System.out.println("我是实现类中的抽象方法");
    }

    //  重写接口中默认方法
    @Override
    public void defaultFun() {
        //  实现类中调用接口类中的默认方法可以使用
        //  接口名.super.方法名()；
        InterX.super.defaultFun();
        System.out.println("我是实现类中的默认方法");
    }

    //  实现类特有方法
    public void fun() {
        //  调用接口中 默认方法
        InterX.super.defaultFun();
        System.out.println("我是实现类中的特有方法fun()");
    }

    //  静态方法又叫 类方法
    public static void staticFun() {
        System.out.println("我是实现类中静态方法staticFun()");
    }
}

---

public static void main(String[] args) {
    //  接口中静态方法的调用 可以直接使用接口名调用
    InterX.staticFun();
    //  创建一个接口的实现类的对象
    InterX x = new InterXImpl();
    //  调用接口中的默认方法
    x.defaultFun();
    //  调用实现类中的特有方法 需要向下转型
    InterXImpl impl = (InterXImpl)x;
    impl.fun();
    //  调用接口类中的静态方法
    InterX.staticFun();
    //  调用实现类中的静态方法
    InterXImpl.staticFun();
}