Python基础-Day08 面向对象初步（2）

目录

1. 方法的动态性

2. 私有属性、私有方法（封装）

3. @property 装饰器

4. 继承

4.1 基本实现

4.2 类成员的继承和重写

4.3 查看类的继承层次结构

4.4 super()

5. 多态

5.1 基本实现

5.2 运算符重载

6. 组合

7. 设计模式-工厂模式

8. 设计模式-单例模式

---

1. 方法的动态性

【注】

1）在Python中，方法不能够进行重载，若在类体中定义多个重名的方法，则只有最后一个方法有效。

2）Python 是动态语言，可以动态地为类添加新的方法，或动态地修改类的已有的方法。

#测试方法的动态性

class Person():
    def study(self):
        print("努力学习！")

def play_game(s):
    print("{0}在玩游戏".format(s))

def study2(s):
    print("好好学习，天天向上！")

Person.play = play_game

p = Person()
p.study()
p.play()

Person.study = study2

p.study()


'''
输出结果：
努力学习！
<__main__.Person object at 0x000001691ADC2388>在玩游戏
好好学习，天天向上！
'''

2. 私有属性、私有方法（封装）

Python 对于类的成员没有严格的访问控制限制。关于私有属性和私有方法，有如下要点：

1）通常约定，两个下划线开头的属性是私有的(private)，其余为公共的(public)；

2）类内部可以访问私有属性(方法)；

3）类外部不能直接访问私有属性(方法)；

4）类外部可以通过 “_类名__私有属性(方法)名” 访问私有属性(方法)。

【注】方法本质上也是属性，只是可以通过()执行。

#测试私有属性、私有方法

class Employee:
    __company = "同福客栈"    #私有类属性

    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有实例属性

    def show(self):
        #类内部可直接访问私有属性        
        print("{0}所属公司是{1}".format(self.name,Employee.__company))   
        print("{0}的年龄是{1}".format(self.name,self.__age))
        self.__work()

    def __work(self):        #私有实例方法
        print("好好工作！")

p1 = Employee("老白",26)
print(p1.name)
p1.show()
print(p1._Employee__age)
p1._Employee__work()


'''
输出结果：
老白
老白所属公司是同福客栈
老白的年龄是26
好好工作！
26
好好工作！
'''

3. @property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”，用于帮助处理属性的读操作、写操作。

#测试@property的用法

class Employee:
    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary

    @property
    def salary(self):
        print("月薪为{0}".format(self.__salary))
        return self.__salary

    @salary.setter
    def salary(self,salary):
        if 0<salary<1000000:
            self.__salary = salary
        else:
            print("工资录入错误！必须在0-1000000之间。")

emp1 = Employee("老白",1000)
print(emp1.salary)

emp1.salary = -10


'''
输出结果：
月薪为1000
1000
工资录入错误！必须在0-1000000之间。
'''

4. 继承

4.1 基本实现

Python 支持多重继承，即一个子类可以继承多个父类，语法格式如下：

        class 子类类名(父类1[，父类2，...])：
                类体

若在类定义中没有指定父类，则默认父类是object 类。也就是说，object 是所有类的父类，object中定义了所有类共有的一些默认实现，如：__new__()。

#测试继承的基本使用

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

    def show_age(self):
        print("{0}的年龄是{1}".format(self.name,self.__age))

class Student(Person):
    def __init__(self,name,age,score):
        self.score = score
        Person.__init__(self,name,age)   
#构造函数中包含调用父类构造函数。子类并不会自动调用父类的__init__()，必须显式地调用它。

print(Student.mro())
s1 = Student("小贝",11,50)
s1.show_age()
print(s1._Person__age)     #子类实例访问父类的私有属性


'''
输出结果：
[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
小贝的年龄是11
11
'''

4.2 类成员的继承和重写

1）成员继承：子类继承了父类除构造方法之外的所有成员。

2）方法重写：子类可以重新定义父类中的方法，并覆盖父类的方法，也称为“重写”。

4.3 查看类的继承层次结构

通过类的方法 mro() 或者类的属性__mro__可以输出这个类的继承层次结构。

