【Java】设计模式二：工厂模式

• Z时代
• 2024-01-10
• 分类：技术分享

// 抽象产品
public interface Car {
void run();
}
// 具体产品1
public class Audi implements Car {
@Override
public void run() {
System.out.println("audi run");
}
}
// 具体产品2
public class Benz implements Car{
@Override
public void run() {
System.out.println("benz run");
}
}
// 具体工厂，用于生成产品
public class SimpleFactory {
// 方式1，根据传入的参数生成对应的产品对象
public static Car getCar(String type){
if ("audi".equals(type)){
return new Audi();
} else if ("benz".equals(type)){
return new Benz();
} else {
return null;
}
}
// 方式2，直接调用生成对应的产品对象的方法
public static Car getAudi(){
return new Audi();
}
public static Car getBenz(){
return new Benz();
}
}
// 调用者
public class SimpleFactoryTest {
public static void main(String[] args) {
// 没有使用简单工厂，那么客户端就需要和接口Car以及其实现类打交道
//        Car audi = new Audi();
//        Car benz = new Benz();
//        audi.run();
//        benz.run();
// 使用简单工厂，方式1
Car audi = SimpleFactory.getCar("audi");
Car benz = SimpleFactory.getCar("benz");
audi.run();
benz.run();
System.out.println("============");
// 使用简单工厂，方式2
Car audi1 = SimpleFactory.getAudi();
Car benz1 = SimpleFactory.getBenz();
audi1.run();
benz1.run();
}
}

// 抽象产品
public interface Car {
void run();
}
// 具体产品1
public class Audi implements Car {
@Override
public void run() {
System.out.println("audi run");
}
}
// 具体产品2
public class Benz implements Car {
@Override
public void run() {
System.out.println("benz run");
}
}
// 抽象工厂
public interface CarFactory {
Car createCar();
}
// 具体工厂1
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
// 具体工厂2
public class BenzFactory implements CarFactory {
@Override
public Car createCar() {
return new Benz();
}
}
// 调用者
public class FactoryMethodTest {
public static void main(String[] args) {
Car audi = new AudiFactory().createCar();
Car benz = new BenzFactory().createCar();
audi.run();
benz.run();
}
}

// 抽象产品A
public interface Engine {
void autoStart();
}
// 具体产品A1
public class HighEngine implements Engine {
@Override
public void autoStart() {
System.out.println("高端发动机有自动启停功能");
}
}
// 具体产品A2
public class LowEngine implements Engine {
@Override
public void autoStart() {
System.out.println("低端发动机没有自动启停功能");
}
}
// 抽象产品B
public interface Tyre {
void monitor();
}
// 具体产品B1
public class HighTyre implements Tyre {
@Override
public void monitor() {
System.out.println("高端轮胎有胎压监控功能");
}
}
// 具体产品B2
public class LowTyre implements Tyre {
@Override
public void monitor() {
System.out.println("低端轮胎无监控胎压功能");
}
}
// 抽象工厂
public interface CarFactory {
Engine createEngine();
Tyre createTyre();
}
// 具体工厂A1B1
public class HighCarFactory implements CarFactory {
@Override
public HighEngine createEngine() {
return new HighEngine();
}
@Override
public HighTyre createTyre() {
return new HighTyre();
}
}
// 具体工厂A2B2
public class LowCarFactory implements CarFactory {
@Override
public LowEngine createEngine() {
return new LowEngine();
}
@Override
public LowTyre createTyre() {
return new LowTyre();
}
}
// 调用者
public class AbstractFactoryTest {
public static void main(String[] args) {
CarFactory highCar = new HighCarFactory();
highCar.createEngine().autoStart();
highCar.createTyre().monitor();
}
}

什么是工厂模式

大家在开发中应该都使用过或者看到过SqlSessionFactory或者BeanFactory，这就是使用工厂模式来生产对象。工厂模式用于封装和管理对象的创建，分离对象的创建者和调用者，实现与对象解耦的目的。

工厂模式可以分为：

• 简单工厂
• 工厂方法
• 抽象工厂

实现方式

简单工厂

简单工厂通过接收的参数的不同来返回不同的对象实例，涉及到的角色有：

• 抽象产品
• 具体产品
• 具体工厂
• 调用者

代码如下：

