工厂模式的疑惑，返回多个不同的实例对象

[darkula]

如题……我有一个工厂，用来创建实例的，大致如下
public class InstanceFactory implements Instance{
public Object create(String className){
if(className.equalsIgnoreCase("Category")){
return new Category();
}
if(className.equalsIgnoreCase("Freight")){
return new Freight();
}
return null;
}
}

interface Instance 有个抽象方法:public Object create(String className);
Category.java和Freight.java是我想创建实例的对象
我想用这个工厂返回多个类的实例；但这样只能接Object的对象……没办法细分下去呀……大家帮忙看看，谢谢了

[darkula]

还是不行~~~返回倒是都对了，但如果
Category里有个方法是setCategoryID()
Freight里有个方法是setFreightID()
的话，还是每法用返回的实例使用这些方法……

[darkula]

咋没人呢？？大家平时都是怎么取实例的？？

[superman421]

为什么要细分！
仔细体会什么是工厂！

[darkula]

已经解决了……做个实例类，让所有想被实例化的类都继承他就OK了 :)

我想做个总体的实例工厂~~~因为这些对象没有共同的行为呀~~只做到实例化阶段就可以了

[funcreal]

我可以很负责人的告诉你，你这叫：少年不只愁滋味，为赋新词强说愁！
因为工厂模式没你想得那么简单。

[funcreal]

不要因为听说了一个工厂模式就非得把它硬套上去。
如果说你非得需要这么一个类的话，只能这样了：

public class InstanceFactory implements Instance{
public Object createCategory(){

return new Category();

}
public Object createFreight(){

return new Freight();

}
}
工厂模式就是用生产具有同等类型的对象，像你这样使用实在是不敢恭维

[holder]

不要为了用模式而用模式
模式是用来解决特定的问题的

[aboush]

要是真的像楼主描述的那样没有抽象的理由存在，那就用构造函数产生吧！简单，优美．

[darkula]

恩，谢谢楼上各位的教诲，我只是想尽快的学以至用；
思而不学则罔嘛~~~

[bluesage]

看看抽象工厂

[禽兽v5]

代码写得多了自然会碰到。

如果真想对模式有更好的了解，多阅读流行开源项目的源码。

[darkula]

谢谢楼上:)
我开始看Hibernate了

[beyondtkl]

轉貼:

设计模式之Factory——买货篇
今天老婆让我去市场买一些水果，具体买什么自己定（哈，老婆放放权了！）。来到市场，我发现主要有一些水果：苹果（Apple），葡萄（Grape）和鸭梨（Pear）。
到底买什么好呢？我一阵思量。俗话说：“饭后一只烟，赛过活神仙。饭后吃苹果，西施见我躲。”为了老婆的漂亮，我决定买苹果。
好，言归正传，开始买吧！

主要有以下三种Factory模式：
Simple Factory模式
专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。
Factory Method模式
将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。
Abstract Factory模式
提供一个共同的接口来创建相互关联的多个对象。

