结构型设计模式---享元模式和组合模式

一、享元模式

       享元模式可以减少创建对象的数量，以减少内存占用和提高性能，运用共享技术有效地支持大量细粒度的对象。常应用于系统底层的开发，以便解决系统的性能问题。

享元模式的实现和注册式容器单例很像。

       抽象员工类：

	public interface Employee {
	    void report();
	}

       经理类：

	public class Manager implements Employee {
	    private String department;
	    private String reportContent;
	
	    public Manager(String department) {
	        this.department = department;
	    }
	
	    public void setReportContent(String reportContent) {
	        this.reportContent = reportContent;
	    }
	
	    @Override
	    public void report() {
	        System.out.println(reportContent);
	    }
	}

       工厂类：

	public class EmployeeFactory {
	    private static final Map<String, Employee> EMPLOYEE_MAP = new HashMap<>();
	
	    public static Employee getManager(String department) {
	        Manager manager = (Manager) EMPLOYEE_MAP.get(department);
	        if (manager == null) {
	            String reportContent = department + "部门汇报: 此次汇报的主要内容是......";
	            manager = new Manager(department);
	            manager.setReportContent(reportContent);
	            System.out.print("创建部门经理: " + department);
	            System.out.println(" 创建报告: " + department);
	            EMPLOYEE_MAP.put(department, manager);
	
	        }
	        return manager;
	    }
	}

       测试类：

	public class FlyWeightTest {
	    private static final String[] departments = {"RD", "QA", "PM", "RM"};
	
	    public static void main(String[] args) {
	        for (int i = 0; i < 10; i++) {
	            String department = departments[(int) (Math.random() * departments.length)];
	            Manager manager = (Manager) EmployeeFactory.getManager(department);
	            manager.report();
	        }
	    }
	}

       测试结果：

二、组合模式

       组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。符合开闭原则。

       员工类：

	public class Employee {
	    private String name;
	    private String dept;
	    private int salary;
	    private List<Employee> subordinates = new ArrayList<>();
	
	    public Employee(String name, String dept, int salary) {
	        this.name = name;
	        this.dept = dept;
	        this.salary = salary;
	    }
	
	    public void add(Employee e) {
	        subordinates.add(e);
	    }
	
	    public void remove(Employee e) {
	        subordinates.remove(e);
	    }
	
	    public List<Employee> getSubordinates() {
	        return subordinates;
	    }
	
	    @Override
	    public String toString() {
	        return "Employee{" +
	                "name='" + name + '\'' +
	                ", dept='" + dept + '\'' +
	                ", salary=" + salary +
	                '}';
	    }
	}

       测试类：

	public class CompositeTest {
	    public static void main(String[] args) {
	        Employee CEO = new Employee("John", "CEO", 30000);
	
	        Employee headSales = new Employee("Robert", "Head Sales", 20000);
	
	        Employee headMarketing = new Employee("Michel", "Head Marketing", 20000);
	
	        Employee clerk1 = new Employee("Laura", "Marketing", 10000);
	        Employee clerk2 = new Employee("Bob", "Marketing", 10000);
	
	        Employee salesExecutive1 = new Employee("Richard", "Sales", 10000);
	        Employee salesExecutive2 = new Employee("Rob", "Sales", 10000);
	
	        CEO.add(headSales);
	        CEO.add(headMarketing);
	
	        headSales.add(salesExecutive1);
	        headSales.add(salesExecutive2);
	
	        headMarketing.add(clerk1);
	        headMarketing.add(clerk2);
	
	        //打印该组织的所有员工
	        System.out.println(CEO);
	        for (Employee headEmployee : CEO.getSubordinates()) {
	            System.out.println("  " + headEmployee);
	            for (Employee employee : headEmployee.getSubordinates()) {
	                System.out.println("    " + employee);
	            }
	        }
	    }
	}

       测试结果：