1.什么是面向对象？（What）
使用模板的思想，将世界完事万物使用对象来表示一个类型
一、Encapsulation 封装（隐藏实现细节）
1．在类中对数据的赋值、内部调用对外部用户是透明的
2. 这使类变成了一个胶囊或容器，里面包含着类的数据和方法
3. 作用：
1）防止数据被随意修改
2）使外部程序不需要关注对象内部的构造，只需要通过对外提供的接口进行直接访问
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。在面向对象编程中它的概念就是将 属性和方法 放到 类内部，通过 对象 访问属性或者方法,隐藏功能的实现细节，当然还可以设置访问权限。
下面我们看一个例子：
class Student(object): # 定义类
def __init__(self,name,age,height): # 封装属性
self.name = name
self.age = age
self.height = height
def print_age(self): # 封装方法
return("{}的年龄是：{}岁".format(self.name,self.age))
def print_height(self): # 封装方法
return("{}的身高是：{}cm".format(self.name,self.height))
student = Student("小明",21,180) # 类的实例化
print(student.print_age()) # 调用方法
print(student.print_height()) # 调用方法
小明的年龄是：21岁
小明的身高是：180cm
二，Inheritance 继承（代码重用）
1. 一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
2. 比如CS中的警察和恐怖分子，可以将两个角色的相同点写到一个父类中，然后同时去继承它
3. 使用经典类： Person.init(self,name,age) 并重写写父类Person的构造方法，实现，先覆盖，再继承，再重构
2.1 单继承
只继承一个类的话称为单继承，下面看一下例子：
class Person(object): # 定义父类
def run(self):
return("我可以跑步")
def sing(self):
return("我可以唱歌")
class Man(Person): # 定义子类，继承父类
def repair(self):
return("我可以修理电脑")
man = Man() # 类实例化对象
print(man.run()) # 调用父类方法
print(man.sing()) # 调用父类方法
print(man.repair()) # 调用子类自己的方法
print(man.name) # 调用父类的属性
我可以跑步
我可以唱歌
我可以修理电脑
由上面的例子我们可以看到，子类可以调用父类的方法，也可以访问父类的属性。
2.2 多继承
多继承的概念就是子类可以继承多个父类，并且具有所有父类的属性与方法，下面我们看一个例子：
class Singer(object):
def fun1(self):
return("我是一个歌手")
class Dancer(object):
def fun2(self):
return("我是一个舞者")
class Man(Singer,Dancer):
def fun3(self):
return("我既是一个歌手又是一个舞者")
man = Man()
print(man.fun1())
print(man.fun2())
print(man.fun3())
我是一个歌手
我是一个舞者
我既是一个歌手又是一个舞者
由上面的例子我们可以看到子类可以调用父类的两个方法
2.3 继承中的注意事项
2.3.1 继承的传递性
假设我们现在有三个类：A、B、C，A是B的父类，B是C的父类，那么C不仅有B的方法与属性还具有A的方法与属性，这个概念就叫做继承的传递性
class Person(object): # 定义父类的父类
def run(self):
return("我可以跑步")
class Male(Person): # 定义父类
def repair(self):
return("我可以修理汽车")
class Boy(Male): # 定义子类
def play(self):
return("我可以玩耍")
boy = Boy()
print(boy.run())
print(boy.repair())
print(boy.play())
我可以跑步
我可以修理汽车
我可以玩耍
2.3.2 父类方法与子类重名
只要子类与父类的方法名相同，调用方法，子类就会覆盖父类的方法(重写父类方法)，在运行中，只会调用在子类中重写的方法而不会调用父类的方法。注意重写后父类方法并不会改变，我们看一下下面的例子：
class Person(object): # 定义父类
def run(self):
return("我可以跑步")
class Man(Person): # 定义子类
def run(self):
return("我可以跑得非常快！！！")
man = Man()
print(man.run()) # 调用的是子类的方法
print(Person.run(man)) # 查看一下父类的方法
我可以跑得非常快！！！
我可以跑步
三、Polymorphism 多态（接口重用）
1．多态是面向对象的重要特性,简单点说:“一个接口，多种实现”
2. 指一个基类中派生出了不同的子类，且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现
3. 这就是同一种事物表现出的多种形态
4. 比如黄种人继承了人talk这个功能，但是他说的是中文，而美国人的talk是英文，但是他们是同样的talk
作用：简单的讲就是允许父类调用子类的方法
class Animal:
def __init__(self, name): # Constructor of the class
self.name = name
def talk(self): # Abstract method, defined by convention only
raise NotImplementedError("Subclass must implement abstract method")
class Cat(Animal):
def talk(self):
return 'Meow!'
class Dog(Animal):
def talk(self):
return 'Woof! Woof!'
animals = [Cat('Missy'),
Dog('Lassie')]
for animal in animals:
print(animal.name + ': ' + animal.talk())
# 运行结果：
# Missy: Meow!
# Lassie: Woof! Woof!
