基础知识: 需求!

我反对的不是这个东西Factory的职责
是写在这个类里面的把构造函数private的static factory
我的观点就是这样的factory，除非里面就是new本身，不然就会影响重用
我已经说明了子类是无法封装起来的，附加的JNDI是无法封装的，因为你在一个地方选择了这种，就没办法在另外一个地方也是选择另外一种
你可以举例说明除了直接写一个new 之外哪些东西可以对两个或多个不同的应用程序透明而可以放在这里面

我这里还要重复一遍，我不是试图证明这种做法是完全不可取，而是证明除非是=new，他必然会要比普通的new失掉了一部分的灵活性

我没有举例子么?
那个Hello的例子好像刚举了不久啊.

那就再举一个吧.

interface Predicate{
  bool eval(Object obj);;
}

final class TruePredicate implements Predicate{
  public bool eval(Object obj);{return true;}
  private static final Predicate singleton = new TruePredicate();;
  public static Predicate instance();{return singleton;}
}

final class TruePredicate implements Predicate{
  public bool eval(Object obj);{return true;}
  public static Predicate instance();{return new TruePredicate();;}
}

final class TruePredicate{
  public static Predicate instance();{
    return new Predicate();{
      public bool eval(Object obj);{return true;}
    };
  }
}

final class TruePredicate{
  public static Predicate instance();{
    return LiteralPredicate.instance(true);;
  }
}

这四个Predicate的instance()里面的东西是不同的吧? 但是这个区别对你外界是透明的.
你根本没有需要去知道TruePredicate到底是个什么样的类.
这是不是在instance()里面的逻辑? 是否影响了灵活性呢? 请举证.

你说要证明静态工厂会牺牲灵活性, 我在一直在翘首等着你的实例呢.

我只要一份代码，可以重用于两个不同的应用情况，一个应用程序要
TruePredicate();
另一个应用程序要
Predicate(){
...}
        public bool eval(Object obj){return true;}
};
客户代码不希望知道TruePredicate（它是个工厂）返回的是TruePredicate还是Predicate(){
...}
        public bool eval(Object obj){return true;}
};
这样行不行

什么意思? 你是在支持我的论点么? 不会吧? 拜托整理一下先?

对了,其实那个LiteralPredicate也是一个例子啊.

final class LiteralPredicate implments Predicate{
  private final bool v;
  public bool eval(Object o);{return v;}
  private LiteralPredicate(bool v);{this.v = v;}
  public static Predicate instance(bool v);{
    return new LiteralPredicate(v);;
  }
}

final class LiteralPredicate implments Predicate{
  private final bool v;
  public bool eval(Object o);{return v;}
  private LiteralPredicate(bool v);{this.v = v;}
  private static Predicate yes = new LiteralPredicate(true);;
  private static Predicate no = new LiteralPredicate(false);;
  public static Predicate instance(bool v);{
    return v?yes:no;
  }
}

也是两个完全等价的实现, instance()里不见得就必须new吧? 影响了灵活性了么?

我怎么看着看着发现这个话题就要奔着我的最爱"抽象工厂+ glue代码"去了呢.

这样吧，我来实现一下：

final class TruePredicate{
   public static Predicate instance(int code);{
    if(code==1);
       return new Predicate();{
       public bool eval(Object obj);{return true;}
     }; 
     else if(code==2);
     return LiteralPredicate.instance(true);; 
  else
   return new TruePredicate();
}

这样readonly的代码可以用TruePredicate.instance(1),potian可以用TruePredicate.instance(2)，charon可以用TruePredicate.instance(XXX)，现在这份代码就可以不经修改在各个应用程序之间使用了，同时也可以让大家不知道具体的子类，反正是Predicate 接口就行了

这样的代码，我看着可怕

final class TruePredicate implements Predicate{
...}
 2   public bool eval(Object obj);{return true;}
 3   private static final Predicate singleton = new TruePredicate();; 
 4   public static Predicate instance();{return singleton;}
 5 }

假设这样一个极端一点的例子：

public interface A{
   public B getB();;
   oublic void setB(B b);;
   public C getC();
   public void setC(C c);;
   public D getD();;
  pulbuic void setD(D d);

}

public AImpl implemens A{
  private A(AB b,C c,D d,...);{
   }
   public static instance();{
      return this( BImpl.instance(); ,Cimpl.instance();,Dompli,instance();..);;


   

耦合这么紧密！难道还敢继续写代码下去？？？？

firebody，关于超类依赖于子类，或并行类之间的相互依赖这些问题我现在还没提出来，不过你说了也一样

我到现在还只是纯粹证明那个灵活性的问题

firebody, 耦合还是有个粒度问题的。不能走极端。完全没有耦合的程序是不存在的。

比如：

class X{
  void f();{... g();; ...}
  void g();;
}

此处， f()就是紧紧耦合于g()的。你难道要把每个函数调用都ioc一下？

类之间的耦合也是。 有的就不应该耦合， 有的就无所谓。
不能一概而论。
比如你如果跟我说， TruePredicate的静态工厂不能直接调用LiteralPredicate， 我只能说你太极端了。 无话可说。

而且， 继承也是两个类直接紧紧耦合的，你用不用继承呢？

ajoo，要依赖也应该是依赖接口，而不是依赖具体的实现，除非是在一个纯粹的工厂里面。