Java抽象类和接口 小白版

什么是抽象

抽象就是从多个事物中将共性的，本质的内容抽象出来。

什么是抽象类

Java语言中，用abstract关键字修饰的类叫作抽象类。类本身是不存在的，所以抽象类无法创建对象无法实例化。

在面向对象领域，抽象类主要用来进行类型隐藏。

什么是抽象方法

抽象类中用关键字abstract修饰的方法叫做抽象方法（只有声明，没有方法体）

例：

public abstract class Car{ //抽象类
    public abstract void start(); //抽象方法
}

抽象类的好处

1. 可以复用代码

2. 利用多态隐藏实现类类型，得到更高的灵活性

抽象类的特点

1. 抽象类，其修饰符必须为public或者protected，不能是private，因为创建抽象类，就是要被其他类继承；
2. 抽象类不能实例化对象，要通过其普通子类进行实例化；
3. 普通类继承抽象类，则该普通类一定要重写父类的抽象方法；
4. 即使不包括任何abstract方法，亦可将一个类声明成抽象类；
5. 抽象类中可以没有抽象方法，但是，有抽象方法的类必须是抽象类。

抽象类和具体类的区别

抽象类只有方法的声明，没有方法体（具体实现），所以抽象类不能实例化对象；

具体类所有的方法包含方法的声明和方法体，所以具体类可以实例化对象。

实例

abstract class Door {

    public int weight;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public abstract void open();
    public abstract void close();
}
class WoodenDoor extends Door{
    public void open(){
        System.out.println("Opening wooden door");
    }
    public void close(){
        System.out.println("Closing wooden door");
    }
}
class IronDoor extends Door{
    public void open(){
        System.out.println("Opening iron door");
    }
    public void close(){
        System.out.println("Closing iron door");
    }
}
public class Main{
    public static void main(String[] args) {
        Door door = new WoodenDoor();//向上类型转换(多态）
        door.open();
        door.close();
        door.setWeight(10);
        System.out.println(door.getWeight());

        door = new IronDoor();
        door.open();
        door.close();
    }
}

什么是接口

接口是一套规范或标准。接口只规定必须实现的功能或要求，但是没有规定如何实现或达到。接口通常用 interface 来声明。

接口的定义格式

interface 接口名{
    接口方法
}

• 接口间多继承格式

interface 接口名 extends 接口名1，接口名2，...{
    ...
}

接口的作用

对外提供统一的接口方法，隐藏接口方法的实现细节。

接口的特点

1. 所有接口方法都是抽象方法(只有方法声明，没有方法实现)
2. 接口不能实例化对象，但类可以使用implements 关键字实现接口(一个类可以实现多个接口)
3. 类实现接口必须实现所有接口方法(否则这个类必须定义成抽象类)
4. 接口中可以定义静态成员变量(但必须用 final 修饰，即变量值不能更改)
5. 接口中的方法是不能在接口中实现的，只能由实现这个接口的类来实现接口中的方法，接口中的方法都是公有的。
6. 一个接口不能继承其他类，但是可以继承别的接口。

接口的优点

1. 接口可以用来对类提供规范或标准(避免类在设计上的不一致性)
2. 接口可用于间接实现多重继承(使用接口为实现类添加额外功能)
3. 接口可以使设计与实现相分离(降低代码耦合度、保证代码安全性)

实例

//TypeC接口
interface TypeC {
    final int MAX_VOLTAGE = 5; //常量
    void methodA();
    void methodB();
}
abstract class Phone {
    void charge(){
        System.out.println("charge");
    }

    void play(){
        System.out.println("play");
    }
}
//小米手机支持TypeC接口
class XiaoMi extends Phone implements TypeC {
    @Override
    public void methodA() {
        System.out.println("methodA");
    }

    @Override
    public void methodB() {
        System.out.println("methodB");
    }
}
//华为手机支持TypeC接口
class HuaWei extends Phone implements TypeC {
    @Override
    public void methodA() {
    }

    @Override
    public void methodB() {
    }
}

public class Client {
    public static void main(String[] args) {
        Phone phone = new XiaoMi();
        phone.charge();
        phone.play();

        XiaoMi xiaomi =new XiaoMi();
        xiaomi.methodA(); //不灵活

        TypeC typeC = new XiaoMi(); //隐藏了具体实现，提高了灵活性
        typeC.methodA(); //更加灵活

        typeC = new HuaWei();
        typeC.methodA();
        typeC.methodB();
    }
}