类和对象 子类父类

 

实例化对象

 

实例化对象格式
对象变量 = 类()
类的类型为 type

类的值就是类本身

对象的类型为类

检测类和对象的成员

 

检测类成员       类名.__dict__

检测对象成员	  对象.__dict__

类和对象成员的操作

类成员操作
访问类中成员
    类名.成员属性名
    类名.成员方法名()      （没有参数要求，所有方法都可以通过类访问）

修改类中成员
    类名.成员属性名 = 值
    类名.成员方法名 = 新值  （如果需要函数只能用lambda）

删除类中成员
    del 类名.成员属性名
    del 类名.成员方法名

添加类中成员
    类名.新成员属性名 = 值
    类名.新成员方法名 = 值  （如果需要函数只能用lambda）
对象成员操作
访问对象中成员
    对象变量.成员属性名
    对象变量.成员方法名()  （必须有一个用于接收对象本身的形参）

修改对象中成员
    对象变量.成员属性名 = 值
    对象变量.成员方法名 = 新值  （如果需要函数只能用lambda）

删除对象中成员
    del 对象变量.成员属性名
    del 对象变量名.成员方法名

添加对象中成员
    对象变量.新成员属性名 = 值
    对象变量.新成员方法名 = 值 （如果需要函数只能用lambda）

 

例子：

 

#人类
class Human:
    #成员属性
    sex = '男'
    age = 18
    color = 'yellow'
    name = '小丽'
    #成员方法
    #非绑定类的方法(设计者决定)
    def eat(self):
        print('吃香的和拉的')
    #绑定类的方法!(设计者决定)
    def drink(self):
        print('喝辣的!来',self,'碗胡辣汤')
    def piao(self):
        #打印self变量
        print('在方法种打印变量',self)
        print('朴一生~')
    #绑定类的方法
    def du():
        print('我才钟是男的~!')
#实例化对象
zl = Human()
print('实例化一个对象',zl)
#调用方法
zl.piao()
#self 代表当前对象本身,以对象方式访问方法,对象会变成一个默认的实参传入方法
#访问没有形灿的方法du
#zl.du()#无法访问
Human.du()
#绑定类的方法:通过类访问的方法称之为绑定类的方法
#非绑定类的方法:通过类或者对象都可以访问的方法称之为非绑定类的方法
#设定通过类来访问drink()
Human.drink(5)
#设定对象和类都可以访问eat()
Human.eat(0)
zl.eat()

#私有化封装

#人类
class DuanZhiPeng:
    #属性
    name = '思乐智'
    sex = '男'
    age = '18'
    #私有化封装
    __heart ='red' #逻辑上心脏不允许访问和修改
    eye = '1.5'
    #方法
    def eat(self):
        print('aaa')
    #
    def la(self):
        print('bbb')
    def say(self):
        print('ccc')
    def sendblood(self):
        print('使用',self.__heart,'输血')

dzp = DuanZhi()
dzp.sendblood()

三个级别：
1.私有化封装 ：

类中/对象中 可以访问   类外/对象外  不可以访问   子类/子类对象     不可以访问
2.受保护的封装：

  类中/对象中      可以访问

  类外/对象外      可以访问（原则上类外不行，但是没实现）

  子类/子类对象     可以访问

3.公共的封装

   

类中/对象中            可以访问

类外/对象外            可以访问

子类/子类对象            可以访问

'''
#私有化封装：在成员名称之前添加__  ， python私有化是骗人的，是通过改名策略实现的，真实的成员变成了_类名_成员名
#1.对象/类外部无法访问
#2.类/对象内部可以访问

#以下方法仅供参考
#print(dzp._DuLi__heart)
#dzp._DuLi__sendblood()

 

#继承的问题

 

#父类：被其他类继承的类称之为父类
#子类：继承其他类的类称之为子类

 

#刘备类
class LiuBei():
    #属性
    firstName='备'
    familyName = '刘'
    sex = '男'
    age = 48
    #私有化成员
    __wife = ['甘夫人','糜夫人','孙尚香']
    #方法
    def makeshoes(self):
        print('编草鞋')
    def dropbaby(self):
        print('摔孩子')
    def sleep(self):
        print('睡觉觉')
    #绑定类的方法
    def shuajian():
        print('耍贱天下第一')
    def xxoo(self):
        print('一起玩耍',self.__wife)

#刘禅类
class LiuChan(LiuBei):#继承
    #添加子类独有的属性
    weight = '360斤'
    secondfather = '诸葛亮'
    #添加子类独有的方法
    def newxxoo(self):  #无法调用父
        print(self.__wife)
    #吃鸡的方法（子类独有法
    def eatchicken(self):
        print('吃鸡方法')
    #重载父亲
    def makeshoes(self):
        print('刘禅大哥做皮鞋')
    #c重载
    def sleep(self):
        #增加属羊的操作
        print('一只羊，两只羊，三只羊')
        #使用父类的功能（从父类中获取功能
        super().sleep()
    #重载刷剑功能
    def shuajian():
        #添加自己的功能
        print('我拿起一把饮')
        #调用父亲刷剑功能
        LiuBei.shuajian()

#s实例化刘备对象
lb = LiuBei()
#访问成员
print(lb.familyName)
print(lb.firstName)
print(lb.sex)
print(lb.age)
lb.sleep()
lb.xxoo()
LiuBei.shuajian()

#实例化刘禅对象
lc = LiuChan()
print(lc.firstName)
print(lc.familyName)
print(lc.sex)
print(lc.age)
lc.sleep()
lc.xxoo()#可以访问私有成员的原因是因为父类操作类该方法并且调用父亲的私有成员
#测试子类是否可以使用父亲私有成员（方法必须是子类中的方法，因为继承的方法依然在父类中
#lc.newxxoo()
#访问子类独有的方法吃鸡
lc.eatchicken()
#访问子类带有的属性
print(lc.weight)
print(lc.secondfather)

#访问重载的方法 makeshoes
lc.makeshoes()
lc.sleep()
LiuChan.shuajian()

'''
1.子类继承父亲则具有父亲的所有成员（私有成员除外）
2.子类继承父亲不是将父亲的成员复制到子类中，而是通过父亲间接调用
3.任何的类都是默认继承object类（在Python2.7中必须写继承，python中可以不写）万物皆对象，任何类都是object类的子类
4.子类可以设置子类独有的成员属性和方法，用于扩充子类的功能
5.子类可以重载父亲的方法，访问方法的时候，子类则会访问自己重载的方法，而不会访问父亲的原有方法
6.重载父亲的方法过程如果还需要调用父亲的方法，可以使用super().方法()的形式进行调用（对象调用的时候）也可以使用类名.方法()通过类调用的时候

