Java SE 接口的使用 实现接口和继承 接口的多态特性

快速入门

public interface UsbInterface { //接口 
    //规定接口的相关方法 
    public void start(); 
    public void stop(); 
}
public class Camera implements UsbInterface{
    //实现接口,就是把接口方法实现
     @Override 
    public void start() {
         System.out.println("相机开始工作..."); 
    }
    @Override 
    public void stop() {
         System.out.println("相机停止工作...."); 
    }    
} 
//Phone 类 实现 UsbInterface 
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法 
public class Phone implements UsbInterface {
    @Override 
    public void start() { 
        System.out.println("手机开始工作...");
    }
    @Override 
    public void stop() {
        System.out.println("手机停止工作.....");
     } 
}
public class Interface01 { 
    public static void main(String[] args) {
         //创建手机，相机对象 
        //Camera 实现了 UsbInterface 
        Camera camera = new Camera(); 
        //Phone 实现了 UsbInterface 
        Phone phone = new Phone(); 
        //创建计算机 
        Computer computer = new Computer();  
        computer.work(phone);//把手机接入到计算机 
        System.out.println("==============="); 
        computer.work(camera);//把相机接入到计算机
    }     
}
public class Computer {
    //编写一个方法, 计算机工作
    //1. UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2. 看到 接收 实现了 UsbInterface接口的类的对象实例
    public void work(UsbInterface usbInterface) {
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

基本介绍

public interface DBInterface { //项目经理
    public void connect();//连接方法
    public void close();//关闭连接
}
//A程序
public class MysqlDB implements DBInterface {
    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
        System.out.println("关闭mysql");
    }
}
//B程序员连接Oracle
public class OracleDB implements DBInterface{
    @Override
    public void connect() {
        System.out.println("连接oracle");
    }
    @Override
    public void close() {
        System.out.println("关闭oracle");
    }
}
public class Interface03 {
    public static void main(String[] args) {
        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }
    public static void t(DBInterface db) {
        db.connect();
        db.close();
    }
}

注意事项

//1. 接口不能被实例化

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

//3. 一个普通类实现接口 , 就必须将该接口的所有方法都实现 , 可以使用 alt+enter 来解决

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

public class InterfaceDetail02 {
    public static void main(String[] args) {
        //接口中属性的访问形式∶ 接口名.属性名
        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() {
    }
}

实现接口和继承

interface A {
    int x = 0;
}  
class B {
    int x = 1;
} //普通属性
class C extends B implements A {
    public void pX() {
        //System.out.println(x); //错误，原因不明确x
        //访问接口的 x 就使用 A.x
        //访问父类的 x 就使用 super.x
        System.out.println(A.x + " " + super.x);
    }

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wuKong = new LittleMonkey("悟空");
        wuKong.climbing();
        wuKong.swimming();
        wuKong.flying();
    }
}
//猴子
class Monkey {
    private String name;

    public Monkey(String name) {
        this.name = name;
    }
    public void climbing() {
        System.out.println(name + " 会爬树...");
    }

    public String getName() {
        return name;
    }
}
//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}
//继承
//小结:  当子类继承了父类，就自动的拥有父类的功能
//      如果子类需要扩展功能，可以通过实现接口的方式扩展.
//      可以理解 实现接口 是 对java 单继承机制的一种补充.
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() + " 通过学习，可以像鸟儿一样飞翔...");
    }
}

接口和继承解决的问题不同
继承的价值主要在于∶解决代码的复用性和可维护性。
接口的价值主要在于∶设计，设计好各种规范（方法），让其它类去实现这些方法。
接口比继承更加灵活，继承是满足 is-a的关系，而接口只需满足like-a的关系。
接口在一定程度上实现代码解耦，即∶接口规范性+动态绑定机制。

 接口的多态特性

         接口的多态体现

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
        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 {}

         多态数组

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给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 Camera_ implements Usb {

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

 演示多态传递现象

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() {}
}