三种工厂模式
简单工厂模式代码实现
工厂方法模式代码实现
抽象工厂模式代码实现
简单工厂模式
基本介绍
1) 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一
个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族
中最简单实用的模式
2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行
为
(代码
)
3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会
使用到工厂模式
优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景：
1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，
"POP3"、
"IMAP"、
"HTTP"，可以把这三个作为产品类，共同实现一个接口。
注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
代码实现
package factory
.simplefactory
.pizzastore
.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
;
}
}
package factory
.simplefactory
.pizzastore
.pizza
;
public class PepperPizza extends Pizza {
@Override
public void prepare() {
System
.out
.println(" 给胡椒披萨准备原材料 ");
}
}
package factory
.simplefactory
.pizzastore
.pizza
;
public class GreekPizza extends Pizza {
@Override
public void prepare() {
System
.out
.println(" 给希腊披萨 准备原材料 ");
}
}
package factory
.simplefactory
.pizzastore
.pizza
;
public class CheesePizza extends Pizza {
@Override
public void prepare() {
System
.out
.println(" 给制作奶酪披萨 准备原材料 ");
}
}
package factory
.simplefactory
.pizzastore
.order
;
import factory
.simplefactory
.pizzastore
.pizza
.CheesePizza
;
import factory
.simplefactory
.pizzastore
.pizza
.GreekPizza
;
import factory
.simplefactory
.pizzastore
.pizza
.PepperPizza
;
import factory
.simplefactory
.pizzastore
.pizza
.Pizza
;
public class SimpleFactory {
public Pizza
createPizza(String orderType
) {
Pizza pizza
= null
;
System
.out
.println("使用简单工厂模式");
if (orderType
.equals("greek")) {
pizza
= new GreekPizza();
pizza
.setName(" 希腊披萨 ");
} else if (orderType
.equals("cheese")) {
pizza
= new CheesePizza();
pizza
.setName(" 奶酪披萨 ");
} else if (orderType
.equals("pepper")) {
pizza
= new PepperPizza();
pizza
.setName("胡椒披萨");
}
return pizza
;
}
public static Pizza
createPizza2(String orderType
) {
Pizza pizza
= null
;
System
.out
.println("使用简单工厂模式2");
if (orderType
.equals("greek")) {
pizza
= new GreekPizza();
pizza
.setName(" 希腊披萨 ");
} else if (orderType
.equals("cheese")) {
pizza
= new CheesePizza();
pizza
.setName(" 奶酪披萨 ");
} else if (orderType
.equals("pepper")) {
pizza
= new PepperPizza();
pizza
.setName("胡椒披萨");
}
return pizza
;
}
}
package factory
.simplefactory
.pizzastore
.order
;
public class PizzaStore {
public static void main(String
[] args
) {
new OrderPizza2();
}
}
package factory
.simplefactory
.pizzastore
.order
;
import factory
.simplefactory
.pizzastore
.pizza
.Pizza
;
import java
.io
.BufferedReader
;
import java
.io
.IOException
;
import java
.io
.InputStreamReader
;
public class OrderPizza2 {
Pizza pizza
= null
;
public OrderPizza2() {
do {
pizza
= SimpleFactory
.createPizza2(getType());
if (pizza
!= null
) {
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 "";
}
}
}
package factory
.simplefactory
.pizzastore
.order
;
import factory
.simplefactory
.pizzastore
.pizza
.Pizza
;
import java
.util
.Scanner
;
public class OrderPizza {
Pizza pizza
= null
;
public OrderPizza(SimpleFactory simpleFactory
){
setFactory(simpleFactory
);
}
public void setFactory(SimpleFactory simpleFactory
){
do {
pizza
= simpleFactory
.createPizza(getType());
if(pizza
!= null
) {
pizza
.prepare();
pizza
.bake();
pizza
.cut();
pizza
.box();
} else {
System
.out
.println(" 订购披萨失败 ");
break;
}
}while (true);
}
private String
getType() {
try {
Scanner scanner
= new Scanner(System
.in
);
System
.out
.println("input pizza的类型为:");
String str
= scanner
.nextLine();
return str
;
} catch (Exception e
) {
e
.printStackTrace();
return "";
}
}
}
工厂方法模式
工厂方法模式介绍
工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点
餐子类中具体实现。
工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方
法模式将对象的实例化推迟到子类
代码实现
package factory
.factorymethod
.pizzastore
.order
;
import factory
.factorymethod
.pizzastore
.pizza
.BJCheesePizza
;
import factory
.factorymethod
.pizzastore
.pizza
.BJPepperPizza
;
import factory
.factorymethod
.pizzastore
.pizza
.Pizza
;
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();
}else{
pizza
= null
;
}
return pizza
;
}
}
package factory
.factorymethod
.pizzastore
.order
;
import factory
.factorymethod
.pizzastore
.pizza
.LDCheesePizza
;
import factory
.factorymethod
.pizzastore
.pizza
.LDPepperPizza
;
import factory
.factorymethod
.pizzastore
.pizza
.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();
}
return pizza
;
}
}
package factory
.factorymethod
.pizzastore
.order
;
import factory
.factorymethod
.pizzastore
.pizza
.Pizza
;
import java
.io
.BufferedReader
;
import java
.io
.IOException
;
import java
.io
.InputStreamReader
;
public abstract class OrderPizza {
abstract Pizza
createPizza(String orderType
);
public OrderPizza() {
Pizza pizza
= null
;
do {
pizza
= createPizza(getType());
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 "";
}
}
}
package factory
.factorymethod
.pizzastore
.order
;
public class PizzaStore {
public static void main(String
[] args
) {
String loc
= "bj";
if (loc
.equals("bj")) {
new BJOrderPizza();
} else {
new LDOrderPizza();
}
}
}
抽象工厂模式
基本介绍
1) 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需
指明具体的类
2) 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3) 从设计层面看，抽象工厂模式就是对简单工厂模式的改进
(或者称为进一步的抽象
)。
4) 将工厂抽象成两层，
AbsFactory(抽象工厂
) 和 具体实现的工厂子类。程序员可以
根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，
更利于代码的维护和扩展。
优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
使用场景：
1、QQ 换皮肤，一整套一起换。
2、生成不同操作系统的程序。
注意事项：产品族难扩展，产品等级易扩展。
代码实现
package factory
.absfactory
.pizzastore
.order
;
import factory
.absfactory
.pizzastore
.pizza
.Pizza
;
public interface AbsFactory {
public Pizza
createPizza(String orderType
);
}
package factory
.absfactory
.pizzastore
.order
;
public class PizzaStore {
public static void main(String
[] args
) {
new OrderPizza(new LDFactory());
}
}
package factory
.absfactory
.pizzastore
.order
;
import factory
.absfactory
.pizzastore
.pizza
.Pizza
;
import java
.io
.BufferedReader
;
import java
.io
.IOException
;
import java
.io
.InputStreamReader
;
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();
pizza
= factory
.createPizza(orderType
);
if (pizza
!= null
) {
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 "";
}
}
}
package factory
.absfactory
.pizzastore
.order
;
import factory
.absfactory
.pizzastore
.pizza
.LDCheesePizza
;
import factory
.absfactory
.pizzastore
.pizza
.LDPepperPizza
;
import factory
.absfactory
.pizzastore
.pizza
.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
;
}
}
package factory
.absfactory
.pizzastore
.order
;
import factory
.absfactory
.pizzastore
.pizza
.BJCheesePizza
;
import factory
.absfactory
.pizzastore
.pizza
.BJPepperPizza
;
import factory
.absfactory
.pizzastore
.pizza
.Pizza
;
public class BJFactory implements AbsFactory {
@Override
public Pizza
createPizza(String orderType
) {
System
.out
.println("~使用的是抽象工厂模式~");
Pizza pizza
= null
;
if(orderType
.equals("cheese")) {
pizza
= new BJCheesePizza();
} else if (orderType
.equals("pepper")){
pizza
= new BJPepperPizza();
}
return pizza
;
}
}
