欢迎大家来这次博客-----抽象类和接口。 

1.抽象类

1.1 抽象类概念

在Java中我们都是通过类来描述对象，但反过来并不是所有的类都是用来描述对象的。当一个类中没有足够的信息来描述一个具体对象，我们就将该类称为抽象类。

如上图中的Shape类，我们想通过Shape类中的draw()方法来实现画各种图形，但由于Shape类不是具体的图形，所以Shape类中的draw()方法也无法实现画各种图形，所以我们将Shape类设置成抽象类。

代码演示

abstract class Shape{
    public abstract void draw();
}
class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个三角形");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个圆");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}
public class Test {
    public static void main(String[] args) {
        Shape[] shapes={new Triangle(), new Cycle(), new Rect()};
        for(Shape shape:shapes){
            shape.draw();
        }
    }
}

代码演示

abstract class Animal{
    public abstract void Bark();
}
class Dog extends Animal{
    @Override
    public void Bark() {
        System.out.println("小狗在汪汪叫");
    }
}
class Cat extends Animal{
    @Override
    public void Bark() {
        System.out.println("小猫在喵喵叫");
    }
}
public class Test {
    public static void func(Animal animal){
        animal.Bark();
    }
    public static void main(String[] args) {
        Dog dog=new Dog();
        func(dog);
        Cat cat=new Cat();
        func(cat);
    }
}

注意，如以上代码有些地方看不懂，后面回一 一介绍。

1.2 抽象类语法

在Java中，当一个类被关键字abstract修饰，该类就被称为抽象类，抽象类中如果有方法被abstract修饰，则该方法就被称为抽象方法，抽象方法不需要具体实现。

//抽象类
abstract class Animal{
    //抽象方法
    public abstract void Bark();
}

注意事项：

抽象类中也可以包含普通的方法，甚至也可以包含构造方法。 

1.3 抽象类的特性

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

2. 抽象方法不能被private修饰。

3. 抽象方法不能被final和static修饰，因为子类要重写抽象方法。

4. 抽象类必须被继承，继承抽象类的子类必须重写抽象类中的抽象方法。否则子类也是抽象类，必须用abstract修饰。

5. 抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类。

6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

1.4 抽象类的作用

抽象类本身是不能实例化的，要想使用抽象类，必须需要继承的子类重写抽象类中的抽象方法。

有人这时候就很疑惑，普通类不是也能被继承吗？

确实如此，但是使用抽象类多了一层编译器的校验。

如上面的代码，我们完成的操作都是由子类去完成的，但是如果交由父类去完成，普通编译器是不会报错的，但使用了抽象类，父类在实例化的时候就会报错，起到一个提醒的作用。

2. 接口

2.1 接口的概念

在生活中，接口比比皆是，如插座，USB插口。

接口通俗来说就是一种固定行为规范，只要你的操作符合规范，就能使用接口。

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

2.2 接口的语法规则

关键字interface  接口名字

举例，如下图，

2.3 接口的特性

1.接口是一种引用数据类型，但是不能直接new关键字来创建对象。

2.接口中的每一个方法都是默认由public abstract 修饰的，也就是说接口中的方法不能被其他关键字修饰。（可以不写修饰接口中方法的关键字，编译器默认为public abstract）

3. 接口中的方法不能在接口中实现，只能在使用接口的类中实现。（有特殊情况）

 4. 如果接口中的方法被default或者static修饰，可以有具体实现。

5.  重写接口中的方法时，不能使用默认的访问权限。

6. 接口中可以含有变量，但会默认为被 public static final 修饰。  

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

8.如果类中没有重写接口中所有的抽象方法，则该类要用abstract修饰。

9.接口虽然不是类，但接口编译完成后的字节码文件的后缀也是 .java 。

2.4 接口的使用

接口不能直接使用，必须要有一个 “实现类” 来重写接口中的抽象方法，通过这个实现类来使用接口。

如果一个类想使用一个接口，要用到implements关键字。

语法格式

public class 类名称 implements 接口名称{
        // ...
}

注意：父类与子类之间的关系为extends，类与接口之间的关系为implements。

实现一个USB接口

interface USB{
     void close();
     void open();
}
class Mouse implements USB{
    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }
    public void open(){
        System.out.println("打开鼠标");
    }
    public void click(){
        System.out.println("点击鼠标");
    }
}
class KeyBoard implements USB{
    public void close(){
        System.out.println("关闭键盘");
    }

    @Override
    public void open() {
        System.out.println("开启键盘");
    }
    public void input(){
        System.out.println("输入功能");
    }
}
class Computer implements USB{
    @Override
    public void close() {
        System.out.println("关闭电脑");
    }
    public void open(){
        System.out.println("打开电脑");
    }
    public void use(USB usb){
        usb.open();
        if(usb instanceof Mouse){
            ((Mouse) usb).click();
        }else{
            ((KeyBoard)usb).input();
        }
        usb.close();
    }

}
public class Test {
    public static void main(String[] args) {
       Computer computer=new Computer();
       computer.open();
       USB usb1=new Mouse();
       computer.use(usb1);
       System.out.println("=======");
       USB usb2=new KeyBoard();
       computer.use(usb2);
       computer.close();
    }
}

2.5  实现多个接口

一个类不能同时继承多个类，但是一个类可以同时使用多个接口。

举个例子：用Java来描述鸭子会飞，会游泳和会跑。

我们可以将会飞，会游泳，会跑设置为三个接口。

ISwimming接口

public interface ISwimming {
    void swim();
}

IRunning接口

public interface IRunning {
     void run();
}

IFly接口

public interface IFly {
    void fly();
}

Duck类

public class Duck extends Animal implements IFly,IRunning,ISwimming{
    public Duck(String name){
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(this.name+"会飞");
    }

    @Override
    public void run() {
        System.out.println(this.name+"会跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"会游泳");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Duck duck=new Duck("小鸭");
        duck.fly();
        duck.run();
        duck.swim();
    }
}

 快捷操作：CTRL+I键 快速实现接口

 使用接口的好处就是可以让程序员忘记类的限制，只需要关注该类有没有此接口对应的功能。

class Robot implements IRunning{
    @Override
    public void run() {
        System.out.println("机器人再跑1");
    }
}
public class Test {
    public static void func(IRunning running){
        running.run();
    }
    public static void main(String[] args) {
        Duck duck=new Duck("小鸭");
        func(duck);
        Robot robot=new Robot();
        func(robot);
    }
}

如以上代码，我们给func函数穿的参数可以是Duck类，也可以是Robot类，只要这两个类具备跑的能力就行了。

2.6 接口之间的继承

在Java中，类与类之间只允许单继承，不允许多继承。但是对于接口来说，接口之间既可以单继承，也可以多继承。

接口之间的继承也是用到extends关键字。

 代码演示

interface Double extends IRunning,ISwimming{
}
class Dog implements Double{
    @Override
    public void run() {
        System.out.println("狗会跑");
    }

    @Override
    public void swim() {
        System.out.println("狗会游泳");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.run();
        dog.swim();
    }
}

到此，抽象类和接口的基础内容就介绍完了，感谢观看。