前言
本篇文章主要讲述了简单工厂模式,工厂方法模式和抽象工厂模式的实现以及三者的区别。
简单工厂模式
其实简单工厂模式并不是真正的设计模式,更像一种编程习惯,可以将客户从具体类中解耦。我们先看他的类图,然后在看具体实现的代码。
首先创建了一个接口,然后创建了几个类实现了该接口,最后定义了一个工厂类,通过传入不同的参数,返回不同的对象。
interface IFruit{
public void createFruit();
}
class Apple implements IFruit{
@Override
public void createFruit() {
System.out.println("生产苹果");
}
}
class Orange implements IFruit{
@Override
public void createFruit() {
System.out.println("生产橘子");
}
}
class Banana implements IFruit{
@Override
public void createFruit() {
System.out.println("生产香蕉");
}
}
class SimpleFactory{
public IFruit createFruit(String fruit){
if("apple".equals(fruit)){
return new Apple();
}else if("orange".equals(fruit)){
return new Orange();
}else if("banana".equals(fruit)){
return new Banana();
}else{
try {
throw new Exception("没有该水果的生产方式");
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
}
调用如下:
SimpleFactory simpleFactory=new SimpleFactory();
simpleFactory.createFruit("apple").createFruit();
simpleFactory.createFruit("orange").createFruit();
simpleFactory.createFruit("banana").createFruit();
接着再看工厂方法模式
工厂方法模式
定义了一个创建对象的接口,但由子类决定要实例化哪一个类。工厂方法让类把实例化推迟到子类。
先上类图
工厂方法模式,也是先定义了一个接口,然后创建了几个子类实现了该接口,继而在为每一个子类实现一个工厂类。具体代码实现如下:
interface Factory {
IFruit create();
}
class AppleFactory implements Factory{
@Override
public IFruit create() {
return new Apple();
}
}
class OrangeFactory implements Factory{
@Override
public IFruit create() {
return new Orange();
}
}
class BananaFactory implements Factory{
@Override
public IFruit create() {
return new Banana();
}
}
调用如下:
Factory appleFactory=new AppleFactory();
Factory orangeFactory=new OrangeFactory();
Factory bananaFactory=new BananaFactory();
appleFactory.create().createFruit();
orangeFactory.create().createFruit();
bananaFactory.create().createFruit();
抽象工厂模式
抽象工厂模式提供一个接口,用于创建相关或者依赖对象的家族,而不需要明确的指定具体类。
具体实现:
interface IFactory{
IProductA createA();
IProductB createB();
}
interface IProductA{
void createProductA();
}
interface IProductB{
void createProductB();
}
class ProductA implements IProductA{
@Override
public void createProductA() {
System.out.println("生产产品A");
}
}
class ProductB implements IProductB{
@Override
public void createProductB() {
System.out.println("生产产品B");
}
}
class AbstractFactory implements IFactory{
@Override
public IProductA createA() {
return new ProductA();
}
@Override
public IProductB createB() {
return new ProductB();
}
}
调用如下:
AbstractFactory abstractFactory=new AbstractFactory();
abstractFactory.createA().createProductA();
abstractFactory.createB().createProductB();
区别
简单工厂模式和工厂方法模式的区别:
简单工厂模式是将通过传递参数给函数,函数通过参数,再确认返回哪一个对象,一个函数就实现了全部;而工厂方法模式,是为每一个对象创建一个工厂,再由工厂返回该对象。在使用的时候,由子类具体操作实例化哪一个。
工厂方法模式和抽象工厂模式的区别:
工厂方法模式是为每一个子类创建一个工厂,一个工场只能创建一种产品;而抽象工厂模式在接口中定义了一个对象的家族,通过工厂获得实例化的对象以后,同一个工厂可以创建多个产品。
最后,简单工厂模式不适合添加产品,因为要修改代码才能完成,这不符合关闭开放原则(即允许扩展类,但是不允许修改类);工厂方法模式是为每一个子类生成一个工厂类,然后由子类决定具体实例化哪一个类,很方便添加产品;抽象工厂模式方便添加产品族,不方便添加新的产品,因为要添加新的产品,需要修改IFactory接口和IFactory接口的实现类AbstractFactory。