设计模式之工厂模式 (二)

工厂模式分为三大类

  1. 简单工厂(SimpleFactory)
  2. 工厂方法模式（Factory Method）

  3. 抽象工厂模式（Abstract Factory）
  4. 动态工厂（Dynamic Factory，属于优化版简单工厂）

一、简单工厂

组成如下：

(1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

(2)
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

(3)
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

具体例子：

抽象产品、具体产品角色类定义如下：

package com.open.design.factory;

public class SimpleFactoryData {

	//2.抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
	public interface Car
	{
		void printName();
	}

	//3.具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
	public static class Benz implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Benz.");
		}
	}

	public static  class BMW implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am BMW.");
		}
	}

	public static class Audi implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Audi.");
		}
	}

	public static class Tesla implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Tesla.");
		}
	}
}

工厂类定义如下：

package com.open.design.factory;

import com.open.design.factory.SimpleFactoryData.Car;

//1.工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现
public class SimpleFactory {

	public static Car produce(String carName)
	{
		Car car=null;
		if("Benz".equals(carName))
		{
			car=new SimpleFactoryData.Benz();
		}
		else if("BMW".equals(carName))
		{
			car=new SimpleFactoryData.BMW();
		}
		else if("Audi".equals(carName))
		{
			car=new SimpleFactoryData.Audi();
		}
		else if("Tesla".equals(carName))
		{
			car=new SimpleFactoryData.Tesla();
		}

		return car;
	}
}

测试类如下：

package com.open.design.factory;

import com.open.design.factory.SimpleFactoryData.Car;

public class SimpleFactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Car car=SimpleFactory.produce("Benz");
		car.printName();

		car=SimpleFactory.produce("BMW");
		car.printName();

		car=SimpleFactory.produce("Audi");
		car.printName();

		car=SimpleFactory.produce("Tesla");
		car.printName();

	}

}

打印结果如下：

优点与缺点：

二、工厂方法模式（也称多态工厂）

组成如下：

(1)抽象工厂角色：
这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

(2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

(3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

(4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

具体例子如下：

抽象产品、具体产品角色类定义如下：

package com.open.design.factory;

public class PolymorphicData {

	//3.抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
	public interface Car
	{
		void printName();
	}

	//4.具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
	public static class Sedan implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Sedan.");
		}
	}

	public static  class Train implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Train.");
		}
	}

	public static class Bike implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Bike.");
		}
	}

}

抽象工厂、具体工厂类定义如下：

package com.open.design.factory;

import com.open.design.factory.PolymorphicData.Car;

public class PolymorphicFactory {

	//1.抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
	public static abstract class CarFactory
	{
		abstract Car createCar();
	}	

	//2.具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
	public static class SedanFactory extends CarFactory
	{
		public Car createCar()
		{
			return new PolymorphicData.Sedan();
		};
	}	

	public static class TrainFactory extends CarFactory
	{
		public Car createCar()
		{
			return new PolymorphicData.Train();
		};
	}	

	public static class BikeFactory extends CarFactory
	{
		public Car createCar()
		{
			return new PolymorphicData.Bike();
		};
	}
}

测试类如下：

package com.open.design.factory;

import com.open.design.factory.PolymorphicData.Car;
import com.open.design.factory.PolymorphicFactory.BikeFactory;
import com.open.design.factory.PolymorphicFactory.CarFactory;
import com.open.design.factory.PolymorphicFactory.SedanFactory;
import com.open.design.factory.PolymorphicFactory.TrainFactory;

public class PolymorphicTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		CarFactory factory=new SedanFactory();
		Car car =factory.createCar();
		car.printName();

		factory=new TrainFactory();
		car =factory.createCar();
		car.printName();

		factory=new BikeFactory();
		car =factory.createCar();
		car.printName();

	}

}

打印结果：

优点与缺点：

三、抽象工厂

组成与工厂方法模式一致，只不过抽象工厂是针对多个产品等级结构（即产品簇），工厂方法是针对一个产品等级结构。

具体例子如下：

抽象产品、具体产品角色类定义如下：

package com.open.design.factory;

public class AbstractFactryCar {

	//2.抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
	public interface Car
	{
		void printName();
	}

