GOF笔记 - 技术栈

Adapter

client

java 复制代码

public class Client {
    public static void main(String[] args) {
//		Target adapter = new Adapter1();     //Target接口创建适配器
        Target adapter = new Adapter2();
        adapter.request();                     //适配器实现Target接口request()方法
    }
}

Adaptee

java 复制代码

/**
 * 第三方外部可变化接口
 */
public class Adaptee {
	public void specificRequest(){
		System.out.println("已有类的接口");
	}
}

接口

java 复制代码

/**
 * 适配器模式
 * 目标接口
 */
public interface Target {
	public void request();
}

对象适配器

java 复制代码

/**
 * 对象适配器
 */
public class Adapter1 implements Target{
	private Adaptee adaptee;   //Adaptee是属性，与Adapter1是关联关系
	public Adapter1(){
		this.adaptee = new Adaptee();  //Adapter1创建Adaptee特别要求适配器
	}

	@Override
	public void request() {
		this.adaptee.specificRequest();		
	}
}

类适配器

java 复制代码

/**
 * 类适配器
 */
public class Adapter2 extends Adaptee implements Target { 
    //Adaptee是Adapter2的泛化，同时Adapter2实现Target 
	@Override
	public void request() {
		super.specificRequest();	
        //	super调用父类（Adaptee）方法，将specificRequest写入Target的request()
	}
}

Factory

抽象工厂

java 复制代码

public interface AbstractFactory {
	IBusinessCar getBusinessCarInstance();  //提供两个接口，让接口负责创建对象
	ISportCar getSportCarInstance();
}

java 复制代码

/**
 * 抽象工厂
 * 实现不同系列产品实例化
 */
public interface IBusinessCar {  //抽象工厂提供的接口
	void info();
}

public interface ISportCar {
	void info();
}

java 复制代码

//通过IBusinessCar实现了创建不同品牌的商务车
//宝马
public class BmwBusinessCar implements IBusinessCar {
	@Override
	public void info() {
		System.out.println("Bmw Business Car was created");
	}
}
//奔驰
public class BenzBusinessCar implements IBusinessCar {
	@Override
	public void info() {
		System.out.println("Benz Business Car was created");
	}
}

java 复制代码

public class BmwCarFactory implements AbstractFactory {
//通过实现AbstractFactory，可以有不同接口创建不同类型的同品牌车
    //宝马商务车
	@Override
	public IBusinessCar getBusinessCarInstance() { //BmwCarFactory制造商务车
		return new BmwBusinessCar();
	}

    //宝马运动车
	@Override
	public ISportCar getSportCarInstance() {  //BmwCarFactory制造运动车
		return new BmwSportCar();  //创建运动车
	}

}

client只需要选择对于品牌工厂接口和对应车型接口即可

java 复制代码

public class Client {
	public static void main(String[] args) {
        //用户选择奔驰品牌运动型车
		AbstractFactory factory = new BenzCarFactory();
		ISportCar car = factory.getSportCarInstance();
		car.info();
	}
}

具体工厂

java 复制代码

/**
 * 工厂方法模式
 * 抽象工厂
 */
public abstract class Factory {
	public abstract Product getInstance();
}

java 复制代码

/**
 * 具体工厂-汽车工厂
 */
public class CarFactory extends Factory{
	@Override
	public Product getInstance() {
		return new Car();
	}
}

/**
 * 具体工厂------飞机工厂
 */
public class PlaneFactory extends Factory {
	@Override
	public Product getInstance() {
		return new Plane();
	}

}

java 复制代码

class Client {   
    //客户指定Driver类创建一个Driver，CarFactory()类创建factory，CarFactory创建product
	public static void main(String[] args) {
		Driver driver = new Driver();
        Factory factory = new CarFactory();
        Product product = factory.getInstance();
        driver.setProduct(product);  //司机拿到车
        driver.drive();
	}
}

简单工厂

java 复制代码

/**
 * 简单工厂模式
 */
public class SimpleFactory {
	public static Product getInstance(String para){
		if("car".equalsIgnoreCase(para))
			return new Car();
		else if("plane".equalsIgnoreCase(para))
			return new Plane();
		else
			return null;		
	}
}

java 复制代码

public class Client {
    public static void main(String args[]){  
        Driver driver = new Driver();
        //客户调用简单工厂，一个工厂即既创建car也创建plane
        Product product = SimpleFactory.getInstance("plane");
        driver.setProduct(product);
        driver.drive();
    }
    
}

spring工厂

java 复制代码

/**
 * 工厂模式在Spring中实现
 */
public class Client {
    public static void main(String args[]){
        //第一句可去掉，不影响， 在xml里面指定是car还是plane
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //
        Driver driver = (Driver) context.getBean("driver");
        driver.drive();
    }
    
}

