面向对象基础总结

对象是特征和金恩过的结合体

类一系列对象相似的特征和技能的结合体

注意：在定义类的阶段会立刻执行类体内的代码，然后将产生的名字存放于类的名称空间

继承

# 继承：它爹有的它都能拿来用
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}

继承的属性查找

查找顺序：

自己--->类--->父类--->object

在这我们要说一个概念：class 爹:的父类默认为object即class 爹(object):

#函数加括号调用，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

# 使用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)

多态
1 什么是多态
    多态指的是同一种事物多种形态
2、为什要用多态
    用基类创建一套统一的规则，强制子类去遵循（使用抽象类实现），这样便可以
    在不用考虑对象具体类型的前提下而直接使用对象下的方法
鸭子类型 python推崇的不是硬性设定，所以鸭子类型就是俗称约定的东西(你长得像鸭子，走路像鸭子，你就是鸭子)


classmethod(绑定类)跟绑定给对象是一样的，谁绑定的就谁来调用，谁帮定的就将谁当作第一参数传入


非绑定方法，就是一个普通函数
特性：既不跟类绑定，也不跟对象绑定，这意味着谁都能用
谁来用都是一个普通函数，也就是说没有自动传值的特性了

面向对象基础总结

猜你喜欢