Java面向对象-接口详解

1.接口是什么

接口是一种高度的抽象！
接口是一种编程的规范，规范实现类应该具有的属性和必须实现的方法！
当然，既然接口是一种抽象，则不可以有具体的实例，也就是没有构造方法，不能直接实例化！

2.接口定义规范

2.1 声明接口的格式

[public] interface <接口名>{
	[<常量>];
	[<抽象方法>];
}

2.2 接口的规范(必看)

1.接口的修饰符必须是 public 或者 默认修饰符（不写），因为接口需要被实现。
   修饰符为 public 时，可以被任何包中的类或者接口访问；
   修饰符为默认（不写）时，可以被当前包中的类或者接口访问。
2.interface 关键字声明接口。

3.接口中的属性只能是常量，且必须用 public static final 三个来进行修饰，
	即保证属性一定时 公有的、静态的和最终的。因此，实现接口的类都能访问到相同的属性。
4.接口中的属性的修饰符可以省略。即默认就是  public static final 。

5.接口中的方法只能是抽象方法，且共有的：public abstract 返回值类型 方法名（参数列表）;
6.接口中的方法修饰符 public abstract 可以省略。
	

2.3 接口实例

1.声明一个接口 InterfaceB, public 修饰，任何包下的类都可以实现该接口

/**
 * 声明一个接口 InterfaceB,
 * public 修饰，任何包下的类都可以实现该接口
 */
public interface InterfaceB {

    // 声明属性 ： public static final
    public static final String NAME_A = "Hello!";
    public final String NAME_B = "Hello World!";
    public static String NAME_C = "Hello Spring!";
    static final String NAME_D = "Hello SpringMVC!";
    public String NAME_E = "Hello Java!";
    static String NAME_F = "Hello SpringBoot!";
    final  String NAME_G = "Hello JDBC!";
    String NAME_H = "Hello Mybatis!";// 推荐使用这种声明方式

    // 声明方法 ： public abstract
    public abstract String sayHello();
    public String sayHelloWorld();
    abstract String sayHelloString();
    String sayHelloSpringMVC(); // 推荐使用这种声明方式
    
}

2.声明一个接口 InterfaceC, 默认修饰符（default），当前包下的类都可以实现该接口

/**
 * 声明一个接口 InterfaceC,
 * 默认修饰符（default），当前包下的类都可以实现该接口
 */
interface InterfaceC{
    // 声明属性 ： public static final
    public static final String NAME_A = "Hello!";
    public final String NAME_B = "Hello World!";
    public static String NAME_C = "Hello Spring!";
    static final String NAME_D = "Hello SpringMVC!";
    public String NAME_E = "Hello Java!";
    static String NAME_F = "Hello SpringBoot!";
    final  String NAME_G = "Hello JDBC!";
    String NAME_H = "Hello Mybatis!"; // 推荐使用这种声明方式

    // 声明方法 ： public abstract
    public abstract String sayHello();
    public String sayHelloWorld();
    abstract String sayHelloString();
    String sayHelloSpringMVC(); // 推荐使用这种声明方式

}

3.接口的使用

接口可以用来 被实现、被继承、可以用来声明引用变量。

3.1 实现接口

接口的实现主要是对接口中声明的抽象方法进行实现。
接口中的抽象方法必须全部都被实现！（因为是抽象方法）
此处实现接口的抽象方法也是方法重写！

1.声明一个接口

/**
 * 声明一个接口
 */
public interface InterfaceA {
    // 1.接口中的属性
    String NAME_A = "Hello World!";
    // 2.接口中的抽象方法（这里也体现了方法的重载）
    String sayHello();
    String sayHello(String name);
}

2.实现一个接口

/**
 * 接口 InterfaceA 的一个实现，
 * 重写了接口中的两个抽象方法
 */
public class ImplementA implements InterfaceA {

    @Override
    public String sayHello() {
        return "Hello";
    }

    @Override
    public String sayHello(String name) {
        return "Hello "+name;
    }
}

3.测试类进行测试使用

