设计模式--工厂设计模式、代理设计模式、适配器设计模式

工厂设计模式、代理设计模式、适配器设计模式

工厂设计模式

在同一个父类（一般是接口）下的子类有多个，每想操作一个子类，就必须new一个子类的对象，这样 很容易造成子类的耦合，如果在操作子类、new一个子类 的时候，在他们之间写一个过渡的类，就是工厂设计模式
父类（接口）

//animal父类
public interface Animal {
	
	public void run();
}

子类dog

//dog子类实现animal父类
public class Dog implements Animal{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("dog like run");
	}
}

子类cat

//cat子类实现animal父类
public class Cat implements Animal{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("cat like run");
	}
}

测试类

public class Test {
	public static void main(String[] args) {
		Animal a=new Dog();
		a.run();
		Animal b=new Cat();
		b.run();
	}
}

得到了

但是如果你想更换操作的子类，你就必须要在Test类更改new的对象，这样的操作在开发中是极其不提倡的一种操作，于是在他们之间加一个过渡类

过渡类

获取name来得知该创建哪一个对象

public class Factory {
	public static Animal getAnimal(String name) {
		if(name.equals("dog")) {
			return new Dog();
		}else if(name.equals("cat")) {
			return new Cat();
		}
		return null;
	}
}

加了过渡的Test测试类，通过name为dog来new Dog（），从而调用run（）方法

public class Test {
	public static void main(String[] args) {
		Animal a=Factory.getAnimal("dog");
		a.run();
	}
}

假如添加一个子类Bird

public class Bird implements Animal{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("bird not like run");
	}
}

更改过渡类

if(name.equals("dog")) {
			return new Dog();
		}else if(name.equals("cat")) {
			return new Cat();
		}else if(name.equals("bird")){
			return new Bird();
		}

测试类调用Bird方法

Animal a=Factory.getAnimal("bird");
a.run();

代理设计模式

什么是代理设计模式？例如：一个玩家想拿首胜，但是他不想自己打，于是他就在一个平台上招募人代他拿首胜，其中平台就是一个主题、一个接口，那个玩家和代练就是两个实现接口的对象，用官方的话就是：为其他对象提供一种代理以控制对这个对象的访问。

interface subject{//定义一个操作的主题
	public void FirstWin();
}

class player implements subject{//玩家实现主题

	@Override
	public void FirstWin() {
		// TODO Auto-generated method stub
		System.out.println("我要拿首胜");
	}
		
}

class GamePlayer implements subject{//代练实现主题
	private subject sub=null;
	public GamePlayer(subject subject) {
		// TODO Auto-generated constructor stub
		this.sub=subject;
	}
	
	public void brfore() {
		System.out.println("接单，热身，找手感");
	}
	
	@Override
	public void FirstWin() {
		// TODO Auto-generated method stub
		brfore();
		this.sub.FirstWin();//代表玩家的想法
		after();
	}
	
	public void after() {
		System.out.println("收钱，欢迎下次光临");
	}
	
}

测试类

public class Demo {
	public static void main(String[] args) {
		subject s=new player();
		subject subject=new GamePlayer(s);
		subject.FirstWin();
	}
}

结果

适配器设计模式

让原本不能一起工作的两个接口可以一起工作
例如 一个十字螺丝刀是一个接口，它只能扭开十字的钉子，另一个一字的螺丝刀是一个接口，它可以扭开一字的钉子，适配器的作用就是让十字的螺丝刀可以扭开一字的钉子，反之亦然。

interface A{//十字螺丝刀
	public void solve();
}

interface B{//一字螺丝刀
	public void help();
}

class AImpl implements A {//我是十字螺丝刀

	@Override
	public void solve() {
		// TODO Auto-generated method stub
		System.out.println("我可以解决十字的钉子");
	}
	
}

class BImpl implements B {//一字螺丝刀

	@Override
	public void help() {
		// TODO Auto-generated method stub
		System.out.println("我可以帮助处理一字的钉子");
	}
	
}

class Adapter implements A,B{//适配器

	private A a;
	private B b;
	
	public Adapter(A a) {
		// TODO Auto-generated constructor stub
		this.a=a;
	}
	
	public Adapter(B b) {
		// TODO Auto-generated constructor stub
		this.b=b;
	}
	
	@Override
	public void help() {
		// TODO Auto-generated method stub
		a.solve();
	}

	@Override
	public void solve() {
		// TODO Auto-generated method stub
		b.help();
	}
	
}

测试类

public class Demo05 {
	public static void main(String[] args) {
	//把十字螺丝刀当成一字的使用
		A a=new AImpl();//定义十字螺丝刀
		Adapter adapterA=new Adapter(a);//实例化适配器 B，把十字螺丝刀当做一字螺丝刀去使用，当在适配器中调用help()的方法时，会执行 A 的方法
		help(adapterA);//其实是调用到Adapter的help()
		//solve(adapterA);
	}
	public static void solve(A a) {//静态方法
		a.solve();
	}
	public static void help(B b) {//静态方法
		b.help();
	}
}

结果