Python第7课：面向对象三特性示例

基础知识：

• 面向对象三特性
  • 封装
  • 继承
  • 多态

# 创建类
class demo:
	# 创建类中函数方法
    def demoFun(self):   # self:特殊参数，必填
    	# 方法内容
    	print("方法内容") 	
# 创建对象
odj = demo()   

封装

class demo1:
    def demo1Fun(self):
        print("我是方法")
obj = demo1()  # 创建对象
obj.demo1Fun() # 通过对象调用方法

我是方法

class demo2:
    # 构造方法，类实例化时初始化数据
    def __init__(self,name,age):
        self.name=name
        self.age=age
    # show方法
    def show(self):
        print('当前对象的姓名为：'+self.name+',今年'+str(self.age)+'岁了！')
        
# 带参构造方法创建对象
obj1 = demo2("李明特",22)
obj2 = demo2("杨同学",18)

obj1.show()
obj2.show()

当前对象的姓名为：李明特,今年22岁了！
当前对象的姓名为：杨同学,今年18岁了！

self

• 是个形式参数
• 当执行obj1 = demo2(‘李明特’,22)时，self等于obj1

通过self调用被封装的内容

class calculator:
    def __init__(self,a,b):
        self.a = a
        self.b = b
    def jia(self):
        print(self.a + self.b)
    def jian(self):
        print(self.a - self.b)
    def cheng(self):
        print(self.a * self.b)
    def chu(self):
        print(self.a / self.b)
cal = calculator(2,4)
cal.jia()
cal.jian()
cal.cheng()
cal.chu() 

6
-2
8
0.5

练习1

• 游戏程序
  • 创建三个人物：
    • 铠甲勇士，男，18，战斗力1000
    • 迪迦奥特曼，男，20，战斗力2000
    • 喜羊羊，男，10，战斗力20
  • 游戏场景
    • 战斗
    • 读书
    • 看报

# 练习1
class person:
    def __init__(self,name,sex,age,power):
        self.name = name
        self.sex = sex
        self.age = age
        self.power = power
    def fight(self):
        print("{},{}岁。在打架".format(self.name,self.age))
    def book(self):
        print("{},{}岁。在读书".format(self.name,self.age))
    def newspaper(self):
        print("{},{}岁。在读报，".format(self.name,self.age))
kaijia = person("铠甲勇士","男",18,1000)
dijia = person("迪迦奥特曼","男",20,2000)
xiyang = person("喜羊羊","男",10,20)

kaijia.fight()
dijia.book()
xiyang.newspaper()

铠甲勇士,18岁。在打架
迪迦奥特曼,20岁。在读书
喜羊羊,10岁。在读报，

继承

• 将多个类的共同方法提取到父类中，子类仅需继承父类即可调用父类方法
• 除了子类和父类，还有叫派生类和基类的，称呼不同而已

多继承

• 继承多个类时，寻找方法的方式有两种
• 深度优先：
  • 说白了深度优先遍历就是一种不撞南墙不会头的算法，他会把一条路走完之后再回溯到有分叉的节点继续遍历
    • 当类是经典类时

                class C1:
                    pass
                class C2(C1):
                    pass
                # C1和C2是经典类

• 广度优先：
  • 广度优先搜索是按层来处理顶点，距离开始点最近的那些顶点首先被访问，而最远的那些顶点则最后被访问
    • 当类是新式类时

                class N1(object):
                    pass
                class N2(N1):
                    pass
                # N1和N2是新式类 

• 在上述查找过程中一旦找到则寻找过程立即中断，不会继续查找了

object

• python3中默认加载了object（即便你没有写上object）
• 拥有更多的可操作对象，是类的高级特性，对于着手写框架或者写大型项目的选手这些特性才比较有用。

# py3中默认加载object
class test:
    name = "不带object类"
a = test
# 内置函数dir()能够显示没模块中定义了哪些名字，返回一个排序好的字符串列表
# 包括变量名、函数名、模块名
print(dir(a))

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']

# 练习2
# 定义一个动物类
class animal:
    def jiao(self):
        print("{}{},叫".format(self.breed,self.name))
    def eat(self):
        print("{}{},吃".format(self.breed,self.name))
        
# 小猫咪实例
class cat(animal):      # 括号内写继承的父类名称
    def __init__(self,name):
        self.name = name
        self.breed = '小猫'
    def maojiao(self):
        print("小猫喵喵叫")
        
# 小狗实例
class dog(animal):      # 括号中写继承的父类名称
    def __init__(self,name):
        self.name = name
        self.breed = '小狗'
    def goujiao(self):
        print("小狗汪汪叫")

# 实例化对象
cat1 = cat("汤姆")
dog1 = dog("山姆")

cat1.eat() # 调用父类方法
dog1.jiao() # 调用父类方法
print("-------------")
cat1.maojiao() # 调用子类方法
dog1.goujiao() # 调用子类方法

