架构师训练营 第三周 学习心得

发布于: 2020 年 06 月 24 日
架构师训练营 第三周 学习心得

一,设计模式的定义

1. 什么是设计模式

  • 每种模式都描述了一种问题的通用的解决方案.这种问题在我们的环境中,反复的出现。

  • 设计模式是一种可重复的解决方案。

2. 一个设计模式的四个部分

  • 模式名称: 由少量的字组成,有助于表达我们的设计。

  • 待解决问题: 描述哪些场景需要使用这种设计模式,以及运用模式的环境(上下文)。

  • 解决方案: 描述解决问题的元素(类和对象),他们的关系,职责及合作,这种解决方案是抽象的,他不代表具体的实现。

  • 结论: 运用这种方案所带来的利和弊。主要指它对系统的弹性,扩展性和可移植性的影响。

3. 设计模式的分类

从功能分

  • 创建模式: 对类实例化过程的抽象。

  • 结构模式: 将类或者对象结合在一起形成更大的结构。

  • 行为模式: 对在不同的对象之间划分责任和算法的抽象化。

从方式分

  • 类模式 以集成的方式实现模式,静态的。

  • 对象模式 以组合的方式实现模式,动态的。

二,几种设计模式的说明

1. 简单工厂

定义

提供一个创建对象实例的功能,而无需关系其具体实现,被创建实例的类型可以是接口、抽象类,也可以是具体的类。

类图

示例

运算抽象类
public abstract class AbstractOperation {
/**
* 返回运算结果
* @param num1
* @param num2
* @return
*/
public abstract double getResult(double num1, double num2);
}
加法
public class AddOperation extends AbstractOperation {
/**
* 加法运算
* @return
*/
@Override
public double getResult(double num1, double num2) {
return num1 + num2;
}
}
减法
public class SubOperation extends AbstractOperation {
/**
* 减法
* @return
*/
@Override
public double getResult(double num1, double num2) {
return num1 - num2;
}
}
乘法
public class MulOperation extends AbstractOperation {
/**
* 乘法
* @return
*/
@Override
public double getResult(double num1, double num2) {
return num1 * num2;
}
}
除法
public class DivOperation extends AbstractOperation {
/**
* 除法
* @return
*/
@Override
public double getResult(double num1, double num2) {
if (num2==0) {
System.out.println("除数不能为0");
return 0;
}
return num1/num2;
}
}
工厂策略方法
public class OperationFactory {
AbstractOperation operation = null;
/**
* 工厂策略模式
*
* @param type
*/
public OperationFactory(String type) {
// 判断并且确认将返回的对象
switch (type) {
case "+":
operation = new AddOperation();
break;
case "-":
operation = new SubOperation();
break;
case "*":
operation = new MulOperation();
break;
case "/":
operation = new DivOperation();
break;
default:
break;
}
}
/**
* 获取结果
* @param num1
* @param num2
* @return
*/
public double getResult(double num1, double num2) {
return operation.getResult(num1, num2);
}
}
客户端调用
public class Client {
public static void main(String[] args) {
OperationFactory con = new OperationFactory("+");
// OperationFactory con = new OperationFactory("-");
// OperationFactory con = new OperationFactory("*");
// OperationFactory con = new OperationFactory("/");
Double result = con.getResult(6.5D, 4.12D);
System.out.print(result);
}
}

2. 单例模式

定义

负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。

类图

单例模式的几种方式

懒汉模式
public class Lazy {
private static Lazy instance;
private Lazy (){}
public static synchronized Lazy getInstance() {
if (instance == null) {
instance = new Lazy();
}
return instance;
}
}
饿汉模式
public class Hungry {
private static Hungry instance = new Hungry();
private Hungry (){}
public static Hungry getInstance() {
return instance;
}
}
双重锁模式
public class DoubleCheckedLock {
private volatile static DoubleCheckedLock singleton;
private DoubleCheckedLock (){}
public static DoubleCheckedLock getSingleton() {
if (singleton == null) {
synchronized (DoubleCheckedLock.class) {
if (singleton == null) {
singleton = new DoubleCheckedLock();
}
}
}
return singleton;
}
}
静态内部类单例模式
public class StaticInternal {
private static class SingletonHolder {
private static final StaticInternal INSTANCE = new StaticInternal();
}
private StaticInternal (){}
public static final StaticInternal getInstance() {
return SingletonHolder.INSTANCE;
}
}
枚举单例模式
public enum EnumSingleton {
INSTANCE;
public static EnumSingleton getInstance() {
return EnumSingleton.INSTANCE;
}
}

3. 模板方法

定义

模板方法模式,定义一个操作中的算法骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

类图

示例

抽象模板
public abstract class AbstractTemplate {
public abstract void operation1();
public abstract void operation2();
/**
* 模板方法,给出了逻辑的骨架
* 而逻辑的组成是一些相应的抽象操作** 他们都推迟到子类实现
*/
public void templateMethod() {
operation1();
operation2();
System.out.println("");
}
}
模板A
public class TemplateA extends AbstractTemplate {
@Override
public void operation1() {
System.out.println("模板A方法1实现");
}
@Override
public void operation2() {
System.out.println("模板A方法2实现");
}
}
模板B
public class TemplateB extends AbstractTemplate {
@Override
public void operation1() {
System.out.println("模板B方法1实现");
}
@Override
public void operation2() {
System.out.println("模板B方法2实现");
}
}
调用
public class Client {
public static void main(String[] args) {
AbstractTemplate c;
c = new TemplateA();
c.templateMethod();
c = new TemplateB();
c.templateMethod();
}
}

