对抽象工厂模式还不是吃的很透,这里只写我的个人看法,希望各位能花些时间看下,帮我指正其中的认识误差。
考虑这样一种情况:有一个产品,不再是由单一的一种产品组成,而是有两种或两种以上的产品组成。比如说电脑,有一个主机和一个显示器。比如A类电脑有一个小主机和一个液晶显示器,B类电脑有一个大主机和CRT显示器。如果使用工厂方法模式来实现,就必须由四个工厂类来分别创建着四个产品。这时候,会想到使用一个类来完成主机和显示器的创建,但是主机和显示器是两个抽象的类,是不能直接实例化的,因此,就需要使用抽象工厂模式来解决这一问题。
个人感觉抽象工厂模式与工厂方法模式非常类似,只不过工厂方法模式中产品的抽象父类只有一个,也就是说产品只由单一的产品组成,而抽象工厂模式中的产品是有两种或两种以上的产品组成的。不知道我这样的理解对不对,如果有错误的地方,还希望各位指正。
约定:产品C1由产品A1和产品B1组成,产品C2由产品A2和产品B2组成。
产品A的抽象类及子类:
同样的,产品B的抽象类及子类:
之后便是抽象工厂类了:
产品C1的工厂类:
产品C2的工厂类:
如果仔细的观察的话,可以发现抽象工厂类也是部分符合开闭原则的。
符合开闭原则的情况是:只增加集成产品的种类,也就是说,增加一个与C1,C2同级的产品C3,C4。。。等情况下(此例中的情况是有一种新的电脑,由另一种主机和显示器组成),是符合开闭原则的。这种情况下,只需要增加相应的产品类和工厂类即可,不需要对现有的代码进行修改。
不符合的情况是:增加产品的组成产品种类,即C产品的组成产品不只由A和B组成(此例中为电脑不再只由显示器和主机组成,可能增加了其他部件,如鼠标等)。这种情况,是需要对现有代码进行修改的,需要修改的是工厂类。
考虑这样一种情况:有一个产品,不再是由单一的一种产品组成,而是有两种或两种以上的产品组成。比如说电脑,有一个主机和一个显示器。比如A类电脑有一个小主机和一个液晶显示器,B类电脑有一个大主机和CRT显示器。如果使用工厂方法模式来实现,就必须由四个工厂类来分别创建着四个产品。这时候,会想到使用一个类来完成主机和显示器的创建,但是主机和显示器是两个抽象的类,是不能直接实例化的,因此,就需要使用抽象工厂模式来解决这一问题。
个人感觉抽象工厂模式与工厂方法模式非常类似,只不过工厂方法模式中产品的抽象父类只有一个,也就是说产品只由单一的产品组成,而抽象工厂模式中的产品是有两种或两种以上的产品组成的。不知道我这样的理解对不对,如果有错误的地方,还希望各位指正。
约定:产品C1由产品A1和产品B1组成,产品C2由产品A2和产品B2组成。
产品A的抽象类及子类:
package com.test;
public abstract class ProductA {
public abstract void action1();
public abstract void action2();
}
package com.test;
public class ProductA1 extends ProductA{
@Override
public void action1() {
System.out.println("ProductA1 action1");
}
@Override
public void action2() {
System.out.println("ProductA1 action2");
}
}
package com.test;
public class ProductA2 extends ProductA{
@Override
public void action1() {
System.out.println("ProductA2 action1");
}
@Override
public void action2() {
System.out.println("ProductA2 action2");
}
}
同样的,产品B的抽象类及子类:
package com.test;
public abstract class ProductB {
public abstract void action1();
public abstract void action2();
}
package com.test;
public class ProductB1 extends ProductB{
@Override
public void action1() {
System.out.println("ProductB1 action1");
}
@Override
public void action2() {
System.out.println("ProductB1 action2");
}
}
package com.test;
public class ProductB2 extends ProductB{
@Override
public void action1() {
System.out.println("ProductB2 action1");
}
@Override
public void action2() {
System.out.println("ProductB2 action2");
}
}
之后便是抽象工厂类了:
package com.test;
public abstract class Factory {
public abstract ProductA factory();
public abstract ProductB factory();
}
产品C1的工厂类:
package com.test;
public class FactoryC1 extends Factory{
@Override
public ProductA factory(){
return new ProductA1();
}
@Override
public ProductB factory(){
return new ProductB1();
}
}
产品C2的工厂类:
package com.test;
public class FactoryC2 extends Factory{
@Override
public ProductA factory(){
return new ProductA2();
}
@Override
public ProductB factory(){
return new ProductB2();
}
}
如果仔细的观察的话,可以发现抽象工厂类也是部分符合开闭原则的。
符合开闭原则的情况是:只增加集成产品的种类,也就是说,增加一个与C1,C2同级的产品C3,C4。。。等情况下(此例中的情况是有一种新的电脑,由另一种主机和显示器组成),是符合开闭原则的。这种情况下,只需要增加相应的产品类和工厂类即可,不需要对现有的代码进行修改。
不符合的情况是:增加产品的组成产品种类,即C产品的组成产品不只由A和B组成(此例中为电脑不再只由显示器和主机组成,可能增加了其他部件,如鼠标等)。这种情况,是需要对现有代码进行修改的,需要修改的是工厂类。