Java基础语法之抽象类和接口

抽象类

什么是抽象类

并不是所有的类都是用来描述对象的，这样的类就是抽象类

例如，矩形，三角形都是图形，但图形类无法去描述具体图形，所以它的draw方法无法具体实现，这个方法就可以没设计成抽象方法，这个类就是抽象类

抽象类语法

被abstract修饰的类是抽象类，abstract修饰的方法是抽象方法，抽象方法不用给出具体的实现体

如上，draw方法没有具体实现体，也就是不用写代码块

继承了抽象类的子类必须重写所有的抽象方法。如下：

如何使用该抽象类及其子类

这就是一种使用方法，在main函数中调用了Test中的静态方法draw(注意一定要是静态的，在静态方法中不可以调用非静态方法，因为非静态方法的调用依赖对象，而静态方法不依赖对象，所以静态方法默认没有this参数，也就无法调用非静态方法)

draw方法的参数是Shape类，而我们传参时传的是其子类，这里就发生了向上转型；

在draw方法中调用shape.draw()时，又会发生动态绑定；

总之这也是多态。

抽象类的特性

1.不能实例化本抽象类的对象

但是可以用它实例化一个子类对象，也就是可以发生向上转型

因为向上转型后，对象的本质还是其子类，只不过用父类来接收了，并不代表实例化了一个父类对象。

2.抽象方法不可以是private权限，也不可以被final，static修饰

首先，子类重写方法的访问权限要大于等于父类；

其次，final修饰的方法是静态方法，static修饰的方法在方法区；

总之，被private，final，static修饰的方法不可以被重写

3.继承抽象类的子类必须重写其方法，否则子类也要被abstract修饰，然后它的继承者要将其父类以及父类的父类中所有的抽象方法重写

4.抽象类中不一定有抽象方法，但由抽象方法的一定是抽象类

5.抽象类中也可以有普通方法和成员

但它里面的普通成员变量及方法只能通过子类对象来调用

其中，shape引用是发生了向上转型的，而reck就是一个子类的引用，由于有继承关系，所以可以通过子类引用来调用抽象类的方法

6.抽象类中可以有构造方法，供子类创建对象时初始化父类的成员变量，但注意，构造方法不能是抽象方法，因为构造方法不可以被重写

抽象类的作用

很多工作不应由父类完成，而应由子类来完成，但如果是一个普通类，用父类的引用去调用某些方法时就不会报错，而要是抽象类就会报错

就比如画图，你要是用父类shape来调用draw方法，如果不是抽象类就能正常编译，但由于图形有很多种，所以shape这个引用画不出具体的图形；而要是抽象类就会及时报错，提醒你调用具体的子类来画图

接口

什么是接口

接口就是公共的行为标准，大家在实现时，只要符号规范标准就可以通用。

具体点说，接口就是多个类的公共规范，是一种引用数据类型。

语法规则

接口要用interface关键字定义，内部是抽象方法；例如：

接口的使用

有了接口就必须要有具体的类来使用这就要用到implements关键字

public class 类名 implements 接口名{

}

如果这个类还和其他类由继承关系，则应该：

public class 类名 extends 父类名 implements 接口名{

} 表示该子类继承了某个类并且还有某个功能

既然都有继承关系了，为什么还要有接口呢？一个父类可以引出多个子类，它们都是由共性的，但也有特性，这些特性就不适合写在父类里面，这时就可以提供接口，有什么功能就使用什么接口

举例：

接口的特性

1.接口默认是被abstract修饰的，因为它里面有抽象方法

 interface USB等价于abstract interface USB

2.接口中的方法默认是被public abstract修饰的(也只能是这种权限，其他的都会报错)

void func(); 等价于public abstract void func();

这也好理解，接口是一种公共标准，一定得是公开的抽象的

3.接口是一种引用类型，但不能直接new一个接口对象

4.接口中可以有成员变量，但这些变量默认是public static final修饰的。既然默认被final修饰了，那么在定义的时候就必须初始化

首先 int a=10;等价于public static final int a=10;

其次，不可以直接int a;必须初始化

5.接口中一般不可以有普通方法，但被static default修饰的方法除外

但注意：static void func(){}等价于public static void func(){}，不可以改成除public的其他权限，default也一样

对于被static修饰的方法，可以直接用接口名调用，而default修饰的方法只能用子类对象调用或者被重写

例如：

