Java中的设计模式

1.你所知道的设计模式有哪些

Java中一般认为有23种设计模式，我们不需要所有的都会，但其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然掌握的越多越好
总体来说设计模式分为三大类
创建型模式，共五种：工厂方法模式、抽象工厂模式、单列模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘模式、状态模式、访问者模式、中介者模式、解释器模式。

2.单例设计模式

最好理解的一种设计模式，分为懒汉式和饿汉式。
饿汉式：

public class Singleton{
	//直接创建对象
	public static Singleton instance = new Singleton();
	//私有化构造函数
	private Singleton(){
	}
	//返回对象实例
	public static Singleton getInstance(){
		return instance;
	}
}

懒汉式：

public class Singleton{
	//声明变量
	private static volatile Singleton singleton2 =null;
	//私有构造函数
	private Singleton2(){
	}
	//提供对外方法
	public static Singleton2 getInstance(){
		if(singleton2 == null){
			synchronized(Singleton2.class){
				if(singleton == null){
					singleton = new Singleton();
				}
			}
		}
		return singleton;
	}
}

3.工厂设计模式

工厂模式分为工厂方法模式和抽象工厂模式

工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
多个工厂方法模式。是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
静态工厂方法模式，将上面的多个工厂方法模式里的方法设置为静态的，不需要创建实例，直接调用即可。
普通工厂模式

public interface Sender { 
	public void Send(); 
} 
public class MailSender implements Sender { 
	@Override
	public void Send() { 
 	System.out.println("this is mail sender!"); 
	} 
} 
public class SmsSender implements Sender { 
	@Override
	public void Send() { 
 	System.out.println("this is sms sender!"); 
 	} 
} 
public class SendFactory {
	public Sender produce(String type) {
		if ("mail".equals(type)) {
			return new MailSender();
		} else if ("sms".equals(type)) {
			return new SmsSender();
		} else {
			System.out.println("请输入正确的类型！");
			return null;
		}
	}
}

多个工厂方法模式
该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

public class SendFactory { 
	public Sender produceMail(){ 
 		return new MailSender(); 
 	} 
 
 	public Sender produceSms(){ 
 		return new SmsSender(); 
 	} 
} 
public class FactoryTest { 
	public static void main(String[] args) { 
 	SendFactory factory = new SendFactory(); 
 	Sender sender = factory.produceMail(); 
 	sender.send(); 
 	} 
}

静态工厂方法模式，将上面的多个工厂方法模式里的方法设置为静态的，不需要创建实例，直接调用即可。

public class SendFactory { 
	public static Sender produceMail(){ 
 	return new MailSender(); 
 	} 
 
 	public static Sender produceSms(){ 
 	return new SmsSender(); 
 	} 
} 
public class FactoryTest { 
	public static void main(String[] args) { 
 	Sender sender = SendFactory.produceMail(); 
 	sender.send(); 
 } 
}

抽象工厂模式
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想拓展程序，必须对工厂进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

public interface Provider { 
	public Sender produce(); 
} 
----------------------------------------------------------------------------
public interface Sender { 
	public void send(); 
} 
---------------------------------------------------------------------------
public class MailSender implements Sender { 
	@Override
	public void send() { 
 	System.out.println("this is mail sender!"); 
 	} 
} 
----------------------------------------------------------------------------
public class SmsSender implements Sender { 
	@Override
	public void send() { 
 	System.out.println("this is sms sender!"); 
 	} 
} 
------------------------------------------------------------------------------------- 
public class SendSmsFactory implements Provider { 
	@Override
	public Sender produce() { 
 	return new SmsSender(); 
 	} 
}
public class SendMailFactory implements Provider { 
	@Override
	public Sender produce() { 
 	return new MailSender(); 
 	} 
} 
----------------------------------------------------------------------------
public class Test { 
	public static void main(String[] args) { 
 	Provider provider = new SendMailFactory(); 
 	Sender sender = provider.produce(); 
 	sender.send(); 
 	} 
}

建造者模式

工厂模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象。所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

public class Builder { 
	private List<Sender> list = new ArrayList<Sender>(); 
	public void produceMailSender(int count) { 
 	for (int i = 0; i < count; i++) { 
 		list.add(new MailSender()); 
 		} 
 	} 
public void produceSmsSender(int count) { 
 	for (int i = 0; i < count; i++) { 
 		list.add(new SmsSender()); 
 		} 
 	} 
}
public class TestBuilder { 
	public static void main(String[] args) { 
 	Builder builder = new Builder(); 
 	builder.produceMailSender(10); 
 	} 
}

适配器设计模式

适配器模式将某个类的接口转换成客户期望的另外一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式

类的适配器模式

