Java语言基础-接口与实现类

接口概述

一方面，有时必须从几个类中派生一个子类，继承他们所有的属性和方法。但是Java不支持多重继承。有了接口，就可以得到多重继承的效果。

另一方面，有时必须从几个类抽取一些共同的行为特征，而他们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如鼠标，键盘，摄像头都属于输入设备，使用USB连接。

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个是不是的关系，接口是一个能不能的关系。

接口的本质是契约，标准，规范，就像我们的法律一样。指定好后大家都要遵守。

举例

比如飞机、子弹、风筝、热气球都可以飞，但是子弹有攻击性。

我可以定义一个可以飞的接口和一个具有攻击性的接口。

飞机、风筝和热气球实现可以飞的接口，子弹实现这两个接口。

/**
 * 接口的使用：
 *      1.接口使用interface来定义
 *      2.Java中，接口和类是并列的两个结构
 *      3.如何定义接口：定义接口中的成员
 *      4.JDK7以前只能定义常量和抽象方法
 *      5.JDK8以后除了定义常量和抽象方法外还有静态方法和默认方法
 *      6.接口中不能定义构造器
 *      7.Java开发中，一般让类实现(implements)接口
 *      8.如果实现类重写了接口的所有抽象方法，就可以实例化
 *      9.Java类可以实现多个接口，弥补了Java无法多重继承
 *      10.接口与接口之间可以多继承
 *      11.接口的实现体现了多态性
 *      12.接口就是一种规范
 * 
 */
public class InterfaceTest {
    public static void main(String[] args) {
        // 全局变量可以直接调用
        System.out.println(Flyable.MAX_SPEED);

        // 实例化实现类Plane
        Plane plane = new Plane();
        plane.fly();
        plane.stop();

        // 实例化实现类Bullt
        Bullet bullet = new Bullet();
        bullet.fly();
        bullet.stop();
        bullet.att();
    }
}

// 飞接口
interface Flyable{

    // 全局常量
    public static final int MAX_SPEED = 7900;
    int MIN_SPEED = 1;

    // 抽象方法
    public abstract void fly();
    void stop();

}

// 攻击性接口
interface Attackable{

    // 抽象方法
    public abstract void att();

}


/**
 * 飞机实现类
 */
class Plane implements Flyable{
    @Override
    public void fly(){
        System.out.println("使用引擎起飞");
    }

    @Override
    public void stop(){
        System.out.println("驾驶员减速降落");
    }
}


/**
 * 风筝实现类
 */
class Kite implements Flyable{
    @Override
    public void fly(){
        System.out.println("乘风而飞");
    }

    @Override
    public void stop(){
        System.out.println("收线降落");
    }
}


/**
 * 子弹实现类
 */

 class Bullet implements Flyable,Attackable{
    @Override
    public void fly(){
        System.out.println("biubiubiu");
    }

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

    @Override
    public void att(){
        System.out.println("攻击性");
    }
 }

// 接口的多继承

interface A extends Flyable,Attackable{

}

如何体会接口是一种规范

我们定义一个电脑类，想要和电脑发生信息交互，就必须通过USB接口。

然后我们定义连接USB接口的规范是什么，首先要建立连接，传输完数据后要断开连接。

public class USBTest {
    public static void main(String[] args) {
        Computer com = new Computer();

        Flash flash = new Flash();

        com.transferData(flash);
    }
}

// 定义一个电脑类
class Computer{
    public void transferData(USB usb){
        usb.start();

        System.out.println("传输数据");

        usb.stop();
    }
}


// 这是一个USB接口
interface USB{
    void start();
    void stop();
}

// 我们可以接入U盘
class Flash implements USB{
    @Override
    public void start(){
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop(){
        System.out.println("U盘结束工作");
    }
}

// 我们可以接入打印机
class Printer implements USB{
    @Override
    public void start(){
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop(){
        System.out.println("打印机结束工作");
    }
}

接口匿名实现类

public class USBTest {
    public static void main(String[] args) {
        // 非匿名实现类
        Computer com = new Computer();
        Flash flash = new Flash();

        com.transferData(flash);

        // 匿名实现类
        com.transferData(new Printer());

        // 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB(){
        
            @Override
            public void stop() {
                System.out.println("手机开始工作");
            }
        
            @Override
            public void start() {
                System.out.println("手机停止工作");
                
            }
        };

        com.transferData(phone);

        // 创建了接口的匿名实现类的匿名对象
        com.transferData(new USB(){
        
            @Override
            public void stop() {
                System.out.println("MP3开始工作");
            }
        
            @Override
            public void start() {
                System.out.println("MP3停止工作");
                
            }
        });
    }
}

// 定义一个电脑类
class Computer{
    public void transferData(USB usb){
        usb.start();

        System.out.println("传输数据");

        usb.stop();
    }
}


// 这是一个USB接口
interface USB{
    void start();
    void stop();
}

// 我们可以接入U盘
class Flash implements USB{
    @Override
    public void start(){
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop(){
        System.out.println("U盘结束工作");
    }
}

// 我们可以接入打印机
class Printer implements USB{
    @Override
    public void start(){
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop(){
        System.out.println("打印机结束工作");
    }
}

JDK8中的接口新特性

Java8中，你可以添加静态方法和默认方法。

静态方法:使用static关键字修饰。可以通过接口直接调用静态方法，并执行方法体。

默认方法:默认方法使用default关键字修饰。可以通过实现类对象来调用。

public class SubClassTest {
    public static void main(String[] args) {
        SubClass s = new SubClass();
        s.method2();
        s.method3();

        // 静态方法只能通过接口直接调用
        CompareA.method1();
    }
}

class SubClass implements CompareA{

}

----------
    


public interface CompareA {
    
    // 魔幻现实主义，接口里面有方法了
    public static void method1(){
        System.out.println("CompareA:北京");
    }

    // 上面的是静态方法，下面的是默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }

    default void method3(){
        System.out.println("CompareA:广州");
    }
}

默认对象也可以重写。

public class SubClassTest {
    public static void main(String[] args) {
        SubClass s = new SubClass();
        s.method2();
        s.method3();

        // 静态方法只能通过接口直接调用
        CompareA.method1();
    }
}

class SubClass implements CompareA{
    public void method2(){
        System.out.println("subclass:上海");
    }
}

----------
    


public interface CompareA {
    
    // 魔幻现实主义，接口里面有方法了
    public static void method1(){
        System.out.println("CompareA:北京");
    }

    // 上面的是静态方法，下面的是默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }

    default void method3(){
        System.out.println("CompareA:广州");
    }
}

问题:如果SubClass继承于父类SuperClass，SuperClass也有一个方法method3，那么SubClass的method3方法输出什么呢？

public class SubClassTest {
    public static void main(String[] args) {
        SubClass s = new SubClass();
        s.method2();
        s.method3();	// 执行父类的method3

        // 静态方法只能通过接口直接调用
        CompareA.method1();
    }
}

class SubClass extends SuperClass implements CompareA{
    public void method2(){
        System.out.println("subclass:上海");
    }
}

----------
    
public class SuperClass {
    public void method3(){
        System.out.println("SupClass:广州");
    }
}
    
    
----------


public interface CompareA {
    
    // 魔幻现实主义，接口里面有方法了
    public static void method1(){
        System.out.println("CompareA:北京");
    }

    // 上面的是静态方法，下面的是默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }

    default void method3(){
        System.out.println("CompareA:广州");
    }
}

总结一下就是方法先找类本身的，再找父类的，再找接口的。

如果实现两个接口，然后两个接口的默认方法冲突了，那么就会报错。如果想要使用该方法，在实现类中必须要重写该方法。