面向对象的自我总结

面向过程是一种以过程为中心的编程思想。
面向对象程序设计主要针对大型软件设计提出的，次编程方式的实现是基于对类和对象的使用。
总结3大特点：封装，继承，多态

class Car():
    def __init__(self,pp="宝马",ys="红色",jg="35W"):#类中的构造方法
        self.pp=pp         #__init__()为构造函数,在创建一个对象时被调用，第一个参数是self
        self.ys=ys         #实例属性
        self.jg=jg

    def jia_shi(self):  #公有方法
        print("我正驾驶一辆%s色的%s车"%(self.ys,self.pp))

    def setter_name(self,n):  #调用该方法可以重置该值
        self.pp = n

    def getter(self):         #调用该方法可以获取该值
        return self.pp

    def __str__(self):        #该方法是魔法方法，可以返回这个对象包含的信息
        return '你的%s爱车要定期保养'%self.pp

    def __del__(self):
        print('我已被删除')     #该方法为析构方法，每次创建对象后Python解释器默认调用该方法，无需手动调用

    car1=Car("奔弛","黑色","40W")  #实例化对象

    car1.jia_shi()                #实例对象调用实例方法
    #我正驾驶一辆黑色色的奔弛车

    print(car1.pp)                #实例对象调用实例属性
     #奔弛

    print(car1)                   #调用__str__方法返回字符串
    #你的奔弛爱车要定期保养

    def car1                      #删除对象后无法再调用该对象

总结：实例方法，属性只能被被实例对象调用，类无法调用！这些方法也叫做公有方法。

私有方法

    def jia_shi(self):       #公有方法
        self.__woshijingtai()#私有方法只能在类中通过self调用，对象无法调用

    def __woshijingtai(self): #私有方法以双下划线开始
        __n = 100   #私有属性
        print('我是静态')
    car1.jia_shi()            #可以间接通过公有方法调用
    #我是静态

总结：私有方法和私有属性只能在类中被调用！

类中的属性与方法

    class Car():
        a = '我是类的属性'
    def jia_shi(self):         #公有方法
        print(self.a)

    @classmethod               #类方法，用该装饰器进行装饰
    def setleifangfa(cls,i):   #一般以cls作为第一个参数
        cls.a = i
    @classmethod
    def getleifangfa(cls):
        return cls.a

    car1.setleifangfa('我要改变私有')  
    #我要改变私有

    print(car1.getleifangfa())
    #我要改变私有

总结：实例对象可以调用类的方法与属性，同样可以被类在自身中调用

静态方法

静态方法中不需要额外添加定义参数，因此在静态方法中必须通过类对象来引用
静态方法是一种普通函数，位于定义的命名空间中，它不会对任何实例类进行操作。

class Car():
    a = '我是静态方法'
    @staticmethod
    def get():
        print(Car.a)
    car1=Car()
    car1.get()
#我是静态方法

总结：静态方法用 @staticmethod装饰器装饰，它可以被类，实例对象调用！

继承

父类可以是一个或者多个，不用继承则空着
继承分为多继承与单继承 注意：父类的属性，方法可以继承给子类，父类的私有属性，方法无法被继承！

class Super_A(object):
    def __init__(self):
        self.name = 'jack'
   def info_a(self):
        print('我是父类')

class Super_B(Super_A):
    def __init__(self):
        Super_A.__init__(self) #调用父类的init函数
    super().__init__()         #也可以用super方法继承过来
        self.age = 18
    def info_b(self):
        print(self.name,self.age)

car2 = Super_B()
car2.info_a()  
car2.info_b()  
#我是父类
#jack 18

总结：派生类定义 init（）时，不会自动调用基类的_init_（）函数，想要得到基类的_init（）中的信息，由派生类调用基类的_init（）函数来对它进行恰当的初始化。

多继承

class Person():

    def run(self):   # 公开方法在子类中可以直接访问，也可以被覆盖
        print('Person 会跑')

    def eat(self):
        print('Person 会吃')

class Man(Person):
    def fight(self): 
        print('Man 打架')

class Woman(Person):
    def taobao(self):
        print('Woman 淘宝')

class NvHanzi(Woman, Man):  # Hanzi继承了Man、Woman的函数和属性
    pass   # 空，什么都不做

hanzi = NvHanzi()
hanzi.run()
hanzi.eat()
hanzi.taobao()
hanzi.fight()

运行结果：
Person 会跑
Person 会吃
Woman 淘宝
Man 打架

修改父类的方法，也叫重写

class Person(): 
     def run(self):   # 公开方法在子类中可以直接访问，也可以被覆盖
          print('Person 会跑')

     def eat(self):
          print('Person 会吃')

class Man(Person):
     def run(self):  # 在子类中修改父类的方法，会覆盖Person类(父类)的run函数
         print('Man在跑')

 m = Man()  # 自动调用父类的构造函数
 m.run()    #  Man类中覆盖父类中的run函数，m调用的是Man类中的run函数
运行结果：
Man在跑

多态

多态是面向对象语言的一个基本特性，多态意味着变量并不知道引用的对象是谁，根据引用对象的不同表现不同的行为方式。

class ChuiFengJi:   # 我们叫具有吹风功能的事物，叫吹风机
    def chui(self):   # 吹风功能
        print("吹风机 能吹风")

class MeiDi(ChuiFengJi):
    def chui(self):
        print("美的   能吹风")

class FeiLiPu(ChuiFengJi):
    pass

def who_zai_chui(arg):  
    arg.chui()  

c = ChuiFengJi()
m = MeiDi()
f = FeiLiPu()

who_zai_chui(c)
who_zai_chui(m)
who_zai_chui(f)
运行结果：

吹风机 能吹风
美的   能吹风
吹风机 能吹风
由于Python是动态语言，所以，传递给函数 who_zai_chui(a)的参数 a 不一定是 ChuiFengJi 或 ChuiFengJi 的子类型。
任何数据类型的实例都可以，只要它有一个chui()的方法即可，这就是多态。

鸭子类型

鸭子类型：
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
在鸭子类型中，不关注对象的类型，只关注它是如何使用的。
比如：吹风机吹风这个功能，在鸭子类型中，只关注它能不能打吹风，而不关心它是谁。
class ChuiFengJi:   # 我们叫具有吹风功能的事物，叫吹风机
    def chui(self):   # 吹风功能
        print("吹风机 能吹风")

class MeiDi(ChuiFengJi):
    def chui(self):
        print("美的   能吹风")

class FeiLiPu(ChuiFengJi):
    pass

class PiXie:   # PiXie具有吹风的功能，我们就称PiXie是吹风机，这就是鸭子类型
    def chui(self):
        print("皮鞋   能吹风")

class WenQuXing:  # 不具有吹风的功能，就不是吹风机
    pass

def who_zai_chui(arg):  # 测试函数，test只接受参数，但是不关心参数arg的类型
    arg.chui()   # 只关心arg能不能调用call函数，不关心它的类型

c = ChuiFengJi()
m = MeiDi()
f = FeiLiPu()
p = PiXie()
w = WenQuXing()

who_zai_chui(c)
who_zai_chui(m)
who_zai_chui(f)
who_zai_chui(p)