Java设计模式--工厂设计模式

需要沉淀沉淀

已于 2022-04-18 20:22:18 修改

阅读量168

点赞数

分类专栏： Java设计模式文章标签： java 简单工厂模式抽象工厂模式工厂方法模式

于 2022-04-18 10:42:50 首次发布

本文链接：https://blog.csdn.net/TIANJIAWEN/article/details/124243362

版权

Java设计模式专栏收录该内容

23 篇文章 2 订阅

订阅专栏

看一个具体的需求

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

1) 披萨的种类很多( 比如 GreekPizz 、 CheesePizz 等 )

2) 披萨的制作有 prepare ， bake, cut, box

3) 完成披萨店订购功能。

传统的实现方式

代码:

public abstract class pizza {
    private String name;
    void prepare(){};
    void cut(){
        System.out.println(name+"cutting");
    }
    void bake(){
        System.out.println(name+"baking");
    }
    void box(){
        System.out.println(name+"boxing");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class cheessPizza extends pizza{
    @Override
    void prepare() {
        System.out.println("奶酪");
    }

}
class greekPizza extends pizza{
    @Override
    void prepare() {
        System.out.println("希腊");
    }
}





import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
    public OrderPizza() {
        pizza p = null;
        String orderType;//订购pizza的类型
        do{
            orderType = getType();
            if(orderType.equals("greek")){
                p = new greekPizza();
                p.setName("greek   ");
            }else if(orderType.equals("cheese")){
                p = new cheessPizza();
                p.setName("cheese   ");
            }else {
                break;
            }
            p.prepare();
            p.bake();
            p.cut();
            p.box();
        }while (true);
    }

    //写一个方法 获取客户希望订购的pizza的种类
    private String getType(){
        try{
            BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
            String str = s.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return"";
        }
    }
}





public class pizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}

传统的方式的优缺点

1) 优点是比较好理解，简单易操作。

2) 缺点是违反了设计模式的 ocp 原则，即 对扩展开放，对修改关闭 。即当我们给类增

加新功能的时候，尽量不修改代码，或者尽可能少修改代码 .

3) 比如我们这时要新增加一个 Pizza 的种类 (Pepper 披萨 ) ，我们需要做如下修改 .

//新增 写
public class pepperPizza extends Pizza {
@Override
public void prepare() {
// TODO Auto-generated method stub
setName("pepper pizza");
System.out.println(name + " preparing;");
}}
//增加一段代码 OrderPizza.java //写
if (ordertype.equals("greek")) {
pizza = new GreekPizza();
} else if (ordertype.equals("pepper")) {
pizza = new PepperPizza();
} else if (ordertype.equals("cheese")) {
pizza = new CheesePizza();
} else {
break;
}
}

4) 改进的思路分析

分析： 修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味

着，也需要修改，而创建Pizza 的代码， 往往有多处 。

思路： 把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该

类就可， 其它有创建到 Pizza 对象的代码就不需要修改了 .-> 简单工厂模式

简单工厂模式(静态工厂模式)

基本介绍

1) 简单工厂模式是属于创建型模式，是工厂模式的一种。 简单工厂模式是由一

个工厂对象决定创建出哪一种产品类的实例 。简单工厂模式是工厂模式家族

中最简单实用的模式

2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行 为 ( 代码 )

3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会
使用到工厂模式

JDK 中的Calendar类中，就使用了简单工厂模式

代码:把原来order的分类功能放到工厂类同时更新order类

public class simpleFactory {
    //根据orderType 返回对应的pizza对象
    public pizza createPizza( String orderType){
        pizza p = null;
        if(orderType.equals("greek")){
            p = new greekPizza();
            p.setName("greek   ");
        }else if(orderType.equals("cheese")){
            p = new cheessPizza();
            p.setName("cheese   ");
        }
        return p;
    }
}





