Java: 抽象类和接口-CSDN博客

本文链接：https://blog.csdn.net/blamep/article/details/139042871

一、抽象类

1.什么是抽象类？

概念：抽象类是指在普通类的结构里面增加抽象方法的组成部分。

2.定义一个抽象类的方法：

abstract class Test {
    public void fun(){
        System.out.println();
    }
    public abstract void chat();//定义一个抽象方法
}

3.如何使用抽象类

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法

abstract class pig {
    public void fun1(){
        System.out.println("猪会上树");
    }
    public abstract void chat();
}

public class TestDemo{
    public static void main(String[] args) {
        Pig pig = new Pig();
    }

4.抽象类语法

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

public abstract class Shape {
    abstract public void draw();
    abstract void calcArea();
    
    public double getArea(){
        return area;
    }
    protected double area;

}

5. 抽象类的特性

我们可以用代码分别描述三个图形

5.1矩形

public class Rect extends Shape {
    private double length;
    private double width;

    Rect(double length, double width) {
        this.length = length;
        this.width = width;
    }
    public void draw() {
        System.out.println("矩形: length= " + length + " width= " + width);
    }
    public void calcArea() {
        area = length * width;
    }
}

5.2 三角形

public abstract class Triangle extends Shape {
    private double a;
    private double b;
    private double c;

    protected Triangle(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    @Override
    public void draw() {
        System.out.println("三角形：a = " + a + " b = " + b + " c = " + c);
    }
}

5.3圆形

public class Circle extends Shape {
    private double r;
    final private static double PI = 3.14;

    public Circle(double r) {
        this.r = r;
    }

    public void draw() {
        System.out.println("圆：r = " + r);
    }

    public void calcArea() {
        area = PI * r * r;
    }
}

6.抽象类和普通类的比较

（1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写
（2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样
（3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到

二、接口

1.接口的理解：

接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。

2.接口的语法实现：

interface p{
    final int a=5;
    void display();
}
class testClass implements p{
    public void display(){
        System.out.println("love");
    }
}

public class Circle {
    public static void main(String[] args) {
        testClass m=new testClass();
        m.display();
        System.out.println(a);
    }
}

3.接口的使用：

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

我们可以通过一个举例在代码中进一步了解接口

步骤1：首先我们要先对USB接口类、笔记本类、鼠标类.、键盘类的描述：

步骤2：然后再通过测试类对代码的实现，从而实现笔记本电脑使用USB鼠标、USB键盘的例子

步骤1的代码分别实现：

USB接口类

public interface USB {
    void openDevice();

    void closeDevice();
}

笔记本类

public class Computer {
    public void powerOn() {
        System.out.println("开电脑");
    }

    public void powerOff() {
        System.out.println("关电脑");
    }

    public void useDevice(USB usb) {
        usb.openDevice();
        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.inPut();
        }
        usb.closeDevice();
    }
}

键盘类

public class KeyBoard implements USB {
    @Override
    public void openDevice() {
        System.out.println("开启键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }

    public void inPut() {
        System.out.println("键盘输入");
    }
}

鼠标类

public class Mouse implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

步骤2的代码实现：

public class TestUSB {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        computer.useDevice(new Mouse());// 使用鼠标设备
        computer.useDevice(new KeyBoard());// 使用键盘设备
        computer.powerOff();
    }
}

4.接口的特性

接口当中的成员变量，默认是public static final修饰的。
```
public static final int a=10;
int c=20;
```
接口当中的抽象方法，默认都是public static修饰的。
```
public abstract void draw()
```
如果接口当中的方法被default修饰，那么可以有具体的实现。
```
default void test(){
    System.out.println("default的方法");
}
```
接口当中的方法被static修饰，那么可以有具体的实现。
```
static void test(){
    System.out.println("static的方法");
}
```

接口不可以进行实例化。

    public static void main(String[] args) {
        Ishape ishape = new Ishape();
    }

类和接口之间可以使用关键词

public class Cycle implements Ishape{
    public void draw(){
        System.out.println("画一个圆");
    }
}

一个接口对应一个字节码文件

5.接口的表示用法

Seriallizable接口，Seriallizable接口的作用是使对象能够“序列化”，但是Seriallizable接口中却没有任何内容，也就是说，如果有一个类需要实现“序列化”的功能，则这个类必须去实现Seriallizable接口，但是却并不用实现方法（因为接口中没有方法），此时，这个Serilizable接口就仅仅是一个“标识”接口，是用来标志一个类的，标志这个类具有这个“序列化”功能。