1、由浅入深,先讲简单工厂模式。简单工厂模式就是说在创建对象时,将需要创建的不同对象的相关代码封装到不同的类中,这些称为具体产品类,而将他们的公共代码抽象到一个抽象产品类中,每一个具体产品类的对象都是抽象产品类的子类;然后提供一个工厂类用于创建各种产品,在工厂类中提供一个创建茶产品的工厂方法,该方法可以根据所传入的参数不同,创建不同的具体产品对象。
package SimpleFactoryPattern;
public interface Product {
public void setProduct();
}
package SimpleFactoryPattern;
public class FactoryProduct {
public Product getConcrectProduct(String type){
if("A".equals(type)){
Product a = new ConcrectProductA();
return a;
}
if("B".equals(type)){
Product b = new ConcrectProductB();
return b;
}
return null;
}
}
package SimpleFactoryPattern;
public class SimpleFactoryTest {
public static void main(String[] args){
FactoryProduct factoryProduct = new FactoryProduct();
Product result = factoryProduct.getConcrectProduct("B");
result.setProduct();
}
}
package SimpleFactoryPattern;
public class ConcrectProductA implements Product {
@Override
public void setProduct() {
System.out.println("创建A产品");
}
}
package SimpleFactoryPattern;
public class ConcrectProductB implements Product {
@Override
public void setProduct() {
System.out.println("创建B产品");
}
}
如上代码所示,FactoryProduct类的getConcrectProduct能根据入参返回不同对象。
2、现在介绍工厂模式,又称工厂方法模式。简单工厂模式在实例化具体产品类的时候(FactoryProduct .getConcrectProduct)需要写很多if的逻辑,这样不符合开闭原则。如果现在需要新增一个ConcreteProductC的话需要写if(“c”.equals(type))…
在工厂模式下只需要新增两个类,一个是ConcreteProductC ,一个是 ConcreteFactoryC。不用修改原有代码。
工厂模式不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构相对应的工厂等级结构。定义如下:
定义一个创建类的接口,让子类决定将哪一个类实例化。该模式让一个类的实例化延迟到子类。
具体代码如下:
package FactoryPattern;
public class ConcreteProductA implements Product {
@Override
public Product setProduct(){
Product a = new ConcreteProductA();
System.out.println("创建A产品");
return a;
}
}
package FactoryPattern;
public class ConcreteProductB implements Product {
@Override
public Product setProduct(){
Product b = new ConcreteProductB();
System.out.println("创建B产品");
return b;
}
}
package FactoryPattern;
public interface Product {
public Product setProduct();
}
package FactoryPattern;
public class ConcreteFactoryA implements Factory {
@Override
public Product factoryMethod(){
return new ConcreteProductA();
}
}
package FactoryPattern;
public class ConcreteFactoryB implements Factory {
@Override
public Product factoryMethod(){
return new ConcreteProductB();
}
}
package FactoryPattern;
public interface Factory {
//声明工厂方法
public Product factoryMethod();
}
package FactoryPattern;
public class FactoryPatternTest {
public static void main(String[] args){
//通过具体工厂方法创建A产品
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.factoryMethod();
productA.setProduct();
//通过具体工厂方法创建B产品
Factory factoryB = new ConcreteFactoryB();
factoryB.factoryMethod();
Product productB = factoryB.factoryMethod();
productB.setProduct();
}
}
网上看到其他人说的工厂模式的好处,引用如下:
来说说我的看法:
工厂模式,也叫做说虚构造器,在简单工厂中间插入了一个具体产品工厂,这个工厂知道产品构造时候的具体细节,而简单工厂模式的产品具体构造细节是在一个个if/else分支,或者在switch/case分支里面的。工厂模式的好处就在于将工厂和产品之间的耦合降低,将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多,只需要添加一个工厂类,一个产品类,就能方便的添加产品,而不需要修改原有的代码。而在简单工厂中,如果要增加一个产品,则需要修改工厂类,增加if/else分支,或者增加一个case分支,工厂模式符合软件开发中的OCP原则(open close principle),对扩展开放,对修改关闭。
抽象工厂模式:这个模式我总是感觉和builder模式非常相似。
工厂方法模式提供的是对一个产品的等级模式,,而抽象工厂方法提供的是对多个产品的等级模式,注意,这里的多个具体产品之间是相互耦合的,也就是说这里的抽象工厂提供的产品之间是存在某种联系的。
3、抽象工厂模式
在工厂模式里面,每一个具体工厂只生产一个具体产品,导致系统中的工厂类太过庞大,因此提出抽象工厂模式。
简单看下类图