import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {
 //定义一个简单工厂对象
    simpleFactory simpleFactory1;
    pizza p = null;


    public OrderPizza(simpleFactory simpleFactory1) {
        setFactory(simpleFactory1);
    }

    public void setFactory(simpleFactory simpleFactory1){
        String orderType = "";
        this.simpleFactory1 = simpleFactory1;//设置简单工厂对象
        do{
            orderType = getType();
            p = this.simpleFactory1.createPizza(orderType);
            //输出pizza
            if(p!=null){
                p.prepare();
            }else {
                System.out.println("NO");
            }
        }while (true);
    }

    //写一个方法 获取客户希望订购的pizza的种类
    private String getType(){
        try{
            BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
            String str = s.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return"";
        }
    }
}





public class pizzaStore {
    public static void main(String[] args) {
        new OrderPizza(new simpleFactory());
    }
}

工厂方法模式

看一个新的需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、

北京的胡椒pizza 或者是伦敦的奶酪 pizza 、伦敦的胡椒 pizza。

思路1

使用简单工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory、

LDPizzaSimpleFactory 等等 . 从当前这个案例来说，也是可以的，但是考虑到项目的

规模，以及软件的可维护性、可扩展性并不是特别好

思路2

使用工厂方法模式

工厂方法模式介绍

工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点

餐子类中具体实现。

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方

法模式将对象的实例化推迟到子类

工厂方法模式应用案例

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪

pizza 、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒pizza

代码:


public class BJCheesePizza extends Pizza {

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的奶酪pizza");
		System.out.println(" 北京的奶酪pizza 准备原材料");
	}

}

public class BJPepperPizza extends Pizza {
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的胡椒pizza");
		System.out.println(" 北京的胡椒pizza 准备原材料");
	}
}

public class LDCheesePizza extends Pizza{

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦的奶酪pizza");
		System.out.println(" 伦敦的奶酪pizza 准备原材料");
	}
}

public class LDPepperPizza extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦的胡椒pizza");
		System.out.println(" 伦敦的胡椒pizza 准备原材料");
	}
}

//将Pizza 类做成抽象
public abstract class Pizza {
	protected String name; //名字

	//准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
	public abstract void prepare();

	
	public void bake() {
		System.out.println(name + " baking;");
	}

	public void cut() {
		System.out.println(name + " cutting;");
	}

	//打包
	public void box() {
		System.out.println(name + " boxing;");
	}

	public void setName(String name) {
		this.name = name;
	}
}

public class BJOrderPizza extends OrderPizza {

	
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new BJPepperPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}

public class LDOrderPizza extends OrderPizza {

	
	@Override
	Pizza createPizza(String orderType) {
	
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDPepperPizza();
		}
		// TODO Auto-generated method stub
		return pizza;
	}

}

public abstract class OrderPizza {

	//定义一个抽象方法，createPizza , 让各个工厂子类自己实现
	abstract Pizza createPizza(String orderType);
	
	// 构造器
	public OrderPizza() {
		Pizza pizza = null;
		String orderType; // 订购披萨的类型
		do {
			orderType = getType();
			pizza = createPizza(orderType); //抽象方法，由工厂子类完成
			//输出pizza 制作过程
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
			
		} while (true);
	}

	

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}

}

public class PizzaStore {

	public static void main(String[] args) {
		String loc = "bj";
		if (loc.equals("bj")) {
			//创建北京口味的各种Pizza
			new BJOrderPizza();
		} else {
			//创建伦敦口味的各种Pizza
			new LDOrderPizza();
		}
		// TODO Auto-generated method stub
	}

}

抽象工厂模式

基本介绍

1) 抽象工厂模式：定义了一个interface 用于创建相关或有依赖关系的对象簇，而无需

指明具体的类

2) 抽象工厂模式可以将简单工厂模式 和 工厂方法模式 进行整合。

3) 从设计层面看，抽象工厂模式就是对简单工厂模式的改进( 或者称为进一步的抽象 ) 。

4) 将工厂抽象成两层，AbsFactory( 抽象工厂 ) 和具体实现的工厂子类。程序员可以

