工厂模式

}
class LowSeat implements Seat {
@Override
public void massage() {
System.out.println("不能按摩...");
}
}
class LuxurySeat implements Seat {
@Override
public void massage() {
Operator<T> createOperator();
}
工厂实现
/**
*加法运算符工厂
* Created by jifang on15/12/7.
*/
public class AddFactory implements Factory<Integer> {
@Override
public Operator<Integer> createOperator() {
虽然根据理论原则,需要使用工厂方法模式,但实际上,常用的还是静态工厂模式.
抽象工厂模式
抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类.
抽象工厂模式与工厂方法模式的区别:
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构.在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类(如下面的Engine, Tyre, Seat).
@Override
public Operator<Double> createOperator() {
return new SqrtOperator();
}
}
优点
基本与静态工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。
缺点
与静态工厂模式差不多,但是增加了类组织的复杂性;
小结
LuxuryCarFactory与LowCarFactory分别代表一类产品族的两款产品,类似于数据库产品族中有MySQL, Oracle, SqlServer
1.产品
Engine
public interface Engine {
void start();
void run();
}
class LowEngine implements Engine {
SpringIoC容器创建并管理Bean对象;
反射Class对象的newInstance;
….
静态工厂模式
静态工厂模式是工厂模式中最简单的一种，他可以用比较简单的方式隐藏创建对象的细节，一般只需要告诉工厂类所需要的类型，工厂类就会返回需要的产品类，而客户端看到的也只是产品的抽象对象(interface)，因此无需关心到底是返回了哪个子类
工厂模式
工厂模式
用工厂方法代替了new操作,将选择实现类,创建对象统一管理和控制.从而将调用者(Client)与实现类进行解耦.实现了创建者与调用者分离;
使用场景
JDK中Calendar的getInstance方法;
JDBC中Connection对象的获取;
MyBatis中SqlSessionFactory创建SqlSession;
}
}
class LuxuryTyre implementsTyre{
@Override
public void revolve() {
System.out.println("旋转-不磨损...");
我们以运算符类为例,解释静态工厂模式.
Operator接口
/**
*运算符接口
* Created by jifang on15/12/7.
*/
public interface Operator<T> {
T getResult(T... args);
}
实现类
public class AddOperator implements Operator<Integer> {
工厂方法模式
由于静态工厂方法模式不满足OCP,因此就出现了工厂方法模式;工厂方法模式和静态工厂模式最大的不同在于:静态工厂模式只有一个(对于一个项目/独立模块)只有一个工厂类,而工厂方法模式则有一组实现了相同接口的工厂类.
工厂
/**
* Created by jifang on15/12/7.
*/
public interface Factory<T> {
public void testMultiplicationName() {
Operator<Integer> operator = OperatorFactory.createMultiOper();
System.out.println(operator.getResult(1, 2, 3, 4, 6));
}
return operator;
}
/* **第二种实现策略** */
public static Operator<Integer> createAddOper() {
return new AddOperator();
}
public static Operator<Integer> createMultiOper() {
@Override
public void start() {
System.out.println("启动快...");
}
@Override
public void run() {
System.out.println("转速快...");
}
}
Seat
public interface Seat {
void massage();
在抽象工厂模式中，提出了产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族(如Engine, Tyre, Seat)。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构.
示例:
现在我们要生产两款车:高档(LuxuryCar)与低档(LowCar),他们分别配有高端引擎(LuxuryEngine),高端座椅(LuxurySeat),高端轮胎(LuxuryTyre)和低端引擎(LowEngine),低端座椅(LowSeat),低端轮胎(LowTyre),下面我们用抽象工
return new AddOperator();
}
}
/**
*乘法运算符工厂
* Created by jifang on15/12/7.
*/
public class MultiFactory implements Factory<Integer> {
@Override
public Operator<Integer> createOperator() {
@Override
public Integer getResult(Integer... args) {
int result = 1;
for (int arg : args)Байду номын сангаас{
result *= arg;
}
return result;
}
}
工厂
/**
*静态工厂(注:只返回产品的抽象[即接口])
*包含两种实现策略
return new MultiOperator();
}
}
Operator, AddOperator与MultiOperator与上例相同.
此时,如果要在静态工厂中新增加一个开根运算类,要么需要在createOperator方法中增加一种case,要么得增加一个createSqrtOper方法,都是需要修改原来的代码的.而在工厂方法中只需要再添加一个SqrtFactory即可:
System.out.println("可提供按摩...");
}
}
Tyre
public interfaceTyre{
void revolve();
}
class LowTyre implementsTyre{
@Override
public void revolve() {
System.out.println("旋转-不耐磨...");
@Override
public Integer getResult(Integer... args) {
int result = 0;
for (int arg : args) {
result += arg;
}
return result;
}
}
public class MultiOperator implements Operator<Integer> {
}
@Test
public void testMultiplication() {
Operator<Integer> operator = OperatorFactory.createOperator("*");
System.out.println(operator.getResult(1, 2, 3, 4, 6));
}
}
优点
隐藏了对象创建的细节，将产品的实例化过程放到了工厂中实现。
客户端基本不用关心使用的是哪个产品，只需要知道用工厂的那个方法(或传入什么参数)就行了.
方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。
遵循了依赖倒转原则。
缺点
适用于产品子类型差不多,使用的方法名都相同的情况.
每添加一个产品子类，都必须在工厂类中添加一个判断分支(或一个方法)，这违背了OCP(开放-封闭原则)。
return Math.sqrt(args[0]);
} else {
throw new RuntimeException("Params Number Error " + args.length);
}
}
}
/**
*开根工厂
* Created by jifang on15/12/7.
*/
public class SqrtFactory implements Factory<Double> {
return new MultiOperator();
}
}
Client
public class Client {
@Test
public void testAdd() {
Operator<Integer> operator = OperatorFactory.createOperator("+");
System.out.println(operator.getResult(1, 2, 3, 4, 6));
@Override
public void start() {
System.out.println("启动慢...");
}
@Override
public void run() {
System.out.println("转速慢...");
}
}
class LuxuryEngine implements Engine {
Operator<Integer> operator;
switch (operName) {
case "+":
operator = new AddOperator();
break;
case "*":
operator = new MultiOperator();
break;
default:
throw new RuntimeException("Wrong Operator Name: " + operName);
* 1.根据传入的operator名进行实例化对象
* 2.直接调用相应的构造实例的方法
* Created by jifang on15/12/7.
*/
public class OperatorFactory {
public static Operator<Integer> createOperator(String operName) {
}
@Test
public void testAddName(){
Operator<Integer> operator = OperatorFactory.createAddOper();
System.out.println(operator.getResult(1, 2, 3, 4, 6));
}
@Test
/**
*开根运算符
* Created by jifang on15/12/7.
*/
public class SqrtOperator implements Operator<Double> {
@Override
public Double getResult(Double... args) {
if (args != null && args.length >= 1) {