'''

#打印类中的成员
print(LiuBei.__dict__)
print(LiuChan.__dict__)

 

#多继承

 

#爷爷类
class YeYe:
    #打麻将
    def damajiang(self):
        print('十三幺 呼啦!')
#奶奶类
class NaiNai:
    #扎金花
    def zhajinhua(self):
        print('AAA豹子!')
#姥姥类
class LaoLao:
    #推排九
    def tuipaijiu(self):
        print('至尊宝!')
#姥爷类
class LaoYe:
    #斗地主
    def doudizhu(self):
        print('四个二带两个王!')
#爸爸类
class BaBa:
    #德州扑克
    def dezhoupuke(self):
        print('唆哈~')
#老段(多继承)
class LaoDuan(LaoYe,BaBa,MaMa):
    pass

#实例化老段
jjld = LaoDuan()
jjld.dezhoupuke()
jjld.doudizhu()
jjld.makehair()

 

#菱形继承BUG

#A动物类
class Animal:
    #发音的方法
    def say(self):
        print('动物类开始发音')
        print('动物类发音结束')
#B鸟类
class Bird(Animal):
    #说话方法
    def say(self):
        print('鸟类开始发音')
        #调用动物类的发音方法
        Animal.say(self)
        print('鸟类结束发音')

#C人类
class Human(Animal):
    #说话方法
    def say(self):
        print('人类开始发音')
        #调用动物类的发音方法
        Animal.say(self)
        print('人类结束发音')


#D鸟人类
class BirdMan(Bird,Human):
    #说话方法
    def say(self):
        print('鸟人类开始发音')
        #调用人类的说话方法
        Human.say(self)
        #调用鸟类的说话方法
        Bird.say(self)
        print('鸟人类结束发音')

#实例化鸟人类对象
lzz = BirdMan()
lzz.say()#结果会导致A类种的方法执行两次 ,程序逻辑错误!

#正确

#A动物类
class Animal:
    #发音的方法
    def say(self):
        print('动物类开始发音')
        print('动物类发音结束')


#B鸟类
class Bird(Animal):
    #说话方法
    def say(self):
        print('鸟类开始发音')
        super().say()#调用人类的say()
        print('鸟类结束发音')


#C人类
class Human(Animal):
    #说话方法
    def say(self):
        print('人类开始发音')
        super().say()#动物类say()
        print('人类结束发音')


#D鸟人类
class BirdMan(Bird,Human):
    #说话方法
    def say(self):
        print('鸟人类开始发音')
        super().say()#调用了鸟类的say()
        print('鸟人类结束发音')

#python本身究带有方法访问顺序的修改方式
#C3算法将改造方法访问顺序
#[鸟人类,鸟类,人类,动物类] -> MRO列表  Method Relation Order 方法关系列表   super会根据mro列表的顺序访问!
result = BirdMan.__mro__
print(result）
#实例化对象
lzz = BirdMan()
lzz.say()

 

(单继承的使用场景)

 

(此类书写麻烦)

#水果类
class Fruit:
    pass
#----------------
#南方水果类
class SouthFruit(Fruit):
    pass
#北方水果类
class NorthFruit(Fruit):
    pass
#----------------
#南方剥皮水果类
class SouthBPFruit(SouthFruit):
    pass
#南方不剥皮水果
class SouthNoBPFruit(SouthFruit):
    pass
#北方剥皮水果
class NorthBPFruit(NorthFruit):
    pass
#北方不剥皮水果
class NorthNoBPFruit(NorthFruit):
    pass


#----------------

#苹果类
class Apple(NorthNoBPFruit):
    pass

#梨
class Pear(NorthNoBPFruit):
    pass

#香蕉
class Banana(SouthBPFruit):
    pass

#橘子
class orange(SouthBPFruit):
    pass

mixin设计模式(多继承的使用场景)

#水果类
class Fruit:
    pass

#南方类
class South:
    pass

#北方类
class North:
    pass

#剥皮类
class BP:
    pass

#不剥皮类
class NoBP:
    pass

#--------------------------------
#苹果类
class Apple(Fruit,North,NoBP):
    pass


#梨
class Pear(Fruit,North,NoBP):
    pass


#香蕉
class Banana(Fruit,South,BP):
    pass


#橘子
class orange(Fruit,South,BP):
    pass