// 抽象产品
public interface Car {
void run();
}
// 具体产品1
public class Audi implements Car {
@Override
public void run() {
System.out.println("audi run");
}
}
// 具体产品2
public class Benz implements Car{
@Override
public void run() {
System.out.println("benz run");
}
}
// 具体工厂，用于生成产品
public class SimpleFactory {
// 方式1，根据传入的参数生成对应的产品对象
public static Car getCar(String type){
if ("audi".equals(type)){
return new Audi();
} else if ("benz".equals(type)){
return new Benz();
} else {
return null;
}
}
// 方式2，直接调用生成对应的产品对象的方法
public static Car getAudi(){
return new Audi();
}
public static Car getBenz(){
return new Benz();
}
}
// 调用者
public class SimpleFactoryTest {
public static void main(String[] args) {
// 没有使用简单工厂，那么客户端就需要和接口Car以及其实现类打交道
//        Car audi = new Audi();
//        Car benz = new Benz();
//        audi.run();
//        benz.run();
// 使用简单工厂，方式1
Car audi = SimpleFactory.getCar("audi");
Car benz = SimpleFactory.getCar("benz");
audi.run();
benz.run();
System.out.println("============");
// 使用简单工厂，方式2
Car audi1 = SimpleFactory.getAudi();
Car benz1 = SimpleFactory.getBenz();
audi1.run();
benz1.run();
}
}

类图如下：

可以看到，如果再增加一种产品，则需要修改工厂类，故这种工厂模式适用于产品对象较少，且产品固定的需求 。其实我们在一般的项目中使用简单工厂就足够了。

工厂方法

为了避免简单工厂不满足开闭原则的缺点，增加产品而不需要去修改工厂类，可以使用工厂方法模式，增加产品的同时通过增加一个对应的工厂类来生产对应的产品，涉及的角色有：

• 抽象产品
• 具体产品
• 抽象工厂
• 具体工厂
• 调用者

代码如下：

// 抽象产品
public interface Car {
void run();
}
// 具体产品1
public class Audi implements Car {
@Override
public void run() {
System.out.println("audi run");
}
}
// 具体产品2
public class Benz implements Car {
@Override
public void run() {
System.out.println("benz run");
}
}
// 抽象工厂
public interface CarFactory {
Car createCar();
}
// 具体工厂1
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
// 具体工厂2
public class BenzFactory implements CarFactory {
@Override
public Car createCar() {
return new Benz();
}
}
// 调用者
public class FactoryMethodTest {
public static void main(String[] args) {
Car audi = new AudiFactory().createCar();
Car benz = new BenzFactory().createCar();
audi.run();
benz.run();
}
}

类图如下：

可以看到，如果新增加一种具体产品，就需要为其增加一个具体工厂类用于生产该产品。

抽象工厂

抽象工厂用于生产一族产品。涉及的角色有：

• 抽象产品
• 具体产品
• 抽象工厂
• 具体工厂
• 调用者

代码如下：

// 抽象产品A
public interface Engine {
void autoStart();
}
// 具体产品A1
public class HighEngine implements Engine {
@Override
public void autoStart() {
System.out.println("高端发动机有自动启停功能");
}
}
// 具体产品A2
public class LowEngine implements Engine {
@Override
public void autoStart() {
System.out.println("低端发动机没有自动启停功能");
}
}
// 抽象产品B
public interface Tyre {
void monitor();
}
// 具体产品B1
public class HighTyre implements Tyre {
@Override
public void monitor() {
System.out.println("高端轮胎有胎压监控功能");
}
}
// 具体产品B2
public class LowTyre implements Tyre {
@Override
public void monitor() {
System.out.println("低端轮胎无监控胎压功能");
}
}
// 抽象工厂
public interface CarFactory {
Engine createEngine();
Tyre createTyre();
}
// 具体工厂A1B1
public class HighCarFactory implements CarFactory {
@Override
public HighEngine createEngine() {
return new HighEngine();
}
@Override
public HighTyre createTyre() {
return new HighTyre();
}
}
// 具体工厂A2B2
public class LowCarFactory implements CarFactory {
@Override
public LowEngine createEngine() {
return new LowEngine();
}
@Override
public LowTyre createTyre() {
return new LowTyre();
}
}
// 调用者
public class AbstractFactoryTest {
public static void main(String[] args) {
CarFactory highCar = new HighCarFactory();
highCar.createEngine().autoStart();
highCar.createTyre().monitor();
}
}

类图如下：

可以看到通过具体工厂A1B1和A2B2可以生产出不同的产品族，在产品固定的情况下，可以通过新增具体工厂类，来组合生成不同的产品族，比如A1B2或者A2B1。但是如果要增加新的产品的话，比如增加产品C，那就需要去修改抽象工厂和具体工厂，就不适合了。

欢迎关注我的公众号，一起学习技术。

以上是 【Java】设计模式二：工厂模式 的全部内容， 来源链接： utcz.com/a/106666.html