面向对象基础总结

# 继承：它爹有的它都能拿来用
class LoL:
    def __init__(self,name,aggressivity ,hp):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
class AD(LoL):
    def info(self):
       print(‘%s射手英雄，她的攻击力为%s，血量为%s‘%(self.name,self.aggressivity,self.hp))
class AP(LoL):
    def info(self):
       print(‘%s法师英雄，她的攻击力为%s，血量为%s‘%(self.name,self.aggressivity,self.hp))
ad=AD(‘vn‘,85,450)
ap=AP(‘ez‘,60,450)
ad.info()#vn射手英雄，她的攻击力为85，血量为450
ap.info()#ez法师英雄，她的攻击力为60，血量为450

# 派生：子类定义自己的属性，如果与父类同名，以子类为准
# 派生的用法
# 方式一：指名道姓
class LoL:
    def __init__(self,name,aggressivity ,hp):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
class AD(LoL):
    print(‘%s射手英雄，她的攻击力为%s，血量为%s‘)
class AP(LoL):
    def __init__(self,name,aggressivity ,hp,magic):
        LoL.__init__(self,name,aggressivity,hp)
        self.magic=magic
    print(‘%s法师英雄，她的攻击力为%s，血量为%s‘)
ad=AD(‘vn‘,85,450)
ap=AP(‘ez‘,60,450,90)
print(ap.__dict__)#{‘name‘: ‘ez‘, ‘aggressivity‘: 60, ‘hp‘: 450, ‘magic‘: 90}
#方式二super()调用（严格依赖于继承关系）
class LoL:
    def __init__(self,name,aggressivity ,hp):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
class AD(LoL):
    print(‘%s射手英雄，她的攻击力为%s，血量为%s‘)
class AP(LoL):
    def __init__(self,name,aggressivity ,hp,magic):
        super().__init__(name,aggressivity ,hp)
        self.magic=magic
    print(‘%s法师英雄，她的攻击力为%s，血量为%s‘)
ad=AD(‘vn‘,85,450)
ap=AP(‘ez‘,60,450,90)
print(ap.__dict__)#{‘name‘: ‘ez‘, ‘aggressivity‘: 60, ‘hp‘: 450, ‘magic‘: 90}

#函数加括号调用，print(函数加括号)调用并得到其返回值 print(函数名)得到的是内存地址
# 绑定对象（只能对象用）
class A(object):
    def b(self):
        x = 2
        print(‘b‘)
        return x
a = A()
print(a.b)
# <bound method A.b of <__main__.A object at 0x000001F4393D9B38>>
print(A.b)
# <function A.b at 0x000001F4393DC730>
# 绑定类（类体内的对象和类东可以用）
class A(object):
    @classmethod
    def b(cls):
        x=2
        print(‘b‘)
        return x
a = A()
print(a.b())
# <bound method A.b of <class ‘__main__.A‘>>
print(A.b())
# <bound method A.b of <class ‘__main__.A‘>>

# 组合：一个类产生的属性的值，就是另一个类实例化的对象
# 一个类产生的对象，该对象有一个属性，这个属性的值，就是另一个类的实例化的对象
# 实例化 是你只要调用了类就是实例化对象，跟init方法无关 init只是用来初始化的
class Date:
    def __init__(self,year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day

    def info(self):
        print(‘‘‘
         年:%s
         月:%s
         日:%s
         ‘‘‘ % (self.year, self.mon, self.day))
class Oldboypeople:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Teacher(Oldboypeople):
    def __init__(self,name,age,sex,leven,salary):
        super().__init__(name,age,sex,)
        self.leven=leven
        self.salary=salary
    def inter(self):
        print(‘学习，选课‘)
class Student(Oldboypeople):
    def __init__(self,name,age,sex,id):
        super().__init__(name,age,sex)
        self.id=id
    def inter(self):
        print(‘学习，选课‘)
tea1=Teacher(‘lxx‘,18,‘man‘,30000,2000,)
stu1=Student(‘wxx‘,16,‘man‘,2002,)
dat=Date(2000,3,3)
tea1.birth=dat
tea1.birth.info()
stu1=dat
stu1.info()

#封装：用__的方法将类内的属性隐藏起来，对内不对外，
# __属性=_类名__属性名
class Teacher:
    __x=2
tea=Teacher()
print(tea.x)

class Teacher:
    def __x(self):
        print(‘x‘)
tea=Teacher()
tea.x()

class Teacher:
    def __init__(self,name):
        self.__name=name
tea=Teacher(‘lxx‘)
print(tea.__name)

# 使用property（将其伪装成数据属性）
class Peopele:
    def __init__(self,name,weight,higiht):
        self.name=name
        self.weight=weight
        self.higiht=higiht
    @property
    def bmi(self):
        return self.weight/(self.higiht*self.higiht)
obj=Peopele(‘egon‘,75,1.75)
print(obj.bmi)