面向对象基础复习

面向对象基础

什么是对象

对象是特征和技能的结合体

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

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

继承

继承是一种新建类的方式，在python中支持一个儿子继承多个类新建类的类称为子类或派生类

继承可以减少代码冗余但是它是强耦合所以写程序的时候还是尽量少用

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

补充：

　　在菱形继承的背景下:

　　深度优先和广度优先

　　深度优先一条条分支一路找到头以从左往右的顺序

　　广度优先也是一条条分支找以从左往右的顺序只不过它只找到金字塔顶端的那个父类的前面一个然后就会去找下一条分支

绑定方法：

　　绑定给谁，就应该谁来用，谁来用就把谁当第一个参数传入

　　绑定方法分为三种绑定给类用的绑定给对象用的静态方法

　　类里面定义的默认绑定给对象用的

　　带@classmethod是绑定给类用的

　　带@startmethod静态方法既不绑定给类用也不绑定给对象用谁都可以用就是个普通的函数没有自动传值这么一说

#函数加括号调用，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'>>
# staticmethod
# 非绑定方法，就是一个普通函数
# 特性：既不跟类绑定，也不跟对象绑定，这意味着谁都能用
# 谁来用都是一个普通函数，也就是说没有自动传值的特性了

组合

　　描述的是类与类之间的关系，是一种什么有什么的关系

　　一个类的属性值是另外一个类实例化的对象

# 组合：一个类产生的属性的值，就是另一个类实例化的对象
# 一个类产生的对象，该对象有一个属性，这个属性的值，就是另一个类的实例化的对象
# 实例化 是你只要调用了类就是实例化对象，跟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

    def bmi(self):
        return self.weight/(self.higiht*self.higiht)
obj=Peopele('egon',75,1.75)
print(obj.bmi())
# 使用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推崇的不是硬性设定，所以鸭子类型就是俗称约定的东西(你长得像鸭子，走路像鸭子，你就是鸭子)

面向对象基础复习

猜你喜欢