java 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<beans
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
	<bean id="car" class="ooad.gof.factory.Car"></bean>
	<bean id="plane" class="ooad.gof.factory.Plane"></bean>
	<bean id="driver" class="ooad.gof.factory.Driver">
		<property name="product"><ref bean="plane"/>  //在xml里面指定是car还是plane（高内聚）
    </property> 
	</bean>	
</beans>

Singleton 单实例

有两种实现方法，一种是单例模式，确保一个类只有一个实例，并提供一个访问它的全局访问点

java 复制代码

/**
 * 单例模式
 * 确保一个类只有一个实例，并提供一个访问它的全局访问点
 */
public class Singleton {
	private static Singleton instance = null;
	private Singleton(){}
	public static Singleton getInstance(){
		if (null == instance){
			instance =  new Singleton();
		}
		return instance;
	}
}

一种是双锁单例模式，保证线程安全

java 复制代码

/**
 * 双锁单例模式
 * 线程安全
 */
public class DoubleLockSingleton {
	// volatile可以保证线程可见性，提供了一定的有序性，但是无法保证原子性。
	private static volatile DoubleLockSingleton instance = null;
	private DoubleLockSingleton(){}
	public static DoubleLockSingleton getInstance(){
		if (null == instance){
			// 线程同步锁
			synchronized(DoubleLockSingleton.class){
				if(null == instance){
				instance =  new DoubleLockSingleton();
				}
			}

		}
		return instance;
	}
}

client

java 复制代码

public class Client {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);
		DoubleLockSingleton dls1 = DoubleLockSingleton.getInstance();
		DoubleLockSingleton dls2 = DoubleLockSingleton.getInstance();
		System.out.println(dls1 ==dls2);
	}
}

Strategy 策略模式

策略接口，子类实现了不同的策略

java 复制代码

/**
 * 策略模式
 * 策略接口
 */
public interface Strategy {
	public int[] sort(int[] array);
}

java 复制代码

/**
 * 选择排序策略
 */
public class SelectionStrategy implements Strategy {
	@Override
	public int[] sort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			int least = i;
			for (int j = i; j < array.length; j++) {
				if (array[j] < array[least])
					least = j;
			}
			int temp = array[i];
			array[i] = array[least];
			array[least] = temp;
		}
		return array;
	}
}

java 复制代码

/**
 * 冒泡排序策略
 */
public class BubbleStrategy implements Strategy {
	@Override
	public int[] sort(int[] array) {
		int temp;
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - i - 1; j++) {
				if (array[j] > array[j + 1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		return array;
	}
}

策略应用的上下文（如何选择不同策略）

java 复制代码

/**
 * 策略应用上下文
 */
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    public Strategy getStrategy() {  
        //根据客户创建的是BubbleStrategy对象还是SelectionStrategy选择不同的策略
        return strategy;
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public int[] sort(int[] array){    
        return this.strategy.sort(array);
    }
}

java 复制代码

public class Client {
	public static void main(String[] args) {
		int[] array = { 9, 3, 5, 7, 10 };
        //客户选择了选择排序策略，创建了SelectionStrategy对象
		Strategy strategy = new SelectionStrategy();  
        //但是调用策略的方法都是sort
		Context context = new Context(strategy);
		context.sort(array);
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

Composite

创建原子对象（Leaf）

java 复制代码

/**
 * 组合模式
 * 树叶对象
 */
public class Leaf extends Component{
	public Leaf(String name){
		super(name);
	}
	
	@Override
	public void operation() {
		System.out.println("这是对象的操作....");		
	}
	
	@Override
	public void add(Component component) {}

	@Override
	public void remove(Component component) {}

	@Override
	public void getAll() {}
}

创建组合对象（composite）

java 复制代码

/**
 * 组合模式
 * 组合对象
 */
public class Composite extends Component{
    //组合对象和Leaf对象都是Component的泛化（都有Component的特征）
	private List<Component> clist;
	public Composite(String name){
		super(name);
		clist = new ArrayList<Component>();
	}
	public Composite(){
		clist = new ArrayList<Component>();
	}
	
	@Override
	public void operation() {
		System.out.println("这是组合的操作.....");
	}

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

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

	@Override
	public void getAll() {
		for (Component c : clist){
			System.out.println(c.getName());
		}		
	}
}

client既可以使用add添加文件，也可以用add添加文件夹

java 复制代码

public class Client {
	public static void main(String[] args) {
		Component root = new Composite("根目录");
		Component file1 = new Leaf("文件1");
		root.add(file1);
		Component dir1 = new Composite("文件夹1");
		Component file2 = new Leaf("文件2");
		dir1.add(file2);
		root.add(dir1);
		root.getAll();	
		dir1.getAll();
	}
}