1
package com.oo.demo;
2
public class Pig implements IAnimal{ //如下每个函数都需要详细实现
3
    public void eat(){
4
        System.out.println("Pig like to eat grass");
5
    }
6

7
    public void run(){
8
        System.out.println("Pig run: front legs, back legs");
9
    }
10

11
    public void sleep(){
12
        System.out.println("Pig sleep 16 hours every day");
13
    }
14

15
    public void speak(){
16
        System.out.println("Pig can not speak"); }
17
}

1
package com.oo.demo;
2
public class Person2 implements IAnimal {
3
    public void eat(){
4
        System.out.println("Person like to eat meat");
5
    }
6

7
    public void run(){
8
        System.out.println("Person run: left leg, right leg");
9
    }
10

11
    public void sleep(){
12
        System.out.println("Person sleep 8 hours every dat");
13
    }
14

15
    public void speak(){
16
        System.out.println("Hellow world, I am a person");
17
    }
18
}

1
package com.oo.demo;
2

3
public class Tester03 {
4
    public static void main(String[] args) {
5
        System.out.println("===This is a person===");
6
        IAnimal person = new Person2();
7
        person.eat();
8
        person.run();
9
        person.sleep();
10
        person.speak();
11

12
        System.out.println("\n===This is a pig===");
13
        IAnimal pig = new Pig();
14
        pig.eat();
15
        pig.run();
16
        pig.sleep();
17
        pig.speak();
18
    }
19
}

1
# 定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
2
class Interface:
3
    # 定接口函数read
4
    def read(self):
5
        pass
6

7
    # 定义接口函数write
8
    def write(self):
9
        pass
10

11

12
# 文本，具体实现read和write
13
class Txt(Interface):
14
    def read(self):
15
        print('文本数据的读取方法')
16

17
    def write(self):
18
        print('文本数据的读取方法')
19

20

21
# 磁盘，具体实现read和write
22
class Sata(Interface):
23
    def read(self):
24
        print('硬盘数据的读取方法')
25

26
    def write(self):
27
        print('硬盘数据的读取方法')
28

29

30
class Process(Interface):
31
    def read(self):
32
        print('进程数据的读取方法')
33

34
    def write(self):
35
        print('进程数据的读取方法')

1
# 一切皆文件
2
import abc  # 利用abc模块实现抽象类
3

4

5
class All_file(metaclass=abc.ABCMeta):
6
    all_type = 'file'
7

8
    # 定义抽象方法，无需实现功能
9
    @abc.abstractmethod
10
    def read(self):
11
        '子类必须定义读功能'
12
        pass
13

14
    # 定义抽象方法，无需实现功能
15
    @abc.abstractmethod
16
    def write(self):
17
        '子类必须定义写功能'
18
        pass
19

20

21
class Txt(All_file):
22
    pass
23

24

25
t1 = Txt()  # 报错,子类没有定义抽象方法
26

27
r'''
28
Traceback (most recent call last):
29
  File "E:\PythonProjects\10面向对象\05组合.py", line 131, in <module>
30
    t1=Txt() #报错,子类没有定义抽象方法
31
TypeError: Can't instantiate abstract class Txt with abstract methods read, write
32
'''

1
# 一切皆文件
2
# 利用abc模块实现抽象类
3
import abc
4

5

6
class All_File(metaclass=abc.ABCMeta):
7
    all_type = 'file'
8

9
    # 定义抽象方法，无需实现功能
10
    @abc.abstractmethod
11
    def read(self):
12
        '子类必须定义读功能'
13
        pass
14

15
    # 定义抽象方法，无需实现功能
16
    @abc.abstractmethod
17
    def write(self):
18
        '子类必须定义写功能'
19
        pass
20

21

22
# 子类继承抽象类，但是必须定义read和write方法
23
class Txt(All_File):
24
    def read(self):
25
        print('文本数据的读取方法')
26

27
    def write(self):
28
        print('文本数据的读取方法')
29

30

31
# 子类继承抽象类，但是必须定义read和write方法
32
class Sata(All_File):
33
    def read(self):
34
        print('硬盘数据的读取方法')
35

36
    def write(self):
37
        print('硬盘数据的读取方法')
38

39

40
# 子类继承抽象类，但是必须定义read和write方法
41
class Process(All_File):
42
    def read(self):
43
        print('进程数据的读取方法')
44

45
    def write(self):
46
        print('进程数据的读取方法')
47

48

49
test_file = Txt()
50

51
video_file = Sata()
52

53
process_file = Process()
54

55
# 这样大家都是被归一化了,也就是一切皆文件的思想
56
test_file.read()
57
video_file.write()
58
process_file.read()
59

60
print(test_file.all_type)
61
print(video_file.all_type)
62
print(process_file.all_type)
63

64
# 文本数据的读取方法
65
# 硬盘数据的读取方法
66
# 进程数据的读取方法
67
# file
68
# file
69
# file