Java 抽象类 /接口的原理 + 使用 + 语法 + 特性 + 作用

---

前言

本次分享的内容需要懂得之前讲到过的继承，如果有需要可以去之前的文章补补课

---

一、抽象类

1.抽象类概念

面向对象技术中，所有的对象都是通过new一个类来创建的。
而抽象类很特殊，抽象类是不可以直接通过new来创建对象的 。

因为抽象类并不是完整的一个类，他的信息是不完整的。

如上图，哺乳类就是一个抽象类

• 熊猫类，大象类，狮子类，都是哺乳类的子类；都继承了哺乳类。
• 虽然哺乳类中也存在吃，喝，睡等方法，但是哺乳类并不确定具体是什么动物， 因此这些方法都是无法实现的。
• 因为哺乳类不是一个具体的物体，他的方法都无法实现，所以他就可以定义成一个抽象类，用来让其他类继承。

2.抽象类语法

• 抽象类的定义方法，与普通类的定义方法大致相同，唯一的区别就是class前多了一个abstract。

//被abstract修饰的类是抽象类
public abstract class animal {
	//被abstr修饰的方法是抽象方法
    abstract public void eat();
    abstract public void sleep();
	
	//抽象类也是类，也可以有普通的成员属性与方法
    public void drink() {
        System.out.println("喝水");
    }

    double weight;//重量
}

• 抽象类也是类，其中可以有普通属性和方法。

3.抽象类特性

1. 抽象类不可以直接new对象。
2. 抽象方法不可以封装起来，也就是不可以用private修饰。
3. 抽象方法不能被final和static修饰，因为抽象方法，一定要被子类重写。
4. 抽象类必须被继承，且子类必须要重写抽象方法，否则子类也是一个抽象类，且子类必须被abstract修饰。
5. 抽象类中可以没有抽象方法，但是有抽象方法的类只能是抽象类。
6. 抽象类也可以有构造方法，供子类来初始化父类的成员变量。

4.抽象类作用

• 普通的类也可以被继承，普通方法也可以被重写，那么为什么要用抽象类呢？

其实这也就是多了一次保障，防止你不小心，使用到了父类的方法。
普通方法没有被重写是不会报错的，而抽象方法如果没有被重写则会报错。
算是多了一层查验。

二、接口

1.接口概念

笔记本电脑上的各个接口，可以插符合这些接口协议的外接设备。
java中的接口也类似如此，
接口可以看作是一个为其他类提供的规范，是引用数据类型。

2.接口语法

接口的定义格式与定义类的格式基本相同，将class关键字换成interface关键字，就定义了一个接口。

public interface 接口名称{
// 抽象方法
public abstract void method1(); 
// public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

3.接口使用

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

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

• 子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系

下面以动物园调用动物狮子，动物熊猫，动物大象上班举例

1. 行为接口：包含上班，下班功能
2. 动物园类：包含开园，闭园，调用动物功能
3. 熊猫类：实现行为接口，并具备与游客嬉戏功能
4. 大象类：实现行为接口，并具备运载顾客功能
5. 狮子类：实现行为接口，并具备捕猎功能

//行为接口
public interface Actions {
    void work();
    void quitting();
}

//大象类，实现了行为接口
public class Elephant implements Actions{
    @Override
    public void work() {
        System.out.println("大象上班了");
    }

    @Override
    public void quitting() {
        System.out.println("大象下班了");
    }

    public void carry() {
        System.out.println("大象在运载顾客");
    }
}

//狮子类，实现了行为接口
public class Lion implements Actions{
    @Override
    public void work() {
        System.out.println("狮子上班了");
    }

    @Override
    public void quitting() {
        System.out.println("狮子下班了");
    }
    public void hunting() {
        System.out.println("狮子在捕猎");
    }
}

//熊猫类，实现了行为接口
public class Panda implements Actions{
    @Override
    public void work() {
        System.out.println("熊猫上班了");
    }

    @Override
    public void quitting() {
        System.out.println("熊猫下班了");
    }
    public void frolic() {
        System.out.println("熊猫在与游客嬉戏");
    }
}

//动物园类，来调用动物
public class Zoo {
    public void commenced() {
        System.out.println("动物园开工了");
    }
    public void rest() {
        System.out.println("动物园休息了");
    }
    public void daily(Actions animal) {
        animal.work();
        if(animal instanceof Panda) {
        //Java中为了提高向下转型的安全性，
        //引入了 instanceof ，如果该表达式为true，则可以安全转换。
		//表达式为:(父类 instanceof 子类)
            Panda panda = (Panda) animal;
            panda.frolic();
        } else if(animal instanceof Elephant) {
            Elephant elephant = (Elephant) animal;
            elephant.carry();
        } else if(animal instanceof Lion) {
            Lion lion = (Lion) animal;
            lion.hunting();
        }
        animal.quitting();
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.commenced();
        zoo.daily(new Panda());
        zoo.daily(new Lion());
        zoo.daily(new Elephant());
        zoo.rest();
    }
}

4.接口特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象
2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)
3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
4. 重写接口中方法时，不能使用默认的访问权限
5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
6. 接口中不能有静态代码块和构造方法
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
9. jdk8中：接口中还可以包含default方法。

5.实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一个动物。

public class Animal {
    public String name;

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

再提供跑，飞，游泳这三个接口

public interface Run {
    void running();
}

public interface Fly {
    void flying();
}

public interface Swim {
    void swimming();
}

接下来创建一个会跑，会飞也会游泳的动物，鸭子。

public class Duck extends Animal implements Run,Fly,Swim{
    public Duck(String name) {
        super(name);
    }

    @Override
    public void running() {
        System.out.println(name + "正在跑步");
    }

    @Override
    public void flying() {
        System.out.println(name + "正在飞行");
    }

    @Override
    public void swimming() {
        System.out.println(name + "正在游泳");
    }
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口

接口与继承的区别

继承	继承
子类拥有父类的所有	只拥有了接口的这一特性

6.接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字

interface Run {
void run();
}

interface Swim {
void swim();
}

// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends Run, Swim {
}

class Frog implements IAmphibious {
...
}

通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 Run 方法, 也需要实现 Swim 方法

接口间的继承相当于把多个接口合并在一起。

总结

以上就是今天要讲的内容，本次的内容并不是很难，但是也要多加练习，才能得心应手的应用。

祝各位一路长红。