面向对象三大特征

面向对象和面向过程的区别
    面向过程
    　　做一件事,从头到尾,每一个细节都要关注,注重于过程
    　　eg:家-> 北京 有多种方式到达,面向过程只关注于他具体是怎么走的(指一个过程)

    面向对象
    　　做一件事,创建对象去做,只关注结果,万物皆对象 
    　　eg: 家 -> 北京 ,只关注结果 

    类
    　　类事物的统称,是抽象的
    方法
    　　一类事物的具体表现形式
        　　特征(属性)
        　　行为(方法)

　　封装
　　　　概念
　　　　　　封装操作可以对受访问保护的成员进行功能开放的控制，达到保护数据不被非法访问的目的,也可以将
          具有同类属性和方法的的特性封装在一个方法中,后 期维护代码比较方便
　　　　作用
　　　　　　提高代码的冗余,方便代码统一管理,提高代码的可读性
　　　　修改私有属性
　　　　　　私有属性可以通过set()和get()方法来进行相对应的修改

class Person:

            """ 默认体力100
            吃饭恢复体力20
            睡觉恢复体力50
            学习消耗体力30
            锻炼消耗体力20
            """
            def __init__(self):
                self.Power = 100
                self.name = None

            def __change_HP(self, num, action):
                if num > 0:
                    self.Power += num
                    # print("正在%s,当前的体力值%d" % (action, self.Power))
                    if self.Power > 100:
                        print("体力值已经爆满,战斗力超强")
                        self.Power = 100
                    else:
                        print("正在%s,当前的体力值%d" % (action, self.Power))
                else:
                    self.Power += num
                    if self.Power < 0:
                        self.Power -= num
                        print("体力已经用完,无法完成%s" % action)
                    else:
                        print("%s正在%s,当前恢复的体力值为%d" % (self.name, action, self.Power))


            def eat(self):
                self.__change_HP(20,  "吃饭")
                # if self.Power >= 0 and self.Power < 100:
                #     self.Power += 20
                #     print("正在吃饭,当前的体力值%d" %(self.Power))
                # else:
                #     print("该体力值爆满,不在需要吃饭")
            def sleep(self):
                self.__change_HP(50, "睡觉")
                # if self.Power >= 0 and self.Power < 100:
                #     self.Power += 50
                #     print("正在吃饭,当前的体力值%d" % (self.Power))
                # else:
                #     print("该体力值爆满,不在需要睡觉")

            def study(self):
                self.__change_HP(-30, "学习")
                # if self.Power > 30:
                #     self.Power -= 30
                #     print("正在吃饭,当前的体力值%d" % (self.Power))
                # else:
                #     print("该体力值爆满,不在需要睡觉")

            def run(self):
                self.__change_HP(-45, "跑步")
                # if self.Power > 45:
                #     self.Power -= 45
                #     print("正在吃饭,当前的体力值%d" % (self.Power))
                # else:
                #     print("该体力值爆满,不在需要睡觉")



            def __str__(self):
                return "当前体力值为%d" % (self.Power)

        p = Person()
        p.name = "小明"
        p.sleep()
        p.run()
        p.run()
        p.run()

　　继承
　　　　概念
　　　　　　子类可以拥有父类所有公有的属性和方法
　　　　作用
　　　　　　提高代码的冗余,方便代码统一管理,提高代码的可读性,方便代码后期的扩展
　　　　单继承  ->  一个子类只能继承一个父类
　　　　　　作用    
　　　　　　　　代码的传递性,但同时只能继承一个父类　　
　　　　　　　　子类如果和父类拥有同样的方法和属性时,创建的对象会优先调用子类自己的方法,如果子类没有在调用父类的方法

class Person(object):
                (单继承)
                def __init__(self,name,age ):
                    self.name = name
                    self.age = age

                def eat(self):
                    print("我想吃饭")

                def sleep(self):
                    print("我要休息")

                def work(self):
                    print("我要工作")

            class P1(Person):
                pass

            class P2(Person):
                def eat(self):   #  重写eat方法
                    print("%s要吃饭" % self.name)

            p = P2("张三",18)
            p.work()
            p.eat()

　　　　多继承 -> 一个子类可以继承多个父类 
　　　　　　在多继承中，使用super()调用父类方法，这样可以避免顶层父类被调用多次
　　　　　　在多继承中，用父类名.方法调用时，最顶层的父类会被调用多次(一般不建议使用)
　　　　　　super()：在多继承中，可以保证顶层父类只被调用一次  
　　　　　　__mro__   c3算法得出的结果,返回一个元祖,一次性可以查看子类继承父类的过程,深度优先原则(优先从最左边开始,左边没有在从右边查找)

class Animal(object):
                def __init__(self,name,color):
                    self.color = color
                    self.name = name
                def run(self):
                    print("跑的快")

                def eat(self):
                    print("爱吃肉")

                def bark(self):
                    print("怒吼")

            class Tiger(Animal):
                def eat(self):
                    print("老虎吃肉")

            class Peacock(Animal):
                def fly(self):
                    print("孔雀会飞")

            class Swan(Tiger,Peacock):
                def feahter(self):
                    print("我天鹅的毛很白")

            a = Swan("旺财","红色")
            a.fly()
            a.bark()
            a.eat()
            # print(a.__mro__())
            print(Swan.__mro__)        

　　多态
　　　　满足多态的条件:
　　　　　　a 一定要有继承
　　　　　　b 必须重写父类的方法
　　　　概念
　　　　　　一个对象具有多种形态，在不同的使用环境中以不同的形态展示其功能，称该对象具有多态特征
　　　　作用
　　　　　　提高代码的刻度性和扩展性
　　　　分类
　　　　　　普通多态
　　　　　　　　同一种事物的不同表现形态

        　　　　

       
　　　　　　鸭子类型
　　　　　　　　鸭子类型是一种特殊的调用现象，当对象在语法层面能够满足调用关系，但对象并不具有对应的对象形态，称该对象此时具备鸭子类型
　　　　　　　　鸭子类型是一种特殊的多态表现形式.
        　　　　　　如:我们想让个程序员写代码:这个程序员叫李刚,另一个程序员叫 "旺财".--------这就是典型的鸭子类型