Python 入门 —— Python 面向对象的三大特点：封装、继承、多态
Python 面向对象的三大特点：封装、继承、多态
- 面向对象的三大特点：
- 封装：将有一定功能的代码封装起来，使用时调用即可
- 继承：将公共的属性和方法放在父类中，自己自考虑特有的属性和方法。
- 多态：程序运行过程中，根据执行条件的不同，动态执行不同的操作代码的过程称为运行时多态。
1 封装
- 封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步将属性和方法封装到一抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
示例一：
要求：
XX爱跑步
1. XX体重75.0公斤
2. XX每次跑步会减肥0.5公斤
3. XX每次吃东西体重会增加1公斤
class Person(): # 定义类
def __init__(self,name,weight):
self.name = name
self.weight = weight
print "%s like to run,and %s's weight is %.2f kg" \
% (self.name,self.name,self.weight)
def run(self,lose_weight): # 定义方法
self.weight -= lose_weight
print "When %s run,weight will be lost %.2f kg ,and the finall weight is %.2f" \
% (self.name,lose_weight,self.weight)
def eat(self,get_weight): # 定义方法
self.weight += get_weight
print "When %s eat,weight will be put on %.2f kg ,and the finall weight is %.2f" \
% (self.name,get_weight, self.weight)
Tom = Person('Tom',75) # 定义对象
Tom.run(0.5) # 调用方法，加上参数，意味，Tom 每跑一次步，就减重0.5
Jarry = Person('Jarry',60)# 可以定义第二个对象，再调用方法
Jarry.eat(1) # 调用方法，加上参数，意味，Tom 每吃一次，就增重1执行如下：
控制台显示如下：
这就是封装，定义不同对象，只需要对类中的方法进行调用，然后让其完成对应的效果
示例二：
摆放家具
需求:
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和战地面积，其中
床:占4平米
衣柜:占2平面
餐桌:占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型，总面积，剩余面积，家具名称列表
class Furniture(object): # 建立类 Furniture
def __init__(self,name,area):
self.name = name
self.area = area
class House(object): # 建立类 House
def __init__(self,model,areas):
self.model = model
self.areas = areas
self.free_area = areas
self.furniture_list = []
def __str__(self):
return '房子户型：%s\n房子大小：%.2f\n剩余空间：%.2f\n家具列表:%s' \
% (self.model,self.areas,self.free_area,self.furniture_list)
def add(self,furniture): # 创建方法 add 进行家具的添加
if furniture.area > self.areas:
print '%s 面积太大，无法添加' % furniture.name
return
self.furniture_list.append(furniture.name)
print '%s 添加成功' % furniture.name
self.free_area -= furniture.area
bed = Furniture('bed',400) # 建立家具类的对象 bed，给bed面积为100
wardrobe = Furniture('wardrobe',2) # 建立家具类的对象 wardrobe
table = Furniture('table',1.5) # 建立家具类的对象 table
my_house = House('三室一厅',100) # 创建对象my_house，给他的面积为100
my_house.add(bed) # 调用方法添加及家具
my_house.add(wardrobe)
my_house.add(table)
print my_house控制台显示如下：
由于bed面积大于房子的面积100，所以无法被添加
2 继承：
- Python 类的继承
在OOP（Object Oriented Programming）程序设计中，当我们定义一个c lass的时候，可以从某个现有的class 继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。- 子类拥有父类的所有属性和方法
子类继承父类，可以直接享受父类已经封装好的方法
子类中应该根据自己的职责，封装子类特有的属性和方法
示例：
class Animal(): # 定义父类 Animal 类
def eat(self): # 定义父类中的方法
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
# 子类根据自己的职责，封装子类特有的属性和方法
def scream(self):
print 'miao~~'
tom = Cat()
tom.eat() # 子类的示例直接可以调用父类中的方法
tom.drink()
tom.run()
tom.sleep()
tom.scream()
执行如下：
控制台显示如下：
继承的传递性：（爷爷，父亲，儿子）
1.C类从B类继承，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
示例：
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
# 子类根据自己的职责，封装子类特有的属性和方法
def scream(self):
print 'miao~~'
class BlueCat(Cat): # 定义子类的子类
def speak(self):
print 'I can spea Chinese'
bluecat = BlueCat()
bluecat.eat()
bluecat.drink()
bluecat.run()
bluecat.sleep()
bluecat.scream()
bluecat.speak() 执行如下：
控制台显示如下：
继承——重写父类
- 重写父类方法有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展
1.覆盖父类的方法
如果在开发中，父类的方法的实现和子类方法的实现，
完全不同，就可以使用覆盖的方式，
在子类中重新编写父类的方法
具体实现方法，相当于在子类中定义了一个父类同名的方法并且实现
重写之后，在运行时，只会调用子类的重写方法
而不会调用父类的封装的方法
示例：
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def scream(self):
print 'miao~~'
# 子类继承父类，可以直接享受父类已经封装好的方法
# 子类中应该根据自己的职责，封装子类特有的属性和方法
class BlueCat(Cat):
def speak(self):
print 'I can speak Chinese'
def scream(self): # 子类中定义与父类相同的方法，进行覆盖
print 'Come here beat me!'
bluecat = BlueCat() # 定义对象
bluecat.eat() # 调用父类的方法
bluecat.drink()
bluecat.run()
bluecat.sleep()
bluecat.scream() # 调用重新定义过的与父类中方法相同的方法
bluecat.speak()执行如下：
控制台显示如下：
2.对父类的方法进行扩展
如果在开发中，子类的方法实现包含有父类的方法实现
（父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法）
1.在子类中重写父类的方法
2.在需要的位置使用父类名.方法（self）来调用父类方法的执行（使用父类名称调用父类方法）
3.代码其他位置针对子类的需求，编写子类特有的代码实现
示例：
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def scream(self):
print 'miao~~'
# 子类继承父类，可以直接享受父类已经封装好的方法
# 子类中应该根据自己的职责，封装子类特有的属性和方法
class BlueCat(Cat):
def speak(self):
print 'I can speak Chinese'
def scream(self):
print 'Come here beat me!'
Cat.scream(self) # 调用父类的同名方法
bluecat = BlueCat()
bluecat.eat()
bluecat.drink()
bluecat.run()
bluecat.sleep()
bluecat.scream()
bluecat.speak()执行如下：
控制台显示如下：
多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
示例：
class A(): # 定义父类 A
def test(self):
print 'A'
class B(): # 定义父类 B
def demo(self):
print 'B'
class C(B,A): # 定义子类C，继承父类 A，B 的特性
pass
c = C()
c.test()
c.demo()执行如下：
控制台显示如下：
若是父类的方法中有相同名称的，子类会继承在前方的属性
示例：定义父类A，B，A，B中有相同的方法，子类会继在前方的父类的方法
class A(): # 定义父类 A
def test(self):
print 'A'
class B(): # 定义父类 B
def test(self):
print 'B'
class C(A,B): # 定义子类C，继承父类 A，B 的特性
pass
c = C()
c.test()执行如下：
控制台显示如下：
若是调换顺序：
class A():
def test(self):
print 'A'
class B():
def test(self):
print 'B'
class C(B,A):
pass
c = C()
c.test()控制台显示如下：
3 多态
面向对象程序设计最有趣的特性是多态，它是是让大多数人犯晕的特性。
多态：（Polymorphism） 按字面的意思就是“多种状态”
在面向对象语言中，接口的多种不同的实现方式即为多态。
多态意味着就算不知道变量所引用的对象类是什么，还是能对它进行操作，而它也会根据对象（或类）类型的不同而表现出不同的行为。
示例一：
class Animal(object):
def __init__(self,name):
self.name = name
def scream(self):
print '没有动物叫'
class Cat(Animal):
def scream(self):
print '喵喵喵喵喵'
class Dog(Animal):
def scream(self):
print '汪汪汪汪汪'
a = Animal('')
a.scream()
c = Cat('Tom')
c.scream()
d = Dog('Senven')
d.scream()代码中有Cat和Dog 两个子类，都继承了类Animal，它们都有scream（）方法，输入不同的动物名称，会得到相应的结果，这就是多态的应用
执行如下：
控制台显示：
示例二：此例子能更清晰点
class Dog(object):
def __init__(self,name):
self.name = name
def scream(self):
print '%s wang,wang,wang' % self.name
def game(self):
print '%s 玩耍，玩飞盘' % self.name
class GodDog(Dog):
def game(self):
print '%s fly and scream' % self.name
class Person(object):
def __init__(self,name):
self.name = name
def game(self,dog):
print '%s play with %s' % (self.name,dog.name)
dog.game()
wangcai = Dog('wangcai')
goddog = GodDog('xiaotian')
yangjian = Person('yangjain')
yangjian.game(wangcai)执行如下：
控制台显示：
