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)

执行如下：

控制台显示：