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

jacktangj 2020-02-19

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中的多态。

相关推荐