Python面向对象

面向对象的三大特性
1,封装
2,继承
3,多态
封装特性
在程序设计中，封装是将类中的某些部位(某些属性或方法)隐藏起来
隐藏对象的属性和方法实现细节，仅对外提供公共访问方式。
封装格式：__属性或方法名称（也称私有属性或方法）

class Girl():
    def __init__(self,name,age):
        self.name=name
        self.__age=age   #封装age
    def show(self):
        print(self.name,self.__age)  #打印结果

zs=Girl('张三',19)
zs.show()
# print(zs.__age)    #在外部调用属性没有找到，因为age已经被封装外部不能调用，所以报错

注意：私有属性和私有方法只能在类的内部使用
私有化封装的限制
类中 可以访问
类外、对象外 不可以访问
子类、子类对象 不可以访问

class Girl():
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def setAge(self,age):
        if age<0 or age>95:
            print('火星人')
            self.__age=18
        else:
            self.__age=age
    def getAge(self):
        return self.__age
zs=Girl("张三",20)
zs.setAge(21)
print(zs.getAge())
print(zs.__dict__)    #查看对象中的所有属性 ，在类中使用私有属性，
								python内部会自动进行转换成_类名__属性名。
zs.__age=99         #在外部添加私有属性名，python内部不会自动转
								换成_类名__属性名，因此不能覆盖类中的私有属性。
print(zs.__dict__)

总结：
可以使用__dict__来查看对象中的所有属性
内部的私有属性会被python自动转换成_类名__属性名，
外部不能给对象添加私有属性。

继承特性
继承分为：单继承和多继承
继承就是让类和类之间产生父子关系，子类可以拥有父类的静态属性和方法。
子类可以继承一个或多个父类
父类：用于被继承的类，称之为父类，也叫做基类，或超类。
子类：继承其他类的类，称之为子类，也叫派生类。

class Animal():            #将子类中的重复内容编写到父类中
    def __init__(self,name,age):
        self.name=name
        self.age=age
class Cat(Animal):      #调用父类的属性
    def jiao(self):
        print("喵喵")
class Dog(Animal):
    def jiao(self):
        print("汪汪")
c=Cat("波斯",3)
d=Dog("京巴",4)
c.jiao()                        
d.jiao()

继承就是提高代码的重用率

class Animal():
    def __init__(self,name,age):
        self.name=name
        self.age=age
class Cat(Animal):
    def __init__(self, name, age, velocity):#子类中定义了和父类中相同的方法
    									，叫做复写重载，重写，复写，覆盖，实例对象
    									调用此方法时会先调用自己类中的方法。
        self.v=velocity
        super().__init__(name, age)   #子类想调用父类相同的方法时，可以用super()方法。
    def jiao(self):
        print("喵喵",self.v)
class Dog(Animal):
    def __init__(self,name,age,heght):
        self.heght=heght
        super().__init__(name,age)
    def jiao(self):
        print("汪汪",self.heght)
c=Cat("波斯",3,35)
d=Dog("京巴",4,1.87)
c.jiao()
d.jiao()

钻石继承

class A():
    def func(self):
        print("A开始")
        print("A结束")
class B(A):
    def func(self):
        print("B开始")
        super().func()
        print("B结束")
class C(A):
    def func(self):
        print("C开始")
        super().func()
        print("C结束")
class D(B,C):          #两个父类的话会先执行在前面的父类
    def func(self):
        print("D开始")
        super().func()
        print("D结束")
d=D()
d.func()

答案：
D开始
B开始
C开始
A开始
A结束
C结束
B结束
D结束
具体过程：程序执行先找D的父类，B在C的前面，先执行B，B执行完不会执行A，而是继续寻找D的父类C，C执行完，寻找C的父类A，A类执行完，返回C类，在返回B类，最后返回执行D类。
多态特性
同一方法在遇到不同对象时，有不同的结果

class Dog():
    def jiao(self):        #调用方法
        print("汪汪")
class Cat():
    def jiao(self):
        print("喵喵")
class Pig():
    def jiao(self):
        print("哼哼")
def hanhan(a):            #设定方法
    a.jiao()
d=Dog()
c=Cat()
p=Pig()
hanhan(d)
hanhan(c)
hanhan(p)

先设定多个类，在设定方法，执行时可执行多个对象。
相对于封装和继承特性，多态特性则比较好理解。