代码编织梦想

5.1 案例引入

 需求:设计一个披萨订购系统。
 设计一个抽象披萨类(Coffee),并定义其两个子类(奶酪披萨【CheessPizza】和水果披萨【FruitPizza】);再设计一个披萨店类(PizzaStore),披萨店具有点披萨的功能。
 类图如下:
在这里插入图片描述
 代码如下:
Pizza类:

package d3_factory.t1_simple.before;
/**
 * 披萨类 - 抽象
 * @author luxianghai
 *
 */
public abstract class Pizza {
	// 咖啡名
	protected String name;
	
	// 准备工作
	protected abstract void prepare();
	
	// 烘烤
	protected void bake() {
		System.out.println(name + " - 烘烤");
	}
	
	protected void cut() {
		System.out.println(name + " - 切割");
	}
	protected void box() {
		System.out.println(name + " - 打包");
	}
}

CheesePizza类

package d3_factory.t1_simple.before;
/**
 * 奶酪披萨
 * @author luxianghai
 *
 */
public class CheesePizza extends Pizza {
	
	public CheesePizza() {
		super.name = "奶酪披萨";
	}
	
	@Override
	protected void prepare() {
		System.out.println(super.name);		
		System.out.println("准备奶酪中...");		
	}
}

FruitPizza类

package d3_factory.t1_simple.before;
/**
 * 水果披萨
 * @author luxianghai
 *
 */
public class FruitPizza extends Pizza {

	public FruitPizza() {
		super.name = "水果披萨";
	}
	
	@Override
	protected void prepare() {
		System.out.println(super.name);
		System.out.println("准备水果中...");
	}

}

PizzaSotre类

package d3_factory.t1_simple.before;

import java.util.Scanner;

/**
 * 披萨店
 * @author luxianghai
 *
 */
public class PizzaStore {
	
	public PizzaStore() {
		orderPizza();
	}
	
	/**
	 * 点披萨
	 */
	private void orderPizza() {
		Pizza pizza = null;
		String type = ""; // 披萨类型
		do {
			type = getType();
			if ( "奶酪披萨".equals(type) ) {
				pizza = new CheesePizza();
			} else if ( "水果披萨".equals(type) ) {
				pizza = new FruitPizza();
			} else {
				System.out.println("退出!!!");
				break;
			}
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		} while(true);
	}
	/**
	 * 获取披萨类型
	 * @return
	 */
	private String getType() {
		System.out.println("输入披萨名:");
		Scanner scan = new Scanner(System.in);
		return scan.next();
	}
}

测试

package d3_factory.t1_simple.before;

public class Client {

	public static void main(String[] args) {
		new PizzaStore();
	}
}

 优缺点分析

  1. 优点是比较好理解,简单易操作。
  2. 缺点是违反了设计模式的ocp原则,即对扩展开放,对修改关闭。即当我们给类增加新功能的时候,尽量不修改代码,或者尽可能少修改代码.
  3. 比如我们这时要新增加一个Pizza的种类(ChickenPizza鸡肉披萨),我们需要在 PizzaStore的orderPizza方法中添加else if来进行判断

 改进思路分析:

  • 分析:修改代码可以接受,但是如果我们在其它的地方也有创建Pizza的代码,就意味着,也需要修改,而创建Pizza的代码,往往有多处。
  • 思路:把创建Pizza对象封装到一个类中,这样我们有新的Pizza种类时,只需要修改该类就可,其它有创建到Pizza对象的代码就不需要修改了 --> 简单工厂模式

5.2简单工厂模式

简单工厂不是一种设计模式,反而比较像是一种编程习惯。

5.2.1 简单工厂模式结构

 简单工厂模式的结构:

  1. 抽象产品 :定义产品的规范,描述产品的主要特性和功能。
  2. 具体产品 :实现或者继承抽象产品的子类
  3. 具体工厂 :提供了创建产品的方法,调用者通过该方法来获取产品。

5.2.2 实现

 使用简单工厂对 5.1小节 中的案例进行改进,我们只需对PizzaStore做修改(把创建对象的语句提取到工厂中),并创建一个简单工厂SimpleFactory类即可,代码如下:
SimpleFactory.java

package d3_factory.t1_simple.after1;
/**
 * 简单工厂类
 * @author luxianghai
 *
 */
public class SimpleFactory {
	
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if ( "奶酪披萨".equals(type) ) {
			pizza = new CheesePizza();
		} else if ( "水果披萨".equals(type) ) {
			pizza = new FruitPizza();
		}
		return pizza;
	}
}

PizzaStore

package d3_factory.t1_simple.after2;

