设置模式之--工厂方法模式与抽象工厂模式_工厂模式 abstract class-优快云博客

本文链接：https://blog.youkuaiyun.com/sinat_34394641/article/details/89071880

本文详细介绍了设计模式中的工厂方法模式与抽象工厂模式，并通过Java代码示例进行解释。从工厂模式的基本概念出发，逐步深入到简单工厂模式、工厂方法模式及抽象工厂模式的具体应用，帮助读者更好地理解和掌握这些设计模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

设计模式之–工厂方法模式与抽象工厂模式

简介:

本篇文章是介绍 23 中设计模式中的工厂方法模式与抽象工厂模式.使用的是 Java 代码.

1.什么是工厂模式

定义:

Factory Method(工厂模式)：定义一个用于创建对象的接口, 让子类决定实例化哪个类. 工厂方法使一个类的实例化延迟到其子类.

工厂模式是属于 GoF 设计模式中的创建型模式.上面这段话是书上的原话. 简单的说就是通过工厂模式帮你生产出你想要的对象实例, 而无需关系实例化的逻辑.

2.工厂模式的使用场景

3.简单工厂模式

介绍:

简单工厂模式不属于 23 种设计模式之一, 只是为了让大家更好的理解工厂方法模式和抽象工厂模式.

模型:

Factory 工厂类

这个是简单工厂模式的核心, 负责实现创建所有实例的内部逻辑. 工厂类的创建产品类的方法可以被外界直接调用, 用来创建所需的产品对象.(这个工厂类责任过于重大就是简单工厂模式的槽点, 这个问题会在工厂方法中得到解决.)

IProduct 抽象产品类

这是简单工厂模式所创建的所有对象的父类, 它负责描述所有实例所共有的公共接口.

Product 具体产品类

这是简单工厂模式的创建目标.

代码实现

(1)抽象产品类


public abstract class Computer {
	public abstract void start();
}

(2)具体产品类


public class AppleComputer extends Computer {
	@Override
	public void start(){
		System.out.println("苹果开机");
	}
}

public class AsusComputer extends Computer {
	@Override
	public void start(){
		System.out.println("华硕开机");
	}
}

public class HPComputer extends Computer {
	@Override
	public void start(){
		System.out.println("惠普开机");
	}
}

(3)工厂类


public class ComputerFactory {
	public static Computer createComputer(String type){
		Computer mComputer = null;
		switch(type){
			case "Apple":
				mComputer = new AppleComputer;
				break;
			case "Asus":
				mComputer = new AsusComputer;
				break;
			case "HP":
				mComputer = new HPComputer;
				break;
		}
	}
}

(4)客户端调用


public class CreatComputer {
	public static void main(String[] args){
		ComputerFactory.createComputer("Apple").start();
	}
}

4.工厂方法模式(Factory Method)

介绍:

工厂方法模式(Factory Method)属于 23 种设计模式中的创建模式.

模型:

Product: 抽象产品类
ConcreteProduct: 具体产品类, 实现 Product 接口
Factory: 抽象工厂类, 该方法返回一个 Product 类型的对象.
ConcreteFactory: 具体工厂类, 返回 ConcreteProduct 的实例.

可以看到多了一个 抽象工厂类 .这个是简单工厂模式所没有的. 假如我们要在简单工厂模式中增加一种产品, 要修改它的工厂类. 工厂方法模式解决了简单工厂模式中工厂类过于臃肿的问题和不符合设计模式的 开放封闭原则 (类.函数.模块.应该是可拓展的, 但不可改变的.)

代码实现

(1)抽象产品类


public abstract class Computer {
	public abstract void start();
}

(2)具体产品类


public class AppleComputer extends Computer {
	@Override
	public void start(){
		System.out.println("苹果开机");
	}
}

public class AsusComputer extends Computer {
	@Override
	public void start(){
		System.out.println("华硕开机");
	}
}

public class HPComputer extends Computer {
	@Override
	public void start(){
		System.out.println("惠普开机");
	}
}

(3)抽象工厂类


public abstract class ComputerFactory {
	public abstract <T extends Computer> T createComputer(Class<T> clz);
}

(4)具体工厂类


public class ComputerFactoryA extends ComputerFactory {
	@Override
	public <T extends Computer> T createComputer(Class<T> clz){
		Computer computer = null;
		String classname = clz.getName();
		try{
			//通过反射来生产不同的厂家计算机
			computer = (Computer) Class.forName(classname).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (T) computer;
	}
}

(5)客户端调用


public class CreatComputer {
	public static void main(String[] args){
		ComputerFactory computerFactory = new ComputerFactoryA();
		AppleComputer mAppleComputer = computerFactory.createComputer(AppleComputer.class);
		mAppleComputer.start();
	}
}

5.抽象工厂模式(Abstract Factory)

介绍:

抽象工厂模式(Abstract Factory)也是属于 23 种设计模式中的创建模式.

模型:

Product: 抽象产品类
ConcreteProduct: 具体产品类.
Factory: 抽象工厂类.

该方法返回一个 Product 类型的对象.在抽象工厂模式中.抽象工厂中声明了多个工厂方法，用于创建不同类型的产品.

ConcreteFactory: 具体工厂类.

代码实现:

(1)抽象产品类

//抽象产品类
public abstract class AbstractProductA {   
     //每个产品共有的方法
     public void shareMethod(){
     }
     //每个产品相同方法，不同实现
     public abstract void doSomething();
}

public abstract class AbstractProductB {   
     //每个产品共有的方法
     public void shareMethod(){
     }
     //每个产品相同方法，不同实现
     public abstract void doSomething();
}

(2)具体产品类

产品A1的实现类
public class ProductA1 extends AbstractProductA {
     public void doSomething() {
             System.out.println("产品A1的实现方法");
     }
}

产品A2的实现类
public class ProductA2 extends AbstractProductA {
     public void doSomething() {
             System.out.println("产品A2的实现方法");
     }
}

产品B1的实现类
public class ProductB1 extends AbstractProductB {
     public void doSomething() {
             System.out.println("产品B1的实现方法");
     }
}

产品B2的实现类
public class ProductB2 extends AbstractProductB {
     public void doSomething() {
             System.out.println("产品B2的实现方法");
     }
}

(3)抽象工厂类


抽象工厂类
public abstract class AbstractCreator {
     //创建A产品家族
     public abstract AbstractProductA createProductA(); 
     //创建B产品家族
     public abstract AbstractProductB createProductB();
}

(4)具体工厂类


产品等级1的实现类
public class Creator1 extends AbstractCreator {    
     //只生产产品等级为1的A产品
     public Abstract ProductA createProductA() { 
             return new ProductA1();
     }
     //只生产产品等级为1的B产品
     public AbstractProductB createProductB() {
             return new ProductB1();
     }
}


产品等级2的实现类
public class Creator2 extends AbstractCreator {    
     //只生产产品等级为2的A产品
     public AbstractProductA createProductA() { 
             return new ProductA2();
     }
     //只生产产品等级为2的B产品
     public AbstractProductB createProductB() {
             return new ProductB2();
     }
}

(5)客户端调用


public class Client {
     public static void main(String[] args) {
             //定义出两个工厂
             Abstract Creator creator1 = new Creator1();
             Abstract Creator creator2 = new Creator2();
             //产生A1对象
             AbstractProductA a1 =  creator1.createProductA();
             //产生A2对象
             AbstractProductA a2 = creator2.createProductA();
             //产生B1对象
             AbstractProductB b1 = creator1.createProductB();
             //产生B2对象
             AbstractProductB b2 = creator2.createProductB();
             
     }
}