python中的三大特点：封装 继承 多态

面向对象的三大特点：

封装：将有一定功能的代码封装起来，使用时调用即可
继承：将公共的属性和方法放在父类中，自己自考虑特有的属性和方法。
多态：程序运行过程中，根据执行条件的不同，动态执行不同的操作代码的过程称为运行时多态。

一 封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

封装的示例

小明和小美爱跑步
1.小明体重75.0公斤
小美体重45.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤

class Person:
    def __init__(self, name, weight):
        # 在初始化方法中增加两个参数由外界传递
        # self.属性 = 形参
        self.name = name
        self.weight = weight

    def __str__(self):
        return '我的名字叫 %s 体重是 %.2f' % (self.name, self.weight)

    def run(self):
        # pass
        print '%s 爱跑步' % self.name
        # 在对象方法的内部，是可以直接访问对象的属性
        self.weight -= 0.5
    def eat(self):
        #pass
        print '%s 吃东西' % self.name
        self.weight += 1

xiaoming = Person('小明',75.5)

xiaoming.run()
xiaoming.eat()
print xiaoming

xiaomei = Person('小美',45.0)
xiaomei.eat()
xiaomei.run()

# 同一个类创建的多个对象之间，属性互补干扰
print xiaomei
print xiaoming

一个对象的属性可以是另外一个类创建的对象

示例需求

1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
Soldier        Gun
---------      ------------
name            model
gun             bullet_count
----------     -------------
__init__(self) __init__(self)
fire(self)     add_bullet(self,count)
               shoot(self)

class Gun:
    def __init__(self, model):
        # 枪的型号
        self.model = model
        # 子弹的数量
        self.bullet_count = 0
    def add_bullet(self,count):
        self.bullet_count += count
    # 只要子弹的数量足够，就能发射，所有shoot方法不需要传递参数
    def shoot(self):
        # 1.判断子弹的数量
        if self.bullet_count <= 0:
            print '[%s] 没有子弹了...' %self.model
            return
        # 2.发射子弹，子弹数量-1
        self.bullet_count -= 1
        # 3.提示发射信息
        print '[%s] 突突突...[%d]' %(self.model,self.bullet_count)


class Soldier:
    def __init__(self,name):
        self.name = name
        # 定义属性的时候，如果不知道设置什么初始值，可以设置为None
        # None关键字表示什么都没有，表示一个空对象，没有方法和属性
        # 是一个特殊的常量，可以将None赋值给任何一个变量
        self.gun = None

    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun == None:
            print '[%s] 还没有枪...' %self.name
            return
        print 'go!!! [%s]' %self.name
        self.gun.add_bullet(50)
        self.gun.shoot()

# 1.创建枪对象
ak = Gun('AK47')
# 2.创建瑞恩   # 枪不能自己发射子弹，枪不能自己开火 需要士兵去完成
ryan = Soldier('Ryan')
ryan.gun = ak
ryan.fire()

二 继承

继承：实现代码的重用，相同的代码不需要重复的写

1 单继承

1.继承的概念：子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)
2.语法
class 类名(父类):
    def 子类特有的方法

示例：

class Student:  #定义父类
    def study(self):
        print '学生要学习'
    def practice(self):
        print '学完要练习'
    def play(self):
        print '练习完要玩耍'
    def sleep(self):
        print '玩耍后睡觉觉'

class homie(Student):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '开黑'

Bob = homie()
Bob.study()
Bob.practice()
Bob.play()
Bob.sleep()
Bob.call()
# 子类继承自父类，可以直接享受父类中已经封装好的方法

2 继承的传递性

class Student:
    def study(self):
        print '学生要学习'
    def practice(self):
        print '学完要练习'
    def play(self):
        print '练习完要玩耍'
    def sleep(self):
        print '玩耍后睡觉觉'

class homie(Student):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '开黑'

class homie1(homie):  # 继承的传递性 子类拥有父类的父类的属性和方法
    def LOL(self):
        print '三人开黑'

james =homie1()
james.study()
james.practice()
james.play()
james.sleep()
james.call()
james.LOL()

3 重写父类和扩展

覆盖父类的方法(重写父类方法)
如果子类中，重写了父类的方法
在运行中，只会调用在子类中重写的方法而不会调用父类的方法

class Student:
    def study(self):
        print '学生要学习'
    def practice(self):
        print '学完要练习'
    def play(self):
        print '练习完要玩耍'
    def sleep(self):
        print '玩耍后睡觉觉'

class Homie(Student):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '开黑'

class Homie1(Homie):
    def LOL(self):
        print '三人开黑'
    def call(self):
        # 1.针对子类特有的需求，编写代码
        print '我的homie一起在一起'
        # 2.调用原本父类中封装的方法
        Homie.call(self)          #重写之后并没有改变父类的方法
        # 3.增加其他子类代码
        print '我们需要五黑'       #对父类方法进行扩展

james =Homie1()
james.call()
james.LOL()

4 多继承

子类拥有一个父类叫作单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
例如:孩子会继承自己父亲和母亲的特征

class A:
    def test(self):
        print 'A----------test方法'
    def demo(self):
        print 'A----demo 方法'
class B:
    def test(self):
        print 'B----------test方法'
    def demo(self):
        print 'B----demo 方法'


class C(B,A):        #谁在前面调用谁，当然也可以指定调用父类的方法
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass

# 创建子类对象
c = C()
c.test()
c.demo()

三 多态

多态(以封装和继承为前提)
面向对象的三大特征：
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承:实现代码的重用，相同的代码不需要重复的编写
子类针对自己特有的需求，编写特定的代码
3.多态：不同的子类对象调用相同的方法，产生不同的执行结果
1.多态可以增加代码的灵活度
2.以继承和重写父类的方法为前提
3.调用方法，不会影响到类的内部设计

class Dog(object):
    def __init__(self,name):
        self.name=name
    def game(self):
        print '%s喜欢耍'%self.name

class Goddog(Dog):
    def game(self):
        print '%s喜欢hotdog'%self.name
       # Dog.game(self)

class Person(object):
    def __init__(self,name):
        self.name=name
    def game_with_dog(self,dog):
        print '%s和%s一起耍'%(self.name,dog.name)


Hotdog=Goddog('Hotdog')
zhangzhenyue=Person('张震岳')
zhangzhenyue.game_with_dog(Hotdog)