字体在线设计网站,信阳专业网站建设,大数据网站建设和,企业建站公司案例封装、继承、多态
当谈到封装、继承和多态时，通常是在面向对象编程 (OOP) 的上下文中讨论的。
封装 (Encapsulation) 示例：
class Person: def __init__(self, name, age): self.__name = name # 使用双下划线前缀将属性变为私有 self.__age = age
de…封装、继承、多态
当谈到封装、继承和多态时，通常是在面向对象编程 (OOP) 的上下文中讨论的。
封装 (Encapsulation) 示例：
class Person: def __init__(self, name, age): self.__name = name # 使用双下划线前缀将属性变为私有 self.__age = age
def get_name(self): return self.__name
def set_name(self, new_name): if len(new_name) 0: self.__name = new_name
def get_age(self): return self.__age
def set_age(self, new_age): if new_age = 0: self.__age = new_age
# 创建一个Person对象并访问属性
person = Person("Alice", 30)
print(person.get_name()) # 输出：Alice
person.set_age(32) # 设置年龄
print(person.get_age()) # 输出：32
在这个示例中，我们通过将属性标记为私有（使用双下划线前缀）来封装数据，并提供公共方法（get_name、set_name、get_age、set_age）来访问和修改这些属性。这样，我们可以控制属性的访问和修改，以确保数据的安全性。
使用面向对象来开发，示例代码如下：
类：理解为模板对象：理解为实物在使用面向过程编程时，当需要对数据处理时，需要考虑用哪个模板中哪个函数来进行操作，但是当用面向对象编程时，因为已经将数据存储到了这个独立的空间中，这个独立的空间（即对象）中通过一个特殊的变量（__class__）能够获取到类（模板），而且这个类中的方法是有一定数量的，与此类无关的将不会出现在本类中，因此需要对数据处理时，可以很快速的定位到需要的方法是谁 这样更方便全局变量是只能有1份的，多个函数需要多个备份时，往往需要利用其它的变量来进行储存；而通过封装 会将用来存储数据的这个变量 变为了对象中的一个“全局”变量，只要对象不一样那么这个变量就可以再有1份，所以这样更方便代码划分更清晰继承 (Inheritance) 示例：
class Animal: def __init__(self, name): self.name = name
def speak(self): pass
class Dog(Animal): def speak(self): return f"{self.name} 说：汪汪汪！"
class Cat(Animal): def speak(self): return f"{self.name} 说：喵喵喵！"
# 创建一个Dog对象和一个Cat对象，并调用speak方法
dog = Dog("旺财")
cat = Cat("小花")
print(dog.speak()) # 输出：旺财 说：汪汪汪！
print(cat.speak()) # 输出：小花 说：喵喵喵！
在这个示例中，我们定义了一个基类 Animal，然后创建了两个派生类 Dog 和 Cat，它们继承了 Animal 的属性和方法。每个派生类都可以覆盖基类的方法（例如 speak），以实现自己的行为。 能够提升代码的重用率，即开发一个类，可以在多个子功能中直接使用继承能够有效的进行代码的管理，当某个类有问题只要修改这个类就行，而其继承这个类的子类往往不需要就修改多态 (Polymorphism) 示例：
class Shape: def area(self): pass
class Circle(Shape): def __init__(self, radius): self.radius = radius
def area(self): return 3.14 * self.radius * self.radius
class Rectangle(Shape): def __init__(self, length, width): self.length = length self.width = width
def area(self): return self.length * self.width
# 创建一个Shape的列表，包含不同类型的图形对象
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
# 计算并输出每个图形的面积
for shape in shapes: print(f"面积：{shape.area()}")
在这个示例中，我们定义了一个基类 Shape，以及两个派生类 Circle 和 Rectangle，它们都具有一个名为 area 的方法。通过多态，我们可以在一个列表中存储不同类型的图形对象，然后通过统一的方法调用来计算它们的面积。这就是多态的核心思想，不同的对象可以对相同的方法做出不同的响应。
class MiniOS(object):"""MiniOS 操作系统类 """def __init__(self, name):self.name = nameself.apps = [] # 安装的应用程序名称列表def __str__(self):return "%s 安装的软件列表为 %s" % (self.name, str(self.apps))def install_app(self, app):# 判断是否已经安装了软件if app.name in self.apps:print("已经安装了 %s，无需再次安装" % app.name)else:app.install()self.apps.append(app.name)class App(object):def __init__(self, name, version, desc):self.name = nameself.version = versionself.desc = descdef __str__(self):return "%s 的当前版本是 %s - %s" % (self.name, self.version, self.desc)def install(self):print("将 %s [%s] 的执行程序复制到程序目录..." % (self.name, self.version))class PyCharm(App):passclass Chrome(App):def install(self):print("正在解压缩安装程序...")super().install()linux = MiniOS("Linux")
print(linux)pycharm = PyCharm("PyCharm", "1.0", "python 开发的 IDE 环境")
chrome = Chrome("Chrome", "2.0", "谷歌浏览器")
chrome2 = Chrome("Chrome2", "3.0", "古哥浏览器")linux.install_app(pycharm)
linux.install_app(chrome)
linux.install_app(chrome)
linux.install_app(chrome2)print(linux)Linux 安装的软件列表为 []
将 PyCharm [1.0] 的执行程序复制到程序目录...
正在解压缩安装程序...
将 Chrome [2.0] 的执行程序复制到程序目录...
已经安装了 Chrome，无需再次安装
正在解压缩安装程序...
将 Chrome2 [3.0] 的执行程序复制到程序目录...
Linux 安装的软件列表为 ['PyCharm', 'Chrome', 'Chrome2']多态需要用到继承，重写，调用某个方法时，要看是父类创建的实例，还是子类创建的实例，实例不同调用的方法不同
关键点:
定义了一个基类App,它具有name、version、desc属性,以及一个install方法用于安装。定义了两个子类PyCharm和Chrome,继承自App。Chrome类对install方法进行了重写,添加了自定义的安装逻辑。在MainOS类中,通过install_app方法安装不同的App实例对象,调用其install方法。对于同一个install_app方法,传入不同的类的实例,会调用各自类中不同的install实现。这就是多态。多态允许我们基于同一接口编写可扩展和可维护的代码。子类可以改变父类的行为,同时保持接口一致。所以多态的关键是:
有继承关系子类覆盖父类方法对不同子类实例调用相同的方法这使得调用者可以一致地调用方法,而具体执行代码依赖于运行时对象的类型。这就是多态 面向过程开发，简单、开发前期快速，越往后越复杂，适合小工程 面向对象开发，复杂、开发前期较慢，越往后开发越方便，适合大工程 没有最好的开发模式，只有经过多多练习，见的多了，感受多了，自然也就能够在不同的任务、不同的工程，使用合适的方式进行开发 静态方法和类方法
类属性、实例属性
它们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同， 实例属性属于对象 类属性属于类 class Province(object):# 类属性country = 'china'def __init__(self, name):# 实例属性self.name = name# 创建一个实例对象
obj = Province('shangdong')
# 直接访问实例属性
print(obj.name)
# 直接访问类属性
Province.country
由上述代码可以看出【实例属性需要通过对象来访问】【类属性通过类访问】，在使用上可以看出实例属性和类属性的归属是不同的。
其在内容的存储方式类似如下图：
由上图看出： 类属性在内存中只保存一份 实例属性在每个对象中都要保存一份 通过类创建实例对象时，如果每个对象需要具有相同名字的属性，那么就使用类属性，用一份既可 实例方法、静态方法和类方法
方法包括：实例方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。 实例方法：由对象调用；至少一个self参数；执行实例方法时，自动将调用该方法的对象赋值给self； 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类赋值给cls； 静态方法：由类调用；无默认参数； class Foo(object):def __init__(self, name):self.name = namedef ord_func(self):""" 定义实例方法，至少有一个self参数 """# print(self.name)print('实例方法')@classmethoddef class_func(cls):""" 定义类方法，至少有一个cls参数 """print('类方法')@staticmethoddef static_func():""" 定义静态方法 ，无默认参数"""print('静态方法')f = Foo("china")
# 调用实例方法
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
实例方法
类方法
静态方法相同点：对于所有的方法而言，均属于类，所以 在内存中也只保存一份不同点：方法调用者不同、调用方法时自动传入的参数不同。# 实例方法
# self参数表示当前对象的实例
class Person:def __init__(self, name):self.name = namedef say_hello(self):print(f'Hello, my name is {self.name}')p = Person('John')
p.say_hello() # 调用实例方法,自动传递当前实例p作为self参数# 静态方法
# 使用@staticmethod装饰器声明,不需要默认的self参数
class Person:def __init__(self, name):self.name = name@staticmethoddef hello():print('Hello!')Person.hello() # 直接使用类名调用静态方法,不需要实例化# 类方法
# 使用@classmethod装饰器声明,默认参数cls代表当前类本身
class Person:count = 0 # 类属性def __init__(self, name):self.name =