一、Simple Factory模式：
1、 在这里，我们先定义水果（Fruit）接口：
public interface Fruit {
void plant(); //水果是被种植的
void enableEat(); //水果能吃
}
2、 苹果（Apple）是对水果（Fruit）接口的实现：
public class Apple implements Fruit{
public void plant(){
System.out.println("种苹果!");
}
public void enableEat(){
System.out.println("苹果好吃!");
}
}
3、 葡萄（Grape）是对水果（Fruit）接口的实现：
public class Grape implements Fruit{
public void plant(){
System.out.println("种葡萄!");
}
public void enableEat(){
System.out.println("葡萄好吃!");
}
}
4、 鸭梨（Pear）是对水果（Fruit）接口的实现：
public class Pear implements Fruit{
public void plant(){
System.out.println("种鸭梨!");
}
public void enableEat(){
System.out.println("鸭梨好吃!");
}
}
5、定义买水果（BuyFruit）这一过程类：
public class BuyFruit {
/**
* 简单工厂方法
*/
public static Fruit buyFruit(String which){
if (which.equalsIgnoreCase("apple")) { //如果是苹果，则返回苹果实例
return new Apple();
}
else if (which.equalsIgnoreCase("pear")){ //如果是鸭梨，则返回鸭梨实例
return new Strawberry();
}
else if (which.equalsIgnoreCase("grape")) { //如果是葡萄，则返回葡萄实例
return new Grape();
}
else{
return null;
}
}
}
6、 编写测试类：
public class FruitTest {
public static void main(String args[]){
BuyFruit buy = new BuyFruit(); //开始买水果这个过程
buy.buyFruit("apple").enableEat(); //调用苹果的enableEat()方法
}
}
7、 说明：
A：我要购买苹果，只需向工厂角色（BuyFruit）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。
B：但是对于工厂角色（BuyFruit）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。
C：因此Simple Factory模式的开放性比较差。
有什么办法可以解决这个问题吗？那就需要Factory Method模式来为我们服务了。
二、Factory Method模式：
1、同样，我们先定义水果（Fruit）接口：
public interface Fruit {
void plant(); //水果是被种植的
void enableEat(); //水果能吃
}
2、苹果（Apple）是对水果（Fruit）接口的实现：
public class Apple implements Fruit{
public void plant(){
System.out.println("种苹果!");
}
public void enableEat(){
System.out.println("苹果好吃!");
}
}
3、葡萄（Grape）是对水果（Fruit）接口的实现：
public class Grape implements Fruit{
public void plant(){
System.out.println("种葡萄!");
}
public void enableEat(){
System.out.println("葡萄好吃!");
}
}
4、鸭梨（Pear）是对水果（Fruit）接口的实现：
public class Pear implements Fruit{
public void plant(){
System.out.println("种鸭梨!");
}
public void enableEat(){
System.out.println("鸭梨好吃!");
}
}
5、在这里我们将买水果（BuyFruit）定义为接口类：
public interface BuyFruit{
/**
* 工厂方法
*/
public Fruit buyFruit(); //定义买水果这一过程
}
6、买苹果是（BuyApple）对买水果（BuyFruit）这个接口的实现
public class BuyApple implements BuyFruit{
public Fruit buyFruit(){
return new Apple(); //返回苹果实例
}
}
7、买鸭梨是（BuyPear）对买水果（BuyFruit）这个接口的实现
public class BuyPear implements BuyFruit{
public Fruit BuyPear (){
return new Pear(); //返回鸭梨实例
}
}
8、买葡萄是（BuyGrape）对买水果（BuyFruit）这个接口的实现
public class BuyGrape implements BuyFruit{
public Fruit BuyGrape (){
return new Grape (); //返回葡萄实例
}
}
9、编写测试类：
public class FruitTest {
public static void main(String args[]){
BuyApple buy = new BuyApple(); //开始买水果这个过程
buy.buyFruit().enableEat(); //调用苹果的enableEat()方法
}
}
10、说明：
A：工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。
B：工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。由于反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。C：如果需要加入一个新的水果，那么只需要加入一个新的水果类以及它所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的水果类而言，这个系统完全支持“开-闭”原则。
D：对Factory Method模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要Factory Method模式帮忙了。
三、Abstract Factory模式
1、同样，我们先定义水果（Fruit）接口：
public interface Fruit {
void plant(); //水果是被种植的
void enableEat(); //水果能吃
}
2、苹果（Apple）是对水果（Fruit）接口的实现：
public class Apple implements Fruit{
public void plant(){
System.out.println("种苹果!");
}
public void enableEat(){
System.out.println("苹果好吃!");
}
}
3、葡萄（Grape）是对水果（Fruit）接口的实现：
public class Grape implements Fruit{
public void plant(){
System.out.println("种葡萄!");
}
public void enableEat(){
System.out.println("葡萄好吃!");
}
}
4、鸭梨（Pear）是对水果（Fruit）接口的实现：
public class Pear implements Fruit{
public void plant(){
System.out.println("种鸭梨!");
}
public void enableEat(){
System.out.println("鸭梨好吃!");
}
}
5、 定义肉（Meat）接口：
public interface Meat {
void feed(); //肉是喂养的
void enableEat(); //肉能吃
}
6、 猪肉（BigMeat）是对肉（Meat）接口的实现：
public class BigMeat implements Meat{
public void feed(){
System.out.println("养猪!");
}
public void enableEat(){
System.out.println("猪肉好吃!");
}
}
7、 牛肉（CowMeat）是对肉（Meat）接口的实现：
public class CowMeat implements Meat {
public void feed(){
System.out.println("养牛!");
}
public void enableEat(){
System.out.println("牛肉好吃!");
}
}
8、 我们可以定义买货人（Buyer）接口：
public interface Buyer {
/**
* 买水果工厂方法
*/
public Fruit buyFruit(Fruit whichFruit);
/**
* 买肉的工厂方法
*/
public Meat buyMeat(Meat whichMeat);
}
9、 我（MyBuyer）是对买货人（Buyer）接口的实现：
public class MyBuyer implements Buyer{
/**
* 买水果工厂方法
*/
public Fruit buyFruit(Fruit whichFruit){
return whichFruit;
}
/**
* 买肉的工厂方法
*/
public Meat buyMeat(Meat whichMeat){
return whichMeat;
}
}
10、编写测试类：
public class MyBuyerAbstractTest {
public static void main(String args[]){
Fruit apple = new Apple(); //苹果实例
Meat big = new BigMeat(); //猪肉实例
MyBuyer my = new MyBuyer(); //我是买者的实例
my.buyFruit(apple).enableEat(); //我买苹果
my.buyMeat(big).enableEat(); //我买猪肉
}
}
11、说明：
A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。
B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。
C：抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构(Fruit、Meat)。

[darkula]

感谢大家了：）
看来还是要增加代码量的