public A(){
this.b=new B();this.c=new C();
}……
public B(){
this.d=new D();
}
public C(){
this.e=new E();this.f=new F();
}
A a=new A();a.service();
Class A {
//B b;
D d;
C c;
public void service(){
Assert d!=null;
Assert c!= null;
....
}
}
请修改问题1中的代码，使A能够正常初始化。
参考答案：
public A(){
this.d=new D();this.c=new C();
}……
A a=new A();a.service();
Class A {
D d;
C c;
G g;
public void service(){
Assert d!=null;
Assert c!= null;
....
}
public void service_2(){
Assert g!= null;
……
}
}
请修改问题2中的代码，以适应新的需求。
参考答案：
public A(D _d, C _c){
this.d=_d;this.c=_c;
}
public A(G _g){
this.g=_g;
}
……
A a=new A(new D(),new C());
a.service();
A a_2=new A(new G());
a.service_2();
private static A a=new A(new D(),new C());private static A a_2=new A(new G());
public static A getA(){
return a;
}
public static A getA_2(){
return a_2;
}
private A(D _d, C _c){
this.d=_d;this.c=_c;
}
private A(G _g){this.g=_g;}……
A a=A.getA();
a.service();
A a_2=A.getA_2();
a.service_2();
Public abstract class Factory {
Public static Factory aFactory(){
Return new FactoryA ();
}
Public static Factory a2Factory(){
Return new FactoryA_2();
}
Create();
}
Public class FactoryA implements Factory {
@Override
Public A Create(){
return new A(new D(),new C());
}
}
Public class FactoryA_2 implements Factory {
@Override
Public A Create(){
return new A_2(new G());
}
}
……
调用代码：
A a = Factory.aFactory().Create();
a.service();
A a_2 = Factory.a2Factory().Create();
a_2.service_2();
问题6、将service()和service_2()方法提取到接口中，再修改问题5中的代码。
参考答案：略
问题7、用问题6的思路，为其它类（B/C/D/E/F/G）等创建工厂
参考答案：略
问题7的出现带来了一个新的困扰：那么多的类，要写那么多的工厂……尤其是，当我们对现有系统进行改造或者重构时，这种重复工作量会有多少，可想而知。
问题8：为了简化问题7的工作，公司定义了一个通用的工厂类
public Class Factory{
/**
* 根据入参，调用指定类的默认构造方法（无参数构造方法），生成一个指定的类的实例。如果找不到指定的类，或者指定的类没有可用的构造方法，则返回null。
* <p />
* 例如，调用
* String a = Factory.product(“java.lang.String”)，将返回一个””。等同于调用了 String a = new String();
*
* @param className 用户指定的类名。必须是全路径名，
* @return 用户指定的类的一个实例，或者是null
*/
public static Object product(String className){
①
}
}
请将①处的代码补充完整。
这里就需要用到java的反射机制了。
综合上述问题，思考一下：为什么会出现Spring IOC框架？它的基本原理是什么？
最简单的说，IOC出现的原因就是为了解耦合。利用一个通用的工厂，来管理各个实现类的创建过程以及在创建过程中引入的类的依赖关系。这样，各个类在代码层级上，是可以做到“兵不知将将不知兵”的，从而减少对类进行修改、扩展时的工作量。
它的基本原理，很明了，就是反射+工厂。
本文转自 斯然在天边 51CTO博客，原文链接：http://blog.51cto.com/winters1224/1327881，如需转载请自行联系原作者
