python实战：继承，封装，多态_python继承封装示例-CSDN博客

本文链接：https://blog.csdn.net/wwwkm123/article/details/124544857

一、面向对象程序设计三大特性：

1. 封装------将属性和⽅法封装到⼀个抽象的类中；

2. 继承------实现代码的重⽤；

3. 多态------不同的对象调⽤相同的⽅法，产⽣不同的执⾏结果，增加代码的

灵活度。

1.封装

类的私有属性和方法

私有属性/方法：对象不希望公开的属性/方法；

定义方式

在定义属性或⽅法时，在属性名或者⽅法名前 增加两个下划线，定义的就

是私有属性或方法。

对于私有属性和私有方法，只能在类的内部访问，类的外部无法访问

class Woman:
    def __init__(self, weight=0, age=0, name=""):
        # weight为私有属性
        self.__weight = weight
        # age为私有属性
        self.__age = age
        self.name = name

    def __secret(self):
        print("我的体重是%d千克，年龄是%d" % (self.__weight, self.__age))

    def show_secret(self):
        self.__secret()


if __name__ == '__main__':
    w = Woman(45, 20, "小丽")
    w.show_secret()

2.继承

一、继承的概念、语法和特点

继承的概念：⼦类拥有⽗类的所有⽅法和属性。北京市昌平区建材城西路金燕龙办公楼一层

电话：400-618-9090

二、继承的语法

class 类名(⽗类名):

pass

⼦类继承⾃⽗类，可以直接享受⽗类中已经封装好的⽅法，不需要再次开发

⼦类中应该根据职责，封装⼦类特有的属性和⽅法

class Animal:
    def __init__(self, name="小花"):
        self.name = name

    def sleep(self):
        print('%d在睡觉' % self.name)

    def eat(self):
        print('%d在吃饭' % self.name)


class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def run(self):
        print('%s的小猫%s在跑' % (self.color, self.name))


if __name__ == '__main__':
    c = Cat("豆豆", "黄色")
    c.run()
# 运行结果：黄色的小猫豆豆在跑

三、基类，派生类

dog 类是 animal 类的⼦类，animal 类是 dog 类的⽗类，dog 类从 animal

类继承

dog 类是 animal 类的派⽣类， animal 类是 dog 类的基类， dog 类从

animal 类派生

class Fish(Animal):
    def __init__(self, name):
        super().__init__(name)

    def swimming(self):
        print("%s游水" %self.name)


class Bird(Animal):
    def __init__(self, name):
        super().__init__(name)

    def fly(self):
        print("%s在飞" % self.name)

四、继承的传递性

C 类从 B 类继承， B 类⼜从 A 类继承 ;

那么 C 类就具有 B 类和 A 类的所有属性和⽅法 ;

⼦类拥有⽗类以及⽗类的⽗类中封装的所有属性和⽅法。

五、⽅法的重写

当⽗类的⽅法实现不能满⾜⼦类需求时，可以对⽅法进⾏重写(override)。

重写⽗类⽅法有两种情况：

1. 覆盖⽗类的⽅法 ;

2. 对⽗类⽅法进⾏扩展。

lass Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def eat(self):
        print('%s在吃猫粮' % self.name)

    def run(self):
        print('%s的小猫%s在跑' % (self.color, self.name))


class Fish(Animal):
    def __init__(self, name):
        super().__init__(name)

    def swimming(self):
        print("%s游水" % self.name)


class Bird(Animal):
    def __init__(self, name):
        super().__init__(name)

    def fly(self):
        print("%s在飞" % self.name)

    def eat(self):
        super().eat()
        print('%s在吃虫子' % self.name)


if __name__ == '__main__':
    c = Cat("豆豆", "黄色")
    c.run()
    c.eat()
    b = Bird("小鸟")
    b.eat()

# 黄色的小猫豆豆在跑
# 豆豆在吃猫粮
# 小鸟在吃饭
# 小鸟在吃虫子

六、⽗类的私有属性和私有⽅法

1. ⼦类对象不能在⾃⼰的⽅法内部，直接访问⽗类的私有属性或私有⽅法；

2. ⼦类对象可以通过⽗类的公有⽅法间接访问到私有属性或私有⽅法；

私有属性、⽅法是对象的隐私，不对外公开，外界以及⼦类都不能直接访问

私有属性、⽅法通常⽤于做⼀些内部的事情。

七、object 类

在 Python 3 中定义类时，如果没有指定⽗类，会默认使⽤ object 作为该类

的基类 —— Python 3 中定义的类都是新式类。

在 Python 2 中定义类时，如果没有指定⽗类，则不会以 object 作为基类。

建议统一继承自 object

class 类名(object):

pass

多态

不同的⼦类对象调⽤相同的⽗类⽅法，产⽣不同的执⾏结果

类属性和类⽅法

不需要创建类的对象，通过类名. 的⽅式就可以访问类的属性或者调用类的方法。

一、类属性

class A(object):
 # name 为类属性，通过 A.name 访问 
   name = "tom" 
   def __init__(self):
 # 属性 age 通过对象访问
      self.age = 20 
      print(A.name)
 
a = A() 
print(a.age)

二、类方法

用@classmethod 修饰的方法为类方法；
类方法的参数为 cls，在类方法内部通过 cls.类属性 或者 cls.类方法 来访问同一个类中的其他类属性和类方法；
类方法不需要实例化就可以调用，类方法只能访问同一个类中的类属性和类方法。

class A(object): 
   # name 为类属性 
   name = "tom" 
   def __init__(self): 
   # 属性 age 只能通过对象访问 
      self.age = 20 
    # show_name 为类方法 
   @classmethod 
   def show_name(cls):
      print(cls.name) 
A.show_name()

三、普通方法访问类属性或者类方法

在普通方法中通过类名.类属性或者类名.类方法来访问类属性和类方法

class A(object): 
    # name 为类属性 
    name = "tom" 
    # show_name 为类方法 
    @classmethod 
    def show_name(cls): 
       print(cls.name) 
    # set_name 为普通方法 
    def set_name(self, name): 
A.name = name 
A.show_name() 
a = A() 
a.set_name("mary") 
A.show_name()

四、静态⽅法

如果需要在类中封装⼀个⽅法，这个⽅法既不需要访问实例属性或者调⽤

实例⽅法也不需要访问类属性或者调⽤类⽅法, 这个时候，可以把这个⽅法封装

成⼀个静态⽅法。

用@staticmethod 修饰的方法为静态方法；
静态方法是独立存在的，不能访问类或者实例的任何属性和方法；
通过类名.静态方法调⽤静态⽅法。

语法如下

@staticmethod

def 静态⽅法名():

pass

class A(object): 
   # show_help 为类的静态方法 
   @staticmethod 
   def show_help(): 
      print("静态方法")