Java—面向对象(高)——接口

一、基本介绍

        接口就是给出一些还没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来

语法：

interface 接口名{

        //属性

        //抽象方法（1.抽象方法  2.默认实现方法  3.静态方法）

}

class 类名 implements 接口{

        //自己的属性

        //自己的方法

        //必须实现的接口的抽象方法

}

• 小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体
• 特别说明：在jdk7.0以前，接口里的所有方法都没有方法体，而在jdk8.0后接口类可以有静态方法、默认方法，也就是说接口中可以有方法的具体实现

二、注意事项和细节

        1.接口不能被实例化

        2.接口中所有的方法都是public方法，接口中抽象方法，可以不用abstract修饰

        3.一个普通类实现接口，就必须将该接口的所有方法都实现（可使用alt+enter快捷键）

        4.抽象类实现接口，可以不用实现接口的方法

        5.一个类同时可以实现多个接口

        6.接口中的属性只能是final，而且是 public static final修饰符

        7.接口中属性的访问形式：接口名.属性名

        8.接口不能继承其他的类，但是可以继承多个别的接口

        9.接口的修饰符只能是public和默认，这点和类的修饰符是一样的

package com.learn.interface_;

public class InterfaceDetail01 {
    public static void main(String[] args) {
        //new IA();
    }
}

//1.接口不能被实例化
//2.接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
//3.一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用alt + enter快捷键来解决
//4.抽象类实现接口时，可以不实现接口的抽象方法
interface IA {
    void say();
    void hi();
}
class Cat implements IA{  //alt + enter 快捷键实现方法

    @Override
    public void say() {

    }

    @Override
    public void hi() {

    }
}

abstract class Tiger implements IA{

}

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //证明 接口中的属性只能是final，而且是 public static final修饰符
        System.out.println(IB.n1); //说明n1是static
        //IB.n1 = 30; //说明n1是final
    }
}

interface IB{
    //接口中的属性只能是final，而且是 public static final修饰符
    int n1 = 10; //等价于 public static final int n1 = 10;
    void hi();
}
interface IC{
    void say();
}
//接口不能继承其他的类，但是可以继承其他的接口
interface ID extends IB,IC{
}
//接口的修饰符只能是public和默认，这点和类的修饰符是一样的
interface IE{}



//一个类可以同时实现多个接口
class Pig implements IB,IC{

    @Override
    public void hi() {

    }

    @Override
    public void say() {

    }
}

三、实现接口 vs 继承类

• 接口和继承解决的问题不同

        继承的价值主要在于：解决代码的复用性和可维护性

        接口的价值主要在于：设计好各种规范(方法)，让其它类去实现这些方法

• 接口比继承更加灵活

        接口比继承更加灵活，继承是满足 is-a 的关系，而接口只需满足 like-a 的关系

is - a  举例：猫是动物              like - a  举例：猫可以像小鸟一样飞

• 接口在一定程度上可以实现代码解耦 [即：接口规范性 + 动态绑定机制]

四、接口的多态特性

        1.多态参数

           接口类型的引用可以指向实现了接口的类的对象实例

public class InterfacePolyParameter {
    public static void main(String[] args) {

        //接口的多态体现
        //接口类型的变量 if01 可以指向 实现了接口的类的对象实例
        IF if01 = new Monster();
        if01 = new Car();

        //继承体现的多态
        //父类类型的变量a 可以指向 继承了AAA的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}
interface IF{}
class Monster implements IF{}
class Car implements IF{}

class AAA{}
class BBB extends AAA{}
class CCC extends AAA{}

        2.多态数组

public class InterfacePolyArr {
    public static void main(String[] args) {

        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Carmera_();
         /*
         给Usb数组中存放Phone和相机对象，Phone类还有一个特有的方法call()，
         请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外，还需要调用Phone特有方法call
          */
        for(int i = 0; i < usbs.length; i++){
            usbs[i].work(); //动态绑定机制
            //和前面一样，需要进行类型的向下转型
            if(usbs[i] instanceof Phone_){ //判断它的运行类型是不是Phone_
                ((Phone_) usbs[i]).call();
            }
        }

    }
}

interface Usb{
    void work();
}
class Phone_ implements Usb{
    public void call(){
        System.out.println("手机可以打电话...");
    }

    @Override
    public void work() {
        System.out.println("手机正在工作...");
    }
}
class Carmera_ implements Usb{

    @Override
    public void work() {
        System.out.println("相机正在工作...");
    }
}

        3.接口多态传递现象

public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG继承了IH接口，而Teacher类又实现了IG接口
        //就相当于Teacher类也实现了IH接口，这就是所谓接口多态传递现象
        IH ih = new Teacher();
    }
}

interface IH{
    void hi();
}

interface IG extends IH{

}

class Teacher implements IG{
    @Override
    public void hi() {

    }
}