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

一、封装
封装：在面向对象编程中，所有的类通常情况下很少让外部直接访问类内部的属性和方法,而是向外部类提供一些按钮,对其内部的成员进行访问,以保证程序的安全性。

1> 封装是面向对象编程的一大特点
2> 面向对象编程的第一步，将属性和方法封装到一个抽象的类中
3> 外界使用类创建对象，然后让对象调用方法
4> 对象方法的细节都被封装在类的内部
示例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和xiaomei
xiaoming = Person('小明', 75.0)
xiaomei = Person('小美', 45.0)

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

print xiaomei
xiaomei.run()
# """结果如下"""
# 我是小明，体重是75.00
# 小明 爱跑步
# 小明 吃饭
# 我是小明，体重是75.50
# 我是小美，体重是45.00
# 小美 爱跑步

示例2：

class Student:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def setter(self, name, age):
        if not isinstance(name, str):
            raise TypeError("名字必须是字符串类型")
        if not isinstance(age, int):
            raise TypeError("年龄必须是整数类型")

        self.__name = name
        self.__age = age

    def tell(self):
        print("学生的信息是:%s\t%s" % (self.__name, self.__age))

if __name__ == '__main__':
    student = Student("Alex", 25)
    student.tell()
    student.setter("Tom", 40)
    student.tell()
"""结果如下"""
# 学生的信息是:Alex   25
# 学生的信息是:Tom    40

二、继承

1、一个类从已有的类那里获得其已有的属性与方法，这种现象叫做类的继承
2、方法重写指在子类中重新定义父类中已有的方法，这中现象叫做方法的重写
3、若A类继承了B类，则aa对象既是A，又是B，继承反映的是一种谁是谁的关系，只有在谁是谁的情况下,才能用继承解决代码冗余的问题。
4、寻找属性和方法的顺序问题：先从对象自己的命名空间中找，然后在自己的类中，最后在从父类当中去找
5、在python3当中，所有的类都是新式，所有的类都直接或者间接的继承了Object
6、在python中，新建的类可以继承一个或多个父类
示例1：单继承
1.继承的概念：子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)
2.语法
class 类名(父类):
def 子类特有的方法

# _*_ coding:utf-8 _*_
class Animal:
    def eat(self):
        print '吃'

    def drink(self):
        print '喝'

    def run(self):
        print '跑'

    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

kitty = Cat()
kitty.eat()
kitty.drink()
kitty.run()
kitty.sleep()
kitty.call()
"""结果如下"""
# 吃
# 喝
# 跑
# 睡
# 喵喵～

Cat类继承了Animal所有的属性和方法，然后Cat类又定义了自己特有的方法。

示例2：继承的传递性
继承的传递性：通俗的讲(爷爷爸爸儿子的关系)

C 类从B类继承，B类又从A类继承
那么C类就具有B类和A类的所有属性和方法。

# _*_ coding:utf-8 _*_
class Animal:
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'

# 创建一个Hellokitty对象
kt = Hellokitty()
kt.speak()
kt.call()

# 继承的传递性 子类拥有父类的父类的属性和方法
kt.eat()
kt.drink()
kt.sleep()
kt.run()
"""结果如下"""
# 我可以说日语
# 喵喵～
# 吃
# 喝
# 睡
# 跑

示例3：
方法的重写

覆盖父类的方法(重写父类方法)
对父类方法进行扩展

# _*_ coding:utf-8 _*_
class Cat(object):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        # 1.针对子类特有的需求，编写代码
        print '欧哈呦～'
        # 2.调用原本子阿父类中封装的方法
        Cat.call(self)

kt =Hellokitty()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用在子类中重写的方法而不会调用父类的方法
kt.call()
"""结果如下"""
# 欧哈呦～
# 喵喵～

示例4：
多继承

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

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

class C(B,A):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass

# 创建子类对象
c = C()
c.test()
c.demo2()
"""结果如下"""
# B -------test方法
# A--------demo方法

多继承C类既继承了A类，也继承了B类，对象c调用方法的时候，若A类和B类的方法同名，则在C类继承A和B的时候谁写在前面就调用谁的方法。不同名的就直接调用对应的类中的方法。

补充：新式类和旧式类
新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看

新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用

在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类，python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类
推荐使用新式类
新式类和旧式类在多继承时会影响到方法的搜索顺序，为保证编写的代码能够同时在python2.x和python3.x运行，今后在定义类时，如果没有父类，建议统一继承自object类

>>> class A(object):
...     pass
...
>>> a = A()
>>> dir(a) #查看内置的属性和方法

>>> class B:
...     pass
...
>>> b=B()
>>> dir(b)

Python早期，它对于class的定义在很多方面都是严重有问题的。当他们承认这一点的时候已经太迟了，所以逼不得已，他们需要支持这种有问题的class 。
为了解决已有的问题,他们需要引入一种“新类”，这样的话“旧类”还能继续使用，而你也有一个新的正确的类可以使用了。
这就用到了“类即是对象”的概念，他们决定用小写的“object”这个词作为一个类，让你在创建新类时从它继承下来。

三、多态
多态是以封装和继承为前提。

1> 多态可以增加代码的灵活度
2> 以继承和重写父类的方法为前提
3> 调用方法，不会影响到类的内部设计
示例：

# _*_ coding:utf-8 _*_
class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print '摇尾巴...'

class GoldDog(Dog):
    def game(self):
        print '上天入地...'

class Person(object):
    def __init__(self, name):
        self.name = name

    def game(self, dog):
        print '%s 和 %s 一起玩耍' % (self.name, dog.name)

dog = Dog('旺财')
# dog = GoldDog('飞天神狗')
XiaoMing = Person('小明')
XiaoMing.game(dog)
"""结果1：注释掉GoldDog类实例的对象"""
# 小明 和 旺财 一起玩耍

"""结果2：注释掉Dog类实例的对象"""
# 小明 和 飞天神狗 一起玩耍

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

猜你喜欢