【python入门到精通】python面向对象三大特点:封装,继承,多态

🚀 作者 :“大数据小禅”

🚀 粉丝福利 :加入小禅的大数据社群

🚀 欢迎小伙伴们 点赞👍、收藏⭐、留言💬

python语言是一门面向对象的语言,面向过程其实就是把过程当做设计核心,根据问题的发展顺序,依次解决问题,尽可能的把过程中涉及到的问题完善解决。他有他的优点,当拿到一个问题时,可以方便的按执行的步骤写代码,但是当逻辑关系变得复杂时,有一个地方出现差错就会导致整个程序无从下手。类似面向对象的编程语言有很多,例如C++ , java等,而面向对象的三大特点就是-----封装,继承,多态,下面将详细说明这三大特点的理解与用法。

开始文章前先解释下object参数:

object:
注意类名后面括号里有个参数object,他代表所有类的基类,也叫作超类。
这就有了一个新式类和旧式类的概念:
当用到多继承的时候,如果子类中没有想用的方法名或属性名,他会自动回到上面去找。那么按广度优先遍历的方法去寻找就是新式类(object);深度优先(括号里啥也没有)。

一,python面向对象的特点------封装

可以简单的理解为隐藏一切可以隐藏的实现细节,只向外界提供简单的编程接口。我们在类中定义的方法其实就是把数据和数据的操作封装起来了,在我们创建了对象之后,只需要给对象发送一个消息(调用方法)就可以执行方法中的代码,也就是说我们只需要知道方法的名字和传入的参数(方法的外部视图),而不需要知道方法内部的实现细节(方法的内部视图)

面向对象第一步 : 将属性和方法封装到一个抽象的类中
外界使用类创建对象,然后让对象调用方法
对象方法的细节都封装在类的内部
  • 含义:对外面隐藏对象的属性和方法,仅提供接口。
  • 作用:安全性(通过私有变量改变对外的使用),复用性
下面两个例子对封装进行理解:

例子1:
1.TOM体重76.0公斤
2.TOM每次跑步会减肥0.5公斤
3.TOM每次吃东西会增重1攻击

class Test():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return '我的名字叫%s 体重是%d' %(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

TOM = Test('TOM',76.0)
print(TOM)
TOM.run()
print(TOM)
TOM.eat()
print(TOM)

输出:

我的名字叫TOM 体重是76.00
TOM爱跑步
我的名字叫TOM 体重是75.50
TOM吃东西
我的名字叫TOM 体重是76.50

例子2:
对tom分数的修改。

class Student(object):
      def __init__(self, name, score):
          # 属性仅前面有两个下划线代表私有变量,外部无法访问,因此我们定义了两个新的方法,这样可以避免外部通过score乱改分数,仅当我们自己知道接口才可以修改
          self.__name = name
          self.__score = score

      def info(self):
         print('name: %s ; score: %d' % (self.__name,self.__score))

      def getScore(self):
         return self.__score

      def setScore(self, score):
         self.__score = score

stu = Student('Tom',99)
print('修改前分数:',stu.getScore())
stu.info()
stu.setScore(59)
print('修改后分数:',stu.getScore())
stu.info()

二,python面向对象的特点------继承

含义:

面向对象编程有个好处就是代码复用,而其中一种方法就是通过继承机制。继承就是说定义的一个新类,继承现有的类,获得现有类的非私有属性、方法。提到个私有,就是上面提到的那个前面加两个下划线的那个东西,他在外部无法调用,继承他的子类也不能。被继承的那个类称为基类、父类或超类,继承的类叫子类也可以叫做派生类。
私有属性(补充):
在Python中,这一约定一般只是用来避免错误的方法调用,但完全无法阻止从外部调用这些被认为是“私有”的属性
python并没有真正的私有属性
用__定义的属性,只是被改名换姓而已
用_定义的属性,意义在于唤起用户的注意,看成私有属性
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

特点:

1、在继承中,基类的构造方法(init()方法)不会被自动调用,需要在子类的构造方法中专门调用。
2、在调用基类的方法时需要加上基类的类名前缀,并带上self参数变量。区别于在类中调用普通函数时不需要带self参数。
3、在python中,首先查找对应类型的方法,如果在子类中找不到对应的方法,才到基类中逐个查找。

在程序中继承是描述事物之间的所属关系,例如猫和狗都属于动物,程序中便可以描述为猫和狗继承自动物;同理,波斯猫和巴厘猫都继承自猫,而沙皮狗和斑点狗都继承自狗,子类可以继承父类的公有属性和公共方法,父类中的私有属性不能被继承。

1,单继承

一般只继承一个父类就叫单继承,在java等静态语言中只能继承一个父类,也就不存在单继承和多继承了,下面看一个实例理解单继承:

# 定义一个父类,如下:
class Cat(object):

    def __init__(self, name, color="白色",source=90):        #关键字参数
        self.name = name
        self.color = color
        self.source=source
    def run(self):
        print("%s--在跑"%self.name)


# 定义一个子类,继承Cat类如下:
class Bosi(Cat):
    # 子类没有实现__init__方法,则自动调用父类的__init__方法

    def setNewName(self, newName):
        self.name = newName

    def eat(self):
        print("%s--在吃"%self.name)


bs = Bosi("波斯猫")
print('波斯猫的名字为:%s'%bs.name)
print('波斯猫的颜色为:%s'%bs.color)
print('波斯猫的评分是:%d'%bs.source)
bs.eat()
bs.setNewName('印度猫')
bs.run()

输出(这里可以看到子类Bosi继承了父类的共有方法和公有属性):

波斯猫的名字为:波斯猫
波斯猫的颜色为:白色
波斯猫的评分是:90
波斯猫--在吃
印度猫--在跑

这两个类不写在一起也是可以的,例如将Cat这个类写到另一个模块animal中,
这时候只要前面的导入模块的知识将这个Cat类导入到有Bosi类的模块中即可跟上面输出的结果一样完成继承。
语法示例: from animal import Cat

有一点要注意:要打印关键词参数的话,子类要调用init后面的关键字参数才不会报错,
要调用除了init的其他方法关键字参数就需要别的办法

2 ,多继承

含义:多继承,即子类有多个父类,并且具有它们的特征,与单继承差别不大类似格式如下。

class A:        # 定义类 A
.....

class B:         # 定义类 B
.....

class C(A, B):   # 继承类 A 和 B
.....
3 , 重写父类的方法

所谓重写,就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法,例子如下:

class Cat:
    def sayHello(self):
        print("hello-----1")

class Bosi(Cat):

    def sayHello(self):
        print("hello-----2")
        
class Bali(Cat):

    def sayHello(self):
        print("hello-----3")

bosi = Bosi()
bali= Bali()
bosi.sayHello()
bali.sayHello()
"""
输出结果:
hello-----2
hello-----3
"""

三.python面向对象的特点------多态

通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本,当我们调用这个经过子类重写的方法时,不同的子类对象会表现出不同的行为,这个就是多态(poly-morphism),如上面的例子。

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>