1、封装
封装是面向对象编程的一大特点,将属性和方法封装到一个抽象的类中
数据被保存在内部，程序的其他部分只有通过被授权的操作（成员方法）才能对数据进行操作。外界使用类创建对象，然后让对象调用方法
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。对象方法的细节都被封装在类的内部
------------------- 练习------------------
需求
1.小明体重75.0公斤
2.小明每次跑步都会减肥0.5公斤
3.小明每次吃东西体重都会增加1公斤
需求
1.小明和小美都爱跑步
2.小美体重45.0公斤
2.每次跑步都会减肥0.5公斤
3.每次吃东西体重都会增加1公斤
class Person:
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字叫 %s 体重是 %.2f' %(self.name,self.weight)
# 在对象的方法内部，是可以直接访问对象的属性的
def run(self):
print('%s 去跑步～～～～' %(self.name))
self.weight -= 0.5
def eat(self):
print('%s 去吃东西～～～' %(self.name))
self.weight += 1
xiaoming = Person('小名',75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
xiaomei = Person('小美',45.0)
xiaomei.eat()
print(xiaomei)
------------------- 练习------------------
根据学生的成绩得到成绩的等级
class Student:
def __init__(self,name,score):
#初始化方法，当使用类创建实例的时候都会调该方法
self.name = name
self.score = score
def get_grade(self):
#对数据封装
if self.score > 90:
print('A')
elif self.score >80:
print('B')
else:
print('C')
toto = Student('toto',95) # 创建对象
toto.get_grade() # 直接使用对象调用方法，得到结果
#输出结果：
A
一个对象的属性 可以是另一个对象创建的类
------------------- 练习------------------
需求：
1.房子有户型,总面积和家具名称列表
新房子是没有家具的
2.家具有名字和占地面积，其中
床：5
桌子：4
椅子：6
3.将以上三件家具添加到房子中
4.打印房子的时候，要求输出：户型 总面积 剩余面积 家具名称列表
class Furniture: # 限定义家具类
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return 'this is %s, %d square '
#使用类创建好对象之后，该对象可以作为参数用于其他函数调用。
class House: #在定义房子类
def __init__(self,type,squa):
self.fu_list = []
self.type = type
self.leftsqua = self.allsqua = squa
def __str__(self):
return ' 户型是: %s\n 总面积是: %.2f\n 剩余面积: %.2f\n 家具列表:%s' \
%(self.type,self.allsqua,self.leftsqua,self.fu_list)
def add_furn(self,item): # 在房子类的方法中使用的参数是家具类的一个实例
if item.area<self.allsqua:
self.fu_list.append(item.name)
self.leftsqua -=item.area
else:
return
bed = Furniture('bed',5)
desk = Furniture('desk',4)
chair = Furniture('cabinet',6) # 先实例化 家具
house1 = House('三室',120) # 在实例化房子
house1.add_furn(bed) # 再使用房子对象的方法，传入的参赛是家具实例
house1.add_furn(desk)
house1.add_furn(chair)
print(house1)
#输出结果：
户型是: 三室
总面积是: 120.00
剩余面积: 105.00
家具列表:['bed', 'desk', 'cabinet']
------------------- 练习------------------
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
class Gun: # 定义枪类
def __init__(self,name):
self.name = name
self.count = 3 # 属性：枪名称以及子弹数量
def add_bullet(self): # 方法：添加子弹，将子弹数充值3
self.count = 3
def launch_bullet(self): # 发射子弹
if self.count <= 0:
self.add_bullet() #如果没有子弹，先进行添加子弹
self.count -= 1 # 然后子弹减少一个
print('%s 已经成功发射子弹 剩余子弹%d' %(self.name,self.count))
class Solair: # 定义士兵类
def __init__(self,name):
self.name = name # 设置属性 ：name
def shoot(self,gun): # 定义方法：直接调用枪对象的方法
gun.launch_bullet()
AK47 = Gun('AK47') # 实例化一个枪对象
ryan = Solair('Ryan') #实例化一个士兵对象
ryan.shoot(AK47) # 士兵对象调用开火方法
ryan.shoot(AK47)
ryan.shoot(AK47)
ryan.shoot(AK47)
#结果：
AK47 已经成功发射子弹 剩余子弹2
AK47 已经成功发射子弹 剩余子弹1
AK47 已经成功发射子弹 剩余子弹0
AK47 已经成功发射子弹 剩余子弹2
2、继承
在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）
最大的好处是子类获得了父类的全部功能，实现代码的重用，相同的代码不需要重复的写。
class Animal(): #定义动物类
def run(self):
print('running~~')
def call(self):
print('hahahah') # 动物类中存在两个方法
class Cat(Animal): # 定义猫类，继承动物类
pass
tom = Cat() # 常见一个猫类实例
tom.run() # 该实例可以直接调用动物类的方法
#输出结果：
running~~
可以在子类中添加自己特定功能的一些方法
class Animal():
def run(self):
print('running~~')
def call(self):
print('hahahah')
class Cat(Animal):
def eat(self):
print('爱吃鱼')
tom = Cat()
tom.run() # 调用父类的方法
tom.eat() # 使用自己类的方法
#输出结果：
running~~
爱吃鱼
当父类方法的实现不能满虚子类的需求的时候可以对方法进行重写，我们说，子类的方法覆盖了父类的方法，在代码运行的时候，总是会调用子类的该方法。
class Animal():
def run(self):
print('running~~') #父类中存在run方法
def call(self):
print('hahahah')
class Cat(Animal):
def run(self):
print('跑得快') # 子类中也存在run方法
def eat(self):
print('爱吃鱼')
tom = Cat()
tom.run() # 当实例调用run方法的时候，总是调用的子类中的程序
#运行结果：
跑得快
可以对父类方法进行扩展。保留父类方法的内容，在其基础上增加新的内容。只需要子子类中定义和父类中相同的方法，并且在该方法中写入super().call()（父类.方法(self) python2.x通过个该实现），然后添加需要扩展的内容即可。
class Animal():
def run(self):
print('running~~')
def call(self):
print('hahahah')
class Cat(Animal):
def run(self):
super().run() # 继承父类给方法的内容，同时添加扩展的内容
print('跑得快')
def eat(self):
print('爱吃鱼')
tom = Cat()
tom.run()
#输出结果：
running~~
跑得快
当父类中使用了初始化方法，在子类中也想使用初始化方法的时候，需要使用在子类初始化方法中使用super().init()，表示对父类初始化方法的继承扩展，如若没有，会出现冲突报错。
class Animal():
def __init__(self,name):
self.name = name
def run(self):
print('running~~')
def call(self):
print('hahahah')
class Cat(Animal):
def __init__(self,color,name):
super().__init__(name) #在子类中必须使用该语句，表示继承父类中的属性。
self.color = color
def run(self):
super().run()
print('跑得快')
def eat(self):
print('爱吃鱼')
tom = Cat('tom','red')
print(tom.name)
print(tom.color)
#输出结果：
red
tom
当子类继承子多个父类的时候，并且多个父类中存在相同的方法，这时候该子类的实例取调用这个方法的时候，就会出现那个被继承的父类写在前面，就使用哪一个父类的方法。建议在定义方法的时候，尽量不要使用相同的名称
class A: #定义A 类
def lala(self):
print('lala')
def toto(self):
print('toto') # 其中由来两个方法
class B: # 定义B类
def lala(self):
print('LALA')
def toto(self):
print('TOTO') # 其中由两个方法，并且方法名称和A中方法名称一致
class C(A,B): #定义类C 继承A，B 两个类
pass
class D(B,A): # 定义类D 继承B，A 两个类
pass
c = C()
d = D()
c.lala()
d.lala()
c.toto()
d.toto() # 当继承父类的顺序不同的时候，导致调用的方法是不同的内容，默认调用位置靠前的父类方法
#输出结果：
lala
LALA
toto
TOTO
3、多态
以封装和继承为前提，存在一个函数，需要一个参数，不用对函数进行修改当参数是不同的对象的时候输出的结果不同，
就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
不同的子类对象调用相同的方法，产生不同的执行结果
首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样 class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
pass
class Cat(Animal):
pass
a = list()
b = Animal()
c = Dog()
d = Cat()
print(isinstance(a,list))
print(isinstance(b,Animal))
print(isinstance(c,Dog))
print(isinstance(d,Cat))
#输出结果：
True
True
True
True
同时子类实例化出来的对象，不仅是子类类型，同时还是父类类型。在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。例如Animal是Dog的父类，使用Dog实例化一个实例，该实例既是Dog类型，也是Animal类型。
class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
pass
b = Animal()
c = Dog()
print(isinstance(b,Animal))
print(isinstance(c,Dog))
print(isinstance(c,Animal))
#输出结果：
True
True
True
首先存在三个类：Animal、Dog、Cat；Dog、Cat 都继承自Animal类，并且都存在run方法。
class Animal(object):
def run(self):
print('Animal is running...')
class Dog(Animal):
def run(self):
print('Dog is running')
class Cat(Animal):
def run(self):
print('Cat is running')
理解多态的好处，我们还需要再编写一个函数，这个函数接受一个Animal类型的变量：
def run_twice(animal):
animal.run()
animal.run()
当我们传入Animal类的实例时，run_twice()就打印出：
def run_twice(animal):
animal.run()
animal.run()
run_twice(Animal())
#输出结果：
Animal is running...
Animal is running...
由于Dog类的实例以及Cat类的实例都可以是Animal数据类型，同样也可以作为参数传入该函数，当传入Dog类的实例以及Cat类的实例时候，函数的输出：
def run_twice(animal):
animal.run()
animal.run()
run_twice(Dog())
run_twice(Cat())
#输出结果：
Dog is running
Dog is running
Cat is running
Cat is running
现在可以在定义一个以Animal作为父类的子类，并将其实例作为参数，函数run_twice可以正常的运行。
class Tortoise(Animal):
def run(self):
print('Tortoise is running slowly~~~')
run_twice(Tortoise())
#输出结果：
Tortoise is running slowly~~~
Tortoise is running slowly~~~
重点：
新增一个Animal的子类，不必对run_twice()做任何修改，实际上，任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行，
函数需要一个Animal类型的参数，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收其Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，然后，按照Animal类型进行操作即可。函数能够正常的运行。
由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，当然，每一个实际类型的run方法内容以及操作的数据都不相同，操作的结果也就相同，这就是多态。
对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，
调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：
对扩展开放：允许新增Animal子类
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。