In this article, you’ll explore inheritance and composition in Python. Inheritance and composition are two important concepts in object oriented programming that model the relationship between two classes. They are the building blocks of object oriented design, and they help programmers to write reusable code
By the end of this article, you’ll know how to
- Use inheritance in Python
- Model class hierarchies using inheritance
- Use multiple inheritance in Python and understand its drawbacks
- Use composition to create complex objects
- Reuse existing code by applying composition
- Change application behavior at run-time through composition
Free Bonus. Click here to get access to a free Python OOP Cheat Sheet that points you to the best tutorials, videos, and books to learn more about Object-Oriented Programming with Python
What Are Inheritance and Composition?
Inheritance and composition are two major concepts in object oriented programming that model the relationship between two classes. They drive the design of an application and determine how the application should evolve as new features are added or requirements change
Both of them enable code reuse, but they do it in different ways
Remove adsWhat’s Inheritance?
Inheritance models what is called an is a relationship. This means that when you have a
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Inheritance is represented using the Unified Modeling Language or UML in the following way
Classes are represented as boxes with the class name on top. The inheritance relationship is represented by an arrow from the derived class pointing to the base class. The word extends is usually added to the arrow
Note. In an inheritance relationship
- Classes that inherit from another are called derived classes, subclasses, or subtypes
- Classes from which other classes are derived are called base classes or super classes
- A derived class is said to derive, inherit, or extend a base class
Let’s say you have a base class
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
This is known as the Liskov substitution principle. The principle states that “in a computer program, if
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You’ll see in this article why you should always follow the Liskov substitution principle when creating your class hierarchies, and the problems you’ll run into if you don’t
What’s Composition?
Composition is a concept that models a has a relationship. It enables creating complex types by combining objects of other types. This means that a class
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
UML represents composition as follows
Composition is represented through a line with a diamond at the composite class pointing to the component class. The composite side can express the cardinality of the relationship. The cardinality indicates the number or valid range of
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
In the diagram above, the
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
- A number indicates the number of
603 instances that are contained in the# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
602# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate - The * symbol indicates that the
602 class can contain a variable number of# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
603 instances# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate - A range 1. 4 indicates that the
602 class can contain a range of# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
603 instances. The range is indicated with the minimum and maximum number of instances, or minimum and many instances like in 1. *# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
Note. Classes that contain objects of other classes are usually referred to as composites, where classes that are used to create more complex types are referred to as components
For example, your
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Composition enables you to reuse code by adding objects to other objects, as opposed to inheriting the interface and implementation of other classes. Both
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
An Overview of Inheritance in Python
Everything in Python is an object. Modules are objects, class definitions and functions are objects, and of course, objects created from classes are objects too
Inheritance is a required feature of every object oriented programming language. This means that Python supports inheritance, and as you’ll see later, it’s one of the few languages that supports multiple inheritance
When you write Python code using classes, you are using inheritance even if you don’t know you’re using it. Let’s take a look at what that means
Remove adsThe Object Super Class
The easiest way to see inheritance in Python is to jump into the Python interactive shell and write a little bit of code. You’ll start by writing the simplest class possible
>>>
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
You declared a class
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
>>>
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
>>>
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
As you can see, the two lists are nearly identical. There are some additional members in
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
This is because every class you create in Python implicitly derives from
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Ghi chú. In Python 2, you have to explicitly derive from
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Exceptions Are an Exception
Every class that you create in Python will implicitly derive from
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
You can see the problem using the Python interactive interpreter
>>>
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn đã tạo một lớp mới để chỉ ra một loại lỗi. Sau đó, bạn đã cố gắng sử dụng nó để đưa ra một ngoại lệ. Một ngoại lệ được đưa ra nhưng đầu ra cho biết ngoại lệ đó thuộc loại
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Cách chính xác để xác định loại lỗi của bạn là như sau
>>>
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Như bạn có thể thấy, khi bạn nâng cấp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Tạo phân cấp lớp
Kế thừa là cơ chế bạn sẽ sử dụng để tạo phân cấp của các lớp liên quan. Các lớp liên quan này sẽ chia sẻ một giao diện chung sẽ được định nghĩa trong các lớp cơ sở. Các lớp dẫn xuất có thể chuyên biệt hóa giao diện bằng cách cung cấp một triển khai cụ thể khi áp dụng
Trong phần này, bạn sẽ bắt đầu lập mô hình hệ thống nhân sự. Ví dụ này sẽ chứng minh việc sử dụng tính kế thừa và cách các lớp dẫn xuất có thể cung cấp triển khai cụ thể của giao diện lớp cơ sở
Hệ thống nhân sự cần xử lý bảng lương cho nhân viên của công ty, nhưng có nhiều loại nhân viên khác nhau tùy thuộc vào cách tính lương của họ
Bạn bắt đầu bằng cách triển khai lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bây giờ, bạn triển khai lớp cơ sở
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Hệ thống nhân sự yêu cầu mỗi
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Ví dụ, nhân viên hành chính có mức lương cố định, vì vậy hàng tuần họ được trả số tiền như nhau
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn tạo một lớp dẫn xuất
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lớp cung cấp phương thức
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Công ty cũng sử dụng công nhân sản xuất được trả lương theo giờ, vì vậy bạn thêm một số 1670 vào hệ thống nhân sự
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Finally, the company employs sales associates that are paid through a fixed salary plus a commission based on their sales, so you create a
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You derive
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Since
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
The problem with accessing the property directly is that if the implementation of
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
You created your first class hierarchy for the system. Sơ đồ UML của các lớp trông như thế này
The diagram shows the inheritance hierarchy of the classes. The derived classes implement the
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Interfaces are represented similarly to classes with the word interface above the interface name. Interface names are usually prefixed with a capital
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
The application creates its employees and passes them to the payroll system to process payroll
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
You can run the program in the command line and see the results
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
The program creates three employee objects, one for each of the derived classes. Then, it creates the payroll system and passes a list of the employees to its
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Notice how the
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
>>>
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
While you can instantiate an
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Abstract Base Classes in Python
The
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You can use leading underscores in your class name to communicate that objects of that class should not be created. Underscores provide a friendly way to prevent misuse of your code, but they don’t prevent eager users from creating instances of that class
The
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You can modify the implementation of the
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
You derive
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
This change has two nice side-effects
- You’re telling users of the module that objects of type
651 can’t be created# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate - You’re telling other developers working on the
421 module that if they derive from# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
651, then they must override the# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
647 abstract method# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
You can see that objects of type
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
>>>
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
The output shows that the class cannot be instantiated because it contains an abstract method
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Implementation Inheritance vs Interface Inheritance
When you derive one class from another, the derived class inherits both
The base class interface. The derived class inherits all the methods, properties, and attributes of the base class
The base class implementation. The derived class inherits the code that implements the class interface
Most of the time, you’ll want to inherit the implementation of a class, but you will want to implement multiple interfaces, so your objects can be used in different situations
Các ngôn ngữ lập trình hiện đại được thiết kế dựa trên khái niệm cơ bản này. They allow you to inherit from a single class, but you can implement multiple interfaces
In Python, you don’t have to explicitly declare an interface. Any object that implements the desired interface can be used in place of another object. This is known as duck typing. Gõ vịt thường được giải thích là “nếu nó hoạt động giống như một con vịt, thì đó là một con vịt. ”
Để minh họa điều này, bây giờ bạn sẽ thêm một lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
- Thuộc tính hoặc thuộc tính
648 trả về id của nhân viên# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate - Thuộc tính hoặc thuộc tính
649 đại diện cho tên của nhân viên# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate - Phương thức
647 không nhận bất kỳ tham số nào và trả về số tiền lương để xử lý# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
Tất cả các yêu cầu này đều được đáp ứng bởi lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn có thể sửa đổi chương trình để sử dụng lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Chương trình tạo một đối tượng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Như bạn thấy,
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Vì bạn không cần phải xuất phát từ một lớp cụ thể để chương trình có thể sử dụng lại các đối tượng của bạn, bạn có thể hỏi tại sao bạn nên sử dụng tính kế thừa thay vì chỉ triển khai giao diện mong muốn. Các quy tắc sau đây có thể giúp bạn
Sử dụng kế thừa để sử dụng lại một triển khai. Các lớp dẫn xuất của bạn nên tận dụng hầu hết việc triển khai lớp cơ sở của chúng. Họ cũng phải mô hình hóa một mối quan hệ. Một lớp
441 cũng có thể có một# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
648 và một# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
649, nhưng một# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
441 không phải là một# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
651, vì vậy bạn không nên sử dụng thừa kế# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rateThực hiện một giao diện được sử dụng lại. Khi bạn muốn lớp của mình được sử dụng lại bởi một phần cụ thể của ứng dụng, bạn triển khai giao diện được yêu cầu trong lớp của mình, nhưng bạn không cần cung cấp lớp cơ sở hoặc kế thừa từ lớp khác
Bây giờ bạn có thể làm sạch ví dụ trên để chuyển sang chủ đề tiếp theo. Bạn có thể xóa tệp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn đã loại bỏ việc nhập mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Về cơ bản, bạn đang kế thừa việc triển khai các thuộc tính
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lưu ý cách lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Vấn đề bùng nổ lớp học
Nếu bạn không cẩn thận, tính kế thừa có thể dẫn bạn đến một cấu trúc phân cấp khổng lồ của các lớp khó hiểu và khó duy trì. Đây được gọi là vấn đề bùng nổ lớp
Bạn đã bắt đầu xây dựng hệ thống phân cấp lớp gồm các loại
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
- quản lý. Họ đi xung quanh và la mắng mọi người bảo họ phải làm gì. Họ là những người làm công ăn lương và kiếm được nhiều tiền hơn
- thư ký. Họ làm tất cả các công việc giấy tờ cho người quản lý và đảm bảo rằng mọi thứ được lập hóa đơn và thanh toán đúng hạn. Họ cũng là người làm công ăn lương nhưng kiếm được ít tiền hơn
- nhân viên kinh doanh. Họ thực hiện rất nhiều cuộc điện thoại để bán sản phẩm. Họ có lương, nhưng họ cũng nhận được hoa hồng khi bán hàng
- Công nhân nhà máy. Họ sản xuất các sản phẩm cho công ty. Họ được trả lương theo giờ
Với những yêu cầu đó, bạn bắt đầu thấy rằng
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn tạo một mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Việc triển khai vẫn giữ nguyên, nhưng bạn chuyển các lớp sang mô-đun
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn chạy chương trình và xác minh rằng nó vẫn hoạt động
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Với mọi thứ đã sẵn sàng, bạn bắt đầu thêm các lớp mới
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Đầu tiên, bạn thêm một lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Sau đó, bạn thêm
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ, bạn có thể thêm lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp theo dõi nhân viên theo phương thức
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Chương trình tạo danh sách nhân viên các loại. Danh sách nhân viên được gửi đến hệ thống năng suất để theo dõi công việc của họ trong 40 giờ. Sau đó, cùng một danh sách nhân viên được gửi đến hệ thống bảng lương để tính lương cho họ
Bạn có thể chạy chương trình để xem đầu ra
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Chương trình hiển thị các nhân viên làm việc trong 40 giờ thông qua hệ thống năng suất. Sau đó, nó tính toán và hiển thị bảng lương cho từng nhân viên
Chương trình hoạt động như mong đợi, nhưng bạn phải thêm bốn lớp mới để hỗ trợ các thay đổi. Khi có các yêu cầu mới, hệ thống phân cấp lớp của bạn chắc chắn sẽ phát triển, dẫn đến vấn đề bùng nổ lớp trong đó hệ thống phân cấp của bạn sẽ trở nên lớn đến mức chúng sẽ khó hiểu và khó duy trì
Sơ đồ sau đây cho thấy hệ thống phân cấp lớp mới
Sơ đồ cho thấy hệ thống phân cấp lớp đang phát triển như thế nào. Các yêu cầu bổ sung có thể có tác động theo cấp số nhân về số lượng lớp học với thiết kế này
Remove adsKế thừa nhiều lớp
Python là một trong số ít ngôn ngữ lập trình hiện đại hỗ trợ đa kế thừa. Đa kế thừa là khả năng dẫn xuất một lớp từ nhiều lớp cơ sở cùng một lúc
Đa kế thừa có tiếng xấu đến mức hầu hết các ngôn ngữ lập trình hiện đại không hỗ trợ nó. Thay vào đó, các ngôn ngữ lập trình hiện đại hỗ trợ khái niệm giao diện. Trong các ngôn ngữ đó, bạn kế thừa từ một lớp cơ sở duy nhất và sau đó triển khai nhiều giao diện, vì vậy lớp của bạn có thể được sử dụng lại trong các tình huống khác nhau
Cách tiếp cận này đặt ra một số ràng buộc trong thiết kế của bạn. Bạn chỉ có thể kế thừa việc triển khai một lớp bằng cách xuất phát trực tiếp từ nó. Bạn có thể triển khai nhiều giao diện, nhưng bạn không thể kế thừa việc triển khai nhiều lớp
Ràng buộc này tốt cho thiết kế phần mềm vì nó buộc bạn phải thiết kế các lớp của mình với ít phụ thuộc lẫn nhau hơn. Ở phần sau của bài viết này, bạn sẽ thấy rằng bạn có thể tận dụng nhiều triển khai thông qua thành phần, giúp phần mềm trở nên linh hoạt hơn. Tuy nhiên, phần này nói về đa thừa kế, vì vậy chúng ta hãy xem nó hoạt động như thế nào
Hóa ra đôi khi thư ký tạm thời được thuê khi có quá nhiều giấy tờ phải làm. Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn nhìn vào thiết kế lớp học của bạn. Nó đã phát triển một chút, nhưng bạn vẫn có thể hiểu nó hoạt động như thế nào. Có vẻ như bạn có hai lựa chọn
Xuất phát từ
476. Bạn có thể lấy từ# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
476 để kế thừa phương thức# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
488 cho vai trò, sau đó ghi đè phương thức# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
647 để triển khai nó dưới dạng# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
670# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rateXuất phát từ
670. Bạn có thể bắt nguồn từ# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
670 để kế thừa phương thức# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
647, sau đó ghi đè phương thức# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
488 để triển khai nó dưới dạng# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
476# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
Sau đó, bạn nhớ rằng Python hỗ trợ đa kế thừa, vì vậy bạn quyết định lấy từ cả
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Python cho phép bạn kế thừa từ hai lớp khác nhau bằng cách chỉ định chúng giữa dấu ngoặc đơn trong khai báo lớp
Bây giờ, bạn sửa đổi chương trình của mình để thêm nhân viên thư ký tạm thời mới
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn chạy chương trình để kiểm tra
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn nhận được một ngoại lệ
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Điều này là do bạn bắt nguồn
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Được rồi, hãy đảo ngược nó
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ, hãy chạy lại chương trình và xem điều gì sẽ xảy ra
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ có vẻ như bạn đang thiếu một tham số
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Có thể triển khai
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Thử nó
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Điều đó cũng không hiệu quả. Được rồi, đã đến lúc bạn đi sâu vào trình tự giải quyết phương pháp Python [MRO] để xem điều gì đang xảy ra
Khi một phương thức hoặc thuộc tính của một lớp được truy cập, Python sử dụng lớp MRO để tìm nó. MRO cũng được sử dụng bởi
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn có thể đánh giá MRO lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
>>>
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
MRO hiển thị thứ tự mà Python sẽ tìm kiếm một thuộc tính hoặc phương thức phù hợp. Trong ví dụ này, đây là điều xảy ra khi chúng ta tạo đối tượng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Phương pháp
414 được gọi là# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commissionCuộc gọi ________ 5415 khớp với ________ 5416
670 gọi# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
418, mà MRO sẽ khớp với# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
404, được kế thừa từ# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
420# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
Bởi vì các tham số không khớp, một ngoại lệ
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn có thể bỏ qua MRO bằng cách đảo ngược thứ tự thừa kế và gọi trực tiếp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Điều đó giải quyết vấn đề tạo đối tượng, nhưng bạn sẽ gặp phải vấn đề tương tự khi cố tính bảng lương. Bạn có thể chạy chương trình để xem vấn đề
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Vấn đề bây giờ là vì bạn đã đảo ngược thứ tự thừa kế, MRO đang tìm phương thức
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Phương thức
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Chương trình hiện hoạt động như mong đợi vì bạn đang buộc thứ tự giải quyết phương thức bằng cách thông báo rõ ràng cho trình thông dịch biết phương pháp nào chúng tôi muốn sử dụng
Như bạn có thể thấy, đa thừa kế có thể gây nhầm lẫn, đặc biệt khi bạn gặp vấn đề về kim cương
Sơ đồ sau đây cho thấy vấn đề kim cương trong hệ thống phân cấp lớp học của bạn
Sơ đồ cho thấy vấn đề kim cương với thiết kế lớp hiện tại.
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Vấn đề kim cương xuất hiện khi bạn đang sử dụng nhiều kế thừa và xuất phát từ hai lớp có lớp cơ sở chung. Điều này có thể gây ra phiên bản sai của một phương thức được gọi
Như bạn đã thấy, Python cung cấp một cách để buộc gọi đúng phương thức và việc phân tích MRO có thể giúp bạn hiểu vấn đề
Tuy nhiên, khi bạn gặp vấn đề về kim cương, tốt hơn hết là bạn nên suy nghĩ lại về thiết kế. Bây giờ bạn sẽ thực hiện một số thay đổi để tận dụng đa kế thừa, tránh vấn đề kim cương
Các lớp dẫn xuất
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Hệ thống năng suất theo dõi năng suất của nhân viên
Hệ thống bảng lương tính toán bảng lương của nhân viên
Điều này có nghĩa là mọi thứ liên quan đến năng suất phải được đặt cùng nhau trong một mô-đun và mọi thứ liên quan đến bảng lương phải được đặt cùng nhau trong một mô-đun khác. Bạn có thể bắt đầu thực hiện các thay đổi đối với mô-đun năng suất
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn có thể làm tương tự với mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bây giờ bạn có thể thêm các lớp cần thiết vào mô-đun
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lưu ý rằng bạn vẫn cần khởi tạo rõ ràng các chính sách tiền lương trong hàm tạo. Bạn có thể thấy rằng phần khởi tạo của
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn sẽ không muốn có kiểu sao chép mã này trong các thiết kế phức tạp hơn, vì vậy bạn phải cẩn thận khi thiết kế hệ thống phân cấp lớp
Đây là sơ đồ UML cho thiết kế mới
Sơ đồ hiển thị các mối quan hệ để xác định
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn có thể chạy chương trình và xem nó hoạt động như thế nào
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn đã thấy cách hoạt động của thừa kế và đa thừa kế trong Python. Bây giờ bạn có thể khám phá chủ đề sáng tác
Remove adsThành phần trong Python
Thành phần là một khái niệm thiết kế hướng đối tượng mà mô hình có một mối quan hệ. Trong thành phần, một lớp được gọi là hỗn hợp chứa một đối tượng của một lớp khác được gọi là thành phần. Nói cách khác, một lớp tổng hợp có một thành phần của lớp khác
Thành phần cho phép các lớp tổng hợp sử dụng lại việc triển khai các thành phần mà nó chứa. Lớp tổng hợp không kế thừa giao diện lớp thành phần, nhưng nó có thể tận dụng việc triển khai của nó
Mối quan hệ thành phần giữa hai lớp được coi là liên kết lỏng lẻo. Điều đó có nghĩa là những thay đổi đối với lớp thành phần hiếm khi ảnh hưởng đến lớp tổng hợp và những thay đổi đối với lớp tổng hợp không bao giờ ảnh hưởng đến lớp thành phần
Điều này cung cấp khả năng thích ứng tốt hơn để thay đổi và cho phép các ứng dụng đưa ra các yêu cầu mới mà không ảnh hưởng đến mã hiện có
Khi xem xét hai thiết kế phần mềm cạnh tranh, một dựa trên tính kế thừa và một dựa trên thành phần, giải pháp thành phần thường là linh hoạt nhất. Bây giờ bạn có thể xem cách sáng tác hoạt động
Bạn đã sử dụng bố cục trong các ví dụ của chúng tôi. Nếu bạn nhìn vào lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
648 để xác định một nhân viên# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
649 để chứa tên của nhân viên# In hr.py class HourlyEmployee[Employee]: def __init__[self, id, name, hours_worked, hour_rate]: super[].__init__[id, name] self.hours_worked = hours_worked self.hour_rate = hour_rate def calculate_payroll[self]: return self.hours_worked * self.hour_rate
Hai thuộc tính này là các đối tượng mà lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Một thuộc tính khác cho một
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn đã triển khai một lớp địa chỉ cơ bản chứa các thành phần thông thường cho một địa chỉ. Bạn đã đặt thuộc tính
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn đã triển khai
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
>>>
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Khi bạn
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ bạn có thể thêm
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ, bạn khởi tạo thuộc tính
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Thành phần là một mối quan hệ kết hợp lỏng lẻo thường không yêu cầu lớp tổng hợp phải có kiến thức về thành phần
Sơ đồ UML thể hiện mối quan hệ giữa
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Sơ đồ cho thấy mối quan hệ thành phần cơ bản giữa
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ bạn có thể sửa đổi lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn kiểm tra xem đối tượng
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn đã thêm một vài địa chỉ vào các đối tượng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lưu ý cách đầu ra bảng lương cho các đối tượng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Thiết kế linh hoạt với bố cục
Thành phần linh hoạt hơn thừa kế vì nó mô hình hóa mối quan hệ kết hợp lỏng lẻo. Các thay đổi đối với một lớp thành phần có ảnh hưởng tối thiểu hoặc không ảnh hưởng đến lớp tổng hợp. Thiết kế dựa trên thành phần phù hợp hơn để thay đổi
Bạn thay đổi hành vi bằng cách cung cấp các thành phần mới triển khai các hành vi đó thay vì thêm các lớp mới vào hệ thống phân cấp của bạn
Hãy xem ví dụ đa thừa kế ở trên. Hãy tưởng tượng chính sách tiền lương mới sẽ ảnh hưởng đến thiết kế như thế nào. Cố gắng hình dung hệ thống phân cấp lớp sẽ như thế nào nếu cần có vai trò mới. Như bạn đã thấy trước đây, việc phụ thuộc quá nhiều vào tính kế thừa có thể dẫn đến bùng nổ giai cấp
Vấn đề lớn nhất không phải là số lượng các lớp trong thiết kế của bạn nhiều như thế nào, mà là mối quan hệ giữa các lớp đó chặt chẽ đến mức nào. Các lớp liên kết chặt chẽ ảnh hưởng lẫn nhau khi các thay đổi được đưa ra
Trong phần này, bạn sẽ sử dụng bố cục để thực hiện một thiết kế tốt hơn mà vẫn phù hợp với các yêu cầu của
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn có thể bắt đầu bằng cách triển khai chức năng của
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Nó cũng hiển thị chức năng trước đó trong phương pháp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ bạn có thể triển khai các lớp vai trò khác nhau
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Mỗi vai trò bạn đã triển khai hiển thị một
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Các lớp vai trò độc lập với nhau, nhưng chúng hiển thị cùng một giao diện, vì vậy chúng có thể hoán đổi cho nhau. Sau này bạn sẽ thấy chúng được sử dụng như thế nào trong ứng dụng
Bây giờ, bạn có thể triển khai
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Việc triển khai
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bây giờ bạn có thể thực hiện các lớp chính sách trả lương
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Trước tiên, bạn triển khai lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Các lớp chính sách khác bắt nguồn từ
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ bạn có thể thêm lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Việc triển khai lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp quản lý các thành phần địa chỉ và cung cấp một biểu diễn đẹp về địa chỉ
Cho đến nay, các lớp mới đã được mở rộng để hỗ trợ nhiều chức năng hơn, nhưng không có thay đổi đáng kể nào đối với thiết kế trước đó. Điều này sẽ thay đổi với thiết kế của mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn có thể bắt đầu bằng cách triển khai một lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Nó hiển thị thuộc tính
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp hiển thị một phương thức
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Theo cách tương tự, nó ủy quyền cho đối tượng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Sơ đồ sau đây cho thấy thiết kế thành phần được sử dụng
Sơ đồ cho thấy thiết kế của các chính sách dựa trên thành phần. Có một
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bây giờ bạn có thể sử dụng thiết kế này trong chương trình của mình
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn có thể chạy chương trình để xem đầu ra của nó
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Thiết kế này được gọi là thiết kế dựa trên chính sách, trong đó các lớp bao gồm các chính sách và chúng ủy quyền cho các chính sách đó để thực hiện công việc
Thiết kế dựa trên chính sách đã được giới thiệu trong cuốn sách Modern C++ Design và nó sử dụng siêu lập trình mẫu trong C++ để đạt được kết quả
Python không hỗ trợ các mẫu, nhưng bạn có thể đạt được kết quả tương tự bằng cách sử dụng bố cục, như bạn đã thấy trong ví dụ trên
Kiểu thiết kế này mang đến cho bạn tất cả sự linh hoạt mà bạn cần khi các yêu cầu thay đổi. Hãy tưởng tượng bạn cần thay đổi cách tính lương cho một đối tượng trong thời gian chạy
Remove adsTùy chỉnh hành vi với thành phần
Nếu thiết kế của bạn dựa trên sự kế thừa, bạn cần tìm cách thay đổi loại đối tượng để thay đổi hành vi của nó. Với bố cục, bạn chỉ cần thay đổi chính sách mà đối tượng sử dụng
Hãy tưởng tượng rằng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Chương trình lấy danh sách nhân viên từ
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Chính sách mới hiện được sử dụng bởi
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Tấm séc cho Mary Poppins, người quản lý của chúng tôi, hiện có giá 2200 đô la thay vì mức lương cố định 3000 đô la mà cô ấy có mỗi tuần
Lưu ý cách chúng tôi đã thêm quy tắc kinh doanh đó vào chương trình mà không thay đổi bất kỳ lớp hiện có nào. Xem xét loại thay đổi nào sẽ được yêu cầu với thiết kế kế thừa
Bạn sẽ phải tạo một lớp mới và thay đổi loại nhân viên quản lý. Không có khả năng bạn có thể thay đổi chính sách trong thời gian chạy
Lựa chọn giữa Kế thừa và Thành phần trong Python
Cho đến giờ, bạn đã thấy cách hoạt động của tính kế thừa và thành phần trong Python. Bạn đã thấy rằng các lớp dẫn xuất kế thừa giao diện và triển khai của các lớp cơ sở của chúng. Bạn cũng đã thấy rằng thành phần cho phép bạn sử dụng lại việc triển khai một lớp khác
Bạn đã triển khai hai giải pháp cho cùng một vấn đề. Giải pháp đầu tiên sử dụng đa kế thừa và giải pháp thứ hai sử dụng thành phần
Bạn cũng đã thấy rằng cách gõ vịt của Python cho phép bạn sử dụng lại các đối tượng với các phần hiện có của chương trình bằng cách triển khai giao diện mong muốn. Trong Python, không cần thiết phải xuất phát từ một lớp cơ sở để các lớp của bạn được sử dụng lại
Tại thời điểm này, bạn có thể hỏi khi nào nên sử dụng thừa kế so với thành phần trong Python. Cả hai đều cho phép sử dụng lại mã. Kế thừa và thành phần có thể giải quyết các vấn đề tương tự trong chương trình Python của bạn
Lời khuyên chung là sử dụng mối quan hệ tạo ra ít phụ thuộc hơn giữa hai lớp. Mối quan hệ này là thành phần. Tuy nhiên, sẽ có lúc việc kế thừa sẽ có ý nghĩa hơn
Các phần sau đây cung cấp một số hướng dẫn để giúp bạn đưa ra lựa chọn đúng đắn giữa kế thừa và thành phần trong Python
Kế thừa mô hình Mối quan hệ “Là A”
Kế thừa chỉ nên được sử dụng để mô hình hóa một mối quan hệ. Nguyên tắc thay thế của Liskov nói rằng một đối tượng kiểu
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Nguyên tắc thay thế Liskov là hướng dẫn quan trọng nhất để xác định xem kế thừa có phải là giải pháp thiết kế phù hợp hay không. Tuy nhiên, câu trả lời có thể không đơn giản trong mọi tình huống. May mắn thay, có một bài kiểm tra đơn giản mà bạn có thể sử dụng để xác định xem thiết kế của mình có tuân theo nguyên tắc thay thế của Liskov hay không
Giả sử bạn có một lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Đánh giá
279 là một# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
278. Hãy suy nghĩ về mối quan hệ này và biện minh cho nó. Liệu nó có ý nghĩa?# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commissionĐánh giá
278 là một# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
279. Đảo ngược mối quan hệ và biện minh cho nó. Liệu nó cũng có ý nghĩa?# In hr.py class CommissionEmployee[SalaryEmployee]: def __init__[self, id, name, weekly_salary, commission]: super[].__init__[id, name, weekly_salary] self.commission = commission def calculate_payroll[self]: fixed = super[].calculate_payroll[] return fixed + self.commission
Nếu bạn có thể biện minh cho cả hai mối quan hệ, thì bạn không bao giờ nên kế thừa các lớp đó từ lớp khác. Hãy xem xét một ví dụ cụ thể hơn
Bạn có một lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Trước khi bắt đầu triển khai, bạn sử dụng nguyên tắc thay thế Liskov để đánh giá mối quan hệ
Một
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Nó có ý nghĩa. Bạn có thể biện minh cho mối quan hệ và giải thích tại sao ________ 6288 lại là ________ 6286. Hãy đảo ngược mối quan hệ để xem nó có hợp lý không
A
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Nó cũng có ý nghĩa. Bạn có thể biện minh cho mối quan hệ và mô tả các ràng buộc đặc biệt cho mỗi lớp. Đây là một dấu hiệu tốt rằng hai lớp này sẽ không bao giờ xuất phát từ nhau
You might have seen other examples that derive
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
First, you implement
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
The
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Now, you derive
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
The
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
The program creates a
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
The program executes correctly, so it seems that
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Later on, you need to support resizing
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You resize the rectangle object and assert that the new area is correct. You can run the program to verify the behavior
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
The assertion passes, and you see that the program runs correctly
So, what happens if you resize a square? Modify the program, and try to modify the
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You pass the same parameters to
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
The program shows that the new area is
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
How can you fix that problem? You can try several approaches, but all of them will be awkward. You can override
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
In a small program like this one, it might be easy to spot the causes of the weird behavior, but in a more complex program, the problem will be harder to find
The reality is that if you’re able to justify an inheritance relationship between two classes both ways, you should not derive one class from another
In the example, it doesn’t make sense that
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Sự khác biệt trong giao diện này biện minh cho việc không xuất phát
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Trộn các tính năng với các lớp Mixin
Một trong những cách sử dụng đa kế thừa trong Python là mở rộng các tính năng của lớp thông qua mixin. Mixin là một lớp cung cấp các phương thức cho các lớp khác nhưng không được coi là một lớp cơ sở
Mixin cho phép các lớp khác sử dụng lại giao diện và triển khai của nó mà không trở thành siêu lớp. Chúng triển khai một hành vi duy nhất có thể được tổng hợp cho các lớp không liên quan khác. Chúng tương tự như thành phần nhưng chúng tạo ra một mối quan hệ mạnh mẽ hơn
Giả sử bạn muốn chuyển đổi các đối tượng thuộc một số loại nhất định trong ứng dụng của mình thành biểu diễn từ điển của đối tượng. Bạn có thể cung cấp phương thức
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Đây có thể là một ứng cử viên sáng giá cho mixin. Bạn bắt đầu bằng cách sửa đổi một chút lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Sự thay đổi là rất nhỏ. Bạn vừa thay đổi thuộc tính
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ, bạn thêm lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Ghi chú. Đây là lý do tại sao chúng tôi tạo các thuộc tính vai trò và bảng lương bên trong lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Như bạn đã thấy ở phần đầu, việc tạo một lớp kế thừa một số thành viên từ
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn duyệt qua tất cả các mục trong
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn có thể sửa đổi lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Tất cả những gì bạn phải làm là kế thừa
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn áp dụng mixin cho lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Chương trình triển khai một
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Sau đó, nó lặp qua tất cả các nhân viên, in biểu diễn từ điển được cung cấp bởi
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn đã tận dụng việc triển khai
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Thành phần cho Mô hình Mối quan hệ “Có A”
Các mô hình thành phần a có mối quan hệ. Với thành phần, một lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Trong ví dụ thành phần ở trên, lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Các lớp khác như
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Một vấn đề bạn có thể gặp phải khi sử dụng thành phần là một số lớp của bạn có thể bắt đầu phát triển bằng cách sử dụng nhiều thành phần. Các lớp của bạn có thể yêu cầu nhiều tham số trong hàm tạo chỉ để truyền vào các thành phần mà chúng được tạo thành. Điều này có thể làm cho các lớp học của bạn khó sử dụng
Một cách để tránh vấn đề là sử dụng Factory Method để xây dựng các đối tượng của bạn. Bạn đã làm điều đó với ví dụ thành phần
Nếu bạn nhìn vào việc triển khai lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Thiết kế này sẽ hoạt động, nhưng lý tưởng nhất là bạn có thể xây dựng một đối tượng
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Những thay đổi sau đây có thể cải thiện thiết kế của bạn. Bạn có thể bắt đầu với mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Trước tiên, bạn tạo nội bộ lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Điều bạn đang nói là
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ, bạn có thể làm tương tự với mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Một lần nữa, bạn tạo nội bộ
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ bạn sẽ làm tương tự với mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Về cơ bản, bạn đang nói rằng chỉ nên có một
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ, bạn có thể làm việc trên mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Trước tiên, bạn nhập các hàm và lớp có liên quan từ các mô-đun khác.
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
You changed the
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Thuộc tính
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bây giờ bạn có thể thay đổi chương trình để kiểm tra các thay đổi
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bạn nhập các hàm có liên quan từ các mô-đun
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lưu ý rằng bây giờ bạn có thể tạo một đối tượng
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Chương trình hoạt động giống như trước đây, nhưng bây giờ bạn có thể thấy rằng một đối tượng
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Hãy xem kỹ lớp học
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn đang sử dụng bố cục theo hai cách khác nhau. Lớp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Tuy nhiên, mối quan hệ giữa
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Thành phần để thay đổi hành vi thời gian chạy
Kế thừa, trái ngược với thành phần, là một mối quan hệ cặp đôi chặt chẽ. Với tính kế thừa, chỉ có một cách để thay đổi và tùy chỉnh hành vi. Ghi đè phương thức là cách duy nhất để tùy chỉnh hành vi của lớp cơ sở. Điều này tạo ra những thiết kế cứng nhắc, khó thay đổi
Mặt khác, thành phần cung cấp một mối quan hệ được kết hợp lỏng lẻo cho phép các thiết kế linh hoạt và có thể được sử dụng để thay đổi hành vi trong thời gian chạy
Hãy tưởng tượng bạn cần hỗ trợ chính sách khuyết tật dài hạn [LTD] khi tính bảng lương. Chính sách quy định rằng một nhân viên tại LTD sẽ được trả 60% tiền lương hàng tuần của họ với giả định 40 giờ làm việc
Với thiết kế kế thừa, đây có thể là một yêu cầu rất khó hỗ trợ. Thêm nó vào ví dụ thành phần dễ dàng hơn nhiều. Hãy bắt đầu bằng cách thêm lớp chính sách
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Lưu ý rằng
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Trước tiên, giao diện công khai kiểm tra xem
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Bây giờ bạn có thể thực hiện một thay đổi nhỏ đối với lớp
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Bạn đã thêm một phương pháp
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Chương trình truy cập vào
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
# In hr.py
class HourlyEmployee[Employee]:
def __init__[self, id, name, hours_worked, hour_rate]:
super[].__init__[id, name]
self.hours_worked = hours_worked
self.hour_rate = hour_rate
def calculate_payroll[self]:
return self.hours_worked * self.hour_rate
Số tiền séc cho nhân viên Kevin Bacon, là nhân viên bán hàng, hiện là $1080 thay vì $1800. Đó là vì
# In hr.py
class CommissionEmployee[SalaryEmployee]:
def __init__[self, id, name, weekly_salary, commission]:
super[].__init__[id, name, weekly_salary]
self.commission = commission
def calculate_payroll[self]:
fixed = super[].calculate_payroll[]
return fixed + self.commission
Như bạn có thể thấy, bạn có thể hỗ trợ các thay đổi chỉ bằng cách thêm một chính sách mới và sửa đổi một vài giao diện. Đây là loại linh hoạt mà thiết kế chính sách dựa trên thành phần mang lại cho bạn
Lựa chọn giữa Kế thừa và Thành phần trong Python
Python, với tư cách là một ngôn ngữ lập trình hướng đối tượng, hỗ trợ cả kế thừa và thành phần. Bạn đã thấy rằng kế thừa được sử dụng tốt nhất để mô hình hóa một mối quan hệ, trong khi các mô hình thành phần a có một mối quan hệ
Đôi khi, thật khó để biết mối quan hệ giữa hai lớp nên như thế nào, nhưng bạn có thể làm theo các hướng dẫn sau
Sử dụng tính kế thừa đối với thành phần trong Python để mô hình hóa mối quan hệ rõ ràng. Đầu tiên, chứng minh mối quan hệ giữa lớp dẫn xuất và cơ sở của nó. Sau đó, đảo ngược mối quan hệ và cố gắng biện minh cho nó. Nếu bạn có thể biện minh cho mối quan hệ theo cả hai hướng, thì bạn không nên sử dụng tính kế thừa giữa chúng
Sử dụng tính kế thừa trên thành phần trong Python để tận dụng cả giao diện và triển khai của lớp cơ sở
Sử dụng tính kế thừa đối với thành phần trong Python để cung cấp các tính năng mixin cho một số lớp không liên quan khi chỉ có một triển khai tính năng đó
Sử dụng thành phần thay vì thừa kế trong Python để mô hình hóa mối quan hệ thúc đẩy việc triển khai lớp thành phần
Sử dụng thành phần thay vì thừa kế trong Python để tạo các thành phần có thể được sử dụng lại bởi nhiều lớp trong các ứng dụng Python của bạn
Sử dụng thành phần thay vì thừa kế trong Python để triển khai các nhóm hành vi và chính sách có thể được áp dụng thay thế cho các lớp khác để tùy chỉnh hành vi của chúng
Sử dụng thành phần thay vì thừa kế trong Python để cho phép thay đổi hành vi trong thời gian chạy mà không ảnh hưởng đến các lớp hiện có
Sự kết luận
Bạn đã khám phá tính kế thừa và thành phần trong Python. Bạn đã học về loại mối quan hệ mà thừa kế và thành phần tạo ra. Bạn cũng đã trải qua một loạt bài tập để hiểu cách kế thừa và thành phần được triển khai trong Python
Trong bài viết này, bạn đã học cách
- Sử dụng tính kế thừa để thể hiện một mối quan hệ giữa hai lớp
- Đánh giá nếu thừa kế là mối quan hệ đúng
- Sử dụng đa kế thừa trong Python và đánh giá MRO của Python để khắc phục sự cố đa kế thừa
- Mở rộng các lớp với mixin và sử dụng lại việc triển khai chúng
- Sử dụng thành phần để thể hiện một mối quan hệ giữa hai lớp
- Cung cấp các thiết kế linh hoạt bằng cách sử dụng thành phần
- Sử dụng lại mã hiện có thông qua thiết kế chính sách dựa trên thành phần
đề xuất đọc
Dưới đây là một số sách và bài viết khám phá sâu hơn về thiết kế hướng đối tượng và có thể hữu ích để giúp bạn hiểu cách sử dụng chính xác tính kế thừa và thành phần trong Python hoặc các ngôn ngữ khác
- mẫu thiết kế. Các yếu tố của phần mềm hướng đối tượng tái sử dụng
- Các mẫu thiết kế đầu tiên. Hướng dẫn thân thiện với não bộ
- Mã sạch. Sổ tay thủ công phần mềm linh hoạt
- Nguyên tắc RẮN
- Nguyên tắc thay thế Liskov
Đánh dấu là đã hoàn thành
Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Kế thừa và thành phần. Hướng dẫn OOP Python
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về Isaac Rodríguez
Xin chào, tôi là Isaac. Tôi xây dựng, lãnh đạo và cố vấn cho các nhóm phát triển phần mềm và trong vài năm qua, tôi đã tập trung vào các dịch vụ đám mây và ứng dụng phụ trợ bằng Python cùng với các ngôn ngữ khác. Rất thích nghe từ bạn ở đây tại Real Python
» Thông tin thêm về Y-sácMỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Alex
Aldren
Joanna
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ EmailBài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. Nhận các mẹo để đặt câu hỏi hay và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi
Kế thừa đơn lẻ với ví dụ trong python là gì?
Kế thừa đơn trong Python
. Để tóm tắt ví dụ này. Có một lớp con gọi là Cat kế thừa các thuộc tính và phương thức của lớp cơ sở Pet. Ngoài ra, lớp Cat còn có phương thức riêng, sound. a child class inherits from a single parent class as shown below. To summarize this example: There is a subclass called Cat that inherits the attributes and methods of the base class Pet. In addition, the class Cat also has its own method, sounds.
Các ví dụ thời gian thực về thừa kế đơn lẻ là gì?
Ví dụ, chúng ta là con người. Chúng tôi thừa hưởng một số thuộc tính từ lớp 'Con người' như khả năng nói, thở, ăn, uống, v.v. Chúng ta cũng có thể lấy ví dụ về ô tô. Lớp 'Xe hơi' kế thừa các thuộc tính của nó từ lớp 'Ô tô', lớp này thừa hưởng một số thuộc tính của nó từ một lớp 'Xe cộ' khác
Kế thừa trong python với ví dụ thời gian thực là gì?
Tính kế thừa trong Python giúp nhà phát triển sử dụng lại các đối tượng . Mỗi khi một lớp kế thừa lớp cơ sở, nó sẽ có quyền truy cập vào chức năng của đối tượng cha. Khả năng sử dụng lại do kế thừa cũng đáng tin cậy vì lớp cơ sở đã được kiểm tra. Việc chuẩn hóa giao diện giữa các lớp trở nên dễ dàng.
Kế thừa cấp đơn giải thích với ví dụ lập trình là gì?
Kế thừa đơn trong C++
. Nó là loại đơn giản nhất trong số tất cả các loại thừa kế vì nó không bao gồm bất kỳ loại kết hợp thừa kế nào hoặc các mức độ thừa kế khác nhau. The inheritance in which a single derived class is inherited from a single base class is known as the Single Inheritance. It is the simplest among all the types of inheritance since it does not include any kind of inheritance combination or different levels of inheritance.