目录
一、问题需求
需求:完成对披萨种类的扩展,便于维护。
1、披萨的种类
2、披萨制作的步骤
3、披萨店的订购功能
示例参考代码:
//将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 GreekPizza extends Pizza {
@Override
public void prepare() {
System.out.println("准备制作希腊披萨的原材料");
}
}
public class CheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("准备制作奶酪披萨的原材料");
}
}
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class OrderPizza {
//订购披萨的类型
public OrderPizza() {
Pizza pizza = null;
String orderType;
do {
orderType = getType();
if (orderType.equals("greek")){
pizza = new GreekPizza();
pizza.setName("希腊披萨");
} else if (orderType.equals("cheese")){
pizza = new CheesePizza();
pizza.setName("奶酪披萨");
} else {
break;
}
//打印披萨制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} while (true);
}
public String getType(){
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要订购的披萨:");
String str = bufferedReader.readLine();
return str;
}catch (Exception e){
e.printStackTrace();
return "";
}
}
}
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza();
}
}
上述代码分析:
1、简单、好操作、容易理解
2、违反了设计模式的ocp原则,对扩展开放,对修改关闭,当给类增加新功能的时候,尽量不修改代码。
3、使用简单工厂模式把创建Pizza对象封装到一个类中,这样我们就有新的Pizza种类时,只需要修改该类就行,其它创建到Pizza对象的代码就不需要修改。
二、工厂模式
2.1、简单工厂模式
1、简单工厂模式是属于创建型模式,是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
2、简单工厂模式:定义了一个创建对象的类,由这个类来封装实例化对象的行为。
3、当在开发中会大量的创建某种、某类或者某批对象时,就会使用到工厂模式。
示例参考代码:
//简单工厂模式
public class SimpleFactory {
private Pizza pizza;
public Pizza createPizza(String orderType){
pizza = null;
if (orderType.equals("greek")){
pizza = new GreekPizza();
pizza.setName("希腊披萨");
} else if (orderType.equals("cheese")){
pizza = new CheesePizza();
pizza.setName("奶酪披萨");
}
return pizza;
}
}
public class OrderPizza {
private SimpleFactory simpleFactory;
private Pizza pizza;
//构造器
public OrderPizza(SimpleFactory simpleFactory) {
setSimpleFactory(simpleFactory);
}
public void setSimpleFactory(SimpleFactory simpleFactory) {
this.simpleFactory = simpleFactory; //设置简单工厂对象
do {
String orderType = "";
orderType = getType();
pizza = this.simpleFactory.createPizza(orderType);
if (pizza != null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
break;
}
}while (true);
}
//用户输入要订购的披萨
public String getType(){
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要订购的披萨:");
String str = bufferedReader.readLine();
return str;
}catch (Exception e){
e.printStackTrace();
return "";
}
}
}
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza(new SimpleFactory());
}
}
简单工厂模式又称静态工厂模式
示例参考代码:
//静态工厂模式
public class SimpleFactory {
public static Pizza createPizza(String orderType){
Pizza pizza = null;
if (orderType.equals("greek")){
pizza = new GreekPizza();
pizza.setName("希腊披萨");
} else if (orderType.equals("cheese")){
pizza = new CheesePizza();
pizza.setName("奶酪披萨");
}
return pizza;
}
}
public class OrderPizza {
private Pizza pizza;
//构造器
public OrderPizza() {
do {
String orderType = "";
orderType = getType();
pizza = SimpleFactory.createPizza(orderType);
if (pizza != null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
break;
}
}while (true);
}
//用户输入要订购的披萨
public String getType(){
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要订购的披萨:");
String str = bufferedReader.readLine();
return str;
}catch (Exception e){
e.printStackTrace();
return "";
}
}
}
2.2、工厂方法模式
需求:客户在点披萨时,可以点不同口味的披萨,如北京的芝士披萨,南京的奥尔良披萨等。
问题:使用简单工厂模式,创建不同的简单工厂类,但是不利于软件的可维护性、可扩展性。
解决方案:将项目的实例化功能抽象成抽象方法,在不同的点餐中由子类实现。
工厂方法模式:定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
示例参考代码:
public abstract class OrderPizza {
private Pizza pizza;
//构造器
public OrderPizza() {
String orderType = "";
do {
orderType = getType();
pizza = createPizza(orderType); //由工厂子类来完成
if (pizza != null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
break;
}
}while (true);
}
//定义一个抽象方法,由各个工厂子类来实现。
abstract Pizza createPizza(String orderType);
//用户输入要订购的披萨
public String getType(){
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要订购的披萨:");
String str = bufferedReader.readLine();
return str;
}catch (Exception e){
e.printStackTrace();
return "";
}
}
}
public class CDCheesePizza extends Pizza {
@Override
public void prepare() {
setName("成都奶酪披萨");
System.out.println("准备成都的奶酪披萨原材料");
}
}
public class CDPepperPizza extends Pizza {
@Override
public void prepare() {
setName("成都pepper披萨");
System.out.println("准备杭州的pepper披萨原材料");
}
}
public class CDOrderPizza extends OrderPizza {
@Override
Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new CDCheesePizza();
} else if (orderType.equals("pepper")){
pizza = new CDPepperPizza();
}
return pizza;
}
}
public class PizzaStore {
public static void main(String[] args) {
new CDOrderPizza();
}
}
2.3、抽象工厂模式
1、定义一个接口用于创建相关或有依赖关系的对象簇,而无需指明具体的类。
2、抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3、从设计层面看,抽象工厂模式就是对简单工厂模式的改进。
4、将工厂抽象成两层,AbsFactory(抽象工厂)和具体实现的工厂子类,我们可以根据创建对象类型使用对应的工厂子类。将单个的简单工厂类变为工厂簇,便于代码的维护和扩展。
示例参考代码:
//抽象工厂模式(抽象层)
public interface AbsFactory {
public Pizza createPizza(String orderType);
}
//工厂子类
public class CDFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new CDCheesePizza();
} else if (orderType.equals("pepper")){
pizza = new CDPepperPizza();
}
return pizza;
}
}
public class OrderPizza {
AbsFactory factory;
public OrderPizza(AbsFactory factory) {
setFactory(factory);
}
private void setFactory(AbsFactory factory) {
Pizza pizza;
String orderType = "";
this.factory = factory;
do {
orderType = getType();
pizza = factory.createPizza(orderType);
if (pizza != null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
} else {
break;
}
}while (true);
}
//用户输入要订购的披萨
public String getType(){
try {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要订购的披萨:");
String str = bufferedReader.readLine();
return str;
}catch (Exception e){
e.printStackTrace();
return "";
}
}
}
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza(new CDFactory());
}
}
五、工厂模式源码分析
在JDK的Calender类:
示例参考代码:
public class Factory {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
System.out.println("calendar.get(Calendar.YEAR) = " + calendar.get(Calendar.YEAR));
System.out.println("calendar.get(Calendar.MONTH) = " + (calendar.get(Calendar.MONTH) + 1));
System.out.println("calendar.get(Calendar.DAY_OF_MONTH) = " + calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("calendar.get(Calendar.HOUR_OF_DAY) = " + calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("calendar.get(Calendar.MINUTE) = " + calendar.get(Calendar.MINUTE));
System.out.println("calendar.get(Calendar.SECOND) = " + calendar.get(Calendar.SECOND));
}
}
第一步:
第二步:
第三步:
六、工厂模式总结
1、工厂模式的意义:将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦,从而提高项目的扩展性和维护性。
2、设计模式依赖抽象的原则
①、创建对象实例时,不要直接new类,而是把这个new类的动作放在一个工厂方法中,并返回,变量不要持有具体类的引用。
②、不要让类继承具体类,而是继承抽象类或者实现接口。
③、不要覆盖基类中已经实现的方法。