Java设计模式总汇一 （适配器、单例、静态代理、简单工厂设计模式）

PS：首先咱们要带着问题读文章

• 什么是设计模式
• 为何要用设计模式
• 使用设计模式有什么好处

　　设计模式是一套被反复使用的、多数人知晓的、通过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石同样。项目中合理地运用设计模式能够完美地解决不少问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在咱们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被普遍应用的缘由。

　　　该篇文章主要写的是（介绍没有顺序）

• 适配器设计模式
• 单例设计模式
• 静态代理设计模式
• 简单工厂设计模式

1：适配器设计模式

意图：将一个类的接口转换成客户但愿的另一个接口。适配器模式使得本来因为接口不兼容而不能一块儿工做的那些类能够一块儿工做。

主要解决：主要解决在软件系统中，经常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能知足的。

官方给出：

优势： 一、可让任何两个没有关联的类一块儿运行。 二、提升了类的复用。 三、增长了类的透明度。 四、灵活性好。

缺点： 一、过多地使用适配器，会让系统很是零乱，不易总体进行把握。好比，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统若是太多出现这种状况，无异于一场灾难。所以若是不是颇有必要，能够不使用适配器，而是直接对系统进行重构。 2.因为 JAVA 至多继承一个类，因此至多只能适配一个适配者类，并且目标类必须是抽象类。

示例：这里我简单写一个关于两个接口的例子，来调用里面的方法来看看效果这两个接口咱们能够理解成充电器，一个是苹果lighting口，一个安卓充电器，咱们都知道这两个充电器接口是不同的，可是淘宝上有卖转换头的，能够在苹果头上套一个转换器就能够冲安卓手机里，这中间的转换头就是咱们所说的适配器，我再配张图（中间一头是方形一头是圆形就是适配器）

好，废话很少说，开始

（1）首先写一个A苹果接口，一个B安卓接口而后实现该接口里的方法，开始工做

　　

//实现A
class PowerA {
	public void workA(){}
}
class PowerAiml extends PowerA{
	public void workA(){
		System.out.println("我是A，我要开始工做了");
	}
}
//实现B
class PowerB {
	public void workB(){}
}
class PowerBiml extends PowerB{
	public void workB(){
		System.out.println("我是B，我要开始工做了");
	}
}

 （2）写一个方法只有A（苹果）接口能够用。

　　

public static void work(PowerA a){
		System.out.println("开始-------");
		a.workA();
		System.out.println("结束-------");
	}

 （3）调用查看效果

PowerA pa=new PowerAiml();
		work(pa);

 

这样使用是没有任何问题的，由于参数就是PowerA a，只要是传入实现PowerA接口的class均可以调用该方法，可是，问题来了，若是我想让使用PowerB怎么办呢，有两个方法，一个是再写一个work2（PowerB b），另外一个是用适配器的方法，显然第一种方法对于这个例子是最简单的，可是在一个软件编写的过程当中不光是这一点代码，代码有不少，难道都要再写方法吗，那样子就太麻烦了，如今就用适配器的方法

（4）适配器

想要使用A方法，就要假装成A，把适配器实现PowerA

//适配器：
class Adapter1 extends PowerA{
	public PowerB b;
	public Adapter1(PowerB b){
		this.b=b;
	}
	//当调用A的时候，就自动调用B里的方法。
	public void workA(){
		b.workB();
	}
}

 调用的时候是，一头与B关联，一头与A关联

PowerB b=new PowerBiml();
Adapter1 adapter=new Adapter1(b);
work(adapter);

 

解释一下：在Adapter1中传入的b，而后把adapter传入work，虽然调用的都是workA，可是关键来了，在workA方法中又调用了b.workB()；就是这么一个思路。

这是一个很是简单的例子，在开发过程当中，真正要用到适配器要比这个看似复杂点，原理都是同样的，毕竟小孩子的性格是天真的，大人的性格就变化莫测了。

2：代理设计模式

