工厂方法模式应该是这样的

    在网上看到工厂方法的模式讲解，作者们都有意无意的跟简单工厂模式联系在一起，我认为这本身似乎就是个错误。我觉得这个模式更像是外观模式的一个变形。
首先来讲简单工厂模式。如一个接口A， 实现类有A1，A2，A3.
在客户端上调用 A a=new A1(); 很多人觉得这样不好,因为这样就把接口跟具体的实现给耦合了。好吧，我也觉得不好，但是我先不会换成简单工厂，而是会这样：
  
A a=null;   
if(type==1){   
a=new A1（）;   
}else if(type==2){   
a=new A2（）;   
}else if(type==3){   
a=new A3（）;   
} ;  

A a=null;
if(type==1){
a=new A1（）;
}else if(type==2){
a=new A2（）;
}else if(type==3){
a=new A3（）;
} ;

但是上面的代码还是不好，因为可能调用这个if else判断的客户端不只有这里，其他的地方也要进行这样的判断，而且判断的逻辑是一样的。于是要考虑封装，自然而然的就要用简单工厂了。 其本质应该是
对A接口的实现类的选择的逻辑的封装
但是工厂方法模式：定义一个抽象的工厂方法，在子类中实现具体应该生成哪个A的接口。看上去确实生成A接口的选择被延时到子类。但是在客户端上调用还是有个很大的问题：谁来选择具体工厂方法模式中的工厂？ 简单工厂模式是把这个逻辑封装了的，到了工厂方法模式这个选择是由客户端自己来选择的：
  
AmethodFactory am=new A1methodFactory();//对应生成对象A1的工厂  

AmethodFactory am=new A1methodFactory();//对应生成对象A1的工厂

下面我们来看看工厂方法模式是如何手jian的。

其实
  
A a=new A1（）;  

A a=new A1（）;
这段代码已经很面向接口编程了。因为后面的操作都是用接口A的引用a进行具体的操作的。
我就是不知道选择new 哪个A的具体实现才用工厂方法模式的。结果工厂方法模式让我这么办
  
AmethodFactory am=new A1methodFactory();   
//我怎么知道选A1methodFactory 而不是选A2methodFactory的？   
A a=am.createA();//当然标准的做法这个方法是不要对外暴露的  

AmethodFactory am=new A1methodFactory();
//我怎么知道选A1methodFactory 而不是选A2methodFactory的？
A a=am.createA();//当然标准的做法这个方法是不要对外暴露的

这样的实现根本就没有起到把我将选择的逻辑封装起来，我还要多加个工厂AmethodFactory  还得在上面加实现
用来“开闭”我需求的增加。  我认为为了开闭的话，下面的代码就够了
  
A a=new A1（）;  

A a=new A1（）;反正客户端已经知道怎么选了，换个实现就行了嘛
A a=new A2（）;
A a=new A3（）;
A a=new A3（）;
要加需求就在加个类实现A接口，在这里在new之就行了，非常的开闭了。似乎是没有必要弄什么工厂方法模式的。

但是工厂模式存在也是有他的原因的，不过不能按简单工厂的思路想，不妨按外观模式的思路想想。
客户端需要一个A的实现完成一定的功能，如
  
A a=new A1（）;   
a.test(1);   
a.test2("soft");  

A a=new A1（）;
a.test(1);
a.test2("soft");但是客户端其实不是需要a， 他需要的是个整体，是
  
a.test(1);   
a.test2("soft");  

a.test(1);
a.test2("soft");

于是需要外观模式封装之。。。
  
class Facade{   
public void face(int i,String soft){   
a.test(i);   
a.test2(soft);   
}   
  
}  

class Facade{
public void face(int i,String soft){
a.test(i);
a.test2(soft);
}

}

face方法里面的逻辑一般上是固定的。 但是问题是
face方法依赖的a是个接口，不是实现类。自然而然的需要加入所谓的工厂方法，
于是有：

  
class Facade{   
  
public abstract create();   
public void face(int i,String soft){//关键是这个方法的逻辑比较固定，这时候用继承的方式更好   
//继承的目的其实主要是这个方法在子类里面不用写了   
A a=create();   
a.test(i);   
a.test2(soft);   
}   
  
}  

class Facade{

public abstract create();
public void face(int i,String soft){//关键是这个方法的逻辑比较固定，这时候用继承的方式更好
//继承的目的其实主要是这个方法在子类里面不用写了
A a=create();
a.test(i);
a.test2(soft);
}

}


这个Facade就变成了一个工厂方法了。 所以很多设计模式在讲到
工厂方法模式的时候会说 里面的create方法最好不给外面调用的。因为其实客户端不是需要对象
A，是需要完成特定的功能，这里是face方法（他才是客户端真正需要的），只是这些功能实现又依赖A罢了。
工厂模式跟简单工厂设计理念是不同的，他没有将选择的逻辑封装，而更像是个外观模式的变体。
其实像下面的这种需求，根本就不需要使用工厂方法模式的：
  
