接口【超详细】

一：接口

1. 思考？

1.1 接口既然是使用interface用来声明，那编译后的文件还是.class吗？

接口是一种引用数据类型，编译之后还是.class字节码文件。

1.2 接口中能写什么？

接口中包含两部分内容：一，常量 二，抽象方法

//定义接口A
interface A{
    //常量
    public static final double PI = 3.1415;
    String s = "Hello";
    int a = 12;
    double d = 3.14;
    
    //抽象方法,因为抽象中是完全抽象的所以abstract可以省略
    public abstract void method();
    public void method1();
}

2. 接口的特点

2.1 接口是完全抽象的，抽象类是半抽象。

因为接口是完全抽象的，所以接口中所有的方法都是抽象方法，也就是都是没有方法体的方法。

public interface A {
    //成员方法
    public abstract void method();
    //接口中所有的方法都是抽象方法，所以会编译报错。
   /*
       public void m1(){   //编译报错
            
        }
    */
}

2.2 接口的定义方式：[修饰符列表] interface 接口名{}

接口使用的关键字是interface

//定义一个接口 【修饰符 public interface 接口名 A】
public interface A {
    
}

2.3 接口中所有的成员都是使用public修饰的

interface是接口的意思其中inter表示internet因特网， face表示脸面， 合起来就是网络的脸面。脸面最大的特点就是【暴露】所以接口里面的所有成员都是public的修饰的。

public interface A {
    //成员变量
    public static final int a = 10;
    //成员方法
    public abstract void method();
}

2.4 接口支持多继承

//定义接口A
interface A{

}
//定义接口B并继承接口A【单继承】
interface B extends A{

}
//定义接口C继承A和B，接口可以支持【多继承】
interface C extends A,B{

}

2.5 接口的调用使用多态的方式。

public class InterfaceTest01 {
    public static void main(String[] args) {
        //使用多态的方法创建对象【父类的引用指向子类的对象】
        A a = new Dog();
        //调用Dog方法
        a.fly();
        //使用多态的方式创建对象【父类的引用指向子类的对象】
        A a1 = new Cat();
        //调用Cat方法
        a1.fly();
    }
}

//定义一个接口A,接口通常提取的是行为动作
interface A {
    void fly();

}

//定义一个父类Animal
class Animal {

}

//定义一个类实现A接口和B接口
class Dog extends Animal implements A {
    @Override
    public void fly() {
        System.out.println("我是哮天犬，会飞！！！");
    }
}

class Cat extends Animal implements A {
    @Override
    public void fly() {
        System.out.println("我是飞翔猫,会飞！！！");
    }
}

2.6 接口不能实例化

接口不能实例化，只有实现接口的子类可以实例化，因为接口中都是抽象方法，假如可以实例化，那调用接口中的方法都是抽象方法没有方法体，会矛盾。所以接口不能实例化

//定义一个接口 【修饰符 public interface 接口名 A】
public interface A {
}
class Test{
    public static void main(String[] args) {
        //会编译报错，因为接口不能实例化，不能创建对象。
        // A a = new A();
    }
}

3. 接口的作用

3.1 规范性

接口的规范性体现在抽象方法中，因为子类实现接口，就必须全部重写接口中所有的抽象方法，而且方法声明一模一样，这就是强制性，也是规范性的体现。

3.2 拓展性

生活中的接口有很多，USB接口，插座孔，充电孔，等只要是按照接口的规则创建，就可以和接口对接，所有按照接口规范创建的都可以对接，所有的实现类只要实现接口重写接口中所有的抽象方法【规则】，就可以使用，这也就是接口的拓展性。

4. 接口的成员特点

4.1 成员变量

接口中所有的变量都是被final修饰的，也就是只能赋值一次。所以接口中也没有变量这一说，都是常量。

• 接口中的常量默认都是final修饰的，只能赋值一次。

• 接口中的常量默认都是static修饰的，也就是说可以通过类名.调用。

• 接口中的常量默认都是public修饰的，都是公开的。

//定义一个接口 【修饰符 public interface 接口名 A】
public interface A {
    //常量
    public static final int B = 10;
}

4.2 成员方法

接口中所有的方法都是抽象方法，所以都默认使用public abstract修饰

• 接口中的方法只能是抽象方法，默认修饰public abstract

//定义一个接口 【修饰符 public interface 接口名 A】
public interface A {
    //成员方法
    public abstract void method();
    //可以省略public abstract 
    void method1();
}

4.3 构造方法

因为接口不能创建对象，所以接口中也没有构造方法，没有构造代码块，没有静态代码块。

• 接口中没有构造方法

• 接口中没有构造代码块

• 接口中没有静态代码块

二：类和接口

1. 思考？

1.1 一个类可以同时实现多个接口吗？

一个类也可以实现多个接口，类似于多继承。这也就弥补了java中类和类只能单继承的缺陷，因为生活中存在很多多继承，所以java中的接口弥补了单继承所带来的缺陷。

//定义一个接口A
interface A{
    
}
//定义一个接口B
interface B{
   
}
//定义一个类实现A接口和B接口
class C implements A,B{
   
}

1.2 非抽象类实现接口时需要重写接口中的抽象方法吗？

一个非抽象类实现接口时，必须把接口中所有的抽象方法都要实现。

interface A{
    //定义一个抽象方法method1
    void method1();

}
//定义一个接口B
interface B{
    //定义一个抽象方法method2
    void method2();

}
//定义一个类实现A接口和B接口
class C implements A,B{
    //重写method1方法
    @Override
    public void method1() {

    }
    //重写method2方法
    @Override
    public void method2() {

    }
}

1.3 extends 和 implements 可以共存吗？

继承和多态可以一起使用，但是extends关键字在前，implements关键字在后。

//定义一个接口A
interface A{

}
//定义一个父类Animal
class Animal{

}
//定义一个类实现A接口和B接口
class B extends Animal implements A{

}

1.4 接口没有构造方法，Why子类默认第一句是super()?

接口不能实例化，也就没有构造方法，但是接口的子类实现接口，而子类可以创建对象，既然可以创建对象，那子类的构造方法默认第一句是super()。super代指的是当前类的父类，而任何子类的父类是Object。

三： 类和类型的关系

1. is a :

​ 例如： Cat is a Animal (猫是一个动物)，凡是满足is…a的表示“继承关系”

​ A extends B

2. has a:

​ 例如： I has a pen(我有一只笔)，凡是满足has…a的关系通用以“属性”的形式存在。

​ A{ B b };

3. like a :

​ 例如：Cooker like a FoodMenu(厨师像一个菜单一样)，凡是满足like…a的关系表示“实现”关系。

​ A implements B

四： 抽象类和接口有什么区别？

1. 抽象类是半抽象的，接口是完全抽象的。
2. 抽象类中有构造方法，接口没有构造方法。
3. 接口和接口之间支持多继承，类和类之间只能单继承。
4. 一个类可以同时实现多个接口，一个抽象类只能继承一个类。
5. 接口中只允许出现常量和抽象方法。

---

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。

JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。

五：思维导图

                                                      不要在最能吃苦的年纪选择了安逸！！！        — Tornado♥