Java SE(10)——抽象类&接口

1.抽象类

1.1 概念

在之前讲Java SE(6)------类和对象（一）的时候说过，所有的对象都可以通过类来抽象。但是反过来，并不是说所有的类都是用来抽象一个具体的对象。如果一个类本身没有足够的信息来描述一个具体的对象，而是用于定义一个模板，为子类提供通用的属性和方法，这样的类就是抽象类

1.2 语法规则

在Java中，被abstract 修饰的类就是抽象类 ；被abstract 修饰的方法就是抽象方法

java 复制代码

//抽象类
public abstract class AbstractClass {
    //抽象方法
    public abstract void abstractMethod();
}

1.抽象类不能直接实例化，它只能作为其他类的父类

2.抽象方法是一种没有具体实现的方法，即没有方法体

3.抽象类中也可以定义普通成员变量/普通成员方法/构造方法。换言之，抽象类中不一定有抽象方法，但是抽象方法所在的类一定是抽象类

4.abstract只能修饰类和方法，没有抽象变量这个概念

5.抽象方法不能用private/static/final修饰

问题：既然抽象类无法直接实例化对象，那么抽象类真正的作用是什么？
在上面讲概念和语法规则的时候说过，抽象类只能作为父类被其他类继承，给子类提供一个模板并由子类来实现。

1.3 抽象类的实现

java 复制代码

public abstract class Shape {
    //普通成员变量
    public int width;
    public int length;
    //普通方法
    public void hello(){
        System.out.println("hello shape");
    }
    //构造方法
    public Shape(int width, int length) {
        this.width = width;
        this.length = length;
    }
    public abstract void draw();
}
public class Circle extends Shape {
    public Circle(int width, int length) {
        super(width, length);
    }
    @Override
    public void draw() {
        System.out.println("draw circle:" + this.width + " * " + this.length);
    }
    @Override
    public void hello(){
        System.out.println("hello circle");
    }
}
public class Test {
    public static void main(String[] args) {
        //无法直接实例化抽象类
        /*Shape shape = new Shape();*/
        Shape circle = new Circle(10,10);
        circle.draw();
        circle.hello();
    }
}

运行结果：

draw circle:10 * 10

hello circle

1.当某一个类（称为实现类）继承抽象类时，该实现类必须重写抽象类中的所有抽象方法 （这也是抽象方法不能使用private/static/final修饰的根本原因）

2.如果是抽象类A继承抽象类B，则暂不需要重写父类中的抽象方法。直到有实现类C来继承抽象类A，那么实现类C要重写A和B中的所有抽象方法

1.4 意义

仔细观察上述代码，抽象类和实现类之间构建了继承关系，发生了向上转型/方法重写。但是普通类和普通类之间好像也可以完成上述操作，换言之，抽象类能完成的功能普通类也可以。那么抽象类存在的意义是什么？

还是以上述代码为例，此时的需求是画一个circle。假设父类使用普通类，如果用户一不小心将父类直接实例化，那么此时调用draw()方法就无法画一个circle出来；再假设父类使用抽象类，如果用户直接实例化父类是会报错的，而且子类如果不重写抽象方法也是会报错的，这就是抽象类在提醒用户。使用抽象类相较于使用普通类，在特定场景下多了一层校验效果

2.接口

2.1 概念

在日常生活中，经常听到接口这个东西。比如：电脑的USB-A接口，既可以连接键盘，又可以连接鼠标、耳机等等，只要是适配UEB协议的设备都可以连接

通过这些例子可以简述一下接口的作用：接口就是公共的行为规范标准 。在实现某些功能时只要符合该规范标准就行了

在Java中，接口可以看作是多个类的公共规范，是一种引用数据类型

2.2 语法规则

定义接口需要借助interface关键字

java 复制代码

public interface 接口名称{
}

1.接口中的方法默认使用public abstract 修饰，所以定义方法时，建议不要再手动添加修饰词

2.接口中的变量默认使用public static final 修饰

3.接口中不能定义构造方法

4.在JDK8及以后，接口中可以定义静态方法和default 方法
default方法时接口中独有的方法，等会儿仔细说说default方法的作用

2.3 接口的实现

接口和抽象类一样，也不能直接实例化对象，只能由某个具体的类来实现。并且在Java SE(8)------继承中讲过，一个类只能拥有一个父类，但是一个类可以实现多个接口

类实现接口使用的是implements关键字

2.3.1 实现单接口

需求：实现电脑使用Usb设备（鼠标、键盘）

IUsb接口：包含打开设备、关闭设备的功能

Mouse类：实现IUsb接口，并具备点击功能

KeyBoard类：实现IUsb接口，并具备输入功能

Computer类：包含开机功能、关机功能和使用IUsb设备功能

java 复制代码