小猫汤姆,吃
小狗山姆,叫
-------------
小猫喵喵叫
小狗汪汪叫

多态

• 多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式
• 继承是多态的前提，函数重写就是多态的体现形式

练习3

• 饲养员喂养熊猫和猴子、老虎等动物
  • 定义饲养员的类和动物的类
  • 定义猴子类，熊猫类等继承动物类
  • 在饲养员中定义类成员方法，喂养

# 练习3
# 1.定义饲养员类和动物类
class Person:
#     def feedPanda(self,panda):
#         print("饲养员用 " + panda.food + " 喂养 " + panda.name)
#     def feedMonkey(self,monkey):
#         print("饲养员用 " + monkey.food + " 喂养 " + monkey.name)
#     def feedTiger(self,tiger):
#         print("饲养员用 " + tiger.food + " 喂养 " + tiger.name)
    def feedAnimal(self,ani):   
        # 随便写个形参代表一个具体动物，在下面将动物实例传进来
        print("饲养员用 " + ani.food + " 喂养 " + ani.name)
class Animal:
    def __init__(self,name,food):
        self.name = name
        self.food = food
    def eat(self):
        print(self.name + " 在吃 " + self.food)

# 2.定义猴子、熊猫、老虎类继承动物类
class Monkey(Animal):
    def __init__(self,name,food):
        super().__init__(name,food)
class Panda(Animal):
    def __init__(self,name,food):
        super().__init__(name,food)
class Tiger(Animal):
    def __init__(self,name,food):
        super().__init__(name,food)

panda = Panda("阿宝","包子")
monkey = Monkey("吉吉国王","香蕉")
tiger = Tiger("悍娇虎","面条")
# 创建一个饲养员实例
P = Person()
P.feedAnimal(panda)
P.feedAnimal(monkey)
P.feedAnimal(tiger)
# P.feedMonkey(monkey)
# P.feedPanda(panda)
# P.feedTiger(tiger)

饲养员用 包子 喂养 阿宝
饲养员用 香蕉 喂养 吉吉国王
饲养员用 面条 喂养 悍娇虎

super()的使用

子类继承父类，但不重写构造方法__init__(初始化),那么子类会自动继承父类属性和方法

class fu:
    def __init__(self):
        self.name = "李同学"
        self.age = "20"
    def hello(self):
        print(self.name+"对你说他今年"+self.age+"岁了,并向你问好！")
        print("已继承父类方法")
class zi(fu):
    pass
F = fu()
Z = zi()
print("子类继承父类的属性:"+Z.name+"今年"+Z.age+"岁")
Z.hello()

子类继承父类的属性:李同学今年20岁
李同学对你说他今年20岁了,并向你问好！
已继承父类方法

子类继承父类，重写构造方法__init__(初始化),但不使用super初始化父类构造方法，那么子类不会自动继承父类的属性，会继承方法

class fu:
    def __init__(self):
        self.name = "李同学"
        self.age = "20"
    def hello(self):
        # print(self.name+"对你说他今年"+self.age+"岁了，并向你问好！") 
        # 子类在不适用super的情况下继承的父类方法不能有子类没有的属性，这里子类没有name和age
        # 但是子类可以正常继承父类方法
        print("已继承父类方法")
class zi(fu):
    def __init__(self):
        self.lover = "杨同学"
F = fu()
Z = zi()
print("父类属性："+F.name+"今年"+F.age+"岁")
# print("子类属性："+Z.name+"今年"+Z.age+"岁")   没有继承父类的属性
# 这句话会报错：AttributeError: 'zi' object has no attribute 'name'
# 因为子类在没用super初始化父类构造方法时不会继承父类属性，但是会继承方法
print("子类属性："+Z.lover)
Z.hello()   # 正常继承了父类方法

父类属性：李同学今年20岁
子类属性：杨同学
已继承父类方法

子类继承父类，重写构造函数__init__(初始化)，且使用super初始化父类构造函数，那么子类会自动继承父类的属性和方法

class fu:
    def __init__(self):
        self.name = "李同学"
        self.age = "20"
    def hello(self):
        print(self.name+"对你说他今年"+self.age+"岁了，并向你问好！")
        print("已继承父类方法")
class zi(fu):
    def __init__(self):
        super().__init__()
        self.lover = "杨同学"
F = fu()
Z = zi()
print("父类属性:"+F.name+"今年"+F.age+"岁了")
print("子类属性:"+Z.name+"今年"+Z.age+"岁了,女朋友是"+Z.lover)    # 这里子类继承了父类的属性值
Z.hello()   # 继承了父类方法

父类属性:李同学今年20岁了
子类属性:李同学今年20岁了,女朋友是杨同学
李同学对你说他今年20岁了，并向你问好！
已继承父类方法