- 一、工厂模式的介绍
- 工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化,不必事先知道每次要实例化哪一个类。
- 工厂模式的几种形态:
- (1)简单工厂(Simple Factory)模式,又称静态工厂方法模式(Static Factory Method
- Pattern)。
- (2)工厂方法(Factory Method)模式,又称多态性工厂(Polymorphic Factory)模式
- 或虚拟构造子(Virtual Constructor)模式;
- (3)抽象工厂(Abstract Factory)模式,又称工具箱(Kit 或Toolkit)模式。
- 二、简单工厂模式
- 2.1简单工厂模式介绍
- 简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据自变量的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
- 2.2简单工厂模式角色
- (1)工厂类(Creator)角色:担任这个角色的是工厂方法模式的核心,含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象,它往往由一个具体Java 类实现。
- (2)抽象产品(Product)角色:担任这个角色的类是工厂方法模式所创建的对象的父类,或它们共同拥有的接口。抽象产品角色可以用一个Java 接口或者Java 抽象类实现。
- (3)具体产品(Concrete Product)角色:工厂方法模式所创建的任何对象都是这个角色的实例,具体产品角色由一个具体Java 类实现。
- 三、工厂方法模式
- 3.1工厂方法模式的介绍
- 工厂方法模式定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。
- 在工厂方法模式中,核心的工厂类不再负责所有的产品的创建,而是将具体创建的工作交给子类去做。这个核心类则摇身一变,成为了一个抽象工厂角色,仅负责给出具体工厂子类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。
- 3.2工厂方法模式角色
- (1)抽象工厂(Creator)角色:担任这个角色的是工厂方法模式的核心,它是与应用程序无关的。任何在模式中创建对象的工厂类必须实现这个接口。在上面的系统中这个角色由Java 接口Creator 扮演;在实际的系统中,这个角色也常常使用抽象Java 类实现。
- (2)具体工厂(Concrete Creator)角色:担任这个角色的是实现了抽象工厂接口的具体Java 类。具体工厂角色含有与应用密切相关的逻辑,并且受到应用程序的调用以创建产品对象。在本系统中给出了两个这样的角色,也就是具体Java 类ConcreteCreator1 和ConcreteCreator2。
- (3)抽象产品(Product)角色:工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。在本系统中,这个角色由Java 接口Product 扮演;在实际的系统中,这个角色也常常使用抽象Java 类实现。
- (4)具体产品(Concrete Product)角色:这个角色实现了抽象产品角色所声明的接口。工厂方法模式所创建的每一个对象都是某个具体产品角色的实例。
- 3.5工厂方法模式的举例
- 例:
- //抽象产品
- PenCore.java
- public abstract class PenCore{
- String color;
- public abstract void writeWord(String s);
- }
- //具体产品
- RedPenCore.java
- public class RedPenCore extends PenCore {
- RedPenCore() {
- color = "红色";
- }
- public void writeWord(String s) {
- System.out.println("写出" + color + "的字" + s);
- }
- }
- BluePenCore.java
- public class BluePenCore extends PenCore {
- BluePenCore() {
- color = "蓝色";
- }
- public void writeWord(String s) {
- System.out.println("写出" + color + "的字" + s);
- }
- }
- BlackPenCore.java
- public class BlackPenCore extends PenCore {
- BlackPenCore() {
- color = "黑色";
- }
- public void writeWord(String s) {
- System.out.println("写出" + color + "的字" + s);
- }
- }
- //构造者
- BallPen.java
- public abstract class BallPen {
- BallPen(){
- System.out.println("生产一只装有"+getPenCore().color+"笔芯的圆珠笔");
- }
- public abstract PenCore getPenCore();
- }
- //具体构造者
- RedBallPen.java
- public class RedBallPen extends BallPen {
- public PenCore getPenCore() {
- return new RedPenCore();
- }
- }
- BlueBallPen.java
- public class BlueBallPen extends BallPen {
- public PenCore getPenCore() {
- return new BluePenCore();
- }
- }
- BlackBallPen.java
- public class BlackBallPen extends BallPen {
- public PenCore getPenCore() {
- return new BlackPenCore();
- }
- }
- 四、抽象工厂模式
- 4.1抽象工厂模式的介绍
- 抽象工厂模式提供一个创建一系列或相互依赖的对象的接口,而无需指定它们具体的类。
- 4.2抽象工厂模式角色
- 抽象工厂模式涉及到的系统角色
- (1)抽象工厂(AbstractFactory)角色:担任这个角色的是工厂方法模式的核心,它是与应用系统的商业逻辑无关的。通常使用Java 接口或者抽象Java 类实现,而所有的具体工厂类必须实现这个Java 接口或继承这个抽象Java 类。
- (2)具体工厂类(Conrete Factory)角色:这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑,而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用具体Java 类实现这个角色。
- (3)抽象产品(Abstract Product)角色:担任这个角色的类是工厂方法模式所创建的对象的父类,或它们共同拥有的接口。通常使用Java 接口或者抽象Java 类实现这一角色。
- (4)具体产品(Concrete Product)角色:抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西,其内部一定充满了应用系统的商业逻辑。通常使用具体Java 类实现这个角色。
- 4.5抽象工厂模式的举例
- 例:
- //抽象产品
- UpperClothes.java
- public abstract class UpperClothes {
- public abstract int getChestSize();
- public abstract int getHeight();
- public abstract String getName();
- }
- Trousers.java
- public abstract class Trousers {
- public abstract int getWaistSize();
- public abstract int getHeight();
- public abstract String getName();
- }
- //具体产品
- WesternUpperClothes.java
- public class WesternUpperClothes extends UpperClothes {
- private int chestSize;
- private int height;
- private String name;
- WesternUpperClothes(String name,int chestSize,int height){
- this.name=name;
- this.chestSize=chestSize;
- this.height=height;
- }
- public int getChestSize() {
- return chestSize;
- }
- public int getHeight() {
- return height;
- }
- public String getName() {
- return name;
- }
- }
- CowboyUpperClothes.java
- public class CowboyUpperClothes extends UpperClothes {
- private int chestSize;
- private int height;
- private String name;
- CowboyUpperClothes(String name,int chestSize,int height){
- this.name=name;
- this.chestSize=chestSize;
- this.height=height;
- }
- public int getChestSize() {
- return chestSize;
- }
- public int getHeight() {
- return height;
- }
- public String getName () {
- return name;
- }
- }
- WesternTrousers.java
- public class WesternTrousers extends Trousers {
- private int waistSize;
- private int height;
- private String name;
- WesternTrousers(String name,int waistSize,int height){
- this.name=name;
- this.waistSize=waistSize;
- this.height=height;
- }
- public int getHeight() {
- return height;
- }
- public String getName() {
- return name;
- }
- public int getWaistSize() {
- return waistSize;
- }
- }
- CowboyTrousers.java
- public class CowboyTrousers extends Trousers {
- private int waistSize;
- private int height;
- private String name;
- CowboyTrousers(String name,int waistSize,int height){
- this.name=name;
- this.waistSize=waistSize;
- this.height=height;
- }
- public int getHeight() {
- return height;
- }
- public String getName() {
- return name;
- }
- public int getWaistSize() {
- return waistSize;
- }
- }
- //抽象工厂
- ClothesFactory.java
- public abstract class ClothesFactory {
- public abstract UpperClothes createUpperClothes(int chestSize,int height);
- public abstract Trousers createTrousers(int waistSize,int height);
- }
- //具体工厂
- BeijingClothesFactory.java
- public class BeijingClothesFactory extends ClothesFactory {
- public Trousers createTrousers(int waistSize, int height) {
- return new WesternTrousers("北京牌裤子",waistSize,height);
- }
- public UpperClothes createUpperClothes(int chestSize, int height) {
- return new WesternUpperClothes("北京牌上衣",chestSize,height);
- }
- }
- ShanghaiClothesFactory.java
- public class ShanghaiClothesFactory extends ClothesFactory {
- public Trousers createTrousers(int waistSize, int height) {
- return new WesternTrousers("上海牌裤子",waistSize,height);
- }
- public UpperClothes createUpperClothes(int chestSize, int height) {
- return new WesternUpperClothes("上海牌上衣",chestSize,height);
- }
- }
下面是一个简单的工厂模式
- package org;
- interface Fruit{
- public void eat();
- }
- class Apple implements Fruit{
- public void eat(){
- System.out.println("吃苹果。");
- }
- }
- class Orange implements Fruit{
- public void eat(){
- System.out.println("吃橘子");
- }
- }
- class Factory{ //工厂类
- public static Fruit getInstance(String className){
- Fruit f=null;
- if(className.equals("apple")){
- f=new Apple();
- }
- if(className.endsWith("orange")){
- f=new Orange();
- }
- return f;
- }
- }
- public class FactoryDemo02 {
- public static void main(String args[]){
- Fruit f=Factory.getInstance("apple");
- f.eat();
- }
- }
但是工厂类如果这样写的话,就有一个问题,如果增加了水果,比如香蕉,那么在工厂类里面也要进行相关的修改了,这样不合理,而java的反射机制可以解决这个问题
- package org1;
- interface Fruit {
- public void eat();
- }
- class Apple implements Fruit {
- public void eat() {
- System.out.println("吃苹果。");
- }
- }
- class Orange implements Fruit {
- public void eat() {
- System.out.println("吃橘子");
- }
- }
- class Factory {
- public static Fruit getInstance(String className) {
- Fruit f = null;
- try {
- f = (Fruit) Class.forName(className).newInstance();
- } catch (Exception e) {
- e.printStackTrace();
- }
- return f;
- }
- }
- public class CopyOfFactoryDemo03 {
- public static void main(String args[]) {
- Fruit f = Factory.getInstance("org1.Apple");
- f.eat();
- }
- }
利用java的反射机制,就能动态的实例化各种类了。