package Demo2;
interface A{
    void Testa();
    static void Testb(){
        System.out.println("A 的static方法");
    }
    default void Testc(){
        System.out.println("A的default方法");
    }
}
class B implements A{
    @Override
    public void Testa() {
        System.out.println("B重写的testa方法");
    }

    @Override
    public void Testc() {
        A.super.Testc();
    }
}

public class Test {
    public static void main(String[] args) {
        A.Testb();
        B b=new B();
        b.Testa();
        b.Testc();
    }
}

用static修饰的方法可以在main中直接用接口名调用，但default方法要么被重写，要么用子类实例化的对象来调用

6.重写接口中的抽象方法时，只可以设置为public权限，因为接口中的抽象方法默认是public的，所以子类的方法权限要大于等于public

7.接口中不能有静态代码块和构造方法

8.如果它的子类没有重写抽象方法，那这个类必须设置为抽象类

举例

abstract interface USB{
    void openDevice() ;

    void closeDevice();
}
class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }
    public void click(){
        System.out.println("疯狂点击鼠标");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
}
class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }
    public void input(){
        System.out.println("疯狂打字");
    }
    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }
}
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 Test {
    public static void main(String[] args) {
        Computer computer=new Computer();
        computer.powerOn();
        KeyBoard keyBoard=new KeyBoard();
        Mouse mouse=new Mouse();
        computer.useDevice(keyBoard);
        computer.useDevice(mouse);
        computer.powerOff();
    }
}

如上，电脑有usb接口，可以实现打开关闭键盘鼠标的操作

注意，电脑本身不需要usb接口来打开，所以电脑是一个独立的类，它通过自己的powerOn powerOff 方法来打开，然后它又有使用设备的方法，然后就是设备要通过usb接口来打开关闭，即usb.openDevice(); usb.closeDevice();但是在打开后，还要工作，可是只用USB类无法调用设备独有的功能，所以发生了向下转型，注意instanceof的判断和括号的类型强转

然后在main函数中，首先实例化一个电脑对象，将电脑打开，再实例化键盘和鼠标，然后就是电脑要开始使用设备了，调用useDevice函数（这里发生了向上转型，因为是用USB这个引用去接收各种需要USB的对象）。最后就关闭电脑

实现多个接口

在Java中，类和类之间只能单继承，一个类只能有一个父类，但是一个类可以有多个特殊的功能，即一个类可以有多个接口

class 类名 implements 接口1，接口2

例如：青蛙会跑也会游泳，鸭子会跑会游泳也会飞，如下

class Animal{
    String name;
    int age;
    public void eat(){
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
 interface Running{
    public abstract void run() ;
}
interface Swimming{
    public abstract void swim();
}
interface Flying{
    public abstract void fly();
}
class Dog extends Animal implements Running{
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void run() {
        System.out.println("正在用囧囧跑步步");
    }

    @Override
    public void eat() {
        System.out.println("吃狗粮");
    }
}
class Flog extends Animal implements Running,Swimming{
    @Override
    public void run() {
        System.out.println("正在用俩只大脚掌跑步步");
    }
    @Override
    public void swim() {
        System.out.println("正在用那小手手游泳");
    }
    public Flog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("吃蛙粮");
    }
}
class Duck extends Animal implements Running,Flying,Swimming{
    @Override
    public void run() {
        System.out.println("正在小跑");
    }
    @Override
    public void swim(){
        System.out.println("正在划水");
    }
    @Override
    public void fly() {
        System.out.println("正在扇翅膀飞飞");
    }
    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("正在吃鸭粮");
    }
}

这就是一个典型的例子

那如何使用呢？

在main函数中可以调用这些static修饰的方法。在=========的上方，是多态的典型例子，将子类对象给到父类，再发生动态绑定，调用重写的方法，

在============的下方就是在使用接口了。注意public static void run(Running run)，这个方法的参数是Running这个引用类型，当有此功能的对象给到这个引用类型时，就是发生了向上转型，所以在run.run()时，表面上是调用了接口的抽象方法，实际上是在调用子类的重写的方法

其实，只要是有这个功能的类，就可以实现这个接口

接口间的继承

在Java中，类和类之间是单继承的，但接口与接口可以多继承

package Demo4;
interface A {
    void testA();
}

interface B {
    void testB();
}
interface C extends A,B{
    void testC();
    void testA();
}
class TestDemo1 implements C {
    @Override
    public void testC() {

    }

    @Override
    public void testA() {

    }

    @Override
    public void testB() {

    }
}

public class Test {
}