public class Application {
    public static void main(String[] args) {
        ImplementA implementA = new ImplementA();
        // 1.接口中的属性 ： 直接使用接口进行调用
        System.out.println("InterfaceA.NAME_A = "+InterfaceA.NAME_A);
        // 2.接口中的属性 ： 通过实现类直接进行调用
        System.out.println("ImplementA.NAME_A = "+ImplementA.NAME_A);
        // 3. 接口中的属性 ：通过实现类对象的方式进行调用
        System.out.println("implementA.NAME_A = "+implementA.NAME_A);

        // 4.接口中的方法 ： 通过 实现类对象的方式进行调用
        System.out.println("implementA.sayHello() : "+implementA.sayHello());
        System.out.println("implementA.sayHello(\"Java\") : "+implementA.sayHello("Java"));

    }
}

运行结果 ： 
InterfaceA.NAME_A = Hello World!
ImplementA.NAME_A = Hello World!
implementA.NAME_A = Hello World!
implementA.sayHello() : Hello
implementA.sayHello("Java") : Hello Java

3.2 继承接口

1.接口的继承同样使用 extends 关键字；
2.接口支持多继承，即一个接口可以有多个直接父接口；
3.子接口会继承父接口中所有的 常量属性、抽象方法、内部类和枚举类的定义；
4.多个父接口在extends之后，用英文逗号 “,”隔开。

5.不同父接口中有相同的属性名，在使用时要注意会产生歧义，因此要主动规避此问题；
6.不同父接口中有相同的抽象方法时:
   6.1 返回值类型相同+方法名相同+参数列表相同 ： 实现类中只会实现一个
   6.2 返回值类型不同+方法名相同+参数列表相同 ： 在子接口中会报错，提示两个方法的返回值不同
   6.3 返回值类型相同（或不同）+方法名相同+参数列表不同 ： 在实现类中会 形成方法重载

1.声明第一个接口

public interface InterfaceA {
    String NAME_A = "A";
    void sayHelloA();
}

2.声明第二个接口（复杂的操作都在这里）

public interface InterfaceB {
    String NAME_A = "B";// 注意这个属性，与InterfaceA 中的属性一致
    String NAME_B = "B2";
    void sayHelloA(); // 注意这个抽象方法，与InterfaceA 中的抽象方法一致,实现类中只会实现一个
    //String sayHelloA(); // 子接口中会报错
    String sayHelloA(String a); // 注意这个抽象方法与 sayHelloA()形成了方法的重载
    void sayHelloB();
}

3.声明第三个接口，继承 前两个接口

public interface InterfaceC extends InterfaceA,InterfaceB {
    String NAME_C = "C";
    void sayHelloC();
}

4.声明实现类，实现第三个接口

public class ImplementC implements InterfaceC {
    @Override
    public void sayHelloC() {
        System.out.println("sayHelloC");
    }

    /**
     * 下面的两个方法的实现是 接口InterfaceC 继承自 接口InterfaceA 和 接口InterfaceB的
     * 注意 sayHelloA() 方法在接口InterfaceA 和 接口InterfaceB 都存在，故只实现一遍即可
     */
    @Override
    public void sayHelloA() {
        System.out.println("sayHelloA");
    }
    // 形成的方法重载
    @Override
    public String sayHelloA(String a) {
        return "Hello "+a;
    }

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

5.测试类进行测试第三个接口和实现类

public class Application {
    public static void main(String[] args) {
        ImplementC implementC = new ImplementC();
        implementC.sayHelloA();
        implementC.sayHelloA("Java");
        implementC.sayHelloB();
        implementC.sayHelloC();
    }
}

运行结果
sayHelloA
Hello Java
sayHelloB
sayHelloC

3.3 引用接口

接口的引用就是 声明接口类型的变量，指向接口对应实现类的对象。

1.声明一个接口

public interface InterfaceA {
    String NAME_A = "A";
    String sayHello(String name);
}

2.创建一个接口的实现类

public class ImplementA implements InterfaceA {
    @Override
    public String sayHello(String name) {
        System.out.println("Hello "+name);
        return "Hello "+name;
    }
}

3.编写测试类进行测试

public class Application {
    public static void main(String[] args) {
        // 接口的引用 指向了 实现类的对象
        InterfaceA interfaceA = new ImplementA();

        // 使用 属性与方法
        System.out.println(interfaceA.NAME_A);
        interfaceA.sayHello("JAVA");
    }
}

运行结果 ： 实现类中的具体程序
A
Hello JAVA

4.完成

Congratulations!
You are one step closer to success!