意图：为其余对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，好比说：要访问的对象在远程的机器上。在面向对象系统中，有些对象因为某些缘由（好比对象建立开销很大，或者某些操做须要安全控制，或者须要进程外的访问），直接访问会给使用者或者系统结构带来不少麻烦，咱们能够在访问此对象时加上一个对此对象的访问层。

什么时候使用：想在访问一个类时作一些控制。

如何解决：增长中间层。

静态代理模式，说白了就是委托，将全部的事情都委托给别人帮你完成，你所要作的，就是给代理一些东西，接下来全部的事情都是代理帮你完成，你彻底不用去关心内部是如何实现的。举个例子简单的说一下，一我的买衣服，能够去实体店也能够去网上，买火车票的时候，你就知道售票员就会给你 你想要的票，并且你只须要给他钱和身份证以及地点就能够了，他会通过处理，最后把票给你，他就处于一个代理模式。下面我简单写一个例子

好比说我只想要水，我就给你送水的公司打电话让他们送一桶水，而后我就在家等着就能够，在这期间谁送水，怎么送，须要多久，什么样的水等一切我都不须要知道，这都被送水公司代理了。OK

（1）先写一个要水的类和接口

class Action{
	public void work(){}
}
class MyAction extends Action{
	public void work(){
		//在这期间可能会有我不想作的事，但仍是要有，好比说一共耗时，打水结果要的是水，但必须要拿水桶等。
		//这些东西都是可让代理给作了，
		System.out.println("得到水");
	}
}

 （2）写代理类

若是不写代理类的话，也能够直接调用work方法，可是就至关于本身去搬水，而不是用代理。

/**
 * 代理类
 * 	控制，在方法前或后所要作的类。
 * */
class DaiLiAction extends Action{
	private Action action;
	public DaiLiAction(Action action){
		this.action=action;
	}
	public void work(){
		System.out.println("我是送水公司");
		System.out.println("代理正在处理中。。。");
		System.out.println("代理处理完了返回给你结果");
		action.work();
	}
}

 （3）调用便可

Action ac=new MyAction();
//把对象给代理类，工做是由代理完成。
DaiLiAction dai=new DaiLiAction(ac);
dai.work();

 

3：单例设计模式

http://www.cnblogs.com/cmusketeer/p/8016550.html

4:简单工厂设计模式

意图：定义一个建立对象的接口，让其子类本身决定实例化哪个工厂类，工厂模式使其建立过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

什么时候使用：咱们明确地计划不一样条件下建立不一样实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

哦，对了，这是简单工厂设计模式，还有抽象工厂设计模式，和这个相似，下一篇再说，这里先举例说明这个模式，使用该模式能够下降使用者和被使用者之间的依赖。好比说，我开了一个工厂，下面有部门，一个是造手机的，一个是造电脑的，OK

（1）建立手机和电脑类

/**
 * 工厂接口
 * */
interface Factory1{
	public void create();
}

/**
 * 手机
 * */
class Phone implements Factory1{
	@Override
	public void create() {
		System.out.println("我是造--手机--的");
		
	}
}
/**
 * 电脑
 * */
class Computer implements Factory1{
	@Override
	public void create() {
		System.out.println("我是造--电脑--的");
	}
}

（2）建立工厂控制类FactoryControl

/**
 * 工厂控制类
 * */

class FactoryControl{
	public static Factory1 getGood(String good){
		if(good.equalsIgnoreCase("phone")){
			return new Phone();
		}else if(good.equalsIgnoreCase("computer")){
			return new Computer();
		}
		return null;
	}
}

 (3)调用和效果

Factory1 factory=FactoryControl.getGood("phone");
		factory.create();
		
		factory=FactoryControl.getGood("computer");
		factory.create();

 

固然，也能够不通过FactoryControl（工厂类）,也是能够调用的，可是若是是大工程，使用该模式能够下降使用者和被使用者之间的依赖。这里就算你传入一个耳机，没有这个功能，它也不会报错，返回null。

好了，下一篇就会继续写剩下的19个设计模式，例子都是简单易懂的，只要理解了，慢慢的再写复杂的代码就轻松了，只要有了思想，写代码就简单了，能够告别有能力但总以为无处施展的尴尬。