	//3.具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
	public static class Benz implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Benz.");
		}
	}

	public static  class BMW implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am BMW.");
		}
	}

	public static class Audi implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Audi.");
		}
	}

	public static class Tesla implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Tesla.");
		}
	}
}

package com.open.design.factory;

public class AbstractFactryHouse {

	//2.抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
	public interface House
	{
		void printHouseName();
	}

	//3.具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
	public static class Villa implements House
	{
		@Override
		public void printHouseName() {
			System.out.println("i am Villa.");
		}
	}

	public static  class TileRoofedHouse implements House
	{
		@Override
		public void printHouseName() {
			System.out.println("i am TileRoofedHouse.");
		}
	}

	public static class CommodityHouse implements House
	{
		@Override
		public void printHouseName() {
			System.out.println("i am CommodityHouse.");
		}
	}
}

抽象工厂、具体工厂类定义如下：

package com.open.design.factory;

import com.open.design.factory.AbstractFactryCar.Car;
import com.open.design.factory.AbstractFactryHouse.House;

public class AbstractFactry {

	//抽象工厂类
	public static abstract class AbsDream
	{
		public abstract Car createCar();
		public abstract House createHouse();
	}

	//2.具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
	public static class DreamAFactory extends AbsDream
	{
		public Car createCar()
		{
			return new AbstractFactryCar.Benz();
		};
		public House createHouse()
		{
			return new AbstractFactryHouse.TileRoofedHouse();
		};
	}

	public static class DreamBFactory extends AbsDream
	{
		public Car createCar()
		{
			return new AbstractFactryCar.Audi();
		};
		public House createHouse()
		{
			return new AbstractFactryHouse.CommodityHouse();
		};
	}

	public static class DreamCFactory extends AbsDream
	{
		public Car createCar()
		{
			return new AbstractFactryCar.Tesla();
		};
		public House createHouse()
		{
			return new AbstractFactryHouse.Villa();
		};
	}
}

测试类如下：

package com.open.design.factory;

import com.open.design.factory.AbstractFactry.AbsDream;
import com.open.design.factory.AbstractFactryCar.Car;
import com.open.design.factory.AbstractFactryHouse.House;

public class AbstractFactryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		AbsDream dream = new AbstractFactry.DreamAFactory();
		Car car =dream.createCar();
		House house=dream.createHouse();

		car.printName();
		house.printHouseName();

		//-------------------
		dream = new AbstractFactry.DreamBFactory();
		car =dream.createCar();
		house=dream.createHouse();

		car.printName();
		house.printHouseName();

		//-------------------
		dream = new AbstractFactry.DreamCFactory();
		car =dream.createCar();
		house=dream.createHouse();

		car.printName();
		house.printHouseName();

	}

}

打印结果如下：

优点与缺点：

四、动态工厂

组成与简单工厂类似。

具体例子：

抽象产品、具体产品角色类定义如下：

package com.open.design.factory;

public class DynamicFactoryData {

	//2.抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
	public interface Car
	{
		void printName();
	}

	//3.具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
	public static class Benz implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Benz.");
		}
	}

	public static  class BMW implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am BMW.");
		}
	}

	public static class Audi implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Audi.");
		}
	}

	public static class Tesla implements Car
	{
		@Override
		public void printName() {
			System.out.println("i am Tesla.");
		}
	}
}

工厂类定义如下：

package com.open.design.factory;

import java.lang.reflect.Constructor;

import com.open.design.factory.DynamicFactoryData.Car;

public class DynamicFactory {

	public static Car produce(String carName)
	{
		ClassLoader mClassLoader=DynamicFactory.class.getClassLoader();
		try {
			Class<?> mClass = mClassLoader.loadClass(carName);
			Constructor<?>[] mConstructor=mClass.getConstructors();
			return (Car) mConstructor[0].newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

}

测试类如下：

package com.open.design.factory;

import com.open.design.factory.DynamicFactoryData.Car;

public class DynamicFactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Car car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$Benz");
		car.printName();

		car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$BMW");
		car.printName();

		car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$Audi");
		car.printName();

		car=DynamicFactory.produce("com.open.design.factory.DynamicFactoryData$Tesla");
		car.printName();
	}

}

打印结果如下：

优点与缺点：

本文代码地址：https://github.com/zz7zz7zz/design-pattern

参考博文：http://www.cnblogs.com/forlina/archive/2011/06/21/2086114.html

