技术人生

[ 需求分析 ] 在我们实际开发中常常会遇到这样的问题：记录一个类的方法运行时间，以分析性能。一般我们的做法是先在类的开始记录一个开始时间，然后在类的结束记录一个结束时间，二者相减就可以获取我们想要的结果。但是很多时候这些类已经打了jar包，我们无法直接修改源码，这个时候我们应该怎么办呢？

Client客户端只和Facade打交道，而Facade方法中封装了多个其他复杂方法。     外观模式（Facade）,为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，从而使得客户端不需要知道一些更加细节的东西。充分体现了依赖倒转原则（高层模块不依赖低层模块，它们都依赖于抽象）和迪米特法则（如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类

适配器模式：将一个类的接口转换成客户希望看到的另一个接口，适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 适用场景：使用一个已经存在的类，但如果它的接口，也就是它的方法和你的要求不相同时，就应该考虑用适配器模式。 //Target类，客户所期待的接口，目标可以是具体的或抽象的类，也可以是接口 public class Target { public void req

单例模式: 保证一个类只有一个实例。 懒汉式单例： public class LazySingleton { private static LazySingleton instance = null; private LazySingleton() { } public static LazySingleton getInstance() { if (instance =

工厂方法模式是简单工厂模式的抽象和扩展。 工厂方法模式是由客户端来决定实例化那一个工厂实现类。 在简单工厂类中如果要增加功能改动的是工厂类，但在工厂方法模式中要改的就是客户端了，由客户端决定 package Factory; public class MainClass { /** * @param args */ public static void main(String

定义Operation抽象类，将各种操作解耦为各个类并实现Operation抽象类，这样可以降低了各种具体操作代码耦合性。总体来说，定义一个抽象类，然后若干类继承抽象类，实现抽象方法，工厂会根据需要生成各种子类对象（多态）。 package simple_factory; public abstract class Operation { private double num

抽象工厂模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 //Department类 public class Department { private int id; private String name; public int getId() { return id; } public void set

建造者模式主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。使用建造者模式，用户只需指定需要建造的类型，具体的建造细节不需要知道。        建造者模式使得建造代码与表示代码分离，若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了，从而可以使一个建造过程生成具有不同的内部表象的产品对象。        Builder

浅复制：被复制对象的所有变量都含有与原来的对象相同的值，而所有的其它对象的引用都仍然指向原来的对象。 //工作经历类 public class WorkExperience { private String workDate; private String company; public String getWorkDate() { return workDate; } pu

结构型模式： 适配器模式： 用来把一个接口转化成另一个接口。 java.util.Arrays#asList()javax.swing.JTable(TableModel)java.io.InputStreamReader(InputStream)java.io.OutputStreamWriter(OutputStream)javax.xml.bind.annotation.a

中介者模式：         用一个中介对象来封装一系列的对象交互，中介者使个对象不需要显示地相互引用，从而使其耦合松散，可以独立地改变它们之间的交互。 // 国家类 public abstract class Country { private UnionNations un; public Country(UnionNations un) { this.un = un; }

代理持有被代理对象的引用，代理对象调用持有被代理对象的引用来调用被代理对象的方法，其中，代理对象和被代理对象要实现共同接口。 代理模式：为其他对象提供一种代理以控制对这个对象的访问。 //代理接口 public interface GiveGift { void giveDolls(); void giveFlowers(); void giveChocolate(); } //

观察者模式又叫发布-订阅（Publish/Subscribe）模式。 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。 //Subject类，可翻译为主题或抽象通知者，一般用一个抽象类或一个接口实现。它把所有对观察者对象的引用保存在一个聚集里面，每个主题都可以有任何数量的观察者。抽象主题

###多例模式： 类可以存在有限的多个实例对象。 ###多例模式的特点 通过容器保存实例对象 利用私有构造器阻止外部创建对象 通过getInstance方法获取实例对象 ###代码演示 创建两个机器人对象： package com.company.section5; import java.util.HashMap; import java.util.Random; /** * 机器人 ...

简单工厂通用的实现代码： ProductFactory： 工厂类，通过它产生product public class ProductFactory { /** * 创建产品对象 * 使用泛型对输入参数做了两层限制： * 1.必须为class类型 * 2.必须为Product的实现类 * 输入参数通常为String、Enum、Class等 * @param c * @r...

享元模式：         运用共享技术有效地支持大量细粒度的对象。 // 网站抽象类 public abstract class WebSite { public abstract void use(User u); } // 具体网站类 public class ConcreteWebSite extends WebSite { private String name; p

访问者模式：         表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。  // 人的抽象类 public abstract class Person { // 接受一个'访问者'为参数 public abstract void accept(Action visitor); } // 男人 public class

解释器模式：         给定一中语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 // 表达式类 public abstract class Expression { public void interpret(PlayContext context) { if (context.getContext().length() == 0)

策略模式：它定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用的算法客户。       应用案例：商场促销的多样性（折扣，满减，积分）      package Strategy; abstract class CashSuper { public abstract double acceptCash(double money); } class C

单一职责原则：一个类应该仅有一个引起它变化的原因。软件设计需要做到职责相互分离。        如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱这个类完成其他职责的能力，牵一发而动全身。这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。        单一职责的代码更容易维护和拓展。

开放-封闭原则： 对扩展时开放的，对修改是封闭的。面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码         开发人员应该仅对程序中频繁变化的那些部分作出抽象，然而，对于程序中的每个部分都刻意地进行抽象也不是个好办法。

依赖倒转原则    抽象不应该依赖细节，细节应该依赖于抽象，针对接口编程，不要对实现编程；针对抽象编程，而不是针对细节编程    A.高层模块不应该依赖低层模块。两个都应该依赖抽象。    B.抽象不应该依赖细节。细节应该依赖抽象。 里氏代换原则（LSP）：子类型必须能够替换掉它们的父类型（好比学习继承的概念时，子类继承了父类，子类就可以以父类的身份出现）     一个软件实体如

模板方法模式，定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 模版方法模式是通过把不变行为搬移到超类，取出子类中的重复代码来体现它的优势。 //AbstractClass是抽象类，其实也就是一抽象模板，定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑骨架，而逻辑的组成步骤在相应的抽

迪米特法则(LoD)(也叫最少知识原则)，如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。     迪米特法则的前提是在类的结构设计上，每一个类都应当尽量降低成员的访问权限，即一个类包装好自己的private状态，不需要让别的类知道的字段或行为就不要公开。     迪米特法则的根本思想，是强调了类之

备忘录模式就是把保存的细节封装在Memento中。 应用场景：Memento模式比较适用于需要维护或记录属性历史的类。 主要缺点：角色状态需要完整的存储到备忘录对象中，如果状态数据很大很多，将会非常的消耗资源。 public class GameRole { private String name; private int vitality; // 生命力 private

组合模式使用户对单个对象和组合对象的使用具有一致性。 应用场景：需求中体香部分和整体层次的结构或希望用户忽略组合对象与单个对象的不同，可以统一地使用组合结构中的所有对象。 优点：基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，可以不断地递归下去。 // 抽象公司类 public abstract class Company { private String name

桥接模式：         当发现我们需要多角度去分类实现对象，而只用继承会造成大量的类增加，不能满足开放-封闭 原则，就应该考虑用桥接模式了。 // 手机接口 public abstract class Mobile { private MobileSoft soft; private String brand; public Mobile(String brand) {

职责连模式：         使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将多个对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 // 管理者 public abstract class Manager { // 当前管理者的上级 private Manager superior; public Manager getSuperior

装饰模式   动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。   装饰模式是为已有功能动态地添加更多功能的一种方式。   装饰模式把每个要装饰的功能放在单独的类中，并让这个类包含它所要装饰的对象，因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地，按顺序地使用装饰功能包装对象了。   装饰模式的优点是： 1.把类中的装饰功能从类

状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。 //State类，抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为 public interface State { public void handle(Context context); } //ConcreteSt

迭代器模式: 类似java中的Iterator类,提供一种方法顺序访问一个聚合对象中各个元素。 // 书籍类 public class Book { private String name = ""; public Book(String name) { this.name = name; } public String getName() { return name;

命令模式：         将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持撤销操作。 // 抽象命令类 public abstract class Command { private Barbecuer barbecuer; public Command(Barbecuer bar) { this.barbecuer = b

简单工厂也是一种比较简单的设计模式，下面为简单的代码实现。 ProductFactory 工厂类，负责创建具体的产品 public class ProductFactory { /** * 创建产品对象 * 使用泛型对输入参数做了两层限制： * 1.必须为class类型 * 2.必须为Product的实现类 * 输入参数通常为String、Enum、Class等 * @p...