JAVA的设计模式大体上分为三大类:
创建型模式(5种):工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式。
结构型模式(7种):适配器模式,装饰器模式,代理模式,外观模式,桥接模式,组合模式,享元模式。
行为型模式(11种):策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
设计模式遵循的原则有6个:
1、开闭原则(Open Close Principle)
对扩展开放,对修改关闭。
2、里氏代换原则(Liskov Substitution Principle)
只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。
3、依赖倒转原则(Dependence Inversion Principle)
这个是开闭原则的基础,对接口编程,依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)
使用多个隔离的借口来降低耦合度。
5、迪米特法则(最少知道原则)(Demeter Principle)
一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)
原则是尽量使用合成/聚合的方式,而不是使用继承。继承实际上破坏了类的封装性,超类的方法可能会被子类修改。
今天首先要介绍的就是简单工厂模式(以实现一个简单计算功能为例)。
做法一:
package com.wmy.designpattern.FactoryMethodPattern;
/**
* 简单工厂模式
*/
public class Operation {
/**
* @Description:
* 使用此种方法时,如果后面还需要加一个运算方法就需要把之前的在编译一次,
* 还很有可能在修改的过程中影响到之前的运算方法。
* @Param: numberA
* @Param: numberB
* @Param: operate
* @return: Double
* @Author: wmy
* @Date: 2019/10/7 9:00
*/
public static Double GetResult(Double numberA, Double numberB, String operate) {
Double result = 0d;
switch (operate) {
case "+":
result = numberA + numberB;
break;
case "-":
result = numberA - numberB;
break;
case "*":
result = numberA * numberB;
break;
case "/":
result = numberA / numberB;
break;
}
return result;
}
public static void main(String[] args) {
double res = GetResult(2d, 6d, "-");
System.out.println("结果是:" + res);
}
}
这种方法我们只使用了面向对象三大特性中的封装。如果使用这种方法,我们在增加一个新的运算就需要在Operation类中进行修改并让其他的运算都要在编译一次,也很可能会导致其他功能变化。
做法二:
我们先创建一个运算类
package com.wmy.designpattern.FactoryMethodPattern;
import lombok.Data;
/**
* @program: 单独定义一个运算类,在针对不容的操作类型定义不同的操作类,
* 这样实现了松耦合,各个操作之间互不影响
* @description: 运算类
* @author: wmy
* @create: 2019-10-07 09:09
**/
@Data
public class Operate {
private Double numberA = 0d;
private Double numberB = 0d;
private Double result = 0d;
// 定义一个对外开发的获取运算结果的方法
public Double getResult() {
return this.result;
}
}
在分别创建加减乘除类
package com.wmy.designpattern.FactoryMethodPattern;
/**
* @program: 继承父类 Operate ,重写父类中的getResult()实现具体的计算规则
* @description: 加法操作
* @author: wmy
* @create: 2019-10-07 09:14
**/
public class OperateAdd extends Operate {
/**
* @Description: 重写获取结果方法,对每种操作类型进行不同结果计算
* @return: Double
* @Author: wmy
* @Date: 2019/10/7 9:20
*/
@Override
public Double getResult() {
return getNumberA() + getNumberB();
}
}
package com.wmy.designpattern.FactoryMethodPattern;
/**
* @program: design pattern
* @description: 减法操作
* @author: wmy
* @create: 2019-10-07 09:17
**/
public class OperateSub extends Operate {
@Override
public Double getResult() {
return getNumberA() - getNumberB();
}
}
package com.wmy.designpattern.FactoryMethodPattern;
/**
* @program: design pattern
* @description: 乘法操作
* @author: wmy
* @create: 2019-10-07 09:18
**/
public class OperateMul extends Operate {
@Override
public Double getResult() {
return getNumberA() * getNumberB();
}
}
package com.wmy.designpattern.FactoryMethodPattern;
/**
* @program: design pattern
* @description: 除法操作
* @author: wmy
* @create: 2019-10-07 09:19
**/
public class OperateDiv extends Operate {
@Override
public Double getResult() {
if (getNumberB()==0)
throw new IllegalArgumentException("除数不能为0");
return getNumberA() / getNumberB();
}
}
创建以上几个类之后,现在我们只需要关注如何来实例化这些对象,
这就需要我们来创建一个简单工厂运算类来实现这个实例化过程
package com.wmy.designpattern.FactoryMethodPattern;
/**
* @program: design pattern
* @description: 简单运算工厂类
* @author: wmy
* @create: 2019-10-07 09:23
**/
public class OperateFactory {
/**
* @Description: 现在是需要根据运算符实例化对应的对象,通过多态返回父类的方式获取计算结果
* 就算后面要增加其他的运算只需要增加相应的计算类在继承Operate父类就可以,不会影响其他的程序
* @Param: operate
* @return: Operate
* @Author: wmy
* @Date: 2019/10/7 9:26
*/
public static Operate createOperate(String operate) {
Operate oper = null;
switch (operate) {
case "+":
oper = new OperateAdd();
break;
case "-":
oper = new OperateSub();
break;
case "*":
oper = new OperateMul();
break;
case "/":
oper = new OperateDiv();
break;
}
return oper;
}
public static void main(String[] args) {
// 我们只需要根据运算符号,工厂就会实例化对应的对象,通过多态返回
// 父类的方式实现计算结果
Operate operate = createOperate("*");
operate.setNumberA(2d);
operate.setNumberB(7d);
System.out.println(operate.getResult());
}
}
通过以上的方式,即使我们后面需要修改计算规则只需要在对应的操作类中进行修改,互不影响。
对于简单工厂模式就介绍到这里,下期分享《二十三种设计模式之策略模式》