设计模式-工厂设计模式模板

package com.no9.interfaces3;

/**
 * 时间 : 2015年03月14日20:24:46
 * 工厂设计模式 
 * 1. 首先设计了一个Service接口(标准),和一个ServiceFactory(工厂).
 * 2. 两个实现类,实现了Service接口(标准),符合Service的标准.
 * 这两个实现类,虽然实现了Service接口(标准),但是无法生产出来
 * 3. 两个实现类工厂,实现了ServiceFactory(工厂),分别负责生产出各自的标准产品.
 * 4. serviceConsumer方法,负责使用产品,我不管你怎么实现的,我只管得到,Service,并调用该标准的方法.
 */

interface Service{
	void method1();
	void method2();
}

interface ServiceFactory{
	Service getService();
}

class Implementation1 implements Service{
	Implementation1(){}
	public void method1() {
		System.out.println("Implementation1 method1");
	}

	public void method2() {
		System.out.println("Implementation1 method2");
	}
}

class Implementation1Factory implements ServiceFactory{
	public Service getService() {
		return new Implementation1();
	}
}

class Implementation2 implements Service{
	Implementation2(){}
	public void method1() {
		System.out.println("Implementation2 method1");
	}
	public void method2() {
		System.out.println("Implementation2 method2");
	}
}
class Implementation2Factory implements ServiceFactory{
	public Service getService() {
		return new Implementation2();
	}
}



public class Factories {
	public static void serviceConsumer(ServiceFactory fact){
		Service s = fact.getService();
		s.method1();
		s.method2();
	}
	public static void main(String[] args) {
		serviceConsumer(new Implementation1Factory());
		serviceConsumer(new Implementation2Factory());
	}
}

package com.no10.inside_Factory;

/**
 * 现在用Implementation1和Implementation2构造器可以是private的了.
 * 而且没有必要去创建工厂的实名类.
 * 另外经常只需要单一的工厂对象,因此public static ServiceFactory factory 是static的.
 * 这样也更有意思.
 */
interface Service{
	void method1();
	void method2();
}

interface ServiceFactory{
	Service getService();
}

class Implementation1 implements Service{
	private Implementation1(){
	}
	public void method1() {
		System.out.println("Implementation1 method1");
	}
	public void method2() {
		System.out.println("Implementation1 method2");
	}
	public static ServiceFactory factory = new ServiceFactory() {
		public Service getService() {
			return new Implementation1();
		}
	};
}
class Implementation2 implements Service{
	private Implementation2(){
	}
	public void method1() {
		System.out.println("Implementation2 method1");
	}
	public void method2() {
		System.out.println("Implementation2 method2");
	}
	public static ServiceFactory factory = new ServiceFactory() {
		public Service getService() {
			return new Implementation2();
		}
	};
}

public class Factories {
	public static void serviceConsumer(ServiceFactory factory){
		Service service = factory.getService();
		service.method1();
		service.method2();
	}
	public static void main(String[] args) {
		serviceConsumer(Implementation1.factory);
		serviceConsumer(Implementation2.factory);
	}
}

public interface 工厂<T>{
	T next();
}

public class 淘宝 {
	private static long counter = 0;
	private final long id = counter++;
	public String toString() {
		return getClass().getSimpleName() + " " + id;
	}
}

class 鞋子 extends 淘宝 {
}
class 娃娃 extends 淘宝 {
}
class 手表 extends 淘宝 {
}


public class 淘宝工厂 implements 工厂<淘宝> {
	public 淘宝 next() {

		private Class[] types = { 鞋子.class,娃娃.class,手表.class};

		try {
				// 向上转型, 返回的实例都继承了 淘宝. 
			return (淘宝) types[random.nextInt(types.length)].newInstance();	// 返回是淘宝下面的产品(随机的)
		} catch (Exception e) {			
			throw new RuntimeException(e);
		}
}