分分钟搞定Java中的抽象类和接口！！！（abstract & interface）_java抽象类和接口

Java中的抽象类与接口

一、抽象类

1.抽象类的定义

概述：我们创建一个动物类，并且在这个类中创建动物对象，但是当你提到动物类，你并不知道我说的是什么动物，只有看到了具体的动物，你才知道这是什么动物，所以说动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物，同理我们也可以推理不同的动物，他们的行为习惯应该是不一样的，所以我们不应该在动物类中给出具体体现，而是给出一个声明即可。

概念：如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

2.如何定义一个抽象类

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用
给出具体的实现体。

语法格式：

abstract class Shape {
    public int a;//抽象类成员变量
    abstract public void func();//抽象类成员方法 
}
1
2
3
4

抽象类中也可以有其他普通方法、普通成员、构造方法和被static修饰的成员变量.

abstract class Shape {
    //普通成员变量
    public int b;
    public static int num;
    private int a;
    protected int c;
    
    abstract public void func1();//抽象方法

    public void func2() {
        //普通方法
    }
    public Shape() {
        //构造方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.关于抽象类的细节

（1）抽象类和普通类不一样，抽象类可以包含抽象方法。

（2）抽象方法是使用abstract修饰的（该方法不能被具体实现）。

（3）抽象类不能被实例化。

（4）如果一个普通类继承了一个抽象类，此时必须在普通类里面重写抽象类里面的抽象方法，否则报错。

Demo：

abstract class Shape {
    public abstract void func();
}
class Circle extends Shape{
    @Override
    public void func() {
        System.out.println("圆！");
    }
}
1
2
3
4
5
6
7
8
9

（5）如果一个抽象类A继承了抽象类B，此时类A当中不需要重写类B中的抽象方法，但如果类A再被普通类继承就需要重写类B中的抽象方法。

Demo：

abstract class B {
    public abstract void func();
}
abstract class A extends B {
    
}
class C extends A {
    @Override
    public void func() {
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

（6）抽象方法不能是private修饰。

（7）抽象方法也不能被final、static修饰，因为该类被继承，此方法还要重写。

（8）重写抽象方法也要遵守重写的规则（public>protected>default>private）。

4.抽象类的作用

讲到这里，可能很多人会说，这抽象类怎么这么复杂，明明普通类就能搞定的事情，为什么还要存在抽象类？

其实这里是因为实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类
了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。

---

二、接口

1.接口的概念

概念：接口（Interface），在Java编程语言中是一个抽象类型，是抽象方法的集合，接口用interface来声明，从而继承接口的抽象方法，在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.语法形式

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

Demo：

interface A {
    public abstract void func1();
    
    void func2();
}
1
2
3
4
5

注：func1和func2的修饰访问权限符都是一样的，都是public abstract.

3.关于接口的细节

（1）接口当中的成员方法不能有具体的实现.

（2）从JDK1.8开始，允许在接口中有可以实现的方法，但只能被default修饰.

（3）接口中可以实现静态方法.

（4）接口中的成员变量默认是public static final 修饰的.

（5）接口也不能被实例化.

A a = new A();//会报错的
1

（6）类和接口之间用implements来实现多个接口，类中必须重写接口当中的抽象方法，其他的方法可以选择重写或者不重写.

（7）子类重写抽象方法，必须是public修饰（因为抽象方法默认是public abstract修饰，所以子类只能为public）

（8）接口当中不能有静态代码块和构造方法( 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错），所以不能含有静态代码块以及静态方法，不能有构造方法原因是因为接口不能被实例化所以就不能有构造方法) .

（9）如果一个类没有实现接口当中所有的抽象方法，则此类必须设置为抽象类（用abstract修饰），如果这个抽象类被其他类继承必须要重写.

4.代码演示

Demo：

interface A {
    void func1();
}
class B implements A {
    @Override
    public void func1() {
        
    }
}
1
2
3
4
5
6
7
8
9

一个类也可以实现多个接口，使用逗号隔开.

Demo：

interface A {
    void func1();
}
interface B {
    void func2();
}
class C implements A,B {
    public C() {
        super();
    }

    @Override
    public void func1() {

    }

    @Override
    public void func2() {

    }
}	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.接口的使用

我们知道，如果某个设备需要向电脑中读取或者写入某些东西，这些设备一般都是采用USB方式与电脑连接的，我们发现，只要带有USB功能的设备就可以插入电脑中使用了，那么我们可以认为USB就是一种功能（接口），只要实现了USB标准的设备我们就认为它已经拥有了USB这种功能。下面是具体的例子：

Demo：

interface USB {
    void openEquipment();
    void closeEquipment();
}
class KeyBroad implements USB {
    @Override
    public void openEquipment() {
        System.out.println("正在打开键盘！");
    }
    @Override
    public void closeEquipment() {
        System.out.println("正在关闭键盘！");
    }
    public void inPut() {
        System.out.println("键盘正在输入！");
    }
}
class Mouse implements USB {
    @Override
    public void openEquipment() {
        System.out.println("正在打开鼠标！");
    }
    @Override
    public void closeEquipment() {
        System.out.println("正在关闭鼠标！");
    }
    public void click() {
        System.out.println("鼠标正在点击！");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //生成一个实现可USB接口（标准）的鼠标对象
        Mouse mouse = new Mouse();
        //调用Mouse里面的openEquipment方法
        mouse.openEquipment();
        //调用Mouse里面的click方法
        mouse.click();
        //调用Mouse里面的closeEquipment方法
        mouse.closeEquipment();
        System.out.println("=====================");
        //生成一个实现可USB接口（标准）的键盘对象
        KeyBroad keyBroad = new KeyBroad();
        //调用KeyBroad里面的openEquipment方法
        keyBroad.openEquipment();
        //调用KeyBroad里面的inPut方法
        keyBroad.inPut();
        //调用KeyBroad里面的closeEquipment方法
        keyBroad.closeEquipment();
    }
}


//执行结果：
正在打开鼠标！
鼠标正在点击！
正在关闭鼠标！
=====================
正在打开键盘！
键盘正在输入！
正在关闭键盘！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

6.实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接
口。

接下来，我们用一组例子来演示：

Demo：

interface Flying {
    void flying();
}
interface Running {
    void running();
}
interface Swimming {
    void swimming();
}
class Animal {
    public String name;

    public Animal() {

    }
}
class Dog extends Animal implements Running,Swimming {
    public Dog(String name) {
        super();
        this.name = name;
    }

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

    @Override
    public void swimming() {
        System.out.println(name+"正在游泳！");
    }
}
class Bird extends Animal implements Flying {
    public Bird(String name) {
        super();
        this.name = name;
    }

    @Override
    public void flying() {
        System.out.println(name+"正在飞！");
    }
}
class Duck extends Animal implements Flying,Swimming,Running {
    @Override
    public void flying() {
        System.out.println(name+"正在飞");
    }

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

    @Override
    public void swimming() {
        System.out.println(name+"正在游泳");
    }
    public Duck(String name) {
        super();
        this.name = name;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑");
        dog.running();
        dog.swimming();
        System.out.println("===========");
        Bird bird = new Bird("小翔");
        bird.flying();
        System.out.println("===========");
        Duck duck = new Duck("小嘎");
        duck.swimming();
        duck.flying();
        duck.running();
    }
}


//执行结果：
小黑正在跑！
小黑正在游泳！
===========
小翔正在飞！
===========
小嘎正在游泳
小嘎正在飞
小嘎正在跑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

7.接口之间的继承

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

举个例子，苹果和香蕉都是水果：

Demo：

interface Fruit{
    
}
interface Apple extends Fruit{
    
}
interface Banana extends Fruit {
    
}
1
2
3
4
5
6
7
8
9

---

三、抽象类和接口的区别

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

---

好啦！本期的博客就到此结束了，如果各位小伙伴们或者发现博客知识点有问题，欢迎后台tt！！！

---

博主在这里祝大家：

前程似锦！！！！