3种常见的设计模式

[b]工厂模式：[/b]
[quote] 定义一个创建产品对象的工厂类,由该工厂统一创建继承了同一个接口的多个产品对象。
根据创建策略的不同,又分为3种类型。
->工厂方法模式:为普通的工厂方法模式。
->多个工厂方法模式:提供了多个工厂方法,分别创建不同的产品对象.
->静态工厂方法模式:工厂方法是静态的,不需要实例化工厂即可创建产品对象。[/quote]
代码分析:
●定义接口

public interface Animal{
					public int sale();
				}

●定义三个具体实现类(数目随意)

			//养猪
				public class Pig implements Animal{
				int price = 10;//价格
				int weight = 200;//重量
				public int sale(){
				return price * weight;
				}
				}
				//养鸡
				public class Chicken implements Animal{
				int price = 5;//价格
				int weight = 20;//重量
				int egg = 20;//鸡蛋
				public int sale(){
				return price * weight + egg;
				}
				}
				//养羊
				public class Sheep implements Animal{
				int price = 10;//价格
				int weight = 100;//重量
				int wool = 50;//羊毛
				public int sale(){
				return price * weight + wool;
				}
				}

●工厂方法模式 类

		public class Farm1{
					public Animal produce(String type){
					if("pig".equals(type)){return new Pig();}
					else if("chicken".equals(type)){return new Chicken();}
					else{return new Sheep();}
					}
				}

●多个工厂方法模式 类

	public class Farm2{
					public Animal producePig(){return new Pig();}
					public Animal produceChicken(){return new Chicken();}
					public Animal produceSheep(){return new Sheep();}
				}

●静态工厂方法模式 类

	public class Farm3{
					public static Animal producePig(){return new Pig();}
					public static Animal produceChicken(){return new Chicken();}
					public static Animal produceSheep(){return new Sheep();}
				}

[b]单例模式：[/b]
[quote] 定义：
单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类
特点：
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
应用：在线计数器、打印机等
单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。[/quote]
一、懒汉式单例在类被加载的时候，唯一实例已经被创建。这个设计模式在Java中容易实现，在别的语言中难以实现。
单例模式-懒汉式单例

public class LazySingleton {

			// 测试一下单例模式
			public static void main(String[] args) {
				LazySingleton lazySingleton = LazySingleton.getInstance();
				LazySingleton lazySingleton1 = LazySingleton.getInstance();

				if (lazySingleton == lazySingleton1) {
					System.out.println("同一个对象实例");
				} else {
					System.out.println("不是同一个对象实例");
				}
			}

			/*** 私有静态对象,加载时候不做初始化 */
			private static LazySingleton m_intance = null;

			/*** 私有构造方法,避免外部创建实例 */
			private LazySingleton() {
			}
			/*** 静态工厂方法,返回此类的唯一实例.* 当发现实例没有初始化的时候,才初始化. * @return LazySingleton */
			synchronized public static LazySingleton getInstance() {
				if (m_intance == null) {
					m_intance = new LazySingleton();
				}
				return m_intance;
			}
		}

二、饿汉式单例在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

/*** 单例模式-饿汉式单例 */
			public class EagerSingleton {

				public static void main(String[] args) {
					// 下面来判断一下有没有达到单例效果(系统运行的时候只出来一个空例)
					EagerSingleton eagerSingleton = EagerSingleton.getInstance();
					EagerSingleton eagerSingleton1 = EagerSingleton.getInstance();

					if (eagerSingleton == eagerSingleton1) {
						System.out.println("同一个对象实例");
					} else {
						System.out.println("不是同一个对象实例");
					}
				}

				/** 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象 */
				private static final EagerSingleton m_instance = new EagerSingleton();
				/*** 私有构造方法,避免外部创建实例 */
				private EagerSingleton() {
				} // 提供了一个空的构造方法
				/*** 静态工厂方法,返回此类的唯一实例.* @return EagerSingleton */
				public static EagerSingleton getInstance() {
					return m_instance;
				}
			}

三、登记式单例这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

import java.util.HashMap;
				import java.util.Map;

				/*** 单例模式- 登记式单例 */
				public class RegSingleton {
					/*** 登记薄,用来存放所有登记的实例 */
					private static Map<String, RegSingleton> m_registry = new HashMap();
					// 在类加载的时候添加一个实例到登记薄
					static {
						RegSingleton x = new RegSingleton();
						m_registry.put(x.getClass().getName(), x);
					}
					/*** 受保护的默认构造方法 */
					protected RegSingleton() {
					}
					/***
					 * 静态工厂方法,返回指定登记对象的唯一实例; 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回
					 * 
					 * @param name
					 * @return RegSingleton
					 */
					public static RegSingleton getInstance(String name) {
						if (name == null) {
							name = "RegSingleton";
						}
						if (m_registry.get(name) == null) {
							try {
								m_registry.put(name, (RegSingleton) Class.forName(name)
										.newInstance());
							} catch (InstantiationException e) {
								e.printStackTrace();
							} catch (IllegalAccessException e) {
								e.printStackTrace();
							} catch (ClassNotFoundException e) {
								e.printStackTrace();
							}
						}
						return m_registry.get(name);
					}

					/** * 一个示意性的商业方法 * @return String */
					public String about() {
						return "Hello,I am RegSingleton!";
					}
				}

[b]代理模式：[/b]
[quote] 代理模式的作用：
为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到的角色有：
抽象角色：
声明真实对象和代理对象的共同接口；
代理角色：
代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：
代理角色所代表的真实对象，是我们最终要引用的对象。[/quote]

实例：
抽象角色：

	 //生产商
				abstract public class Subject{ 
					abstract public void request(); //生产手机
				} 

真实角色：实现了Subject的request()方法。

public class RealSubject extends Subject { 
					public RealSubject() { 
					} 
					public void request() { 
						System.out.println("From real subject."); 
					} 
				} 

代理角色：

public class ProxySubject extends Subject { 
					private RealSubject realSubject;
					//以真实角色作为代理角色的属性 
					public ProxySubject() { 
					} 

					//该方法封装了真实对象的request方法
					public void request()  { 
						preRequest(); 
						if( realSubject == null ) { 
							realSubject = new RealSubject(); 
						} 
						realSubject.request(); //此处执行真实对象的request方法 
						postRequest(); 
					}

					private void preRequest() { 
						//something you want to do before requesting 
					} 

					private void postRequest() { 
						//something you want to do after requesting 
					} 
				} 

			客户端调用： 
				Subject sub=new ProxySubject(); 
				Sub.request();