面向对象三大特性（封装、继承和多态）

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

第一步：将内容封装到某处：

class Foo(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
obj1=Foo('Mike','18') #将Mike和18分别封装到obj1的name和age属性中

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

1、通过对象直接调用被封装的内容：

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
obj2=Foo('Mike', 18)
print(obj2.name)# 直接调用obj1对象的name属性
print(obj2.age) # 直接调用obj1对象的age属性

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容：

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def detail(self):
        print(self.name)
        print(self.age)
        
obj2 = Foo('Mike', 18)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj2.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是Mike ；self.age 是 18

　　综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

二、继承

继承

　　Python2中，经典类按深度优先，新式类按广度优先来继承

　　Python3中，经典类、新式类都是按广度优先来继承

# class People: 经典类
class People(object): #新式类  继承自object父类
    def __init__(self,name,age,):
        self.Name=name
        self.Age=age
    def eat(self):
        print("%s is eating..."%self.Name)
    def sleep(self):
        print('%s is sleeping...'%self.Name)

# class Man(People):
#     def work(self):
#         pass
#     def sleep(self): #重构父类方法   为父类方法添加新功能、新方法
#         People.sleep(self)
#         print("%s sleeps in the sofa."%self.Name)

class Man(People):
    def __init__(self,name,age,money): #重构父类的构造函数  重构父类初始化方法时，父类的初始方法会被覆盖，不会被自动调用，因此，我们需要显式调用它
        # People.__init__(self,name,age)
       #通过super()获取父类的定义，
        super(Man,self).__init__(name,age)#更方便一点，推荐


        self.Money=money

    def value(self):
        print()
    def work(self):
        pass

class Woman(People):
    def cooking(self):
        print('%s is cooking in the kitchen'%self.Name)

m1=Man('Mike',33,100)
m1.eat()
m1.sleep()

w1=Woman('Jane',18)
w1.cooking()

多继承：

class People(object): #新式类
    def __init__(self,name,age,):
        self.Name=name
        self.Age=age
    def eat(self):
        print("%s is eating..."%self.Name)
    def sleep(self):
        print('%s is sleeping...'%self.Name)

class Relation(object):
    def make_friends(self,obj):
        print('%s is making friend with %s'%(self.Name,obj.Name))

class Man(People,Relation):
    def __init__(self,name,age,money): #重构父类的构造函数
        # People.__init__(self,name,age)
        super(Man,self).__init__(name,age)#更方便一点
        self.Money=money
    def value(self):
        print()
    def work(self):
        pass

class Woman(People,Relation):
    def cooking(self):
        print('%s is cooking in the kitchen'%self.Name)


m1=Man('Mike',33,100)
w1=Woman('Lisa',30)

m1.make_friends(w1)

三、多态

#多态  一种接口，多种实现
#作用：接口的重用

　　多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

　　那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

 

Pyhon不直接支持多态，但可以间接实现

 

通过Python模拟的多态

class Animal(object):
    def __init__(self,name):
        self.name=name
    def greet(self):
        print("Hello I am a %s",self.name)
class Dog(Animal):
    def greet(self):
        print("Woof! Woof! I am a lovely %s"%self.name)

class Cat(Animal):
    def greet(self):
        print("'Meow! I am a lovely %s"%self.name)

def hello(animal):
    animal.greet()

#继承
dog=Dog('dog')
cat=Cat("cat")
dog.greet()
cat.greet()

#多态
hello(dog)
hello(cat)