摘要
背景
开发面临哪些问题（痛点）？
代码需具备哪些特性（需求）？
tips：如何学习设计模式？
总体原则
单一职责
开放-封闭原则
依赖倒置原则
里氏替换原则
tips：实现总体原则的方法论：24个设计模式
23 种设计模式详解（全23种） - 知乎
简单工厂模式
需求举例
分析
Java实现
抽象操作符父类
public abstract class Operation {
private double numberA = 0;
private double numberB = 0;
/**省略get和set方法*/
public double getResult(){
return 0;
}
}加法子类
public class AddOperation extends Operation{
@Override
public double getResult(){
return super.getNumberA() + super.getNumberB();
}
}简单工厂类
public class OperationFactory {
public static Operation createOperation(String opr){
Operation operation = null;
switch (opr){
case "+":
operation = new AddOperation();
break;
default:
}
return operation;
}
}客户端调用
public static void main(String[]args){
Operation opr ;
opr = OperationFactory.createOperation("+");
opr.setNumberA(1);
opr.setNumberB(2);
System.out.println(opr.getResult());
}扩展新功能
扩展减法子类
public class SubOperation extends Operation{
@Override
public double getResult(){
return super.getNumberA() - super.getNumberB();
}
}修改简单工厂类
public static Operation createOperation(String opr){
Operation operation = null;
switch (opr){
case "+":
operation = new AddOperation();
break;
case "-"://添加减法类
operation = new SubOperation();
break;
default:
}
return operation;
}存在的问题？
策略模式
Java实现
策略接口
public interface IStrategy {
double algorithm(double money);
}业务策略1
public class CashReturn implements IStrategy{
private double moneyCondition = 0.d;
private double moneyReturn = 0.d;
public CashReturn(double moneyCondition,double moneyReturn){
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
@Override
public double algorithm(double money) {
if(money > moneyCondition){
return money - Math.floor( money/moneyCondition) * moneyReturn;
}
return money;
}
}业务策略2
public class CashRebate implements IStrategy{
private double rebate = 1d;
public CashRebate(double rebate){
this.rebate = rebate;
}
@Override
public double algorithm(double money) {
return money*rebate;
}
}策略上下文类
public class CashContext {
IStrategy strategy;
public CashContext(String type){
switch (type){
case "discount":
strategy = new CashRebate(0.8);
break;
case "return":
strategy = new CashReturn(200,30);
break;
default:
}
}
public double getResult(double money){
return strategy.algorithm(money);
}
}client调用
public static void main(String[]args){
double inputMoney = 100;
String type = "discount";
//1.简单工厂方法：类型为参数通过工厂方法返回不同计算对象，对象计算最终值。
//client需要使用工厂类 + 不同计算类
//2.类型作为参数，通过上下文对象，直接获取最终值。将不同计算对象封装入上下文对象。
//client只需要使用上下文类。
double outputMoney = new CashContext(type).getResult(inputMoney);
System.out.println(outputMoney);
}简单工厂和策略模式区别
工厂方法模式
需求举例
Java实现
操作符父类
public abstract class IOperation {
public double numA = 0;
public double numB = 0;
abstract double getResult();
}加法子类
public class AddOperation extends IOperation{
public AddOperation(double numA,double numB){
super.numA = numA;
super.numB = numB;
}
@Override
public double getResult() {
return numA + numB;
}
}
工厂方法接口
public interface IFactory {
IOperation createOperation(double numA,double numB);
}加法工厂子类
public class AddFactory implements IFactory{
@Override
public IOperation createOperation(double numA,double numB) {
return new AddOperation(numA,numB);
}
}客户端调用
public static void main(String[]args){
IOperation opr = new AddFactory().createOperation(1,3);
System.out.println(opr.getResult());
}扩展新功能
减法子类
public class SubOperation extends IOperation{
public SubOperation(double numA,double numB){
super.numA = numA;
super.numB = numB;
}
@Override
public double getResult() {
return numA - numB;
}
}减法工厂子类
public class SubFactory implements IFactory{
@Override
public IOperation createOperation(double numA,double numB) {
return new SubOperation(numA,numB);
}
}优缺点
满足开放封闭原则
业务扩展产生过多工厂子类
简单工厂与工厂方法区别
抽象工厂模式
需求举例
分析
Java实现
user、department接口和实现
//接口定义
public interface IUserService {
User getUser();
}
//Access实现
public class AccessUser implements IUserService {
@Override
public User getUser() {
System.out.println("访问access get user");
return null;
}
}
//Sqlserver实现
public class SqlserverUser implements IUserService {
@Override
public User getUser() {
System.out.println("访问Sqlserver get user");
return null;
}
}//接口定义
public interface IDepartmentService {
Department getDepartment();
}
//Access实现
public class AccessDepartment implements IDepartmentService {
@Override
public Department getDepartment() {
System.out.println("访问access get department");
return null;
}
}
//Sqlserver实现
public class SqlserverDepartment implements IDepartmentService {
@Override
public Department getDepartment() {
System.out.println("访问Sqlserver get department");
return null;
}
}优化简单工厂类
public class DataAccessFactory {
//根据变量的值，选择Access或Sqlserver方式访问数据库。该值可以写入配置文件中，更加方便
String dbAccessMethod = "test.factory.abstfactory.impl.access.";
public IUserService createUserService() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
String className =dbAccessMethod + "AccessUser";
Class clazz = Class.forName(className);
return (IUserService) clazz.getDeclaredConstructor().newInstance();
}
public IDepartmentService creteDeparmentService() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
String className =dbAccessMethod + "AccessDepartment";
Class clazz = Class.forName(className);
return (IDepartmentService) clazz.getDeclaredConstructor().newInstance();
}
}client调用
public static void main(String[]args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
DataAccessFactory dataAccess = new DataAccessFactory();
IUserService userService = dataAccess.createUserService();
userService.getUser();
IDepartmentService departmentService = dataAccess.creteDeparmentService();
departmentService.getDepartment();
}优缺点
抽象工厂总结
觉得不错，点个👍吧，(*^▽^*)