4. 组合模式

定义

组合模式允许你将对象组合成树形结构来表现”部分-整体“的层次结构,使得客户以一致的方式处理单个对象以及对象的组合。

组合模式实现的最关键的地方是——简单对象和复合对象必须实现相同的接口。这就是组合模式能够将组合对象和简单对象进行一致处理的原因。

类图

  • 组合部件(Component):它是一个抽象角色,为要组合的对象提供统一的接口。

  • 叶子(Leaf):在组合中表示子节点对象,叶子节点不能有子节点。

  • 合成部件(Composite):定义有枝节点的行为,用来存储部件,实现在Component接口中的有关操作,如增加(Add)和删除(Remove)。

示例

Component 抽象组件
public abstract class Component {
public void add(Component child) {
throw new UnsupportedOperationException("对象不支持此功能");
}
public void remove(Component child) {
throw new UnsupportedOperationException("对象不支持此功能");
}
public Component getChildren(int index) {
// 缺省的实现,抛出异常,因为叶子对象没有这个功能,或子类未实现这个功能
throw new UnsupportedOperationException("对象不支持此功能");
}
/**
* 打印组件
*/
public abstract void printComponent();
}
节点组件 Node
public class Node extends Component{
/**
* windows
*/
private String name;
/**
* 登录框
*/
private List<Component> children;
public Node(String name) {
this.name = name;
this.children = new ArrayList<>();
}
/**
* 添加 form 组件
*
* @param component
*/
@Override
public void add(Component component) {
children.add(component);
}
/**
* 移除 form 组件
* @param component
*/
@Override
public void remove(Component component) {
children.remove(component);
}
/**
* 打印组件
*
*/
@Override
public void printComponent() {
// 打印自己
System.out.println(name);
// 打印子组件
if (children.size() > 0) {
for (Component component: children) {
component.printComponent();
}
}
}
}
子组件 Child
public class Child extends Component {
private String name;
public Child(String name){
this.name = name;
}
/**
*
*/
@Override
public void printComponent() {
System.out.println(name);
}
}
调用 Client
public class Client {
public static void main(String[] args) {
Node root = new Node("window窗口");
Node frame = new Node("FRAME1");
root.add(new Child("登录"));
root.add(new Child("注册"));
root.add(new Child("LOGO图片"));
root.add(frame);
frame.add(new Child("用户名Lable"));
frame.add(new Child("用户名TextBox"));
frame.add(new Child("密码Lable"));
frame.add(new Child("密码TextBox"));
frame.add(new Child("复选框Checkbox"));
frame.add(new Child("记住用户名Lable"));
frame.add(new Child("忘记密码LinkLable"));
root.printComponent();
}
}

5. 装饰器模式

定义

允许向一个现有的对象添加新的功能,同时又不改变其结构。这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装

类图

  • Component(抽象构件):它是装饰类和具体构件的公共父类(一般是接口或者抽象类);

  • ConcreteComponent(具体构件):具它是抽象构件对象的子类,用来定义具体的构件对象(Component的子类或者具体实现);

  • Decorator(抽象装饰类):进继承抽象构件,用于给具体的构件添加一些新的职责(一般是一个继承了Component的接口);

  • ConcreteDecoraror(具体装饰类):实现了抽象装饰类,它负责向构件添加新的职责;

示例

奶茶抽象组件接口
public interface MilkyTea {
/**
* 奶茶制作接口
*/
public void recipe();
}
奶茶实现组件类
public class BubbleTea implements MilkyTea {
@Override
public void recipe() {
System.out.print("一杯珍珠奶茶");
}
}
装饰抽象类
public class Decorator implements MilkyTea {
private MilkyTea milkyTea;
public void setMilkyTea(MilkyTea milkyTea) {
this.milkyTea = milkyTea;
}
@Override
public void recipe() {
milkyTea.recipe();
}
}
珍珠配料装饰类
public class BubbleIngredients extends Decorator {
@Override
public void recipe() {
super.recipe();
//对现有类进行功能增强
addBubble();
}
/**
* 加红豆
*/
public void addBubble() {
System.out.print("... 加珍珠");
}
}
红豆配料装饰类
public class RedBeanIngredients extends Decorator {
@Override
public void recipe() {
super.recipe();
//对现有类进行功能增强
addRedBean();
}
/**
* 加红豆
*/
public void addRedBean() {
System.out.print("... 加红豆");
}
}
调用
public class Client {
public static void main(String[] args) {
// 创建一杯奶茶
MilkyTea tea = new BubbleTea();
// 配料 红豆
RedBeanIngredients redBean = new RedBeanIngredients();
// 配料 珍珠
BubbleIngredients bubble = new BubbleIngredients();
// 加红豆
redBean.setMilkyTea(tea);
// 加珍珠
bubble.setMilkyTea(redBean);
// 制作
bubble.recipe();
}
}

发布于: 2020 年 06 月 24 日 阅读数: 10
用户头像

李君

关注

结硬寨,打呆仗。 2018.09.11 加入

还未添加个人简介

评论

发布
暂无评论
架构师训练营 第三周 学习心得