5.6笔记+day10 作业

#封装：是将类中的某些部分（某些属性或方法）隐藏起来，使其私有化。
#私有属性 __属性名=值，在类的外部不能使用，对象不能调用私有属性

class A():
    __count=0#这就是私有属性，对象不能调用私有属性
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def getAge(self):
        return self.__age
zs=A("张三",19)
print(zs.getAge())
print(zs.name)
# print(zs.__count)#报错，对象不能调用私有属性

#私有方法：在方法前添加__,在类的外部不能使用，（对象不能调用私有方法）

    class A:
        def test(self):
            print("test")
        def __func(self):
            print("测试1")
        def func2(self):
            print("测试2")
            self.__func()#在类内部调用
    x=A()
    x.test()#test
	# x.__func()#报错
	x.func2()#测试2 测试1

#私有化封装后的限制
#在类中可以访问，但在类外/对象外，子类/子类对象都不可以访问
#可以使用__dict__查看属性（包括私有属性）的值

class Person():
    def setAge(self,age):
        self.__age=age

    def getAge(self):
        return self.__age
zs=Person()
zs.setAge(19)
print(zs.getAge())#19

zs.__age=29
print(zs.__age)#29

print(zs.getAge())#19
print(zs._Person__age)#19
print(zs.__dict__)#{'_Person__age': 19, '__age': 29}

#继承:让类与类之间产生父子关系，子类可以拥有父类的属性和方法

class People():
    def sing(self):
        print("唱歌")
class Man(People):
    def dance(self):
        print("跳舞")

zs=Man()
zs.sing()
zs.dance()

class Animal():
    def __init__(self,name,gender,age):
        self.name=name
        self.gender=gender
        self.age=age
    def jiao(self):
        print("haha")
class Dog(Animal):      #继承
    def jiao(self):     #重载
        print(self.name,"汪汪")
class Cat(Animal):
    def jiao(self):
        print(self.name,"喵喵")
d=Dog("旺财","公",2)
c=Cat("小咪","母",1)
d.jiao()
c.jiao()
#__bases__ 查看继承的父类
print(Dog.__bases__)#(<class '__main__.Animal'>,)
print(Cat.__bases__)#(<class '__main__.Animal'>,)
print(Animal.__bases__)#(<class 'object'>,)

#super（） 子类想调用父类相同的方法，可以使用super（）方法
#init,在子类继承父类时，如果子类不复写父类的__init__方法，子类在创建对象时会自动调用父类__init__方法
#如果子类复写了父类的__init__方法，那么后面就不会再调用

class Human():
    def __init__(self,name,sex):
        self.name=name
        self.sex=sex
    def show(self):
        print(self.name,self.sex)

class Man(Human):
    def __init__(self,name,sex,salary):
        super().__init__(name,sex)
        self.salary=salary
    def show(self):
        super().show()
        print(self.salary)

class Woman(Human):
    def __init__(self,name,sex,shop):
        super().__init__(name,sex)
        self.shop=shop
    def show(self):
        super().show()
        print(self.shop)
m=Man("张三","男",20000)
w=Woman("李四","女",5000)
m.show()
w.show()

#派生属性：子类可以添加属性，对象调用的时候将调用自己的属性，如果添加的属性与父类属性重名
#再调用的时候将调用子类的属性，这种现象较属性的覆盖

class Person():
    num=10
    def __init__(self,name,age):
        self.name=name
        self.age=age

class Man(Person):
    num=20#属性覆盖
    def __init__(self,name ,age,sex):
        super().__init__(name,age)
        self.sex=sex
    def eat(self):
        print("吃。。。",self.num)#默认调用自己类中的num
        print("吃。。。",Person.num)#调用父类中的num
        print("吃。。。",super().num)#调用父类中的num
#1、派生属性
zs=Man("张三",10,"男")
print(zs.sex)
print(zs.name)
#2、静态变量
zs=Man("张三",12,"男")
print(zs.num)

#注意：父类的私有方法和私有属性都是不能被子类继承下来的

#多继承
#super的本质不是直接查找父类，而是根据调用节点的广度优先顺序执行

class A():
    def __init__(self):
        print("A开始")
        print("A结束")

class B(A):
    def __init__(self):
        print("B开始")
        super().__init__()
        print("B结束")
class C(A):
    def __init__(self):
        print("C开始")
        super().__init__()
        print("C结束")
class D(B,C):
    def __init__(self):
        print("D开始")
        super().__init__()
        print("D结束")
d=D()

#多态
#例1

class Dog():
    def jiao(self):
        print("汪汪")
class Cat():
    def jiao(self):
        print("喵喵")
class Pig():
    def jiao(self):
        print("哼哼")
def bite(x):
    x.jiao()
d=Dog()
c=Cat()
p=Pig()
bite(d)#汪汪
bite(c)#喵喵
bite(p)#哼哼

#例2

class Pay():
    def pay(self):
        pass
class AliPay(Pay):
    def pay(self,money):
        print("支付宝支付.")
class Wechat(Pay):
    def pay(self,money):
        print("微信支付")
class Person():
    def pay(self,way,money):
        way.pay(money)
a=AliPay()
w=Wechat()
zs=Person()
zs.pay(a,100)
zs.pay(w,200)

#抽象类

from abc import ABCMeta,abstractmethod,abstractstaticmethod,abstractclassmethod
class Person(metaclass=ABCMeta):
    @abstractmethod
    def eat(self):
        pass
    @abstractmethod
    def sleep(self):
        pass
    def breath(self):
        print("呼吸空气")

class Student(Person):
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")

a=Student()
a.eat()
a.sleep()
a.breath()

二郎神和哮天犬

class Dog():
    def __init__(self,name):
        self.name=name
    def game(self):
        print(self.name,"在玩耍")
class x_Dog(Dog):
    def game(self):
        print(self.name,"玩玩玩")
class Person():
    def __init__(self,name):
        self.name=name
    def game1(self,dog):
        print("{}和{}一起玩".format(self.name,dog.name))
        dog.game()

d=x_Dog("哮天犬")
s=Person("二郎神")
s.game1(d)