面向对象基本特征
封装
封装是指对外界隐藏信息，不能随意访问、修改对象的数据和方法
封装是通过限制类的属性和方法的访问方式来实现的封装效果
封装的三个层次：
- 类的封装：外部可以任意访问、修改类中的属性和方法
- 私有属性：外部不可以访问、修改勒种的属性和方法
- 公有方法+私有属性：外部有条件限制的访问、修改属性，调用方法
封装表现1：
类的定义：将某些特定属性和方法进行“隔离”
每个学生有自己的年龄，外部可以任意读取或者修改
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
s1 = Student("李白",18)
s2 = Student("杜甫",20)
s2.age = 200
print(s1.name)
print(s2.age)
封装表现2：
属性私有：只能在类的内部使用，外部不能使用
不让外部读取、修改学生的年龄
class Student:
def __init__(self,name,age):
self.name = name
self.__age = age #使用两个下划线开头的属性，定义为私有属性
print(self.__age)
__secret = True
s1 = Student("李白",18)
# print(s1.__age) #外界无法直接通过属性名称来访问
#虽然语法可以在外部通过_Student__age访问到私有属性，但是不推荐使用
print(s1._Student__age)
#__dict__查看当前对象或者类有哪些属性
print(s1.__dict__)
print(Student.__dict__)
封装表现3：
私有属性+ 公有方法：有限制条件的开放给外部
可以读取年龄，但不能随意修改年龄
设定年龄必须在（1,125）之间
class Student:
def __init__(self,name,age):
self.name = name
self.__age = age
def getAge(self):
return self.__age
def setAge(self,age):
if 0 < age < 125:
self.__age = age
else:
print("年龄不符合人类")
s1 = Student("李白",18)
print(s1.getAge())
s1.setAge(200)
print(s1.getAge())
私有方法
可以在类的内部使用，有条件的开放给外部
class Person:
def __tellSercert__(self):
print("夏天夏天悄悄过去，留下小秘密~~~~")
def talk(self,object):
if object == "好基友":
self.__tellSercert__()
else:
print("我是一个木得感情木得秘密的人")
ming = Person()
ming.talk("好基友")
ming.talk("隔壁小黑")
封装的简化写法
装饰器
property装饰器：把一个方法伪装成一个属性，在调用这个方法的时候不需要加（）就可以直接得到返回值
class Dog:
@property #装饰器
def bark(self):
print("旺旺旺~~~")
return 89757
d = Dog()
num = d.bark #注意这里没有括号呦
print(num)
总结
使用@property装饰器时，方法名不必与属性名相同
可以更好的防止外部通过猜测私有属性名称来访问
凡是赋值语句就会触发set方法，获取属性值会触发get方法
继承
面临的问题：
- 相似类型的定义会产生大量重复的代码
- 类的定义没有很好的扩展性‘
解决的方法：
定义类和类之间的关系，子类拥有父类的全部属性和方法，并可以为之扩充
示例
class Pet:
def __init__(self,name,age):
self.name = name
self.age = age
print(f"一只名字叫{self.name}的宠物出生了")
def eat(self):
print(f"{self.name}在吃东西~~~")
def run(self):
print(f"{self.name}在溜达~~~")
class Dog(Pet):
pass
class Cat(Pet):
pass
d = Dog("咯咯",3)
d.run()
c = Cat("布丁",1)
c.eat()
1.继承的概念：
- Dog和Cat继承了Pet类
- Dog和Cat称为Pet的子类、派生类
- Pet称为Dog和Cat的父类、超类、基类
- 子类默认拥有父类公有的属性和方法的定义
2.子类调用方法的顺序
- 调用方法时，子类中有的，调用子类中的
- 子类中没有的，调用父类的
- 一旦在子类中找到，就不在去父类中查找了
子类不能继承父类的私有属性或者方法
class Father:
__secret = "小秘密"
story = "从前有座山，山上有座庙"
def tellStory(self):
print(self.story)
def __tellSecret(self):
print(self.__secret)
class Son(Father):
def tell(self):
# self.tellStory()
self.__tellSecret()
s = Son()
s.tell()
3.重写/覆盖
- 子类和父类拥有相同名称的方法
- 可以理解为子类对于父类行为的扩展和补充
class Pet:
master = True
def __init__(self,name,age):
self.name = name
self.age = age
print(f"一只名字叫{self.name}的宠物出生了")
def eat(self):
print(f"{self.name}在吃东西~~~")
def run(self):
print(f"{self.name}在溜达~~~")
class Dog(Pet):
#重写父类方法
def eat(self):
print(f"{self.name}在啃骨头")
#扩充，定义子类特有功能
def lookAfter(self):
print(f"{self.name}在看门，汪汪汪！")
d = Dog("旺财",2)
d.eat()
d.lookAfter()
4.子类可以在类定义时，可以使用super（）调用父类的方法
应用1：和重写不同，重写是对父类方法的完全覆盖，这是对父类方法的补充
class Pet:
def __init__(self,name,age):
self.name = name
self.age = age
print(f"一只名字叫{self.name}的宠物出生了")
def eat(self):
print(f"{self.name}在吃东西~~~")
def run(self):
print(f"{self.name}在溜达~~~")
class Cat(Pet):
def eat(self):
print(f"{self.name}伸了个懒腰")
super().eat()
print(f"{self.name}吃完东西后，舔了舔爪子")
c = Cat("布丁",2)
c.eat()
应用2：对象初始化时，简化重复属性的赋值
class Cat(Pet):
def __init__(self,name,age,sex):
# self.name = name
# print(f"一只名叫{self.name}的宠物出生了")
super().__init__(name) #代替了上两句代码，简化了重复属性的赋值
self.age = age
self.sex = sex
5.多继承
- 子类可以有多个父类
- 例如：狗是脊椎动物，哺乳动物，宠物。。。
class Father:
caihua = "有才"
class Mother:
yanzhi = "有貌"
class Child(Father,Mother):
pass
c = Child()
print(c.caihua,c.yanzhi)
print(Child.__bases__) #可以通过类名.__bases__查看其父类
6.访问子类的属性或者方法时，解析的路径（顺序）
class Father:
def getMoney(self):
print("爸爸给了零花钱")
class Mother:
def getMoney(self):
print("妈妈给了零花钱")
class Child(Father,Mother):
def getMoney(self):
super().getMoney()
#按照继承的顺序查找父类中的方法，所以先找Father类
print("孩子获得了零花钱")
c = Child()
c.getMoney()
从第一个父类开始向上查找，直到查找结束都没有，再对第二个父类进行查找
深度优先：Child -> Father -> GrandFather -> Mother
class GrandFather:
pass
# def getMoney(self):
# print("爷爷给了零花钱")
class Father(GrandFather):
pass
# def getMoney(self):
# print("爸爸给了零花钱")
class Mother:
def getMoney(self):
print("妈妈给了零花钱")
class Child(Father,Mother):
def getMoney(self):
super().getMoney()
#按照继承的顺序查找父类中的方法，所以先找Father类
print("孩子获得了零花钱")
c = Child()
c.getMoney()
print(Child.mro()) #可以通过类名.mro()的方式来查看类的解析顺序
- object是所有类的父类
- “万事万物”皆为对象，因为所有的类都默认继承object
7.菱形继承
广度优先:Child -> Father -> Mother -> Human
多态
想要解决的问题
- 让程序能够有更强的灵活性
- 让程序能够有更好的适应性
- 概念：一个类的多种形态
情况1：通过继承和重写来实现
class Animal:
def eating(self):
print("动物在吃东西")
class Pet(Animal):
def eating(self):
print("宠物在吃东西")
class Dog(Pet):
def eating(self):
print("狗在啃骨头~")
class Cat(Pet):
def eating(self):
print("小猫在吃鱼")
class Zoo:
def animalEating(self,animal):
animal.eating()
z = Zoo()
a = Animal()
p = Pet()
d = Dog()
c = Cat()
#Dog和Cat都作为Animal的不同形态
#都可以直接调用animal所具有的属性和方法
z.animalEating(a)
z.animalEating(p)
z.animalEating(d)
z.animalEating(c)
情况2：Python持有
没有继承关系，但是也具备相同的特征、方法，也可以直接使用
class venusFlytrap: #捕蝇草
def eating(self):
print("捕蝇草在吃小虫子")
v = venusFlytrap()
z.animalEating(v)
捕蝇草不继承于Animal类，但是具有和它相同的特征，在python只要具有相同的特征和方法，没有继承关系也可以直接使用
type和isinstance
#type判断类型时，只看直接类型
print(type(c) is Cat) #True
print(type(c) is Animal) #False
print(type(c) is Pet) #False
#isinstance 判断对象是否为一个类型的实例
#判断实例类型时，涵盖父类的类型
print(isinstance(c,Cat)) #True
print(isinstance(c,Pet)) #True
print(isinstance(c,Animal)) #True
print(isinstance(venusFlytrap,Animal)) #False