面向对象特性

封装特性

封装（Encapsulation）是将类中的某些部分（某些属性和方法）隐藏起来。

对象不能直接使用隐藏起来的属性或者方法，具有保护作用的功能

封装格式：__属性或者方法名称。

封装的目的是为了保护隐私。

私有属性

格式：__属性名=值

在类的外部不能使用（对象不能调用私有属性）

class Girl():
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def show(self):
        print(self.name,self.__age)
zs=Girl('张三',18)
zs.show()
print(zs.name)
print(zs.__age) #AttributeError: 'Girl' object has no attribute '__age'

                # " Girl "对象没有属性" _age "

私有方法：

在方法面前添加__例如__send_message()

私有方法的作用：就是在开发的过程中保护核心代码。

在类的外部不能使用（对象不能调用私有方法）

class Phone():
    def _phone(self):
        print('正在拨打电话')
    def phone(self,m):
        if m >=30:
            self._phone()
        else:
            print('请先给你的手机交满30话费，再来打电话')
x=Phone()
x.phone(12)    #请先给你的手机交满30话费，再来打电话

x.phone(33)    #正在拨打电话

私有化封装后的限制：

类中                         可以访问

类外/对象外             不可以访问

子类/子类对象         不可以访问

1.可以使用__dict__可以查看属性（包括私有属性）的值

在类的内部使用私有属性，python内部会自动转换成_类__属性名。

在类的外部不能给对象添加私有属性因为不能转换成_类名__属性名类型。

class A():
    def __init__(self,age):
        self.__age=19
    def setAge(self,age):
        self.__age=age
    def __str__(self):
        return str(self.__age)
a=A(1)
a.__age=100
print(a.__dict__)
print(a._A__age)
a._A__age=99
print(a.__dict__)

继承：

继承就是让类和类之间产生父子关系，子类可以拥有父类的静态属性和方法。

父类：用于被继承的类，称之为父类，也叫基类，或者叫超类。

子类：继承其他类的类，称之为子类，也叫派生类。

class Animal():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def jiao(self):
        print('叫')
    def eat(self):
        print('吃')
    def __str__(self):
        return '品种：%s %d岁 性别：%s'%(self.name,self.age,self.sex)
class Cat(Animal):
    def climb(self):
        print('爬树')
class Dog(Animal):
    def swimming(self):
        print('游泳')


d=Dog('藏獒',3,'公') 
print(d)            #品种：藏獒 3岁 性别：公
c=Cat('波斯',2,'母')
print(c)            #品种：波斯 2岁 性别：母
c.climb()           #爬树
d.swimming()        #游泳

#查看继承的父类
#格式：类名.__bases__
#(1)python3中如果一个类没有继承任何类，默认继承object类。管这种类叫新式类。
#(2)object类，是python中的祖宗，所有的类都是从object类中继承下来的。
print(Cat.__bases__)      #(<class '__main__.Animal'>,)
print(Animal.__bases__)   #(<class 'object'>,)

方法的覆写：

子类中定义了和父类中相同的方法，我们叫做方法的复写（派生方法）。实例对象调用此方法的时候就会调用自己类中的方法了。

class A():
    def hehe(self):
        print('A:笑')
class B(A):
    def hehe(self):
        print('B:哈哈')
class C(A):
    def hehe(self):
        print('C:呵呵')
a=A()
b=B()
c=C()
a.hehe()  #A:笑
b.hehe()  #B:哈哈
c.hehe()  #C:呵呵

super( )

子类和父类有相同的方法，如果子类想调用父类相同的方法。可以使用super()方法。

super默认省略了两个参数，第一个是类名，第二个是self。两个参数可以省略不传递例如super(Student,self)

格式：

父类名称.方法名称（self）

super( ).方法名称（）

class Animal():
    def __init__(self,name,age):#重载、重写、复写、覆盖
        self.name=name
        self.age=age
class Cat(Animal):
    def __init__(self,name,age,speed):
        self.speed = speed
        # 重写父类的方法一
        super().__init__(name,age)
        # 重写父类的方法二
        #Animal.__init__(self,name,age)
    def jiao (self,):
        print('喵喵')
    def __str__(self):
        return '猫：%s,，%d岁，速度%d'%(self.name,self.age,self.speed)
class Dog(Animal):
    def __init__(self,name,age, height):
        self.height = height
        super().__init__(name, age)
    def jiao(self):
        print('汪汪')
    def __str__(self):
        return '狗：%s,，%d岁，身高%d'%(self.name,self.age,self.height)
c=Cat('波斯',3,120)
print(c)            #猫：波斯,，3岁，速度120
d=Dog('京巴',5,180)
print(d)            #狗：京巴,，5岁，身高180
c.jiao()         #喵喵
d.jiao()         #汪汪

多继承

一个子类可以继承多个父类，就是多继承。并且拥有所有父类的属性和方法。

语法：

class 子类名（父类名1，父类名2...）: pass

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()

多态

声明形参的时候是父类对象，实际运行的时候是子类对象

class Dog():
    def jiao(self):
        print('汪汪')
class Cat():
    def jiao(self):
        print('喵喵')
class Pig():
    def jiao(self):
        print('哼哼')

def honghong(a):
    a.jiao()
d=Dog()
c=Cat()
p=Dog()
honghong(d)
honghong(c)
honghong(p)

class Ali():
    def pay(self,money):
        print('阿里支付',money)
class Weixin():
    def pay(self,money):
        print('微信支付',money)
class Person():
    def consume(self,pay,money):
        pay.pay(money)
ali=Ali()
weixin=Weixin()
zs=Person()
zs.consume(ali,100)
zs.consume(weixin,200)