设计模式之：简单工厂

第一步：

/*******************新建一个Apple类**********************/
public class Apple {
	/**
	 * 采集
	 */
	public void get() {
		System.out.println("采集苹果");
	}
}
/******************新建一个Banana类**********************/
public class Banana implements Fruit {
	/**
	 * 采集
	 */
	public void get() {
		System.out.println("采集香蕉");
	}
}
/***************再新建一个MainClass主类******************/
public class MainClass {

	public static void main(String[] args) {
		Apple apple = new Apple();
		Banana banana = new Banana();
		apple.get();
		banana.get();
	}
}
/*
 * 输出
 * 采集苹果
 * 采集香蕉
 */
//由此可以看出Apple,Banana这两个类可以抽象出一个方法,他们都是水果,他们都有一个get()这个方法

第二步：

//抽取一个接口
public interface Fruit {
	/**
	 * 采集
	 */
	public void get();
}

//Apple去实现Fruit这个接口
public class Apple implements Fruit{
	/**
	 * 采集
	 */
	public void get() {
		System.out.println("采集苹果");
	}
}
//Banana也去实现Fruit这个接口
public class Banana implements Fruit {
	/**
	 * 采集
	 */
	public void get() {
		System.out.println("采集香蕉");
	}
}
//这么做的好处是什么呢?我们用了多肽,这是我们要去new Apple,Banana的话,我们可以用接口来做
public class MainClass {
	public static void main(String[] args) {
		Fruit apple = new Apple();
		Fruit banana = new Banana();
		apple.get();
		banana.get();
	}
}
/*
 * 输出
 * 采集苹果
 * 采集香蕉
 */

回归概念：简单工厂模式
简单工厂模式属于类的创建模式,又叫做静态工厂方法模式.通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类.
第三步：

//根据以上定义来定义一个工厂
public class FrutiFactory {
	/**
	 * 获得Apple实例
	 */
	public static Fruit getApple() {
		return new Apple();
	}

	/**
	 * 获得Banana实例
	 */
	public static Fruit getBanana() {
		return new Banana();
	}
}
//这是的MainClass
public class MainClass {
	public static void main(String[] args) {
		// 实例化一个Apple
		Fruit apple = FrutiFactory.getApple();
		// 实例化一个Banana
		Fruit banana = FrutiFactory.getBanana();
		apple.get();
		banana.get();
	}
}
/*
 * 输出
 * 采集苹果
 * 采集香蕉
 */
//这就是静态工厂的实现
/**
 * 1,工厂角色(FrutiFactory)
 *   简单工厂模式的核心,它负责实现所有实例的内部逻辑.
 *   工厂类可以被外界直接调用,创建所需的产品对象
 * 2,抽象角色(Fruit)
 *   简单工厂模式所创建的所有对象的父类,他负责描述所有实例所共有的公共接口
 * 3,具体产品角色(apple.get(),banana.get())
 *   简单工厂模式所创建的具体实例的对象
 */

第四步：

//来改进FrutiFactory
public class FrutiFactory {
	/**
	 * get方法,获得所有产品对象
	 * 
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	public static Fruit getFruit(String type) throws InstantiationException,
			IllegalAccessException {
		if (type.equalsIgnoreCase("apple")) {
			return Apple.class.newInstance();
		} else if (type.equalsIgnoreCase("banana")) {
			return Banana.class.newInstance();
		} else {
			System.out.println("找不到相应的实例化类");
			return null;
		}
	}
}
//MainClass运行
	public static void main(String[] args) throws InstantiationException,
			IllegalAccessException {
		Fruit apple = FrutiFactory.getFruit("apple");
		Fruit banana = FrutiFactory.getFruit("banana");
		apple.get();
		banana.get();
	}

第五步：

//继续改进FrutiFactory
public class FrutiFactory {
	/**
	 * get方法,获得所有产品对象
	 * 
	 * @throws ClassNotFoundException
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 * 
	 * @throws IllegalAccessException
	 * @throws InstantiationException
	 */
	public static Fruit getFruit(String type) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class<?> fruit = Class.forName(type);
		return (Fruit) fruit.newInstance();
	}
}
//MainClass运行
public class MainClass {
	public static void main(String[] args) throws InstantiationException,
			IllegalAccessException, ClassNotFoundException {
		Fruit apple = FrutiFactory.getFruit("cobra.simpleFactory.Apple");
		Fruit banana = FrutiFactory.getFruit("cobra.simpleFactory.Banana");
		apple.get();
		banana.get();
	}
}

总结：
工厂类是整个模式的关键所在,它包含了必要的判断逻辑,能够根据外界给定的信息,决定究竟创建哪个具体类的对象.在使用时可以直接根据工厂类去创建所需实例,而无需了解这些对象是如何创建的.有利于整个软件体系的结构优化
缺点就是：高类聚做的不够好,另外,当系统中的具体产品类不断增多时,可能会出现要求工厂类的修改,扩展性不好.

写得不错.简单易懂.......如果不用框架...就用配置文件比较好

不错，简单易懂

现来一个绝的。 第六步：
  import java.util.HashMap;

public class FruitFacotry {
static HashMap<String, Fruit> fruits = new HashMap<String, Fruit>();
static {
fruits.put("banana", new Banana());
fruits.put("apple", new Apple());
}

/**
* 获取类
*
* @param name
* @return
*/
public Fruit getFruit(String name) {
if (this.checkName(name)) {
return this.getFruitByFullName(name);
}
return this.getFruitBySimpleName(name);
}
/**
* 通过Class
* @param className
* @return
*/
public Fruit getFruit(Class<?> className){
try {
return (Fruit) className.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}

/**
* 判断 是否调用全名方法
*
* @param name
* @return
*/
private boolean checkName(String name) {
return name.indexOf(".") > 0 ? true : false;
}

/**
* 采用简单获取方式
*
* @param simpleName
* @return
*/
@SuppressWarnings("static-access")
private Fruit getFruitBySimpleName(String simpleName) {
return this.fruits.get(simpleName.toLowerCase());
}

/**
* 采用名字
*
* @param fullName
* @return
*/
private Fruit getFruitByFullName(String fullName) {
try {
Class<?> className = Class.forName(fullName);
try {
return (Fruit) className.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}

第3、5、6值得参考学习

第五步就有些看不懂了,为什么要这样做呢?这个还叫工厂模式吗,自己都知道类路径了,就是把它实例出来,然后再用接口引用它.与一个一般的class.forname有什么区别呢?
挺简单一件事搞的那么复杂.工厂模式不就是为了隐藏实现,对扩展开发,这些目标吗.看java与模式,还不如看候捷译的effective java里描述的对象创建.不只是告诉我们what,how,最重要是讲解why.
小弟对模式更是不懂一二,只是看了贵贴后,一点感受,如有冒犯，还请多谅解！