2021-2-22阿杰学python，详解面向对象，继承

阿杰学python，详解面向对象，继承

class Example(object):
    # 构造函数:（用于初始化对象的属性)
    def __init__(self, height, money, power):
        self.height = height
        self.power = power
        """
        在属性前加双下划线后，该属性则被限制外部访问，一般来说要通过内部定义的函数来访问和更改，因为该
        属性的名称已经改变了，不同的解释器改变后的名称不同
        """
        self.__money = money

    # 通过get函数来访问具有私有属性的变量__money

    def get_money(self):
        print(self.__money)

    # 通过set函数来修改具有私有属性的变量__money

    def set_money(self, money):
        self.__money = money

    def eat(self, food):
        print("我已经吃了" + food)

    """
    def E_money(self):
        print("I have %s 元" % self.money)
    """

    # 析构函数(释放对象，释放后对象就不能再访问，程序结束自动释放或手动释放在函数里定义的对象会在函数结束时释放)

    def __del__(self):
        print("这里是析构函数")

    # 重写: 将函数重新定义写一遍
    """
    __str__():在调用print()打印对象是自动调用，是给用户用的，是一个描述对象的方法
    __repr__():是给机器用的,在python解释器里面直接敲对象名在回车后调用的方法
    注意:在没有str时，且有repr时，str = repr
    优点:当需要打印一个对象的所有属性时，可以使代码简便
    """

    def __str__(self):
        return "%s-%d" % (self.power, self.height)


example1 = Example(175, 100000, "big")
example1.eat("apple")
# example1.E_money()
print(type(example1.power))
print(example1)
example1.get_money()


# 单继承

class Father(object):
    def __init__(self, name, age, power, money):
        self.name = name
        self.age = age
        self.__money = money  # 这里的__money是私有属性，不可以直接访问
        self.power = power

    # 通过get和set函数来调用私有属性__money

    def get_money(self):
        return self.__money

    def set_money(self, money):
        self.__money = money

    def eat(self, food):
        print("我已经吃了%s" % food)

    def __str__(self):
        return "%s-%d-%d-%s" % (self.name, self.age, self.__money, self.power)

    def run(self):
        print("我正在跑步")


class Son1(Father):  # 注意这里括号里面写的是Father,也就是继承于Father，那么Father的所有属性和函数Son1都可以用
    def __init__(self, name, age):
        super(Son1, self).__init__(name, age, power="low", money=0)
        # 上面一行的写发也可以写成:super().__init__(name, age, power="", money=0)

    # 这里的重写函数__str__(self)是覆盖了原父类函数中的重写函数的，所以如果子类中有与父类重名的函数时会覆盖父类的函数，子类调用此函数时自身
    # 的这个函数而不是父类的

    # def __str__(self):
    # return "%s%d" % (self.name, self.age)


son = Son1("开心鬼", 18, )
print(son.name)
# 这里的eat()函数时继承了父类函数的eat()的
son.eat("banana")
print(son)


# 多继承
class Mother(object):
    def __init__(self, name, age, face_value):
        self.name = name
        self.age = age
        self.face_value = face_value

    def dress(self):
        print("我正在梳妆")

    def __str__(self):
        return "%s-%d-%d" % (self.name, self.age, self.face_value)


mother1 = Mother("clover", 21, 100)
print(mother1)
mother1.dress()


class Son2(Father, Mother):  # 注意这里括号里面写的是Father,Mother,那么Father和Mother的所有属性和函数Son1都可以用
    def __init__(self, name, age, power, money, face_value, game_name, grade):
        Father.__init__(self, name, age, power, money)
        Mother.__init__(self, name, age, face_value)
        # 这里因为加了子类自己的属性所以需要加入自己的参数
        self.grade = grade
        self.game_name = game_name

    def __str__(self):
        return "name-%s-age-%d-power-%s-face_value-%d-game_name-%s-grade-%d" % (
            self.name, self.age, self.power, self.face_value, self.game_name, self.grade)