A a=new A1();   
a.test();// 客户端就只调这么一个方法，没有其他更复杂的逻辑了   
//如果手不jian实在不需要在搞个工厂方法模式出来。  

A a=new A1();
a.test();// 客户端就只调这么一个方法，没有其他更复杂的逻辑了
//如果手不jian实在不需要在搞个工厂方法模式出来。



大家觉得如何？

我表示看不懂

  
//Context是Android里的，该方法用来创建view   
public static <T extends BaseUnit> T createUnit(Class<T> cls,Context context) {   
        BaseUnit bu = null;   
        try {   
            bu = (BaseUnit)Class.forName(cls.getName()).getConstructor(Context.class).newInstance(context);   
        } catch (IllegalAccessException e) {   
            e.printStackTrace();   
        } catch (InstantiationException e) {   
            e.printStackTrace();   
        } catch (ClassNotFoundException e) {   
            e.printStackTrace();   
        } catch (IllegalArgumentException e) {   
            e.printStackTrace();   
        } catch (SecurityException e) {   
            e.printStackTrace();   
        } catch (InvocationTargetException e) {   
            e.printStackTrace();   
        } catch (NoSuchMethodException e) {   
            e.printStackTrace();   
        }   
        return (T)bu;   
    }  

//Context是Android里的，该方法用来创建view
public static <T extends BaseUnit> T createUnit(Class<T> cls,Context context) {
                BaseUnit bu = null;
                try {
                        bu = (BaseUnit)Class.forName(cls.getName()).getConstructor(Context.class).newInstance(context);
                } catch (IllegalAccessException e) {
                        e.printStackTrace();
                } catch (InstantiationException e) {
                        e.printStackTrace();
                } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                } catch (SecurityException e) {
                        e.printStackTrace();
                } catch (InvocationTargetException e) {
                        e.printStackTrace();
                } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                }
                return (T)bu;
        }

我很懒，一般都这么用

请教一下
public class buildhouse(){  //根据不同的参数类型
...
public gethouse(args){
switch(args.type){
case "red":new redhouse(args).getHouse(); break;
                        case "blue":new bluehouse(args).getHouse();break;
}

}
...
}

public interface house(){
void setcolor(args);
        void setwin(args);
void setdoor(args);
        String getHouse();
}

public class redhouse implements house{
void setcolor(args){color = args.color;}
void setwin(args){ winnumber = args.winnum; }
        void setdoor(args) { door = 1;
                             door.setColor("black");
                             door.setclock(1);
}
        String getHouse(args){
this.setcolor(args);
this.setwin(args);
this.setdoor(args);
};
}


public class bluehouse implements house{
void setcolor(args){color = args.color;}
void setwin(args){ winnumber = args.winnum; }
        void setdoor(args) { door = 2;
                             door.setColor("yellow");
                             door.setclock(1);
}
        String getHouse(args){
this.setcolor(args);
this.setwin(args);
this.setdoor(args);
};
}


如果需要增加新类型的房子,需要做的事情:
1,增加一个新的类
2,修buildhouse()的调用

如果buildhouse()需要增加新的方法,需要做的事情:
1,在buildhouse()中增加方法
2,修改所有的子类

问题:
class redhouse与class bluehouse中的方法,setcolor,setwin内容都是一样的,这样算代码重复吗?

第二种方式

public class buildhouse(){
...
public gethouse(args){
color = args.color;
winnumber = args.winnum;
        if(args.type=="red") {
door = 1;
                        door.setColor("black");
}
if(args.type=="blue"){
     door = 2;
                             door.setColor("yellow");
                           
}
door.setclock(1);

}
...
}

如果需要增加新类型的房子,需要做的事情:
需要修改gethouse的方法gethouse

问题:
每次需要修改代码的时候,都要修改gethouse.如果某些参数类型是不同的处理,又需要重新修改buildhouse.
如:

public class buildhouse(){
...
public gethouse(args){
color = args.color;
winnumber = args.winnum;
        if(args.type=="red") {
door = 1;
                        door.setColor("black");
}
if(args.type=="blue"){
     door = 2;
                             door.setColor("yellow");
                           
}
if(args.type=="green"){   //新增加的类型的处理与原来的不同
door.setclock(3);
}else{
door.setclock(1);
}
}
...
}


两种方式相比,哪种比较好?原理是什么

我觉得楼主钻研的太细了。
工厂方法，外观模式从目的上来说，是完全不同的，没有必要放在一起讨论。

设计模式中，功能相近或者结构相似的模式有很多，不用像答题一样，花费大量时间，把各个细微之处都抠得这么仔细。

看不懂……

工厂方法模式最简单的说法就是：用一维的工厂族对应二维的产品族

我也表示看不懂

我硬是没看懂！

最应该关心的应该是某个模式是用于在什么环境下解决什么问题、怎么解决问题，以及为什么要这样解决问题的。很多文章太表面化、形式化，看了都懂，就是跟实际应用联系不上，过后全忘。