public class Source { 
	public void method1() { 
 	System.out.println("this is original method!"); 
 	} 
} 
------------------------------------------------------------- 
public interface Targetable { 
	/* 与原类中的方法相同 */
	public void method1(); 
	/* 新类的方法 */
	public void method2(); 
} 
public class Adapter extends Source implements Targetable { 
	@Override
	public void method2() { 
 	System.out.println("this is the targetable method!"); 
 	} 
} 
public class AdapterTest { 
	public static void main(String[] args) { 
 	Targetable target = new Adapter(); 
 	target.method1(); 
 	target.method2(); 
 	} 
}

对象的适配器模式
基本思路和类的适配器模式相同，只是将Adapter类作为修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。

public class Wrapper implements Targetable { 
	private Source source; 
	public Wrapper(Source source) { 
 	super(); 
 	this.source = source; 
 	} 
	@Override
	public void method2() { 
 	System.out.println("this is the targetable method!"); 
 	} 
	@Override
	public void method1() { 
 	source.method1(); 
 	} 
} 
-------------------------------------------------------------- 
public class AdapterTest { 
 
 public static void main(String[] args) { 
 	Source source = new Source(); 
 	Targetable target = new Wrapper(source); 
 	target.method1(); 
 	target.method2(); 
 	} 
 }

接口的适配器模式

接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此外了解这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。

装饰模式（Decorator）

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个
接口，装饰对象持有被装饰对象的实例。

public interface Sourceable { 
	public void method(); 
} 
---------------------------------------------------- 
public class Source implements Sourceable { 
	@Override
	public void method() { 
 	System.out.println("the original method!"); 
 	} 
} 
---------------------------------------------------- 
public class Decorator implements Sourceable { 
	private Sourceable source; 
	public Decorator(Sourceable source) { 
 	super(); 
 	this.source = source; 
 } 
	@Override
	public void method() { 
		System.out.println("before decorator!"); 
		source.method(); 
		System.out.println("after decorator!"); 
 	} 
} 
---------------------------------------------------- 
public class DecoratorTest { 
	public static void main(String[] args) { 
 	Sourceable source = new Source(); 
 	Sourceable obj = new Decorator(source); 
 	obj.method(); 
 	} 
}

策略模式（strategy）

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。测量模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。

public interface ICalculator { 
	public int calculate(String exp); 
} 
--------------------------------------------------------- 
public class Minus extends AbstractCalculator implements ICalculator { 
	@Override
	public int calculate(String exp) { 
 	int arrayInt[] = split(exp, "-"); 
 	return arrayInt[0] - arrayInt[1]; 
 	} 
} 
--------------------------------------------------------- 
public class Plus extends AbstractCalculator implements ICalculator { 
	@Override
	public int calculate(String exp) { 
 	int arrayInt[] = split(exp, "\\+"); 
 	return arrayInt[0] + arrayInt[1]; 
 	} 
} 
-------------------------------------------------------- 
public class AbstractCalculator { 
	public int[] split(String exp, String opt) { 
 	String array[] = exp.split(opt); 
 	int arrayInt[] = new int[2]; 
 	arrayInt[0] = Integer.parseInt(array[0]); 
 	arrayInt[1] = Integer.parseInt(array[1]); 
 	return arrayInt; 
 	} 
}
public class StrategyTest { 
	public static void main(String[] args) { 
 	String exp = "2+8"; 
 	ICalculator cal = new Plus(); 
 	int result = cal.calculate(exp); 
 	System.out.println(result); 
 	} 
}

观察者模式（Observer）

观察者模式很好理解，类似于邮件订阅和 RSS 订阅，当我们浏览一些博客或 wiki 时，经常会看到 RSS 图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。

public interface Observer { 
	public void update(); 
} 
public class Observer1 implements Observer { 
	@Override
	public void update() { 
 	System.out.println("observer1 has received!"); 
 	} 
} 
public class Observer2 implements Observer { 
	@Override
	public void update() { 
 	System.out.println("observer2 has received!"); 
 	} 
} 
	public interface Subject { 
	 /*增加观察者*/ 
 	public void add(Observer observer); 
 
	 /*删除观察者*/ 
	 public void del(Observer observer);
  	/*通知所有的观察者*/ 
	public void notifyObservers(); 
 
 	/*自身的操作*/ 
 	public void operation(); 
} 
public abstract class AbstractSubject implements Subject { 
	private Vector<Observer> vector = new Vector<Observer>(); 
	@Override
	public void add(Observer observer) { 
 	vector.add(observer); 
 	} 
	@Override
	public void del(Observer observer) { 
 	vector.remove(observer); 
 	} 
	@Override
	public void notifyObservers() { 
 	Enumeration<Observer> enumo = vector.elements(); 
 	while (enumo.hasMoreElements()) { 
 		enumo.nextElement().update(); 
 		} 
 	} 
} 
public class MySubject extends AbstractSubject { 
	@Override
	public void operation() { 
 		System.out.println("update self!"); 
 		notifyObservers(); 
 	} 
} 
public class ObserverTest { 
	public static void main(String[] args) { 
 	Subject sub = new MySubject(); 
 	sub.add(new Observer1());
 	sub.add(new Observer2()); 
 	sub.operation(); 
 	} 
}