文章目录
设计模式学习(二)——《大话设计模式》
1.属性和修饰符
属性(Attributes)
属性是类中定义的变量,用于存储对象的状态信息。它们代表了对象的特征,比如一个Person类可能有name和age属性。在设计模式中,如何定义和使用属性对于实现特定模式的效果至关重要。
私有属性:一般用于类内部,不希望外部直接访问。在Java中使用private修饰符,在Python中可以通过前缀__来表示(虽然这只是一种约定,并非真正意义上的私有)。
公有属性:可以被外部访问和修改。通常公开访问的属性应该谨慎使用,以避免破坏对象的封装性。
受保护属性:这类属性通常只允许在类本身以及其子类中访问,使用protected修饰符。
代码示例:
class Person:
def __init__(self, name, age):
self.name = name # 公有属性
self.__age = age # 私有属性,通过双下划线前缀表示
def display_info(self):
print(f"Name: {self.name}, Age: {self.__age}")
# 使用类
person = Person("Alice", 30)
print(person.name) # 正常访问
# print(person.__age) # 会引发错误,因为__age是私有属性
person.display_info() # 通过类的公有方法访问私有属性
修饰符(Modifiers)
修饰符定义了对类、方法或属性的访问控制级别。它们在不同的编程语言中可能有所不同,但常见的有:
public(公有):成员对所有类可见。
private(私有):成员只对定义它们的类可见。
protected(受保护):成员对定义它们的类及其子类可见。
default(默认,仅Java):如果没有指定修饰符,则使用默认访问级别,成员对同一包内的类可见。
final(最终,主要用于Java):表示变量值一旦被赋值后不能改变,方法不能被重写,类不能被继承。
在设计模式中的应用
单例模式(Singleton):通常将构造函数设置为私有(private),以确保只能从类内部创建实例。
工厂模式(Factory Method):可以使用受保护(protected)或私有(private)修饰符来限制对工厂方法的访问,从而控制对象的创建。
装饰器模式(Decorator):通过扩展类的功能而不修改其原始代码,通常需要对原始类的属性和方法进行访问,这可能涉及到对属性和方法访问级别的调整。
策略模式(Strategy):可以将策略接口作为公有(public)属性或方法暴露出来,以便在运行时切换策略。
代码示例
#@property装饰器允许你将一个方法转化为只读属性,并可以结合setter装饰器来控制属性的修改。
class Person:
def __init__(self, name, age):
self._name = name # 使用单下划线定义受保护属性
self.__age = age # 私有属性
@property
def age(self):
return self.__age
@age.setter
def age(self, value):
if value < 0:
raise ValueError("Age cannot be negative")
self.__age = value
@property
def name(self):
return self._name
# 使用类
person = Person("Bob", 25)
print(person.name) # 访问公有属性
print(person.age) # 通过@property装饰的方法访问私有属性
person.age = 26 # 修改私有属性值
# person.age = -1 # 尝试设置不合法的年龄,会引发ValueError
2.封装
封装是面向对象编程(OOP)的三大基本特征之一,另外两个是继承和多态。封装的核心思想是将对象的数据(属性)和操作这些数据的方法绑定在一起,形成一个紧密的单元,并对外隐藏对象的具体实现细节。这样做的目的是提高代码的安全性、可维护性和复用性。
封装的主要目的:
- 隐藏实现细节:用户只需要知道对象提供了哪些方法来操作数据,而不需要知道这些方法是如何实现的。
- 简化接口:通过将复杂的实现细节隐藏起来,只暴露简单的接口给外部使用,使得对象更加易于理解和使用。
- 增强安全性:限制对某些内部数据的直接访问,只能通过对象提供的方法来修改这些数据,可以避免外部的非法访问和修改,保护对象的状态安全。
封装的优势:
- 良好的封住能够减少耦合;
- 类内部的实现可以自由的修改;
- 类具有清晰的对外接口;
实现封装:
在面向对象语言中,封装通常通过使用访问修饰符(如private、protected、public)来实现。通过将类的某些属性或方法声明为私有(private),就可以防止外部直接访问这些成员,只能通过公有(public)方法来间接访问或修改这些私有成员。
代码示例:
class Account:
def __init__(self, owner, balance=0):
self.owner = owner
self.__balance = balance # 私有属性
def deposit(self, amount):
if amount > 0:
self.__balance += amount
print(f"Added {amount} to the balance")
else:
print("Deposit amount must be positive")
def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
print(f"Withdrew {amount} from the balance")
else:
print("Invalid withdrawal amount")
def get_balance(self):
return self.__balance
# 使用
acc = Account("John", 100)
acc.deposit(50)
acc.withdraw(75)
print(acc.get_balance()) # 通过公有方法访问私有属性
# 直接访问__balance会失败
# print(acc.__balance) # AttributeError
// 封装
class Person {
private:
// 私有属性
std::string name;
public:
// 公共方法来访问私有属性
void setName(std::string n) {
name = n;
}
std::string getName() {
return name;
}
};
public class Person {
private String name; // 私有属性
// 公共方法来访问私有属性
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
3.继承
继承是面向对象编程(OOP)的另一个核心概念,它允许我们定义一个类(子类或派生类)来继承另一个类(基类或父类)的属性和方法。继承机制使得子类可以重用父类的代码,这不仅可以减少重复代码,还可以实现代码的组织和模块化。
继承的特点:
- 子类拥有父类非private的属性和功能;
- 子类具有自己的属性和功能,即子类可以扩展父类没有的属性和功能;
- 子类还可以以自己的方式实现父类的功能(方法重写);
- 继承使的所有子类公共的部分都放在了父类,使的代码得到了共享,避免了重复,继承可使得修改或者扩展而来的实现都较为容易。
- 继承的缺点
- 父类改变,则子类也会随之改变
- 继承破坏包装,父类实现细节会暴露给子类
- 继承是一种类与类之间的强耦合的关系
继承的主要目的:
- 代码重用:通过继承,子类可以使用父类中定义的方法和属性,无需重新编写相同的代码。
- 实现多态:子类可以根据需要覆盖或扩展父类的行为,提供新的实现,这是多态性的基础。
- 建立类之间的关系:继承可以表达不同类之间的层次关系,为设计更复杂的系统提供了一种自然的方式。
继承的类型:
- 单继承:一个子类只继承自一个父类。
- 多重继承:一个子类可以同时继承多个父类。在某些语言中(如Python),这是支持的,但在其他语言中(如Java),则通过接口实现类似功能。
代码示例
# 定义一个基类(父类)
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
# 定义一个子类,继承自Animal
class Dog(Animal):
def speak(self):
return f"{self.name} says Woof!"
# 定义另一个子类,也继承自Animal
class Cat(Animal):
def speak(self):
return f"{self.name} says Meow!"
# 使用子类
dog = Dog("Buddy")
print(dog.speak()) # 输出: Buddy says Woof!
cat = Cat("Whiskers")
print(cat.speak()) # 输出: Whiskers says Meow!
// 基类
class Animal {
public:
void eat() {
std::cout << "I can eat!" << std::endl;
}
};
// 派生类
class Dog : public Animal {
public:
void bark() {
std::cout << "I can bark! Woof woof!" << std::endl;
}
};
// 基类
class Animal {
void eat() {
System.out.println("I can eat!");
}
}
// 派生类
class Dog extends Animal {
void bark() {
System.out.println("I can bark! Woof woof!");
}
}
4.多态
多态表示不同的对象可以执行相同的动作,但是要通过它们自己的代码实现;多态性允许我们以统一的接口操作不同类型的对象,而具体的行为则取决于对象的实际类型。这种机制使得代码更加灵活和可扩展。
第一:子类以父类的身份出现;
第二:子类在工作时以自己的方式来实现;
第三:子类以父类的身份出现时,子类特有的方法和属性不可使用;
多态的工作原理:
当方法被调用时,无论对象是否被转换为其父类,都只有位于对象继承链最末端的方法实现会被调用。
- 接口的统一:多态性要求不同的对象能响应同一消息(或方法调用),即它们有共同的接口。
- 实现的差异:虽然接口统一,但不同对象对同一消息可以有不同的响应方式,即它们的实现可以不同。
多态的优点:
- 提高代码的可复用性:可以通过抽象类或接口编写通用的代码,这些代码可以与任何具体实现协作。
- 提高代码的扩展性:可以引入新的对象类型,而无需修改使用旧对象类型的代码。
- 提高代码的可维护性:多态性可以帮助隐藏具体实现的细节,使得代码更易于理解和维护。
代码示例:
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Woof!"
class Cat(Animal):
def speak(self):
return "Meow!"
def animal_sound(animal):
print(animal.speak())
# 创建Dog和Cat的实例
dog = Dog()
cat = Cat()
# 调用函数,传入不同的对象
animal_sound(dog) # 输出: Woof!
animal_sound(cat) # 输出: Meow!
'''函数animal_sound接受一个Animal类型的参数。由于Dog和Cat都是Animal的子类,它们都可以作为参数传递给这个函数。函数内部调用了animal.speak(),具体调用哪个版本的speak方法取决于传入对象的实际类型。这就是多态性的体现'''
// 基类
class Shape {
public:
virtual void draw() = 0; // 纯虚函数,提供接口框架
};
// 派生类1
class Circle : public Shape {
public:
void draw() override {
std::cout << "Drawing Circle" << std::endl;
}
};
// 派生类2
class Square : public Shape {
public:
void draw() override {
std::cout << "Drawing Square" << std::endl;
}
};
void drawShape(Shape* shape) {
shape->draw();
}
// 基类
abstract class Shape {
abstract void draw(); // 抽象方法
}
// 派生类1
class Circle extends Shape {
void draw() {
System.out.println("Drawing Circle");
}
}
// 派生类2
class Square extends Shape {
void draw() {
System.out.println("Drawing Square");
}
}
public class TestPolymorphism {
public static void drawShape(Shape shape) {
shape.draw();
}
public static void main(String[] args) {
Shape circle = new Circle();
Shape square = new Square();
drawShape(circle);
drawShape(square);
}
}
void draw() {
System.out.println(“Drawing Square”);
}
}
public class TestPolymorphism {
public static void drawShape(Shape shape) {
shape.draw();
}
public static void main(String[] args) {
Shape circle = new Circle();
Shape square = new Square();
drawShape(circle);
drawShape(square);
}
}