一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第16天，点击查看活动详情。
一.简单工厂模式
场景：当两种物品实现同一个接口，根据不同场景使用不同物品
目的：可以通过一个类根据不同参数实例化不同的物品，对操作统一处理。
优点：
-
屏蔽内部
-
对不同的操作进行统一管理
缺点：每添加一种类别都需要修改工厂类。所以这个是不提倡的。
类图：
1.代码
接口
public interface IProduct {
public void method();
}
实现类
public class ProductA implements IProduct{
public void method() {
System.out.println("产品A方法");
}
}
public class ProductB implements IProduct{
public void method() {
System.out.println("产品B方法");
}
}
工厂类
public class Creator {
private Creator(){}
public static IProduct createProduct(String productName){
if (productName == null) {
return null;
}
if (productName.equals("A")) {
return new ProductA();
}else if (productName.equals("B")) {
return new ProductB();
}else {
return null;
}
}
}
调用
复制代码
public class Client {
public static void main(String[] args) {
IProduct product1 = Creator.createProduct("A");
product1.method();
IProduct product2 = Creator.createProduct("B");
product2.method();
//如果不用工厂模式
ProductA product1 = new ProductA();
ProductB product1 = new ProductB();
}
}
二.工厂方法模式
场景：简单工厂模式每添加一个物品，就需要修改工厂。为了避免修改工厂，抽象了工厂方法模式。
优点：
-
避免工厂中if else的判断
-
当添加产品时。可以不修改工厂
缺点：项目类变多了，结构变复杂了。
类图：
1.代码
产品接口:
public interface IProduct {
public void method();
}
产品实现类：
public class ProductA implements IProduct{
public void method() {
System.out.println("产品A方法");
}
}
public class ProductB implements IProduct{
public void method() {
System.out.println("产品B方法");
}
}
工厂接口：
public interface Factory{
public IProduct create();
}
工厂实现类：
public class FactoryToA implements Factory{
public IProduct create(){
return new ProductA();
}
}
public class FactoryToB implements Factory{
public IProduct create(){
return new ProductB();
}
}
调用：
public class Client {
public static void main(String[] args) {
Facotry facotry = new FacotryToA();
Product product= facotry.create();
product.method();
Facotry facotry2 = new FacotryToB();
Product product2= facotry2.create();
product2.method();
}
}
三.抽象工厂模式
场景：产品不是一个产品，而是一系列产品。
缺点：项目类变多了，结构变复杂了。
类图：
1.代码
产品接口：
interface ProductA {
void methodA();
}
interface ProductB {
void methodB();
}
产品实现
class ProductA1 implements ProductA{
public void methodA() {
System.out.println("产品A1");
}
}
class ProductA2 implements ProductA{
public void methodA() {
System.out.println("产品A2");
}
}
class ProductB1 implements ProductB{
public void methodB() {
System.out.println("产品B1");
}
}
class ProductB2 implements ProductB{
public void methodB() {
System.out.println("产品B2");
}
}
工厂类接口
public interface Facotry{
ProductA createProductA();
ProductB createProductB();
}
工厂实现类
public class FacotryToA implements Facotry{
public ProductA createProductA() {
return new ProductA1();
}
public ProductB createProductB() {
return new ProductB1();
}
}
public class FacotryToB implements Facotry{
public ProductA createProductA() {
return new ProductA2();
}
public ProductB createProductB() {
return new ProductB2();
}
}
调用：
public class Client {
public static void main(String[] args) throws Exception {
Factory factory = new FactoryToA();
ProductA productA = factory.createProductA();
ProductB productB = factory.createProductB();
productA.methodA();
productB.methodB();
Factory factory = new FactoryToB()
productA = factory.createProductA();
productB = factory.createProductB();
productA.methodA();
productB.methodB();
}
}
