Python面向对象的三大特征 --- 封装、继承、多态

一、封装

1）封装：是面向对象的一大特点；将属性和方法封装在一个抽象类中。外界使用类创建对象，然后让对象调用内部方法。对象方法的细节都被封装在类的内部。

---

class Person():

  def __init__(self,name,weight):    # 初始化方法

      self.name = name

      self.weight = weight

  def __str__(self):     # 定义返回方法

      return 'my name is %s,my weight is %.2f.' %(self.name,self.weight)

  def run(self):        # 定义跑步方法

      self.weight -= 0.5

      print '每次跑步会减重0.5公斤。'

  def eat(self):       # 定义吃方法

      self.weight += 1.0

      print '每次吃东西会增重1.0公斤'

# 创建类的实例化对象，并调用方法 

ming = Person('小明',65)

ming.run()

ming.eat()

print ming

 

lili = Person('lili',45)

lili.run()

print lili

---

2)举例1：

    需求：摆放家具

    1、房间有户型，总面积和家具名称列表。新房间五家具

    2、家具上有名字和占地面积

    3、将家具添加在房子中

解析如下：

 # 定义一个家具类。有姓名和占地面积的属性； 

class fortn():

   def __init__(self,name,area):

        self.name = name

        self.area = area

   def __str__(self):

        return '%s的占地面积是%.2f' %(self.name,self.area)

# 定义房子类。有户型、总面积、剩余面积、家具的属性；方法为添加家具

class home():

   def __init__(self,name,area):

       self.name = name

       self.area = area

       self.leaveArea = area   # 剩余面积初始值为总面积

       self.fortn_list = []

   def __str__(self):

       return '户型：%s ,总面积：%.2f ,剩余面积：%.2f , 家具：%s' %(self.name,self.area,self.leaveArea,self.fortn_list)

   def add_thing(self,argc):

       print "要添加%s"  %argc.name

       if self.leaveArea < argc.area:

           print "%s占地面积太大，不能添加" %argc.name

           return

       self.fortn_list.append(argc.name)

       self.leaveArea -= argc.area

 

# 创建家具对象

bed = fortn('bed',4)

chest = fortn('chest',2)

table = fortn('table',1.5)

# 创建房子对象

my_house = home('两室一厅',200)

my_house.add_thing(bed)

my_house.add_thing(chest)

my_house.add_thing(table)

print my_house 

---

举例2：

    需求：士兵有枪，当枪里有子弹才可以射击

解析如下：

# 创建枪类

class  Gun():

   def __init__(self,model):

       self.model = model

       self.bullet_count = 0

   def shoot(self):

       if self.bullet_count <= 0:

           print "%s没有子弹" %self.model

           return 

       self.bullet_count -= 1

       print '发射一次，子弹还有%s' %self.bullet_count

   def add_bullet(self,count):

       self.bullet_count += count

# 创建士兵类

class Sodlier():

   def __init__(self,name):

       self.name = name

       self.gun = None    # 当属性不确定的时候，可以使用None来初始化

   def fire(self):

       if self.gun == None:

           print "%s还没有枪" %self.name

       print "go to fire!%s" %self.name

       self.gun.add_bullet(10)

       self.gun.shoot()

 

# 定义枪对象

ak47 = Gun('AK47')

# ak47.add_bullet(10)

# ak47.shoot()

 

# 定义士兵对象

ryan = Soldier（'Ryan'）

ryan.gun = ak47

ryan.fire()

print ryan.gun

二、继承

1）继承实现的是代码的重用，相同部分代码不需要重写，分为单继承和多继承。多继承：一个子类可以继承多个父类。

  2)单继承：一个子类只能继承一个父类

 # 定义父类

class Animal():

   def call(self):

       print "我会叫"

   def run(self):

       print "我会跑"

# 定义子类Cat,并重写父类的call方法

class Cat(Animal):

   def call(self):  # 由于和父类中的call方法重名，所以实现重写

      print "我会喵喵叫～～～"

# 定义HelloKitty子类，继承Cat类

class HelloKitty(Cat):

    def speak(self):

        print "我会说"

# 创建对象

tom = HelloKitty()

tom.run()           # 在子类中没有定义run方法，但在父类和祖父类中有

tom.call()         

tom.speak(）

3)多继承：一个子类可以有多个父类

# 定义父类1

class  A():

   def test(self):

       print "A ---> test"

   def demo(self):

       print "A ---> demo"

# 定义父类2

class B():

   def test(self):

       print "B ---> test"

   def demo(self):

       print "B ---> demo"

# 定义子类C，继承父类A和B的方法和属性

class C(A,B):

   # 当父类中的方法同名时，按括号中父类的先后顺序继承

   pass

# 定义子类的实例化对象

c = C()

c.test()    # 此时调用的均为父类A的结果

c.demo()

  4）继承中的重写问题：在开发过程中，若父类方法和子类方法的实现完全不同，可以重写父类方法，实现方法覆盖。

# 定义父类

class Animal():

   def call(self):

       print "我会叫"

   def run(self):

       print "我会跑"

# 定义子类Cat,并重写父类的call方法

class Cat(Animal):

   def call(self):  # 由于和父类中的call方法重名，所以实现重写

      print "我会喵喵叫～～～"

tom.run()     # 此时可以使用创建出来的对象，调用父类的方法

# 创建对象

tom = Cat()

tom.call()           # 此时，调用call显示的为：我会喵喵叫

  5）继承中的扩展问题

# 定义父类

class Animal():

   def call(self):

       print "我会叫"

   def run(self):

       print "我会跑"

# 定义子类Cat,并重写父类的call方法

class Cat(Animal):

   def call(self):  # 由于和父类中的call方法重名，所以实现重写

       print "我会喵喵叫～～～"

# 创建对象

tom = Cat()

tom.call()           # 此时，调用call显示的为：我会喵喵叫

三、多态

  1）同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果

class Dog(object):

   def __init__(self,name):

       self.name = name

   def game(self):

       print "%s是一只普通的狗" %self.name

class amazing(Dog):

   def game(self):

       print "%s是一只神奇的狗" %self.name

class Person(object):

   def __init__(self,name):

       self.name = name

   def game_with_dog(self,dog):

       print "%s和%s快乐地玩耍" %（self.name,dog.name）

       dog.game()

wangcai = amazing("旺财")

xiaoming = Person("小明")

xiaoming.game_with_dog(wangcai)