#封装:是将类中的某些部分(某些属性或方法)隐藏起来,使其私有化。
#私有属性 __属性名=值,在类的外部不能使用,对象不能调用私有属性
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)