area += item.get_height() \* item.get_width()
return area
我们有一个包含矩形数据的Rectangle类,以及一个用作Rectangle对象集合的Board类。使用此设置,我们可以通过循环遍历rectangles集合属性中的项目并计算它们的面积来轻松找出板的面积。
此设置的问题在于我们受到可以传递给Board类的对象类型的限制。例如,如果我们想将一个Circle对象传递给Board类,我们需要编写条件语句和代码来检测和计算Board的面积。
解决这个问题的正确方法是将面积计算代码移到形状类中,并让所有形状类都扩展一个Shape接口。我们现在可以创建一个Rectangle和Circle形状类,它们将在被要求时计算它们的面积。
import math
class ShapeMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'area') and callable(subclass.area))
class ShapeInterface(metaclass=ShapeMeta):
pass
class Rectangle(ShapeInterface):
def __init__(self, width, height):
self._width = width
self._height = height
def get\_width(self):
return self._width
def set\_width(self, width):
self._width = width
def get\_height(self):
return self._height
def set\_height(self, height):
self._height = height
def area(self):
return self.get_width() \* self.get_height()
class Circle(ShapeInterface):
def __init__(self, radius):
self._radius = radius
def get\_radius(self):
return self._radius
def set\_radius(self, radius):
self._radius = radius
def area(self):
return self.get_radius() \* self.get_radius() \* math.pi
现在 可以重新设计Board类,使其不关心传递给它的形状类型,只要它们实现 area() 方法即可。
class Board():
def __init__(self, shapes):
self._shapes = shapes
def calculateArea(self):
area = 0
for shape in self._shapes:
area += shape.area()
return area
我们现在已经设置了这些对象,这意味着如果我们有不同类型的对象,我们不需要改变Board类。我们只是创建实现Shape的对象,并以与其他类相同的方式将其传递到集合中。
### 里氏替换原则
由 Barbara Liskov 在 1987 年创建,它指出对象应该可以被它们的子类型替换而不改变程序的工作方式。换句话说,派生类必须可以替代它们的基类而不会导致错误。
下面的代码定义了一个Rectangle类,我们可以用它来创建和计算矩形的面积。
class Rectangle():
def __init__(self, width, height):
self._width = width
self._height = height
def get\_width(self):
return self._width
def set\_width(self, width):
self._width = width
def get\_height(self):
return self._height
def set\_height(self, height):
self._height = height
def area(self):
return self.get\_width() \* self.get\_height()
使用它,我们可以将其扩展为Square类。因为正方形与矩形略有不同,我们需要重写一些代码以允许正方形正确存在。
class Square(Rectangle):
def __init__(self, width):
self._width = width
self._height = width
def get\_width(self):
return self._width
def set\_width(self, width):
self._width = width
self._height = width
def get\_height(self):
return self._height
def set\_height(self, height):
self._height = height
self._width = height
这看起来不错,但最终正方形不是矩形,因此我们添加了代码来强制这种情况起作用。
我读过的一个很好的类比是考虑类代表的鸭子和橡皮鸭。尽管可以将 Duck 类扩展为 Rubber Duck 类,但我们需要重写许多 Duck 功能以适应 Rubber Duck。例如,鸭子嘎嘎叫,但橡皮鸭不叫(好吧,也许它会吱吱叫),鸭子是活的,但橡皮鸭不是。
覆盖类中的大量代码以适应特定情况可能会导致维护问题。您为覆盖特定条件而添加的代码越多,您的代码就会变得越脆弱。
矩形与正方形情况的一种解决方案是创建一个名为Quadrilateral的接口,并在单独的Rectangle和Square 类中实现它。在这种情况下,我们允许类负责它们自己的数据,但强制要求某些方法足迹可用。
class QuadrilateralMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'area') and callable(subclass.area)) \
and (hasattr(subclass, 'get\_height') and callable(subclass.get_height)) \
and (hasattr(subclass, 'get\_width') and callable(subclass.get_width)) \
class QuadrilateralInterface(metaclass=QuadrilateralMeta):
pass
class Rectangle(QuadrilateralInterface):
pass
class Square(QuadrilateralInterface):
pass
这里的底线是,如果你发现你覆盖了很多代码,那么你的架构可能是错误的,你应该考虑 Liskov 替换原则。
### 接口隔离原则
这表明许多特定于客户端的接口优于一个通用接口。换句话说,不应强制类实现它们不使用的接口。
让我们以Worker接口为例。这定义了几种不同的方法,可以应用于典型开发机构的工作人员。
class WorkerMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'take\_break') and callable(subclass.take_break)) \
and (hasattr(subclass, 'write\_code') and callable(subclass.write_code)) \
and (hasattr(subclass, 'call\_client') and callable(subclass.call_client)) \
and (hasattr(subclass, 'get\_paid') and callable(subclass.get_paid))
class WorkerInterface(metaclass=WorkerMeta):
pass
问题是因为这个接口太通用了,我们不得不在实现这个接口的类中创建方法来适应这个接口。
例如,如果我们创建一个Manager类,那么我们将被迫实现一个 write\_code() 方法,因为这是接口所需要的。因为经理通常不编写代码,所以我们实际上无法在此方法中执行任何操作,因此我们只返回 false。
class Manager(WorkerInterface):
def write_code(self):
pass
此外,如果我们有一个实现Worker的Developer类,那么我们将被迫实现一个 call\_client() 方法,因为这是接口所需要的。
class Developer(WorkerInterface):
def call_client(self):
pass
拥有一个臃肿的接口意味着必须实现什么都不做的方法。
正确的解决方案是将我们的界面拆分成单独的部分,每个部分处理特定的功能。在这里,我们从我们的通用Worker接口中分离出Coder和ClientFacer接口。
class WorkerMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'take\_break') and callable(subclass.take_break)) \
and (hasattr(subclass, 'get\_paid') and callable(subclass.get_paid))
class WorkerInterface(metaclass=WorkerMeta):
pass
class ClientFacerMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'call\_client') and callable(subclass.call_client))
class ClientFacerInterface(metaclass=ClientFacerMeta):
pass
class CoderMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'write\_code') and callable(subclass.write_code))
class CoderInterface(metaclass=CoderMeta):
pass
有了这个,我们就可以实现我们的子类,而不必编写我们不需要的代码。所以我们的Developer和Manager类看起来像这样。
class Manager(WorkerInterface, ClientFacerInterface):
pass
class Developer(WorkerInterface, CoderInterface):
pass
拥有许多特定接口意味着我们不必编写代码来支持接口。
### 依赖倒置原则
也许是最简单的原则,它指出类应该依赖于抽象,而不是具体化。本质上,不依赖于具体类,依赖于接口。
以使用MySqlConnection类从数据库加载页面的PageLoader类为例,我们可以创建这些类,以便将连接类传递给PageLoader类的构造函数。
class MySqlConnection():
def connect(self):
pass
class PageLoader():
def __init__(self, mysql_connection: MySqlConnection):
self._mysql_connection = mysql_connection
这种结构意味着我们基本上只能在数据库层使用 MySQL。如果我们想将其换成不同的数据库适配器会怎样?我们可以扩展MySqlConnection类以创建到 Memcache 或其他东西的连接,但这会违反 Liskov 替换原则。可能会使用备用数据库管理器来加载页面,因此我们需要找到一种方法来执行此操作。
这里的解决方案是创建一个名为DbConnectionInterface的接口,然后在MySqlConnection类中实现这个接口。然后,我们不再依赖传递给PageLoader类的MySqlConnection对象,而是依赖任何实现DbConnectionInterface接口的类。
class DbConnectionMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))
def \_\_subclasscheck\_\_(self, subclass):
return (hasattr(subclass, 'connect') and callable(subclass.connect))
class DbConnectionInterface(metaclass=DbConnectionMeta):
pass
最后
🍅 硬核资料:关注即可领取PPT模板、简历模板、行业经典书籍PDF。
🍅 技术互助:技术群大佬指点迷津,你的问题可能不是问题,求资源在群里喊一声。
🍅 面试题库:由技术群里的小伙伴们共同投稿,热乎的大厂面试真题,持续更新中。
🍅 知识体系:含编程语言、算法、大数据生态圈组件(Mysql、Hive、Spark、Flink)、数据仓库、Python、前端等等。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!