Java 面向对象编程（四）——抽象类和接口

文章目录

• 抽象类
• • 抽象类概念
  • 抽象类使用方法
• 接口
• • 使用场景
  • 模拟USB接口实现
  • • 代码实现USB接口
    • 接口表示能力

抽象类 抽象类概念

若要强制要求自雷覆写方法，就要用到抽象类。

其实现实生活中有多抽象类，这些类都是概念化的。没办法具体到某个实例，

抽象类是普通类的“超集”，只是比普通类多了一些抽象方法而已~~普通类有的，抽象类都有。

抽象方法所在的类必须是抽象类，自雷若继承了抽象类，必须覆写锁头抽象方法（子类是普通类）。

Java中定义抽象类或者抽象方法使用abstract关键字。

抽象类使用方法

1.抽象方法所在的类必须使用abstract关键字声明为抽象类。

使用abstract关键字声明，只有方法声明，没有方法体的方法称之为抽象方法。

判断题：在Java中没有方法体的方法就是抽象方法？

答案：错，本地方法也没有方法体~~

2.若一个类使用abstract声明为抽象类，无法直接通过该类实例化对象，不管这个类中有没有抽象方法，哪怕该类中一个抽象方法都没有。

当一个类是抽象类，不管他有没有抽象方法，这个类本身就是一个抽象的概念，没办法具体到某个特定的实例。只能通过子类向上转型变为抽象父类的引用。

例如：

Sharp sharp = new Sharp(); ->这个就是错误的

人类抽象：

Person person = new Person();->这个也是错误的

Person person = new Person();->这是个正确写法

3.子类继承了抽象类，就必须强制子类覆写抽象类中的所有方法（子类是普通类），也满足单继承局限，一个子类只能继承（extends）一个抽象类。

代码示例：

abstract class A {
    abstract void printA();
}

/**
 * B是抽象类，可以选择性覆写A的方法
 */
abstract class B extends A {
    abstract void printB();
}

/**
 * C是普通类，必须覆写B中的所有方法，包括继承来的方法~~~
 */
public class C extends B {
    @Override
    void printA() {

    }

    @Override
    void printB() {

    }
}

4.抽象类是普通类的超集（普通类有的内容，抽象类全都有）

问题：

阅读下面代码，答出输出后的num的值

abstract class BaseTest {
    public BaseTest() {
        this.print();
    }

    abstract void print();
}

public class Fun extends BaseTest {
    private int num = 10;

    /**
     * 由于父类是个抽象类必须覆写父类的抽象方法
     */
    @Override
    void print() {
        System.out.println("num = " + num);
    }

    public static void main(String[] args) {
        new Fun();
    }
}

//输出：num = 0;

分析：

这个题的流程是，先从方法执行，想要产生一个Fun()的对象，但是Fun是继承BaseTest类的，所以要先产生父类对象，父类对象又要通过父类构造方法产生，所以会执行父类的构造方法。弗雷德构造方法又调用了抽象方法print，但是在子类Fun中又覆写了这个方法，所以调用覆写后的print方法，这时候根本该没有执行 private int num = 10;，所以输出结果是 num = 0;

接口

​ 抽象类机虽然没法直接实例化对象，需要通过向上转型为抽象父类的引用，但是子类仍然满足is a原则，子类和抽象父类之间仍然满足”继承树“的关系

使用场景

一般来说，接口的使用表示两种场景：

1.接口表示具备某种能力或者行为，子类实现接口时候不是is a关系，而是具备这种行为或能力。

比如：“游泳”是一种能力或者行为，但是Person类满足游泳接口，Dog类也满足游泳接口。

2.接口表示一种规范或者标准

比如“USB接口”，“5G标准”

注意：

接口中只有全局常量和抽象方法，其他东西都没有！！！

使用关键字interface声明接口，子类使用implements实现接口。（类似继承）

模拟USB接口实现

下面来看简单的模拟USB接口实现

代码实现USB接口

public interface USB {
    //插入
    public abstract void plugIn();
    //实现
    public abstract void work();
}

子类使用implements实现接口，必须覆写所有的抽象方法：

以模拟一个鼠标接口为例，后边提到的Mouse，KeyBoard，以及Camera实现类似。

public class Mouse implements USB{
    @Override
    public void plugIn() {
        System.out.println("安装鼠标驱动中");
    }

    @Override
    public void work() {
        System.out.println("鼠标正常工作");
    }
}

再模拟第一个电脑Computer类

public class Computer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //插入鼠标
        Mouse mouse = new Mouse();
        computer.fun(mouse);
        //插入键盘
        KeyBoard keyboard = new KeyBoard();
        computer.fun(keyboard);
        //插入相机
        Camera camera = new Camera();
        computer.fun(camera);
    }
    //模拟USB接口
    public void fun(USB usb) {
        usb.plugIn();
        usb.work();
    }
}

鼠标，键盘等外设都属于USB接口的子类，那么电脑这个类算不算USB接口的子类？

答案是不算。因为电脑是USB规范的使用者，所有带USB插入线的设备都应该满足USB规范。电脑叫做USB规范的使用者！！！

用现实生活中的例子理解接口这一抽象概念

对于电脑的使用者来说，我根本不关心到底哪个具体设备插入到电脑上，只要这个设备满足了USB规范，都能被电脑识别~~~

就可以实现，一个接口接收无数种设备，只要这个设备满足USB接口。都可以插入且被电脑识别。

那么问题来了，为什么上面代码中所写的fun方法中的参数是 USB usb？

那么我们假设fun方法中的参数是 fun(Mouse mouse){}，这样的话这个接口只能插入鼠标，其他的设备都违法是识别，这是两个毫无相关的类，所以要用USB usb这个参数，去实现可以满足所有子类。只要是USB接口的子类，不管你是什么，都可以被识别~~~

方便拓展，不影响已经写好的程序~~~比如现在多了个Camera类，对于这个电脑的fun方法一点影响都没有。

接口表示能力

接口允许多实现，一个接口可具备多个能力，同时实现多个父接口，若实现多个父接口，需要覆写所有的抽象方法，（子类为普通类）。

代码实例：

public interface ISwim {
    void swim();
}
public interface IFly {
    void fly();
}
public interface IRun {
    void run();
}

public class Duck implements ISwim, IFly, IRun {
    @Override
    public void fly() {
        System.out.println("鸭子在飞");
    }

    @Override
    public void run() {
        System.out.println("鸭子在跑");
    }

    @Override
    public void swim() {
        System.out.println("鸭子在游泳");
    }
}

由于接口中只有全局常量和抽象方法，因此接口中的

public abstract 和 static final可以省略~~~

在接口声明中，这些关键字都不用写，只保留最核心的方法返回值，方法参数列表，名称即可~~~

现在只是初始接口，接口的知识还有太多，随着后边的学习我还会届大会介绍到！！！

未完待续……