[TOC]
设计模式学习（二）——《大话设计模式》
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);
}
}
