设计模式关系图

原创 已于 2024-09-21 17:20:49 修改 · 1.8k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #java #开发语言

于 2024-09-21 17:19:26 首次发布
设计模式关系图(重点)
通过关系图理解设计模式的用途,含义，他们之间的转换，更好的理解每一个模式的边界。
可以看出组合模式的关联是最多的，从这个开始，组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户对单个对象和组合对象的使用具有一致性。是树形结构，单纯的理解为空间上的层级结构，不会有时间上的联系，其中每一个可以分出来。分出来都是单个独立的个体了，不管个体的其中的复杂度，先分出来再操作。其中只有新增 add,remove,display操作，其他模式可以创建对象给他，也可以拿他的对象操作。
例子// 组件接口 
interface Component { 
    void add(Component component); 
    void remove(Component component); 
    void display(int depth); 
} 
 
// 叶子对象 - 员工 
class Employee implements Component { 
    private String name; 
 
    Employee(String name) { 

this.name = name; 
    } 
 
    @Override 
    public void add(Component component) { 

// 叶子对象不应有添加子对象的方法 

throw new UnsupportedOperationException(); 
    } 
 
    @Override 
    public void remove(Component component) { 

// 叶子对象不应有移除子对象的方法 

throw new UnsupportedOperationException(); 
    } 
 
    @Override 
    public void display(int depth) { 

for (int i = 0; i < depth; i++) { 

System.out.print("--"); 

} 

System.out.println(name); 
    } 
} 
 
// 组合对象 - 团队 
class Team implements Component { 
    private String name; 
    private List<Component> members = new ArrayList<>(); 
 
    Team(String name) { 

this.name = name; 
    } 
 
    @Override 
    public void add(Component component) { 

members.add(component); 
    } 
 
    @Override 
    public void remove(Component component) { 

members.remove(component); 
    } 
 
    @Override 
    public void display(int depth) { 

for (int i = 0; i < depth; i++) { 

System.out.print("--"); 

} 

System.out.println(name); 
 

for (Component component : members) { 

component.display(depth + 1); 

} 
    } 
}  
建造者与组合的关系
建造者将一个复杂对象的构建和他的表示分离。拿取组合中的对象，对象里面进行分离。可以用接口也可用建造者方法，意思都一样。
public class Employee { 
    private String name; 
    private String position; 
    private double salary; 
 
    // 私有构造方法，防止外部直接实例化 
    private Employee() {} 
 
    // Getter 和 Setter 省略 
 
    // 显示员工信息 
    public void display() { 

System.out.println("Name: " + name); 

System.out.println("Position: " + position); 

System.out.println("Salary: " + salary); 
    } 
 
    // 静态内部类：EmployeeBuilder，用于构建Employee对象 
    public static class EmployeeBuilder { 

private Employee employee; 
 

public EmployeeBuilder() { 

employee = new Employee(); 

} 
 

public EmployeeBuilder withName(String name) { 

employee.setName(name); 

return this; // 链式调用 

} 
 

public EmployeeBuilder withPosition(String position) { 

employee.setPosition(position); 

return this; 

} 
 

public EmployeeBuilder withSalary(double salary) { 

employee.setSalary(salary); 

return this; 

} 
 

// 构建并返回最终的Employee对象 

public Employee build() { 

return employee; 

} 
    } 
 
    // Getter 和 Setter 
    public String getName() { 

return name; 
    } 
 
    public void setName(String name) { 

this.name = name; 
    } 
 
    public String getPosition() { 

return position; 
    } 
 
    public void setPosition(String position) { 

this.position = position; 
    } 
 
    public double getSalary() { 

return salary; 
    } 
 
    public void setSalary(double salary) { 

this.salary = salary; 
    } 
}
装饰者模式与组合模式
装饰者模式是动态地给一个对象添加一些额外的职责。就扩展功能而言，装饰器模式相比生成子类更为灵活。装饰者模式是结构性的，是用一个装饰类来装饰现有的类的子类。需要加一个装饰类。
public abstract class EmployeeDecorator implements Employee { 
    protected Employee employee; 
 
    public EmployeeDecorator(Employee employee) { 

this.employee = employee; 
    } 
 
    @Override 
    public double getSalary() { 

return employee.getSalary(); 
    } 
 
    @Override 
    public String getDescription() { 

return employee.getDescription(); 
    } 
}public class SalaryBonus extends EmployeeDecorator { 
    private double bonus; 
 
    public SalaryBonus(Employee employee, double bonus) { 

super(employee); 

this.bonus = bonus; 
    } 
 
    @Override 
    public double getSalary() { 

return super.getSalary() + bonus; 
    } 
 
    @Override 
    public String getDescription() { 

return super.getDescription() + ", Bonus: $" + bonus; 
    } 
} 
 