import java.util.Scanner;

/**
 * 披萨店
 * @author luxianghai
 *
 */
public class PizzaStore {
	
	public PizzaStore() {
		orderPizza();
	}
	
	/**
	 * 点披萨
	 */
	private void orderPizza() {
		String type = ""; // 披萨类型
		do {
			type = getType();
			Pizza pizza = SimpleFactory.createPizza(type);
			if(null != pizza) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println("退出!!!");
				break;
			}
		} while(true);
	}
	/**
	 * 获取披萨类型
	 * @return
	 */
	private String getType() {
		String type = "";
		Scanner scan = null;
		try {
			System.out.println("输入披萨名:");
			scan = new Scanner(System.in);
			type = scan.next();
		} finally {
			if ( null != scan ) {
				scan.close();
			}
		}
		return type;
	}
	
}

 此时如果我们新增一个鸡肉披萨,只需创建新类ChickenPizza,然后在SimpleFactory添加一个判断即可,就不需要修改客户端了,更容易扩展了:
ChickenPizza

package d3_factory.t1_simple.after2;
/**
 * 鸡肉披萨
 * @author luxianghai
 *
 */
public class ChickenPizza extends Pizza {
	
	public ChickenPizza() {
		super.name = "鸡肉披萨";
	}
	@Override
	protected void prepare() {
		System.out.println("鸡肉披萨");
		System.out.println("准备鸡肉中...");
	}
}

SimpleFactory

package d3_factory.t1_simple.after2;
/**
 * 简单工厂类
 * @author luxianghai
 *
 */
public class SimpleFactory {
	
	public static Pizza createPizza(String type) {
		Pizza pizza = null;
		if ( "奶酪披萨".equals(type) ) {
			pizza = new CheesePizza();
		} else if ( "水果披萨".equals(type) ) {
			pizza = new FruitPizza();
		} else if ( "鸡肉披萨".equals(type) ) {
			pizza = new FruitPizza();
		}
		return pizza;
	}
}

 如此边添加了一个新的披萨种类

5.2.3 优缺点分析

 优点:封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
 缺点:增加新产品时还是需要修改工厂类的代码,违背了“开闭原则”

5.3 工厂方法模式

定义一个用于创建对象的接口或抽象类,让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

5.3.1 工厂方法模式结构

工厂方法模式的主要角色:

  1. 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。
  2. 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
  3. 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
  4. 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。

5.3.2 新需求

披萨项目新的需求:客户在点披萨时,可以根据所在地点不同的披萨,比如 北京的水果pizza、北京的奶酪pizza 或者是伦敦的奶酪pizza、伦敦的水果pizza。

5.3.3 思路

 思路1:使用简单工厂模式,创建不同的简单工厂类,比如BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等.从当前这个案例来说,也是可以的,但是考虑到项目的规模,以及软件的可维护性、可扩展性并不是特别好
 思路2:使用工厂方法模式

5.3.4 实现

 类图如下:
在这里插入图片描述
 代码如下:
抽象产品

/**
 * 披萨类 - 抽象产品
 * @author luxianghai
 *
 */
public abstract class Pizza {
	// 咖啡名
	protected String name;
	
	// 准备工作
	public abstract void prepare();
	
	// 烘烤
	public void bake() {	
		System.out.println(name + " - 烘烤");
	}
	
	public void cut() {
		System.out.println(name + " - 切割");
	}
	public void box() {
		System.out.println(name + " - 打包");
	}
}

具体产品

/**
 * 奶酪披萨 – 具体产品
 * @author luxianghai
 *
 */
public class BJCheesePizza extends Pizza {
	
	public BJCheesePizza() {
		super.name = "北京奶酪披萨";
	}
	
	@Override
	public void prepare() {
		System.out.println(super.name);		
		System.out.println("准备奶酪中...");		
	}
}

/**
 * 水果披萨 – 具体产品
 * @author luxianghai
 *
 */
public class BJFruitPizza extends Pizza {

	public BJFruitPizza() {
		super.name = "北京水果披萨";
	}
	
	@Override
	public void prepare() {
		System.out.println(super.name);
		System.out.println("准备水果中...");
	}

}

/**
 * 奶酪披萨 – 具体产品
 * @author luxianghai
 *
 */
public class LDCheesePizza extends Pizza {
	
	public LDCheesePizza() {
		super.name = "伦敦奶酪披萨";
	}
	
	@Override
	public void prepare() {
		System.out.println(super.name);		
		System.out.println("准备奶酪中...");		
	}
}

/**
 * 水果披萨  – 具体产品
 * @author luxianghai
 *
 */
