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

一、封装

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

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

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

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

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

View Code