JAVA 几种常见的设计模式

一、单例模式

单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类永远只会有一个实例化对象产生。常见方法是将采用单例设计模式的类的构造方法私有化，并在其内部产生该类的实例化对象，并将其封装成private static类型，时定义一个静态方法返回该类的实例。

根据实例对象按需产生或是加载类时就产生可分为懒汉式和饿汉式

饿汉式：

public class SingleDemo {
	private SingleDemo(){}
	private static SingleDemo s=new SingleDemo();
	public static SingleDemo getInstance(){
		return s;
	}
}

懒汉式：两种方案

方案一

public class SingleDemo2 {

	private SingleDemo2(){};
	private static SingleDemo2 s=null;
	public SingleDemo2 getInstance(){
		if(s==null){
			synchronized (SingleDemo2.class) {
				if(s==null){
					s=new SingleDemo2();
				}
			}
		}
		return s;
	}
}

方案二

class Single1 {
	private Single1() {
	}

	// 定义私有的内部静态类 对外隐藏 ，外部类加载时内部类不会同时加载
	private static class SingleUtil {
		static Single1 single_new = new Single1();
	}

	public static Single1 getInstance() {
		// 此时有调用到内部类的静态方法，加载，实现了延迟加载的目的,同时类加载只加载一次，因此线程安全
		return SingleUtil.single_new;
	}
}

二、模板模式

模板模式中父类为抽象类，其中制定一个涵盖了实现逻辑的方法，并将部分逻辑以具体方法的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。
不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。
先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。
我的理解是父类方法向子类指明了实现一个方法的具体步骤，其中某个步骤可以由父类指明具体实现，有些步骤则必须有子类亲自去具体实现.

下面是一个模板模式的例子

public abstract class Produce {

	protected void make() {

		proNum();// 获取商品编号
		System.out.println("生产一产品主体");
		color();// 定制颜色
		pack();// 包装
	}

	protected abstract void proNum();

	protected abstract void color();

	protected abstract void pack();

}

class MyProduce extends Produce{

	@Override
	protected void proNum() {
		// TODO Auto-generated method stub
		System.out.println("赋予商品编号"+System.currentTimeMillis());
	}

	@Override
	protected void color() {
		// TODO Auto-generated method stub
		System.out.println("赋予商品红色");
	}

	@Override
	protected void pack() {
		// TODO Auto-generated method stub
		System.out.println("将产品使用环保纸盒包装");
	}
	
}

测试：

public class BlogTest {
	public static void main(String[] args) {
		MyProduce produce=new MyProduce();
		produce.make();
	}
}

三、装饰模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。

如：自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件（时，能够在读取的每行前面都加上有行号和冒号。

这时需要自定义一个MyFileReader，并传入一个FileReader类,生成自己想要的新功能新方法。

public class BlogTest{
	public static void main(String[] args) throws Exception {
		MyFileReader in = new MyFileReader(new FileReader(new File(
				"D:\\test4.txt")));
		String line;
		while ((line = in.readLine()) != null) {
			System.out.print(line);
		}
	}
}

class MyFileReader {
	private FileReader reader;
	private int lineNum;

	public int getLineNum() {
		return lineNum;
	}

	public void setLineNum(int lineNum) {
		this.lineNum = lineNum;
	}

	public MyFileReader(FileReader reader) {
		this.reader = reader;
	}

	private MyFileReader() {

	}

	public String readLine() throws Exception {
		lineNum++;
		StringBuffer buf = new StringBuffer();
		// buf.append(lineNum+":");
		int data = 0;

		while ((data = reader.read()) != -1) {
			if ('\n' == data)
				break;
			buf.append((char) data);
		}
		if (buf.length() == 0)
			return null;
		return lineNum + ":\t" + new String(buf.toString().getBytes("UTF-8"), "UTF-8");

	}
}

四、工厂模式

1.简单工厂模式（结合反射）

public abstract class Electronics {
	abstract void run();
}

public class PC extends Electronics {

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

}

public class Phone extends Electronics {

	@Override
	void run() {
		// TODO Auto-generated method stub
		System.out.println("phone---打电话");
	}

}

下面是一个工厂类，根据传入的ClassName反射生成一个实例

public class Factory {
	public static Object getInstance(String className) throws Exception{
		Class clazz=Class.forName(className);
		return clazz.newInstance();
	}
}

测试