public class LDFruitPizza extends Pizza {

	public LDFruitPizza() {
		super.name = "伦敦水果披萨";
	}
	
	@Override
	public void prepare() {
		System.out.println(super.name);
		System.out.println("准备水果中...");
	}

}

抽象工厂

import java.util.Scanner;

import d3_factory.t2_factorymethod.pizza.*;

/**
 * 抽象工厂
 * @author luxianghai
 *
 */
public abstract class PizzaStore {
	// 工厂子类需要实现的方法 - 常用创建具体产品
	public abstract Pizza createPizza(String type);
	
	public PizzaStore() {
		orderPizza();
	}
	
	/**
	 * 点披萨
	 */
	private void orderPizza() {
		Pizza pizza = null;
		String type = ""; // 披萨类型
		do {
			type = getType();
			pizza = createPizza(type);
			if ( null != pizza ) {
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				break;
			}
		} while(true);
	}
	/**
	 * 获取披萨类型
	 * @return
	 */
	private String getType() {
		System.out.println("输入披萨名:");
		Scanner scan = new Scanner(System.in);
		return scan.next();
	}
	
}

具体工厂

/**
 * 伦敦披萨 - 具体工厂
 * @author luxianghai
 *
 */
public class LDPizzaStore extends PizzaStore {

	@Override
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if ( "奶酪披萨".equals(type) ) {
			pizza = new LDCheesePizza();
		} else if ( "水果披萨".equals(type) ) {
			pizza = new LDFruitPizza();
		}
		return pizza;
	}

}

/**
 * BJ披萨 - 具体工厂
 * @author luxianghai
 *
 */
public class BJPizzaStore extends PizzaStore {

	@Override
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if ( "奶酪披萨".equals(type) ) {
			pizza = new BJCheesePizza();
		} else if ( "水果披萨".equals(type) ) {
			pizza = new BJFruitPizza();
		}
		return pizza;
	}
}

测试

public class Client {

	public static void main(String[] args) {
		
		//new BJPizzaStore();
		new LDPizzaStore();
	}
}

5.3.5 优缺点分析

 工厂方法就是对简单工厂在进行一次封装而已,由于多态性使得工厂方法仍然保持了简单工厂的优点。
 缺点:仍然违反开闭原则

5.4 抽象工厂

5.4.1 介绍

 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类。
 抽象工厂模式就是将工厂方法改进了一下,使其能够管理多个抽象产品。
 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
 将工厂抽象成两层,AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。

5.4.2 结构

 抽象工厂模式的主要角色如下:

  1. 抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品。
  2. 具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
  3. 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
  4. 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。

5.4.3 实现

我们只需要保留下工厂方法代码中的抽象产品和具体产品即可,其他的代码均删除,添加以下代码:
抽象工厂

/**
 * 抽象工厂
 * @author luxianghai
 *
 */
public interface AbsFactory {
	
	Pizza createPizza(String type);
	
}

具体工厂

/**
 * BJ披萨 - 具体工厂
 * @author luxianghai
 *
 */
public class BJPizzaStore implements AbsFactory {

	@Override
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if ( "奶酪披萨".equals(type) ) {
			pizza = new BJCheesePizza();
		} else if ( "水果披萨".equals(type) ) {
			pizza = new BJFruitPizza();
		}
		return pizza;
	}
}

/**
 * 伦敦披萨 - 具体工厂
 * @author luxianghai
 *
 */
public class LDPizzaStore implements AbsFactory {

	@Override
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if ( "奶酪披萨".equals(type) ) {
			pizza = new LDCheesePizza();
		} else if ( "水果披萨".equals(type) ) {
			pizza = new LDFruitPizza();
		}
		return pizza;
	}
}

业务类

/**
 * 业务类
 * @author luxianghai
 *
 */
public class PizzaStore {

	private AbsFactory factory;
	
	public PizzaStore() {
		
	}
	
	public void setFactory(AbsFactory factory) {
		this.factory = factory;
		orderPizza();
	}
	
	/**
	 * 点披萨
	 */
	private void orderPizza() {
		Pizza pizza = null;
		String type = ""; // 披萨类型
		do {
			type = getType();
			pizza = factory.createPizza(type);
			if ( null != pizza ) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				break;
			}
		} while(true);
	}
	/**
	 * 获取披萨类型
	 * @return
	 */
	private String getType() {
		System.out.println("输入披萨名:");
		Scanner scan = new Scanner(System.in);
		return scan.next();
	}
}

测试

public class Client {