public class Benefits extends EmployeeDecorator { 
    private String benefitDetails; 
 
    public Benefits(Employee employee, String benefitDetails) { 

super(employee); 

this.benefitDetails = benefitDetails; 
    } 
 
    @Override 
    public String getDescription() { 

return super.getDescription() + ", Benefits: " + benefitDetails; 
    } 
 
    // 注意：Benefits 装饰者可能不修改薪资，所以我们没有重写 getSalary() 方法 
}
享元模式和组合模式
享元模式运用共享技术有效地支持大量细粒度的对象。可以参考围棋的黑白子。就是组合的对象拿过来放在EmployeeFactory管理。
public class Manager implements Employee { 
    private String department; // 部门名称，这是内部状态，可以共享 
    private transient String reportContent; // 报告内容，这通常是外部状态，不应共享 
 
    public Manager(String department) { 

this.department = department; 
    } 
 
    // 设置报告内容，这里作为示例，实际中可能通过其他方式生成 
    public void setReportContent(String reportContent) { 

this.reportContent = "来自" + department + "部门的经理报告：" + reportContent; 
    } 
 
    @Override 
    public void report() { 

System.out.println(reportContent); 
    } 
}public class EmployeeFactory { 
    private static final Map<String, Employee> employeeMap = new HashMap<>(); 
 
    public static Employee getManager(String department) { 

Manager manager = (Manager) employeeMap.get(department); 

if (manager == null) { 

manager = new Manager(department); 

// 这里不直接设置报告内容，因为它可能是外部状态 

employeeMap.put(department, manager); 

} 

// 如果需要，可以在这里为manager设置默认的报告内容或进行其他初始化 

return manager; 
    } 
}public class Client { 
    public static void main(String[] args) { 

Employee manager1 = EmployeeFactory.getManager("IT部门"); 

manager1.setReportContent("本月工作完成情况..."); 

manager1.report(); // 输出：来自IT部门的经理报告：本月工作完成情况... 
 

Employee manager2 = EmployeeFactory.getManager("IT部门"); 

// 注意：由于manager1和manager2是同一个对象，所以这里不需要重新设置报告内容 

manager2.report(); // 输出：来自IT部门的经理报告：本月工作完成情况... 
 

// 检查是否为同一个对象 

System.out.println(manager1 == manager2); // 输出：true 
 

// 为另一个部门的经理设置报告内容 

Employee manager3 = EmployeeFactory.getManager("HR部门"); 

manager3.setReportContent("招聘进度报告..."); 

manager3.report(); // 输出：来自HR部门的经理报告：招聘进度报告... 
    } 
}
建造者与访问者模式关系
访问者模式表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。将组合模式的对象的元素进行操作，比如信息，把元素拿出类，其他对象可以操作，可以有效解耦。
// 绩效评估访问者 
public class PerformanceEvaluator implements Employee { 
    @Override 
    public void visit(Manager manager) { 

System.out.println("Evaluating performance of Manager: " + manager.getName()); 

// 具体的绩效评估逻辑 
    } 
 
    @Override 
    public void visit(Staff staff) { 

System.out.println("Evaluating performance of Staff: " + staff.getName()); 

// 具体的绩效评估逻辑 
    } 
} 
 
// 薪资调整访问者 
public class SalaryAdjustor implements Employee { 
    @Override 
    public void visit(Manager manager) { 

System.out.println("Adjusting salary of Manager: " + manager.getName()); 

// 具体的薪资调整逻辑 
    } 
 
    @Override 
    public void visit(Staff staff) { 

System.out.println("Adjusting salary of Staff: " + staff.getName()); 

// 具体的薪资调整逻辑 
    } 
}
组合模式和命令模式是将组合模式中的对象拿过来，加上命令罢了，也就是加操作。
// Employee 接口 
public interface Employee { 
    void submitReport(); 
    void scheduleMeeting(); 
    // 可能还有其他方法... 
 
    // 这里我们不直接在Employee接口中定义execute命令，因为执行命令是外部控制器（如Invoker）的职责 
    // 但为了示例完整性，我们可以想象Employee类有一个方法用于执行命令（通常这是不必要的） 
} 
 
// Employee 的一个实现类 
public class Staff implements Employee { 
    private String name; 
 
    public Staff(String name) { 

this.name = name; 
    } 
 
    @Override 
    public void submitReport() { 

System.out.println(name + " is submitting a report."); 
    } 
 
    @Override 
    public void scheduleMeeting() { 

System.out.println(name + " is scheduling a meeting."); 
    } 
}
组合模式、享元模式和策率模式、状态、解释器，就是将对象的算法、状态、解释表用一个管理而已，享元模式就是提供一个factory而已，封装和解耦。

犁桦
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值