设计模式之工厂模式 (二),布布扣,bubuko.com

时间： 2024-10-01 05:48:10

设计模式之工厂模式 (二)的相关文章

浅析JAVA设计模式之工厂模式(二)

1 工厂方法模式简介 工厂方法 (Factroy Method) 模式:又称多态性工厂模式(Polymorphic Factory),在这种模式中,核心工厂不再是一个具体的类,而是一个抽象工厂,提供具体工厂实现的接口,具体创建产品交由子工厂去做,抽象工厂不涉及任何产品被实例化的细节.而不同等级的产品,就对应一个不同等级的工厂,如下图. 图1 1.1工厂方法模式(多态性工厂模式): 工厂方法模式有三个角色: 1. 抽象产品接口 2. 具体产品类 3. 抽象工厂接口 4.具体工厂类. 1.2工厂方法

浅析JAVA设计模式之工厂模式(三)

在阅读本文之前,请先阅读(一)和(二)中的简单工厂模式和工厂方法模式. 1抽象工厂模式简介 抽象工厂 (Abstract Factroy) 模式:工具箱模式(kit).抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态,如下图. 图1.1 上图左边有一个工厂类的等级结构,右边有两个不同的产品等级结构,分别是产品A的等级结构和产品B的等级结构,工厂1和工厂2分别负责不同一个产品等级,同一个产品族的产品的生产.又例如下图: 图1.2 上图表示的是Button和Text两个不同产品的等级

设计模式之工厂模式（二）

之前已经带大家稍微入门了工厂模式(即简单工厂模式)的方法,没看过的朋友可以移步去查看一番.设计模式之工厂模式(一).今天我们继续吃着披萨,学习着工厂模式的接下来部分吧. 加盟披萨店 我们先前的披萨店已经经营有成,击败了部分竞争者,接下来的计划就是开加盟店.作为经营者,你肯定希望确保加盟店运营的质量,所以希望这些店都是用你那些经过时间考验的代码. 但是每个地方可能需要不同口味的披萨(比如A地区.B地区.C地区等),这就是开店地点以及该地区披萨美食家口味的影像. 如果利用先前的简单工厂,那么就是需要

设计模式-抽象工厂模式（C#）

设计模式--抽象工厂模式(JAVA) 在抽象工厂模式中,一个具体工厂可以生产一组相关的具体产品,这样的一组产品成为产品族,产品族中的每一个产品都属于某一个产品继承等等级结构.当系统所提供的工厂生产的具体产品并不是一个简单的对象,而是多个位于不同产品等级结构.属于不同类型的具体产品时就可以使用抽象工厂模式. 抽象工厂模式与工厂方法模式最大的区别在于,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式需要面对多个产品等级结构,一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建,当一个工

浅谈php设计模式(1)---工厂模式

一.接口继承直接调用 先看看这样一段代码: 1 <?php 2 3 interface db{ 4 function conn(); 5 } 6 7 class dbmysql implements db { 8 public function conn(){ 9 echo "连接到了mysql"; 10 } 11 } 12 13 class dbsqlite implements db{ 14 public function conn(){ 15 echo "连接到了

Java经典23种设计模式之创造型模式(二)

本文记录5种创造型模式的剩下两种:建造者模式(Builder).原型模式(PROTOTYPE). 一.建造者模式(别名:生成者模式) 将复杂对象的构建和它的表示分离,使得同样的构建过程可以创建不同的表示.一个完整的建造者模式包含以下几个概念: 1.产品类 Product public class Person { private String head; private String body; private String foot; public String getHead() { ret

Android设计模式——抽象工厂模式(Abstract Factory)

二十三种设计模式分为三大类: 创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 1 package com.example.main; 2 3 import android.app.Activity; 4 import

php设计模式——抽象工厂模式(Abstract Factory)

二十三种设计模式分为三大类: 创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 1 <?php 2 /* 3 * php设计模式——抽象工厂模式(Abstract Factory) 4 */ 5 6 7 /* 8 * I

5. 星际争霸之php设计模式--抽象工厂模式

题记==============================================================================本php设计模式专辑来源于博客(jymoz.com),现在已经访问不了了,这一系列文章是我找了很久才找到完整的,感谢作者jymoz的辛苦付出哦! 本文地址:http://www.cnblogs.com/davidhhuan/p/4248178.html============================================