【注】Python 支持多继承，若在不同父类中存在名字相同的方法，则在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。

#测试mro()、多重继承方法解析顺序

class A:
    def aa(self):
        print("aa")
    def say(self):
        print("say AAA!")

class B:
    def bb(self):
        print("bb")
    def say(self):
        print("say BBB!")

class C(B,A):
    def cc(self):
        print("cc")

c = C()
print(C.mro())   #打印类的层次结构
c.say()          #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()


'''
输出结果：
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
say BBB!
'''

4.4 super()

在子类中，可以通过 super() 来获得父类的方法。

【注】super() 代表父类的定义，而非父类对象。

#super()

class A:
    def say(self):
        print("A: ",self)
        print("say AAA")

class B(A):
    def say(self):
        #A.say(self) 调用父类的say 方法
        super().say()      #通过super()调用父类的方法
        print("say BBB")

a = A()
a.say()
b = B()
b.say()


'''
输出结果：
A:  <__main__.A object at 0x000001CB43ABA388>
say AAA
A:  <__main__.B object at 0x000001CB43A1AFC8>
say AAA
say BBB
'''

5. 多态

5.1 基本实现

1）多态是方法的多态，属性没有多态；

2）多态的存在有两个必要条件：继承、方法重写。

#测试多态

class Animal:
    def shout(self):
        print("动物叫了一声。")

class Dog(Animal):
    def shout(self):
        print("小狗，汪汪汪！")

class Cat(Animal):
    def shout(self):
        print("小猫，喵喵喵！")

class Sheep(Animal):
    def shout(self):
        print("小羊，咩咩咩！")

def animalShout(a):
    if isinstance(a,Animal):
        a.shout()
    else:
        print("不是动物！")

d = Dog()
c = Cat()
s = Sheep()
animalShout(d)
animalShout(c)
animalShout(s)


'''
输出结果：
小狗，汪汪汪！
小猫，喵喵喵！
小羊，咩咩咩！
'''

5.2 运算符重载

Python 的运算符实际上是通过调用对象的特殊方法实现的。

#重载运算符

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

    def __add__(self, other):
        if isinstance(other,Person):
            return "{0}-{1}".format(self.name,other.name)
        else:
            return "不是同类对象，不能相加。"

    def __mul__(self, other):
        if isinstance(other,int):
            return self.name*other
        else:
            return "不是同类对象，不能相乘。"

p1 = Person("香芋")
p2 = Person("小郭")

x = p1 + p2
print(x)

print(p1*5)


'''
输出结果：
香芋-小郭
香芋香芋香芋香芋香芋
'''

6. 组合

使用“组合”，也可拥有另一个类的方法和属性。

#测试组合实现代码的复用

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("计算中……")

class Screen:
    def display(self):
        print("显示画面……")

c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()   #通过组合调用cpu对象的方法，相当于手机对象间接拥有了“cpu的方法”
m.screen.display()


'''
输出结果：
计算中……
显示画面……
'''

7. 设计模式-工厂模式

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

#测试工厂模式

class CarFactory:
    def createCar(self,brand):
        if brand == "奔驰":
            return Benz()
        elif brand == "宝马":
            return BMW()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌，无法制造"

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.createCar("比亚迪")
c2 = factory.createCar("奔驰")
print(c1)
print(c2)


'''
输出结果：
<__main__.BYD object at 0x000001624B5A8408>
<__main__.Benz object at 0x000001624B620B48>
'''

8. 设计模式-单例模式

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，减少了对系统资源的开销。

单例模式有多种实现方式，这里使用重写__new__()的方法。

#测试单例模式

class MySingleton:
    __obj = None
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self,name):
        if MySingleton.__init_flag == True:
            print("init……")
            self.name = name
            MySingleton.__init_flag = False

a = MySingleton("aa")
print(a)
b = MySingleton("bb")
print(b)


'''
输出结果：
init……
<__main__.MySingleton object at 0x000002C1E0394808>
<__main__.MySingleton object at 0x000002C1E0394808>
'''