	public static void main(String[] args) {
		
		PizzaStore store = new PizzaStore();
//		store.setFactory(new LDPizzaStore());
		store.setFactory(new LDPizzaStore());
	}
}

 此时的类图如下:在这里插入图片描述

5.4.4 使用场景

  1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。
  2. 系统中有多个产品族,但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
  3. 系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。
  4. 如:输入法换皮肤,一整套一起换。生成不同操作系统的程序。

5.5 工厂+配置文件实现解耦

 简单工厂+配置文件解除耦合
可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名,并创建对象进行存储,客户端如果需要对象,直接进行获取即可。
第一步:创建配置文件
resources/bean.properties 文件内容

ChickenPizza=d3_factory.t4_config_factory.ChickenPizza
FruitPizza=d3_factory.t4_config_factory.FruitPizza

第二步:创建简单工厂

package d3_factory.t4_config_factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Properties;
import java.util.Set;

public class SimpleFactory {
	
	// 加载配置文件 - 获取配置文件中配置的全类名,通过反射技术来创建对象
	// 1.定义容器来存储Pizza对象
	private static HashMap<String, Pizza> map ;
	
	static {
		map = new HashMap<String, Pizza>();
		// 1.创建Properties对象
		Properties properties = new Properties();
		// 2.读取配置文件
		InputStream is = SimpleFactory.class.getClassLoader().getResourceAsStream("bean.properties");
		try {
			// 3.加载配置文件
			properties.load(is);
			// 获取 properties 中所有的键的 Set 集合
			Set<Object> keys =  properties.keySet();
			for ( Object key: keys ) {
				// 获取键对应的值
				String className = properties.getProperty((String)key);
				// 通过反射技术根据全类名创建对象
				Class clazz = Class.forName(className);
				Pizza pizza = (Pizza)clazz.newInstance();
				map.put((String)key, pizza);
			}
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	/**
	 * 根据名称获取对象
	 * @param name
	 * @return
	 */
	public static Pizza createPizza(String name) {
		return map.get(name);
	}
}

相关文章索引

设计模式概述
UML类图
软件设计原则
单例设计模式


后记

我水平有限,错误难免,还望各位加以指正。

本文内容到此结束,感谢您的阅读!!!如果内容对你有帮助的话,记得给我三连丫(点赞、收藏、关注)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_43113381/article/details/128013378

Java设计模式之创建型:工厂模式详解(简单工厂+工厂方法+抽象工厂)-爱代码爱编程

        在面向对象编程中,创建对象实例最常用的方式就是通过 new 操作符构造一个对象实例,但在某些情况下,new 操作符直接生成对象会存在一些问题。举例来说,对象的创建需要一系列的步骤:可能需要计算或取得对象的初始位置、选择生成哪个子对象实例、或在生成之前必须先生成一些辅助对象。 在这些情况,新对象的建立就是一个 “过程”,而不仅仅是一个操作,就

设计模式之工厂模式-爱代码爱编程

工厂模式 1、简单工厂模式 1.1、定义 简单工厂模式(Simple Factory Pattern)是指有一个工厂对象决定创建出哪一种产品类的实例,不属于23种设计模式。 简单工厂是产品的工厂 1.2、应用场景 简单工厂模式适用于工厂类创建的对象较少的场景,且客户端只需要传入工厂参数,对如何创建对象的逻辑不需要关心。 1.3、缺点 工厂类

Java常见设计模式总结-爱代码爱编程

 一、设计模式总述: 1、什么是设计模式:         设计模式是一套经过反复使用的代码设计经验,目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 设计模式于己于人于系统都是多赢的,它使得代码编写真正工程化,它是软件工程的基石,如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现实中都有相应的原理来与之

设计模式之游戏--工厂模式详解-爱代码爱编程

工厂模式 一.简单工厂模式二.工厂方法模式三.抽象工厂模式使用总结 引入问题:在面向对象编程中,创建一个对象的最常用的方法是new一个对象实例,new对象操作符就是用来构造对象实例的,但是在一些情况下,new操作符直接生成对象会带来一些问题,举例说,许多类型对象的创建都需要一系列的步骤,可能需要计算或取得对象的初始设置,选择生成哪个子对象实例,

PHP 常见设计模式——工厂模式-爱代码爱编程

最近参加了几次面试,对于应用常见的几种设计模式问题,深有感触。为加强自身理解,同时也希望能给一些初级开发者一定的参考学习,决定开始就PHP常见的设计模式写下几篇博文,工作原因,会不定期更新,感谢您的耐心阅读! 今天这篇文章主要是描述一下PHP常见设计模式之工厂模式。工厂模式其实可以划分为:简单工厂模式、工厂方法模式、抽象工厂模式等。 1.简单工厂模式

C++设计模式之工厂模式-爱代码爱编程

设计模式之工厂模式 一. 简单工厂模式:定义一个用于创建对象的接口。 纯虚函数和抽象类 1、纯虚函数: 在函数原型后面加上符号 “=0” 1)纯虚函数是一个在基类中只有声明的虚函数,在基类中无定义。要求在任何派生类中都定义自己的版本; 2)纯虚函数为各派生类提供一个公共界面(接口的封装和设计,软件的模块功能划分); 2、抽象类:包含纯虚函数的类成为抽象类

