设计模式

依赖和关联（简单理解）：当A使用B作为变量或者方法参数，叫依赖关系。当A使用B作为类属性，则叫关联关系，关联关系是一种强依赖关系。
多态的向上转型：父类类型父类引用名 = new 子类类型();
- 编译阶段看左边的父类型，所以不能调用子类特有的成员，否则编译不通过
- 运行阶段看右边的子类型，调用方法从子类开始查找，一般调用子类重写的方法，属性无重写

1. 单例模式

理解：单例模式确保某一个类只有一个实例，自行实例化，给系统提供全局访问方法
例子：任务管理器、身份证、打印池
优缺点
- 缺点：违反“单一职责原则”
类图：见书

代码：

public class Singleton
{
    private static Singleton instance = null; // 静态私有成员变量
    // 私有构造函数
    private Singleton(){
        
    }
    // 静态公有工厂方法，返回唯一实例
    public static Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

测试：

public class Singleton{
	public static void main(String a[]){
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
	}
}

2. 迭代器模式

理解：聚合对象有两个功能：一是存储内部数据，二是遍历内部数据。把遍历行为提取成为迭代器。
大概率只考察类图：抽象和具体迭代器 and 抽象和具体聚合类
例子：迭代器——电视遥控器聚合类————电视机
代码理解：
- 抽象迭代器只有抽象迭代方法声明，抽象聚合类只有抽象创建迭代器方法声明
- 具体聚合类：一是有数据，二是实现创建具体迭代器（返回一个具体迭代器对象），三是包含具体迭代器的类（即内部类的方式，也可以用另一种方式，单独写一个具体迭代器类，初始化需要具体聚合类参数）

3. 策略模式

理解：将一系列算法封装起来，由环境类（使用算法的角色）选择使用哪种算法
例子：环境类（数组处理类）、抽象策略类、具体策略类（冒泡插入选择排序）

代码理解：

环境类有set方法，用于设置具体策略类

public class Context{ // 环境类
	private Strategy strategy;
	
	public void setStrategy(Strategy strategy){
		this.strategy = strategy;
	}
	private void contextAlgorithm(...){
		strategy.algorithm(...);
	}
}
public interface Strategy{ // 抽象策略类 or 策略类接口
    public void algotithm(...);
}
public class StrategyA implements Strategy{ // 具体策略类A
    public void algotithm(...){
        ...
    };
}
public class StrategyB implements Strategy{ // 具体策略类B
    public void algotithm(...){
        ...
    };
}

测试

public class Client{
    public static void main(){
        Context c = new Context();
        StrategyA sa = new StrategyA();
        c.setStrategy(sa);
        c.contextAlgorithm(...);
    }
}

4. 工厂模式

三个模式之间的关系：
- 当抽象工厂模式每一个具体工厂类只创造一个产品对象，抽象工厂退化为工厂方法模式
- 当工厂方法模式抽象工厂与具体工厂合并，只有一个统一的工厂来创建产品对象，工厂方法模式退化为简单工厂模式
关于抽象工厂模式是否符合开闭原则
- 如果增加产品族（由一个工厂生产的所有商品），只需要增加具体工厂，符合OCP
- 如果增加产品等级结构（同一种商品），要修改所有工厂类，不符合OCP
关于工厂模式与策略模式的比较：工厂模式用于创建对象，策略模式用于选择各种方法
工厂方法UML图：

5. 观察者模式

很好理解
例子：主题类（猫），观察者（老鼠、狗）猫叫后老鼠和狗都有动作
类图：抽象主题（观察者数组、增加、删除观察者）、抽象观察者、具体主题（提醒观察者）、具体观察者
代码示例：

// 抽象目标类
public abstract class MySubject {
	protected ArrayList observers = new ArrayList();
	
	// 注册观察者
	public void attach(MyObserver observer) {
		observers.add(observer);
	}
	
	// 删除观察者
	public void detach(MyObserver observer) {
		observers.remove(observer);
	}
	
	public abstract void cry();
}

// 抽象观察者（接口）
public interface MyObserver {
	void response();
}

// 具体主题
public class Cat extends MySubject{

	@Override
	public void cry() {
		System.out.print("猫叫！！！");
		System.out.print("---------------------");
		
		for(Object obs:observers) {
			((MyObserver)obs).response();
		}
		
	}
	
}
// 具体观察者
public class Dog implements MyObserver{

	@Override
	public void response() {
		// TODO Auto-generated method stub
		System.out.print("狗也开始叫！！！");
	}

}
// 具体观察者2
public class Mouse implements MyObserver{

	@Override
	public void response() {
		// TODO Auto-generated method stub
		System.out.print("老鼠赶紧逃跑！");
	}

}
// 客户端测试类
public class Client {

	public static void main(String[] args) {
		MySubject subject = new Cat();
		
		MyObserver obs1, obs2, obs3;
		obs1 = new Mouse();
		obs2 = new Mouse();
		obs3 = new Dog();
		
		subject.attach(obs1);
		subject.attach(obs2);
		subject.attach(obs3);
		
		subject.cry();
		
		subject.detach(obs3);
		
		subject.cry();
	}

}

6. 建造者模式

和工厂模式很像，也是对象创建型模式，创建复杂的对象，关注各个配件的创建，有一个指挥者

7. 原型模式

通过复制(clone)原型来创建对象

8. 适配器模式

让目标类可以做适配类的行为，类适配要用接口，对象适配只用继承
分为类适配器和对象适配器
- 类适配器实现目标类，继承适配类的接口（比如让robot可以学dog叫，因为狗叫是dog已实现的方法，所以继承dog，实现robot）（抽象和实现的区别：抽象可以选择父类方法调用，实现必须实现接口所有方法）
- 对象适配器继承目标类，关联适配类（把适配类当作变量）
使用时候，用目标类作为父类创建适配器
类图：