public class MyTest {
	public static void main(String[] args) throws Exception {
		Electronics phone = (Electronics) Factory.getInstance(Phone.class.getName());
		phone.run();
		Electronics pc = (Electronics) Factory.getInstance(PC.class.getName());
		pc.run();
	}
}

结果：

phone---打电话
PC---Eclipse

2.工厂方法模式

interface Factory {
	public abstract Electronics getInstance();
}

class PhoneFactory implements Factory {

	@Override
	public Electronics getInstance() {
		// TODO Auto-generated method stub
		return new Phone();
	}

}

class PCFactory implements Factory {

	@Override
	public Electronics getInstance() {
		// TODO Auto-generated method stub
		return new PC();
	}

}

用户需要不同设备只需调用不同工厂

public class MyTest {
	public static void main(String[] args) throws Exception {
		Factory phoneFactory = new PhoneFactory();
		Electronics phone = phoneFactory.getInstance();
		Factory pcFactory = new PCFactory();
		Electronics pc = pcFactory.getInstance();
		phone.run();
		pc.run();
	}
}

3.抽象工厂模式

前面两种工厂模式在实际使用中较少，而抽象工厂模式在开发中最为常见，可以配合配置文件切换数据库等等。

如下面的例子，有Iphone和Galaxy实现Phone接口，MacBook和Laptop实现PC接口，AppleFactory和SamsungFactory继承Factory抽象类，AppleFactor只生产Iphone和MacBook，SamsungFactory只生产Galaxy和LapTop。现在要实现不改变程序代码的情况下，只对配置文件做修改达到切换工厂，以改变生产的产品的目的。

interface PC{
	void run();
}

interface Phone{
	void run();
}

public class Iphone implements Phone {

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

}

public class Galaxy implements Phone {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("三星Galaxy手机 running...");
	}

}

public class LapTop implements PC{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("三星 PC running...");
	}

}

public class MacBook implements PC {

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

下面是工厂类：

public abstract class Factory {
	abstract PC getPC();

	abstract Phone getPhone();

	static void getFactory() {

	};
}

class AppleFactory extends Factory {

	@Override
	public PC getPC() {
		// TODO Auto-generated method stub
		return new MacBook();
	}

	@Override
	public Phone getPhone() {
		// TODO Auto-generated method stub
		return new Iphone();
	}

}

class SamsungFactory extends Factory {

	@Override
	public PC getPC() {
		// TODO Auto-generated method stub
		return new LapTop();
	}

	@Override
	public Phone getPhone() {
		// TODO Auto-generated method stub
		return new Galaxy();
	}

}

测试：

public class MyTest {
	public static void main(String[] args) throws Exception {
			Factory factory=new AppleFactory();//此处建立苹果工厂
			Phone phone=factory.getPhone();
			PC pc=factory.getPC();
			phone.run();
			pc.run();	
	}
}

打印结果：

Iphone running....
MacBook running...

public class MyTest {
	public static void main(String[] args) throws Exception {
			Factory factory=new SamsungFactory();//此处建立苹果工厂
			Phone phone=factory.getPhone();
			PC pc=factory.getPC();
			phone.run();
			pc.run();	
	}
}

打印结果：

三星Galaxy手机 running...
三星 PC running...

以上实现了手动切换工厂实例，现在将Factory抽象类中加入静态方法getFactory()来读取配置文件

public abstract class Factory {
	abstract PC getPC();

	abstract Phone getPhone();

	static Factory getFactory() throws Exception {
		Properties properties = new Properties();
		properties.load(new FileReader(new File("d:\\properties.config")));
		String factory = properties.getProperty("factory");
		Class clazz = Class.forName(factory);
		return (Factory) clazz.newInstance();
	};
}

配置文件如下：

factory=factoryTest.SamsungFactory

测试：

public class MyTest {
	public static void main(String[] args) throws Exception {
			Factory factory=Factory.getFactory();
			Phone phone=factory.getPhone();
			PC pc=factory.getPC();
			phone.run();
			pc.run();	
	}
}

打印结果：

三星Galaxy手机 running...
三星 PC running...

更改配置文件：

factory=factoryTest.AppleFactory
打印结果：

Iphone running....
MacBook running...

如上实现了，不改变代码而且换工厂以获取不同对象的功能。在实际应用中，工厂调用者并知道phone接口和pc接口的具体实现，只是获取到实例的引用，实现了对不应该暴露给用户资源的隐藏。