son2 = Son2("cmx", 18, "big", 10000, 100, "王者", 150)
print(son2)
son2.eat("strawberry")
son2.dress()
son2.run()
# 因为money继承于父类，且属于私有属性，子类也不能直接调用用，一般来说只能用父类里面的get和set函数来调用
print(son2.get_money())

"""
# 多态: 一种事物的多种形态
    最终目标: 人可以喂任何一种动物
"""


class Animal(object):
    def __init__(self, name):
        self.name = name

    def eat(self, food):
        print(self.name + "已经吃了" + food)


class Person(object):
    def feed_animal(self, animal, food):
        print("给你食物")
        animal.eat(food)


jerry = Animal("jerry")
per1 = Person()
per1.feed_animal(jerry, "apple")

"""
对象属性和类属性
    类属性: 通过类名来调用
    对象属性: 通过对象来调用
    对象属性的优先级高于类属性
"""


class Temp(object):
    # 以下是类属性
    name = "cmx"
    age = 18

    # 以下是对象属性(对象属性通过__init__函数来初始化)
    def __init__(self, age, money):
        self.age = age
        self.money = money
    # __slots__变量是为了给属性添加限制，注意这里添加的内容是为了让这些属性值可更改，其他没有添加的属性只读不可更改
    # __slots__ = ("car", "speak", "voice", "money", "age")


temp1 = Temp(20, 10000)
temp2 = Temp(21, 20000)
print(Temp.name, Temp.age)
# 由于对象属性没有name， 所以这里的temp1.name 结果为"cmx"
print(temp1.name)
# 由于对象属性优先级高于类属性，所以这里temp1.age 的结果为20
print(temp1.age)
# 当删除temp1的age属性后，那么再打印的将是类的属性了
del temp1.age
print(temp1.age)
temp1.money = 10000

# 动态添加属性: 注意该属性仅这个对象拥有，这里也就是仅temp1拥有, temp2是没有的
temp1.car = "lamborghini"
print(temp1.car)


class Proper(object):
    def __init__(self, student_id, name, age):
        self.name = name
        self._student_id = student_id
        self.__age = age

    # 以下介绍几种@property的使用方法
    @property
    def say_name(self):
        return "my name is" + self.name

    @property
    def student_id(self):
        return self._student_id

    # 因为age是私有属性，以往我们用get和set来取值和赋值
    """
    def get_age(self):
        return self.__age
    def set_age(self, age):
        if age< 0:
            age = int(input("年龄输入有误，请核对后再输入"))
            self.__age = age
    """

    # 现在我们用@property来取值和赋值
    @property
    def age(self):
        return self.__age

    """
    python中的 @ *.setter装饰器可以总结为两个作用：(注意:这里的*必须是与@property下的函数同名的函数)
    对要存入的数据进行预处理
    设置可读属性(不可修改)
    """

    @age.setter
    def age(self, age):
        if age < 0:
            age = int(input("年龄输入有误，请核对后再输入"))
            self.__age = age


data1 = Proper(1910911311, "cmx", 5)
# 这里因为加了@property，现在的say_name是属性而不是函数，在后面加()会报错
print(Proper.say_name)
# 这里因为加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）,也使得_student_id无法被修改，因为用户不知道名称,保护了数据的安全
print(data1.student_id)
data1.age = 10
print(data1.age)

# 运算符重载:由于一般只有"+"用的比较多，这里就只介绍"+"
"""
    就如同一般使用+-*/, 因为其之只能是字符串或者数字之间运算，所以不能直接用于对象相加
"""


class Num(object):
    def __init__(self, num):
        self.num = num

    def __add__(self, other):
        return Num(self.num + other.num)

    def __str__(self):
        return "num = %d" % self.num


num1 = Num(45)
num2 = Num(30)
# 注意我们这里相加时是直接用对象相加的
print(num1 + num2)
# 若果没有运算符重载，我们得到结果时以上num1.num + num2.num