//IUsb接口
public interface IUsb {
    void openDevice();
    void closeDevice();
}
//Mouse类实现IUsb接口
public class Mouse implements IUsb {
    @Override
    public void openDevice() {
        System.out.println("Mouse open");
    }
    @Override
    public void closeDevice() {
        System.out.println("Mouse close");
    }
    public void click(){
        System.out.println("Mouse click");
    }
}
//KeyBoard类实现IUsb接口
public class KeyBoard implements IUsb {
    @Override
    public void openDevice() {
        System.out.println("KeyBoard open");
    }
    @Override
    public void closeDevice() {
        System.out.println("KeyBoard close");
    }
    public void input(){
        System.out.println("KeyBoard input");
    }
}
//电脑类，使用Use设备(鼠标、键盘)
public class Computer {
    public void open(){
        System.out.println("Computer open");
    }
    public void useUsb(IUsb iusb){
        iusb.openDevice();
        if (iusb instanceof KeyBoard){
            //向下转型
            KeyBoard keyBoard = (KeyBoard)iusb;
            keyBoard.input();
        }
        if (iusb instanceof Mouse){
            //向下转型
            Mouse mouse = (Mouse)iusb;
            mouse.click();
        }
        iusb.closeDevice();
    }
    public void close(){
        System.out.println("Computer close");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.open();
        computer.useUsb(new Mouse());
        computer.useUsb(new KeyBoard());
        computer.close();
    }
}

运行结果：

Computer open

Mouse open

Mouse click

Mouse close

KeyBoard open

KeyBoard input

KeyBoard close

Computer close

2.3.2 实现多接口

java 复制代码

public interface IRunning {
    void run();
}
public interface ISwimming {
    void swim();
}
public class Animal {
    public String name;
    public Animal(String name){
        this.name = name;
    }
}
//青蛙既能跑又能游
public class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + " is running");
    }
    @Override
    public void swim() {
        System.out.println(this.name + " is swimming");
    }
    public void act(){
        this.run();
        this.swim();
    }
}
public class Test {
    public static void main(String[] args) {
        Frog frog = new Frog("Frog");
        frog.act();
    }
}

运行结果：

Frog is running

Frog is swimming

2.4 接口的继承

在Java中，类和类之间是单继承 的，⼀个类可以实现多个接口，接口与接口之间可以多继承。

即：用接口可以达到多继承的目的

java 复制代码

public interface IRunning {
    void run();
}
public interface ISwimming {
    void swim();
}
//Act接口继承IRunning和ISwimming接口
public interface Act extends IRunning,ISwimming{
    @Override
    void run();
    @Override
    void swim();
}
public class Animal {
    public String name;
    public Animal(String name){
        this.name = name;
    }
}
//青蛙既能跑又能游
public class Frog extends Animal implements Act{
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + " is running");
    }
    @Override
    public void swim() {
        System.out.println(this.name + " is swimming");
    }
    public void act(){
        this.run();
        this.swim();
    }
}
public class Test {
    public static void main(String[] args) {
        Frog frog = new Frog("Frog");
        frog.act();
    }
}

运行结果不变

2.5 default方法的作用

默认实现：允许拥有具体的实现。实现类可以选择是否重写该方法

多重继承的解决方法：当某个具体类实现了非常多的接口时，接口之间可能会存在同名的方法。通过default方法可以解决同名方法的冲突 ```java public interface IA {
default void func(){
System.out.println("IA func");
} } public interface IB {
default void func(){
System.out.println("IB func");
} } public class Demo implements IA,IB {
@Override
public void func() {
//调用IA中的默认方法
IB.super.func();
} } public class Test {
public static void main(String[] args) {
Demo demo = new Demo();
demo.func();
} } ````在上述代码中必须在Demo类中重写func()方法才能解决同名冲突问题，所谓的重写就是选择调用IA还是IB中的default方法，并没有改变方法的原有实现。`如果IA和IB中是public
abstract修饰的方法，没有具体实现，只能由Demo类来实现，那么必然有一个接口中的func()方法无法被重写

向后兼容性：default方法使得在现有的接口中添加新方法成为可能，而不会破坏已有的实现类。如果没有default方法，添加新方法到接口会导致所有实现类都需要实现这个新方法，这会破坏向后兼容性

2.5 接口和抽象类的区别

核心区别：抽象类中可以包含普通方法和普通字段（变量），这样的普通方法和字段可以被子类直接使用(不必重写)；而接口中不能包含普通方法，子类必须重写所有的抽象方法

如之前写的 Animal 例子。此处的Animal中包含⼀个name这样的属性，这个属性在任何子类中都是存在的。因此下面的Animal只能作为⼀个抽象类，而不应该成为一个接口

java 复制代码

public class Animal {
    public String name;
    public Animal(String name){
        this.name = name;
    }
}