23种设计模式

1.单例模式

详见javase第七章

2.工厂模式

创建对象时，不再需要new，对于创建者而言，不需要知道创建细节，通过getXXX（）就可以得到实例对象。

• 2.1简单工厂模式（静态工厂模式）
  用来生产同一等级结构中的任意产品
  (对于增加的新产品，需要覆盖已有代码)

public interface Car {
	void name();
}

public class CarFactory {
	//方法一
	public static Car getCar(String car) {
		
		if(car.equals("五菱")) {
			return new WuLing();
		}else if(car.equals("特斯拉")){
			return new Tesla();
		}else {
			return null;
		}
	}
	
	//方法二
	//public static Car getWuLing() {
	//	return new WuLing();
	//}
	//public static Car getTesla() {
	//	return new Tesla();
	//}
	
}

public class Tesla implements Car{

	@Override
	public void name() {
		System.out.println("特斯拉！");
	}

}

public class WuLing implements Car{

	@Override
	public void name() {
		System.out.println("五菱宏光");
	}

}

public class Consumer {
	public static void main(String[] args) {
		
		Car car = CarFactory.getCar("五菱");
		Car car2 = CarFactory.getCar("特斯拉");
		
		car.name();
		car2.name();
		
	}
}

• 2.2工厂方法模式
  用来生产同一等级结构中的固定产品（支持增加任意产品）

public interface Car {
	void name();
}

public interface CarFactory {
	Car getCar();
}

public class TeslaFactory implements CarFactory{

	@Override
	public Car getCar() {
		return new Tesla();
	}

}

public class Tesla implements Car{

	@Override
	public void name() {
		System.out.println("特斯拉！");
	}

}

public class WulingFactory implements CarFactory{

	@Override
	public Car getCar() {
		return new WuLing();
	}

}

public class WuLing implements Car{

	@Override
	public void name() {
		System.out.println("五菱宏光");
	}

}

public class MoBaiFactory implements CarFactory{

	@Override
	public Car getCar() {
		return new MoBai();
	}

}

public class MoBai implements Car{

	@Override
	public void name() {
		System.out.println("摩拜单车");
	}
	
}

public class Consumer {
	public static void main(String[] args) {
		Car WCar = new WulingFactory().getCar();
		Car TCar = new TeslaFactory().getCar();
		Car MoBai = new MoBaiFactory().getCar();
		WCar.name();
		TCar.name();
		MoBai.name();
	}
}

• 简单工厂模式与工厂方法模式对比
  结构复杂度:Simple
  代码复杂度:Simple
  编程复杂度:Simple
  管理上的复杂度:Simple
  根据设计模式:工厂方法模式
  根据实际业务:简单工厂模式（更为常用）

3.静态代理模式

• 3.1 实现方式
  真实角色–You
  代理角色–WeddingCompany
  真实角色和代理角色实现公共接口（常用来记录日志）
• 3.2 优点
  客户端不必知道实现类（委托类）的内部方法实现，只需要调用代理类即可。

例子1

public class Thread05_StaticProxy {
	public static void main(String[] args) {
		new WeddingCompany(new You()).happyMarry();
		//new Thread(线程对象).start();多线程就是此原理。
	}
}

//公共接口Marry
interface Marry{
	void happyMarry();
}

//真实角色
class You implements Marry{

	@Override
	public void happyMarry() {
		System.out.println("you and 嫦娥 终于奔月了...");
		
	}
}

//代理角色
class WeddingCompany implements Marry{

	//真实角色
	private Marry target;

	public WeddingCompany(Marry target) {
		this.target = target;
	}
	
	@Override
	public void happyMarry() {
		ready();
		this.target.happyMarry();
		after();
	}
	
	private void ready() {
		System.out.println("布置猪窝...");
	}
	
	private void after() {
		System.out.println("闹嫦娥...");
	}
}

例子2
接口：UserIface.java

//关于用户管理的接口
public interface UserIface {
	void addUser();
	void delUser();
	void updUser();
	void findUser();
	void setRole();
}

真实角色类：UserImpl.java

public class UserImpl implements UserIface {

	@Override
	public void addUser() {
		System.out.println("addUser");
	}

	@Override
	public void delUser() {
		System.out.println("delUser");
	}

	@Override
	public void updUser() {
		System.out.println("updUser");
	}

	@Override
	public void findUser() {
		System.out.println("findUser");
	}

	@Override
	public void setRole() {
		System.out.println("setRole");
	}

}

静态代理类：UserProxy.java

public class UserProxy implements UserIface {
	private UserIface iface;
	
	
	public UserProxy(UserIface iface) {
		this.iface = iface;
	}

	@Override
	public void addUser() {
		check();
		iface.addUser();
	}

	@Override
	public void delUser() {
		check();
		iface.delUser();
	}

	@Override
	public void updUser() {
		check();
		iface.updUser();
	}

	@Override
	public void findUser() {
		check();
		iface.findUser();
	}
	
	@Override
	public void setRole() {
		check();
		iface.setRole();;
	}
	
	public void check() {
		System.out.println("check");
	}
	
}

静态代理测试类：Test.java

public class Test {
	public static void main(String[] args) {
		
		//真实角色（被代理对象）
		UserIface ui = new UserImpl();
		
		//静态代理
		UserProxy userProxy = new UserProxy(ui);
		userProxy.addUser();
		userProxy.setRole();
	}
	
}

4.动态代理模式

接口：UserIface.java
与3.2代码相同

真实角色类：UserImpl.java
与3.2代码相同

动态代理类：JdkHandler.java

public class JdkHandler  implements InvocationHandler{
	
	private Object obj;//目标对象
	
	public Object newProxy(Object obj) {
		this.obj = obj;
		ClassLoader loader = obj.getClass().getClassLoader();
		Class<?>[] clasz = obj.getClass().getInterfaces();
		return Proxy.newProxyInstance(loader, clasz, this);
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		check();
		return method.invoke(this.obj, args);
	}
	
	private void check() {
		System.out.println("check");
	}
	
}

动态代理测试类：Test.java

public class Test {
	public static void main(String[] args) {
		//真实角色（被代理对象）
		UserIface ui = new UserImpl();
		
		//动态代理
		JdkHandler handler = new JdkHandler();
		UserIface user = (UserIface) handler.newProxy(ui);
		user.addUser();
		user.setRole();
	}

}

动态代理优点：
与静态代理相比，静态代理类与真实角色都实现同一接口，当业务内容增加，接口中方法发生改变时，静态代理类也必须随之改变；
但动态代理类并不实现与真实角色相同的接口，使用反射原理完成对真实角色的代理，所以一经定义好后，静态代理类就不再需要改变。