根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了 工厂簇 ，

更利于代码的维护和扩展。

代码:

pizza:

public class BJPepperPizza extends Pizza {
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的胡椒pizza");
		System.out.println(" 北京的胡椒pizza 准备原材料");
	}
}


public class BJCheesePizza extends Pizza {

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("北京的奶酪pizza");
		System.out.println(" 北京的奶酪pizza 准备原材料");
	}

}

public class LDCheesePizza extends Pizza{

	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦的奶酪pizza");
		System.out.println(" 伦敦的奶酪pizza 准备原材料");
	}
}

public class LDPepperPizza extends Pizza{
	@Override
	public void prepare() {
		// TODO Auto-generated method stub
		setName("伦敦的胡椒pizza");
		System.out.println(" 伦敦的胡椒pizza 准备原材料");
	}
}

//将Pizza 类做成抽象
public abstract class Pizza {
	protected String name; //名字

	//准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
	public abstract void prepare();

	
	public void bake() {
		System.out.println(name + " baking;");
	}

	public void cut() {
		System.out.println(name + " cutting;");
	}

	//打包
	public void box() {
		System.out.println(name + " boxing;");
	}

	public void setName(String name) {
		this.name = name;
	}
}

接口:

//一个抽象工厂模式的抽象层(接口)
public interface AbsFactory {
	//让下面的工厂子类来 具体实现
	public Pizza createPizza(String orderType);
}

接口的实现类工厂子类 :

//这是工厂子类
public class BJFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		// TODO Auto-generated method stub
		Pizza pizza = null;
		if(orderType.equals("cheese")) {
			pizza = new BJCheesePizza();
		} else if (orderType.equals("pepper")){
			pizza = new BJPepperPizza();
		}
		return pizza;
	}

}

public class LDFactory implements AbsFactory {

	@Override
	public Pizza createPizza(String orderType) {
		System.out.println("~使用的是抽象工厂模式~");
		Pizza pizza = null;
		if (orderType.equals("cheese")) {
			pizza = new LDCheesePizza();
		} else if (orderType.equals("pepper")) {
			pizza = new LDPepperPizza();
		}
		return pizza;
	}

}

orderPizza:

public class OrderPizza {

	AbsFactory factory;

	// 构造器
	public OrderPizza(AbsFactory factory) {
		setFactory(factory);
	}

	private void setFactory(AbsFactory factory) {
		Pizza pizza = null;
		String orderType = ""; // 用户输入
		this.factory = factory;
		do {
			orderType = getType();
			// factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
			pizza = factory.createPizza(orderType);
			if (pizza != null) { // 订购ok
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			} else {
				System.out.println("订购失败");
				break;
			}
		} while (true);
	}

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

pizzaStore:

public class PizzaStore {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//new OrderPizza(new BJFactory());
		new OrderPizza(new LDFactory());
	}

}

工厂模式小结

1) 工厂模式的意义

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的

依赖关系的解耦。从而提高项目的扩展和维护性。

2) 三种工厂模式 ( 简单工厂模式、工厂方法模式、抽象工厂模式 )

3) 设计模式的 依赖抽象 原则

· 创建对象实例时，不要直接 new 类 , 而是把这个 new 类的动作放在一个工厂的方法

中，并返回。有的书上说，变量不要直接持有具体类的引用。

· 不要让类继承具体类，而是继承抽象类或者是实现 interface( 接口 )

· 不要覆盖基类中已经实现的方法

需要沉淀沉淀

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java设计模式--工厂设计模式

看一个具体的需求看一个披萨的项目：要便于披萨种类的扩展，要便于维护 1) 披萨的种类很多(比如 GreekPizz、CheesePizz 等) 2) 披萨的制作有 prepare，bake, cut, box 3) 完成披萨店订购功能。传统的实现方式代码:public abstract class pizza { private String name;...
复制链接

扫一扫

专栏目录