(09)-Python3之--类的三大特性（封装、继承、多态）

1、封装

封装，就是只能在类的内部访问，外部访问属性或方法会报异常，python中的封装很简单，只要在属性前或者方法名前加上两个下划线就可以，如self.__name，def __eat(self)这样就完成了属性和方法的私有化，也就是封装。

class hj:

    _arg = 'world'  # 封装

    __kws = 'kws'   # 封装

    def __init__(self):

        print(self._arg)   # 内部调用一个下划线的封装

        print(self.__kws)  # 内部调用两个下划线的封装

    # 提供封装访问函数让外部可以使用

    def get(self):

        print(self.__kws)

h = hj()

print(h._arg)   # 一个下划线的封装 外部是可以调用的

#print(h.__kws)  # 两个下划线的封装 外部是无法调用的(其实是可以调用的,只不过python给你做个一个重名的操作(_hj__kws))

h.get()    # 通过封装的方法来调用

2、继承

官方解释：所谓继承指提供了同一类对象共性的处理方法，子类继承父类共性的东西。这样有利于代码的复用性，即子类拥有父类的方法。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。

通俗讲就是：父类的是子类的，子类的还是子类的。

python中继承也非常简单，定义一个Animal类，下面有一个eat()方法，再定义一个Dog类，Dog类中什么都不写，用pass代替。然后实例化一个dog，让dog继承Animal类,dog可以使用eat()方法。

class Animal(object):

    def __init__(self,name):

        self.name = name

    def eat(self):

        print(self.name,"吃饭")

class Dog(Animal):

    pass

dog=Dog("旺财")

dog.eat()

结果：

旺财 吃饭

重写：和父类的方法名称一样。但是在子类里面，重新实现。

　　1、完全覆盖

class Animal:

    def __init__(self,name,private_v1):

        self.name = name

        self._private_v1 = private_v1

        self.__private_v2 = "private_really"　　# 私有化，不对子类开放

    def run(self):

        print("跑！！")

class Dog(Animal): # 继承父类（Animal）

    def __init__(self,name,kind):

        self.name = name

        self.kind = kind

    def eat(self):

        print("一只名叫 {} 的 {} 在啃骨头！！".format(self.name,self.kind))

    def run(self): # 重写父类的run（）方法

        print("我是一条狗，我有四条腿跑！！")

# 实例化

dog = Dog("二狗","哈士奇")

dog.run()

dog.eat()

结果：

我是一条狗，我有四条腿跑！！

一只名叫 二狗 的 哈士奇 在啃骨头！！

　　2、保留父类的做法，在它的基础上再扩展其它的内容。（扩展方式：super()）

　　　　super()的2种表达：

　　　　　　super().方法(参数列表)

　　　　　　super(子类名，self).方法(参数列表)

class Animal:

    def __init__(self, name, private_v1):

        self.name = name

        self._private_v1 = private_v1

        self.__private_v2 = "private_really" 

    def run(self):

        print("跑！！")

class Dog(Animal):  # 继承父类Animal

    def __init__(self, name, kind, private_v1):

        # 方法一

        super().__init__(name, private_v1)  # 调用父类现成的方法

        # 方法二

        # super(Dog,self).__init__(name)

        self.kind = kind  # 扩展子类自己的特性

    def eat(self):

        print("一只名叫 {} 的 {} 在啃骨头！！".format(self.name, self.kind))

    def gogo(self):  # 完全颠覆父类的做法

        super().run()   # 父类做法

        print("我是一条狗，我有四条腿跑！！") # 我的做法

# 实例化

dog = Dog("小白","二哈","private_v1")

dog.eat()

dog.gogo()

结果：

一只名叫 小白 的 二哈 在啃骨头！！

跑！！

我是一条狗，我有四条腿跑！！

多继承：

在python中是可以多继承的，继承的先后顺序是有区别的，当我们调用方法的时候，如果第一个继承的找不到，才会去第二个中找，但是只要在第一个类中找到调用的那个方法，即使参数个数不匹配也不会调用第二个父类中的，此时会报错。

class Student:

    def study(self):

        print("我是学生，我爱学习，我爱班级！")

class Employee:

    def work(self):

        print("我要赚钱，我要工作，我爱工作！！")

class People(Student,Employee): # 继承Student类,Employee类

    def do_something(self):

        self.work()

        self.study()

p = People()

p.do_something()

结果：

我要赚钱，我要工作，我爱工作！！

我是学生，我爱学习，我爱班级！

3.多态

python中本质上是没有真正多态这种思路，只是形式上有这样一个多态的思路。

class Animal(object):

    def __init__(self,color):

        self.color=color

    def eat(self):

        print("吃饭")

class Cat(Animal):

    def eat(self):

        print("猫吃鱼")

class Dog(Animal):

    def __init__(self,name,age,color):

        super(Dog,self).__init__(color)

        self.name=name

        self.age=age

    def eat(self):

        print("狗吃肉")

def feed(obj):

        obj.eat()

an=Animal("白色")#实例化Animal

cat=Cat("棕色")#实例化Cat

dog=Dog("小黄",2,"黄色")#实例化Dog

feed(an)

feed(cat)

feed(dog)

结果：

吃饭

猫吃鱼

狗吃肉

定义了一个Animal父类，两个子类Cat和Dog里面都有eat()方法，最后再定义一个feed()喂养方法，

传入一个obj对象，调用obj.eat()，然后实例化Animal，Cat和Dog，分别在feed中传入实例化对象an，cat和dog会分别打印出不同的语句，这个就是python中的多态。

巴特西

(09)-Python3之--类的三大特性（封装、继承、多态）

1、封装

2、继承

3.多态

最新文章

热门文章