关于面向对象三大特征： 封装/继承/多态 面向对象设计原则：开闭/单一/倒置，day13 

继承：
   多个子类在概念上一致的，所以就抽象出一个父类.
   多个子类的共性，可以提取到父类中.
   在实际开发过程中：
   从设计角度讲：先有子，再有父.
   从编码角度讲：先有父,再有子.

python 内置函数
1. 判断对象是否属于一个类型
1 # "老师对象" 是 一个老师类型
2 print(isinstance(t01, Teacher))  # True
3 # "老师对象" 不是 一个学生类型
4 print(isinstance(t01, Student))  # Flase
5 # "老师对象" 是 一个人类型
6 print(isinstance(t01, Person))  # True
View Code
2.判断一个类型是否属于另一个类型
1 # "老师类型" 不是 一个学生类型
2 print(issubclass(Teacher, Student))  # Flase
3 # "老师类型" 不是 一个学生类型
4 print(issubclass(Teacher, Person))  # True
5 # "人类型" 不是 一个老师类型
6 print(issubclass(Person, Teacher))  # Flase
View Code
子类若没有构造函数，使用父类的.
子类若具有构造函数，则必须先调用父类构造函数
super().__init__(name)


继承 -- 设计(1)

""
    继承 -- 设计(1)
"""


# 需求：老张开车去东北
# 变化：    坐飞机
#          坐火车
#          骑车
#          ...

# 违反了开闭原则：
#  如果增加火车，需要增加"火车类",再修改人类中的go_to方法.

class Person:
    def __init__(self, name):
        self.name = name

    def go_to(self, vehicle, str_position):

        # 如果是汽车
        if type(vehicle) == Car:
            vehicle.run(str_position)
        # 否则如果是飞机
        elif type(vehicle) == Airplane:
            vehicle.flay(str_position)


class Car:
    def run(self, str_position):
        print("汽车开到", str_position)


class Airplane:
    def flay(self, str_position):
        print("飞机飞到", str_position)


p01 = Person("老张")
c01 = Car()
a01 = Airplane()
p01.go_to(c01, "东北")
p01.go_to(a01, "东北")
View Code
继承 -- 设计(2)

 1 """
 2     继承 -- 设计(2)
 3     练习:exercise03.py
 4 """
 5 
 6 
 7 # 需求：老张开车去东北
 8 # 变化：    坐飞机
 9 #          坐火车
10 #          骑车
11 #          ...
12 
13 class Vehicle:
14     """
15         交通工具,代表所有具体的交通工具(火车/飞机..)
16         继承：隔离子类变化,将子类的共性(坐/飞..)提取到父类(运输)中.
17     """
18 
19     def transport(self, str_position):
20         # 因为父类太过于抽象，所以写不出方法体.
21         pass
22 
23 
24 # 客户端代码，用交通工具。
25 class Person:
26     def __init__(self, name):
27         self.name = name
28 
29     def go_to(self, vehicle, str_position):
30         # 多态：调用父，执行子.
31         # 调用的是交通工具的运输方法
32         # 执行的是飞机的运输方法或者汽车的运输方法
33         vehicle.transport(str_position)
34 
35 
36 # -------以上是架构师完成的--以下是程序员完成的-----
37 class Car(Vehicle):
38     def transport(self, str_position):
39         print("汽车开到", str_position)
40 
41 
42 class Airplane(Vehicle):
43     def transport(self, str_position):
44         print("飞机飞到", str_position)
45 
46 
47 p01 = Person("老张")
48 c01 = Car()
49 a01 = Airplane()
50 p01.go_to(c01, "东北")
51 p01.go_to(a01, "东北")
View Code
体会：面向对象三大特征：
        封装/继承/多态
     面向对象设计原则：
        开闭/单一/倒置







            

            
posted @ 
2019-06-18 23:07 
__SAIL 
阅读(163) 
评论(0) 
 
收藏 
举报