Unity 常用设计模式之工厂模式-爱代码爱编程

工厂模式(Factory Pattern)是 游戏开发中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对用户暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 先来看一个生活中的真实的案例,某个品牌的汽车制造工厂,对外提供生产这个品牌的不同型号汽车的服务。外界只要下一

iOS常见的设计模式:工厂设计模式-爱代码爱编程

iOS常见的设计模式:工厂设计模式 简单工厂模式: 简单工厂模式(Simple Factory Pattern):专门定义一个类(工厂类)来负责创建其他类的实例。可以根据创建方法的参数来返回不同类的实例,被创建的实例通常都具有共同的父类。 ①创建一个工厂类,可乐抽象类。 ②可口可乐和百事可乐继承于可乐抽象类。 // 简单工厂实现 @im

简单工厂模式-爱代码爱编程

        简单工厂模式定义为:简单工厂模式又称为静态工厂方法模型,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。         简单工厂模式结构图:                  简单工厂模式包含如下角色:         

Unity3D常用设计模式之工厂模式-爱代码爱编程

Unity3D常用设计模式《工厂模式》   工厂模式(Factory Pattern)是游戏开发中比较常用的设计模式。这种类型的设计模式属于创建型模式,它提供了一种创建对象实例的最佳方式。在工厂模式中,我们在创建对象时不会对用户暴露创建对象的具体细节,而是通过提供一个共同的接口来创建需要的对象。   如果不好理解,先来看看生活中的一个真

工厂设计模式-爱代码爱编程

1、概念 工厂模式分三种:简单工厂模式、工厂方法模式、抽象工厂模式 简单工厂模式(Simple Factory Pattern):属于类的创新型模式,又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。简单工厂模式严重违背了“开闭原则”,难以拓展

【设计模式】简单工厂模式(c#)_会敲键盘的肘子的博客-爱代码爱编程

【设计模式】简单工厂模式(C#) 1、概述 工厂模式总结三个要点: 不想直接new这个类的对象,防止这个类改变的时候在new的地方到处去改,麻烦且容易遗漏;这个类的对象构建过程非常复杂,不想在代码的各个地方将这么复杂的构建过程反复书写;这个类的对象在构建过程中依赖了很多其他的类,而你无法在调用的地方提供。2、结构 简单工厂包含如下角色: 抽象产品

js设计模式之工厂模式_ㅤㅤ ㅤ ㅤ ㅤ ㅤ ㅤ ㅤ的博客-爱代码爱编程

科普 工厂模式是一种众所周知的设计模式,广泛应用于软件工程领域,用于抽象创建特定对象的过程。 示例 function creatPerson() { let p = new Object(); p.id = id; p.name = name; p.age = age;

23种设计模式——抽象工厂模式-爱代码爱编程

目录 抽象工厂模式(AbstractFactory) 产品族 理解 UML图 优缺点 应用场景 抽象工厂模式VS和工厂模式 实例 数据访问(工厂方法) 数据访问(抽象工厂) 用简单工厂改造抽象工厂 C#中的反射 Java实现反射+配置文件+抽象工厂数据访问程序 抽象工厂模式(AbstractFactory) 本质:

java设计模式之工厂模式详解_java工厂模式详解-爱代码爱编程

目录 1.什么是工厂模式? 2.作用: 3.核心本质: 4.详细分类: 5.简单工厂模式/静态工厂模式: 6.工厂方法模式 7.两种模式对比总结: 1.什么是工厂模式? 工厂模式的主要解决的问题是,将原来分布在各个地方的对象创建过程单独抽离出来,交给工厂类负责创建。其他地方想要使用对象直接找工厂(即调用工厂的方法)获取对象。 2

设计模式——工厂方法模式-爱代码爱编程

工厂方法 也被称作:抽象构造 目的 工厂方法是一种创建设计模式,它在父类中提供了创建对象的接口但允许子类更改将要创建的对象的类型。 问题 假设您正在创建一个物流管理应用程序。你的应用的第一个版本只能处理卡车运输,