UML关系：
参考资料
注意：箭头指向为被
泛化：类的继承
实现：类实现接口
依赖：表现为局部变量、方法的参数或者对静态方法的调用。
关联：表现为成员变量，地位平等（学生和老师）。可以单向也可以双向仅仅是知道或者不知道的意思
聚合：表现为成员变量，地位为包含关系整体和部分（工厂和工人）
组合：表现为成员变量，地位为强拥有（人和心脏）
它们表现的依赖关系强弱程度不同，这4种关系所表现的强弱程度依次为：组合（Composite） > 聚合（Aggregation） > 关联（Association） > 依赖（Dependency）。
关联关系：每个对象都有自己的生命周期，对象之间不存在从属关系
聚合关系：整体和部分是可以分离的，整体和部分都可以拥有各自的生命周期
组合关系：整体和部分是不可以分离的，整体的生命周期结束时，也意味着部分的生命周期结束。
设计模式
参考资料
创建模式：普通工厂，工厂方法，抽象工厂，单例，建造者，原型
结构模式：适配器，装饰，代理，门面，桥接，享元，组合
行为模式：
传递消息：中介者 观察者(访问订阅模式) 访问者
方法解耦：策略 状态 模版方法 命令
备份：备忘录
遍历：迭代器 责任链
设计模式
类：具有相同属性和功能的抽象的集合
面向对象的三大特性
普通工厂方法感觉为上转型对象的优化实现
好处在于，不要创建的引用的时候区别不同的Sender，而只需要在输入参数的时候修改即可得到不同的Sender
多个工厂方法：普通工厂方法容错性较低，如果传入错误的字符串则无法创建对象
静态工厂方法：将多个工厂方法中创建对象的改为静态实例public static Sender produceMail(){
return new MailSender();
}
抽象工厂类：上述如果扩展程序，需要修改工厂类，破坏封闭性。
而抽象工厂类，扩展程序只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口
单例模式：
1：对于一些大型的对象创建比较复杂，这是一笔很大的系统开销。
2：省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3：有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。
实现方式：
饿汉式：没有懒加载，如果没有用到浪费内存
（容器加载：即在初始化时实例化类，存入到Map中）
// 饿汉式单例
public class Singleton1 {
// 指向自己实例的私有静态引用，主动创建
private static Singleton1 singleton1 = new Singleton1();
// 私有的构造方法
private Singleton1(){}
// 以自己实例为返回值的静态的公有方法，静态工厂方法
public static Singleton1 getSingleton1(){
return singleton1;
}
}
懒汉式：只能单线程
// 懒汉式单例
public class Singleton2 {
// 指向自己实例的私有静态引用
private static Singleton2 singleton2;
// 私有的构造方法
private Singleton2(){}
// 以自己实例为返回值的静态的公有方法，静态工厂方法
public static Singleton2 getSingleton2(){
// 被动创建，在真正需要使用时才去创建
if (singleton2 == null) {
singleton2 = new Singleton2();
}
return singleton2;
}
}
DCL：
public class Singleton {
private static volatile Singleton singleton;
private Singleton() {}
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
三个关键点：
1：构造方法是private，且为空
2：volatile Singleton
3：DCL
建造者模式：创建复合对象（如queue），并且关注复合对象的组合顺序
Director类：起到封装作用，调用Builder的方法
Builder类：抽象类
ConcreteBuilder：抽象类的实现，拥有很多子方法
此时，我们只需要修改Director，就可以得到 按不同顺序调用Builder方法得到的组合对象。
参考资料
原型模式：利用clone产生新对象的模式。
避免调用构造函数，而是利用重写的clone方法用二进制流进行对象的复制
结构型模式
适配器模式
类的适配器模式：想获得一个实现接口A的类B，为了不破坏封装性，创建类C继承B并实现A目的在于获得新的方法
对象的适配器模式：使用继承只能继承一个，而如果想聚合多个对象，需要改成成员变量
接口的适配器模式：有时不想重写接口的所有方法，则利用抽象类实现接口并重写所有方法，则继承类继承抽象类后只用重写需要使用的方法
当需要增加类方法的内容时，根据开闭原则，不能直接修改类，而是需要利用装饰模式或者代理模式
装饰模式
为对象的某个方法增加新的功能：目的在于对某个方法增强功能
代理模式：AOP
和装饰模式类似，区别在于装饰模式的成员变量由外部传入，代理模式成员变量由自己实例化
装饰者模式可以让使用者直观的看到增强了哪些功能（可以知道加了牛奶，奶泡等），而代理模式完全限制了使用者，只去调用代理，至于代理里面增加了什么功能，使用者是不知道，隐藏了一个对象的具体信息
区别在于新类中是否需要传递Sourceable。
对于装饰着模式，用户需要new Source,再将其传入Decorator
对于代理模式，用户直接new Proxy
外观模式：facade zookeeper 类似于提供总开关
slf4j
桥接模式：JDBC，驱动程序。将继承转化为关联，使得二者可以独立变化
例如：5种笔，3种颜色可以组合成15个类
但是如果我们按照下图实现，就只需要8个类
public class BigPen implements Pen(){
public Color color;
public void set(Color color){
this.color=color;
}
}
如果再想，多了4种线条。那么如果用继承的方式，就会有534=60，四，层继承
而如果用关联的方式，就只需要5+3+4=12，二层实现
组合模式：整体与局部（树）
public class TreeNode {
private Vector children = new Vector();
}
享元模式：String常量池，线程池
利用HashMap< key,value>进行存储
第一次对于key1,创建新的key1,value
第二次使用key1,因为HashMap中有，直接从hashMap中获取
共享，string。实现形式通常为HashMap
行为模式
策略模式：系统本身提供不同算法的实现，对各种算法做封装，算法之间可以相互替代（利用多态）。用户只需要决定使用哪种算法即可
计算器：计算器就是环境上下文，ICalculator就是策略角色，±就是具体策略角色
即多态的基本实现
状态模式：当对象的状态改变时，同时改变其行为
QQ的多种状态，在线离线等。正常情况下用if-else语句，过于累赘。改进后context关联一个State引用，并将在线离线等状态抽象为类，继承State
与策略模式的区别：
1：状态模式的状态间往往是具有耦合性的，而策略模式算法簇之间完全解耦。
2：策略模式针对于某个方法，比如痛苦的叫，快乐的叫。而状态模式是针对状态从而导致方法也随之改变(因为痛苦，所以痛苦的叫，痛苦的走)
访问者模式：增加访问者非常容易。
多个被访问对象stuff
客户端:List< stuff>,Visitor vi
访问者visitor
对客户端传入不同的visitor会对stuff执行不同的visitor方法
利用接口回调和方法重载代替if-else
即原始代码：
public class ReportUtil {
public void visit(Staff staff) {
if (staff instanceof Manager) {
Manager manager = (Manager) staff;
System.out.println("经理: " + manager.name + ", KPI: " + manager.kpi +
", 新产品数量: " + manager.getProducts());
} else if (staff instanceof Engineer) {
Engineer engineer = (Engineer) staff;
System.out.println("工程师: " + engineer.name + ", KPI: " + engineer.kpi);
}
}
}
使用访问者模式后：
public class CTOVisitor implements Visitor {
@Override
public void visit(Engineer engineer) {
System.out.println("工程师: " + engineer.name + ", 代码行数: " + engineer.getCodeLines());
}
@Override
public void visit(Manager manager) {
System.out.println("经理: " + manager.name + ", 产品数量: " + manager.getProducts());
}
}
模版方法：
参考资料
模版方法：final不能被重写，调用抽象方法，对过程进行描述
抽象方法：子类需要重写
制作豆浆：选材—>添加配料—>浸泡—>放到豆浆机就是模版方法，添加配料就是抽象方法，需要子类去重写添加不同的配料
AQS框架
发布消息类：
观察者模式（发布订阅模式）：
发布者维护一个队列，订阅者订阅后加入队列，如果有消息则传入给队列中的订阅者
中介者模式：多个对象相互通信，通常强耦合。利用中介者模式，Mediator存储user的LinkedList，而每一个user只需要聚合Mediator，通过Mediator即可对其他user进行操作
实例：QQ
参考资料
责任链模式：每个对象持有对下一个对象的引用，形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。
Tomcat的container
switch的解耦合形式
spring的拦截器
好处：避免访问者和多个被访问对象耦合。
通常如果访问多个对象，需要遍历访问。使用责任链，则后面对象的访问是由前一个对象管理，访问者只用得到第一个访问对象即可
h1.operator()即可开始链的传递
命令模式：Hystrix
达到命令的发出者和执行者之间解耦，实现请求和执行分开。
例如遥控进行开关设备。正常来讲，遥控需要利用if/else识别用户发出的命令然后根据命令调用不同的方法，但需要新增命令的时候就会改动遥控的方法。
所以将遥控关联一个Command对象，如果新增功能则只需要创建一个类实现Command并实现其方法，遥控不知道具体调用的是什么方法
public class client{
public Command command;
public void execute(Command command){
command.execute();
}
}
public class Light {
public void on() {
System.out.println("灯亮了...");
}
public void off() {
System.out.println("灯暗了...");
}
}
public class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.on();
}
@Override
public void undo() {
light.off();
}
}
备忘录模式：
参考资料
应用于备份或者回退操作，回退到某一个特定的历史状态。
Memento：备忘录（理解为Original里信息的备份）
Storage：备忘录管理员 List< Memento >，存储备忘录信息
迭代者模式：顺序访问聚集中的对象
LInkedList 底层链表实现：使用get进行遍历时间复杂度是O(n*n)
好处：将类的访问和实现解耦合
因为迭代器里的hasNext和next只是待用被迭代的某些方法实现遍历，所以如果被迭代者更改设计，不需要修改迭代器的方法
参考资料
public class BookShelfIterator implements Iterator {
private BookShelf bookShelf;
private int index;
public BookShelfIterator(BookShelf bookShelf) {
this.bookShelf = bookShelf;
this.index = 0;
}
public boolean hasNext() {
if (index < bookShelf.getLength()) {
return true;
} else {
return false;
}
}
public Object next() {
Book book = bookShelf.getBookAt(index);
index++;
return book;
}
}
扫一扫
3174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
