目录
简单工厂
先创建两个类Car和Bike,看成是工厂要生成的两类产品,代码如下:
/**
* Created by leboop on 2020/5/23.
*/
public interface Movable {
void go();
}
/**
* Created by leboop on 2020/5/23.
*/
public class Car implements Movable{
@Override
public void go() {
System.out.println("Car going!");
}
}
/**
* Created by leboop on 2020/5/23.
*/
public class Bike implements Movable {
@Override
public void go() {
System.out.println("Bike going!");
}
}
通常做法是在客户端直接通过new方式创建各类产品对象,但是很多时候需要在创建对象前后做一些其他操作,比如权限管理等,这些代码如果暴露在客户端是不合适的,所以可以将这些代码整合到单独的一个简单工厂类中实现:
/**
* Created by leboop on 2020/5/23.
*/
public class SimpleFactory {
public Car createCar() {
/*
* 创建对象前的一些预处理
*/
Car car = new Car();
/*
* 创建对象后的一些预处理
*/
return car;
}
public Bike createBike() {
/*
* 创建对象前的一些预处理
*/
Bike bike = new Bike();
/*
* 创建对象后的一些预处理
*/
return bike;
}
}
简单工厂类中可以做很多复杂操作。客户端就可以如下简单调用了:
/**
* Created by leboop on 2020/5/23.
*/
public class Main {
public static void main(String[] args) {
SimpleFactory factory = new SimpleFactory();
Movable car = factory.createCar();
car.go();
Movable bike = factory.createBike();
bike.go();
}
}
这样对使用的客户来说非常友好。
静态工厂
所谓静态工厂,指的是工厂类中创建实例的方法是静态的,这样的话就可以直接通过工厂类调用创建实例了,而不需要先实例化工厂类了,代码如下:
/**
* Created by leboop on 2020/5/23.
*/
public class StaticFactory {
public static Car createCar() {
/*
* 创建对象前的一些预处理
*/
Car car = new Car();
/*
* 创建对象后的一些预处理
*/
return car;
}
public static Bike createBike() {
/*
* 创建对象前的一些预处理
*/
Bike bike = new Bike();
/*
* 创建对象后的一些预处理
*/
return bike;
}
}
客户端代码如下:
/**
* Created by leboop on 2020/5/23.
*/
public class StaticFactoryMain {
public static void main(String[] args) {
Movable car=StaticFactory.createCar();
car.go();
Movable bike=StaticFactory.createBike();
bike.go();
}
}
现在就不用如下创建工厂类了:
StaticFactoryfactory = new StaticFactory();
简单工厂存在的一个弊端是每次新增一个产品,比如现在要新增火车,就需要修改原来的工厂类StaticFactory,能不能不修改原来的工厂类呢?可以的。可以通过抽象工厂实现,为每类产品创建一个单独工厂,该工厂仅生产对应类别产品。
抽象工厂
先创建一个抽象工厂(也可以使用接口),含有一个可以创建所有产品的抽象方法,代码如下:
/**
* Created by leboop on 2020/5/23.
*/
public abstract class AbstractFactory {
abstract Movable create();
}
为每个产品创建一个具体的抽象类,只生产对应的产品,比如CarFactory只生产Car,代码如下:
/**
* Created by leboop on 2020/5/23.
*/
public class CarFactory extends AbstractFactory{
@Override
Movable create() {
/*
* 创建对象前的一些预处理
*/
Car car = new Car();
/*
* 创建对象后的一些预处理
*/
return car;
}
}
/**
* Created by leboop on 2020/5/23.
*/
public class BikeFactory extends AbstractFactory{
@Override
Movable create() {
/*
* 创建对象前的一些预处理
*/
Bike bike = new Bike();
/*
* 创建对象后的一些预处理
*/
return bike;
}
}
客户端代码如下:
/**
* Created by leboop on 2020/5/23.
*/
public class AbstractFactoryMain {
public static void main(String[] args) {
CarFactory carFactory=new CarFactory();
Movable car=carFactory.create();
car.go();
BikeFactory bikeFactory=new BikeFactory();
Movable bike=bikeFactory.create();
bike.go();
}
}
现在如有新增产品火车的时候,就不需要修改原来的工厂类代码。具体如下:
创建产品Train的类
/**
* Created by leboop on 2020/5/23.
*/
public class Train implements Movable {
@Override
public void go() {
System.out.println("train going!");
}
}
创建该产品的工厂类
/**
* Created by leboop on 2020/5/23.
*/
public class TrainFactory extends AbstractFactory {
@Override
Movable create() {
/*
* 创建对象前的一些预处理
*/
Train train = new Train();
/*
* 创建对象后的一些预处理
*/
return train;
}
}
在客户端代码中添加创建train的代码,如下:
/**
* Created by leboop on 2020/5/23.
*/
public class AbstractFactoryMain {
public static void main(String[] args) {
CarFactory carFactory=new CarFactory();
Movable car=carFactory.create();
car.go();
BikeFactory bikeFactory=new BikeFactory();
Movable bike=bikeFactory.create();
bike.go();
TrainFactory trainFactory=new TrainFactory();
Movable train=trainFactory.create();
train.go();
}
}
从上面我们能看到,使用了抽象工厂模式之后,新增产品时只需要修改客户端少量代码,新增两个类即可,总体来看,新增的代码有所增加,但是不要修改原先的工厂类代码,隔离性非常好。