keyboard专栏

单一职责原则 定义一个类，应该仅有一个引起它变化的原因 核心思想：应该有且仅有一个原因引起类的变更 问题描述：假如有类Class 完成职责T1，T2，当职责T1或T2有变更需要修改时，有可能影响到该类的另外一个职责正常工作。 开放封闭原则 类、模块、函数等应该是可以拓展的，但是不可以修改 核心思想：尽量通过扩展软件实体来解决需求变化，而不是通过修改已有的代码来完成变化。 里氏替换原则 所有引用基类的地方必须能透明地使用其子类的对象 依赖倒置原则 高层模块不应该依赖于底层模块，两者都应该依赖于抽象。抽象不应该

/** * 模板方法 * * 定义一个操作中算法的框架， * 而将一些步骤延迟到子类中，使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤。 */ public class TestTemplate { public static void main(String[] args) { AbstractTemplate t=new ConcreteTemplate(); t.templateMethod(); } } /** * ap.

/** * 责任链模式 * * 责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了， * 后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了 * */ public class TestResponsibility { public static void main(String[] args) { Context context=new Context(); .

/** * 观察者模式 * * 定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。 * */ public class TestObserver { public static void main(String[] args) { //定义一个主题 Subject subject=new Subject(); //主题的观察者 new BinaryObserver(sub.

/** * 策略模式 * * 定义了算法族，分别封装起来，让他们之间可以相互替换 * 此模式的变化对独立于算法的使用者 * * 优点： * 算法可以自由切换，改变算法很方便 * 扩展性良好，增加一个策略，只需要增加一个类 * * 缺点： * 上层模块必须知道有哪些策略，所有的策略需要对外暴露 * * 应用场景： * ThreadPoolExecutor * */ public class TestStrategy { public static void main..

/** * 桥梁模式 * * 桥梁模式，其实就是理解代码抽象和解耦 * * */ public class TestBridge { public static void main(String[] args) { Shape redCircle=new Circle(new RedPen(),10); Shape rectangle=new Rectangle(new GreenPen(),10,9); redCircle.draw..

/** * * 组合模式 * * * 组合模式用于表示具有层次结构的数据，使得我们对单个对象和组合对象的访问具有一致性。 * 每个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空）， * 而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合。 * */ public class TestCombination { public static void main(String[] args) { List&.

/** * 装饰者模式 * * 在不改变原有对象的基础上，将功能附加到对象上 * * 符合开闭原则，对扩展开放，对修改关闭 * * 应用场景： * 扩展一个类的功能或者给一个类添加附加职责 * * 优点： * 1、不改变原有对象的情况下给一个对象扩展功能 * 2、使用不同的组合可以实现不同的效果 * */ public class TestDecorator { public static void main(String[] args) { Compo.

/** * 享元模式 * * 运用共享技术有效地支持大量细粒度的对象 * * 优点： * 如果系统中有大量类似的对象，可以节省大量的内存和cpu资源 * */ public class TestFlyweight { public static void main(String[] args) { TreeNode treeNode = new TreeNode(4, 5, TreeFactory.getTree("suntree", "good tree")); .

/** * 门面模式 * 为子系统中的一组接口提供一个一致的接口，facede模式定义了一个高层接口 * 这个接口是的这个子系统更加可以使用 * * 应用场景： * 1、当您需要使用多个子系统的接口时，可以封装接口，使用门面模式 * 2、使用子系统组成的层时，使用facede模式 * * 用到的地方： * 1、spring 中的controller */ public class TestFacade { public static void main(String[] a.

/** * 适配器模式 * 将一个类的接口转换成客户希望的另一个类的接口 * Adapter模式使得原来由于接口不兼容不能一起工作的类可以一起工作 * 就像220V电源不能直接连接手机，需要手机充电适配器才行 * 对象适配器模式 * * 适配器模式的应用场景 * 1、当你希望使用某些现有类，但其接口与您的其他代码不兼容是，请使用适配器类 * 2、当你希望重用几个现有的子类，这些子类缺少一些不能添加到超类中的公共功能时，请使用改模式 */ public class TestAdapter.

静态代理（Static proxy） public interface IHello { public void hello(String name); } /** * 定义原有的不能修改的业务类， * 现在的任务：在不修改此类的前提下，完成打印日志等其他事情 */ public class HelloStaticProxy implements IHello { @Override public void hello(String name) { Sy..

/** * 实现Cloneable的接口，使其具有clone的能力 */ public class Product implements Cloneable{ private String name; private String part1; private String part2; private int age; private ProductBase productBase; public String getName() { .

public class User{ private String name; private String password; private String nickName; private int age; //将构造方法私有化 private User(String name,String password,String nickName,int age){ this.name=name; this.password=

/** * 嵌套类 */ public class SingletonNest { private SingletonNest(){} //主要使用了嵌套类可以访问外部类的静态属性和静态方法的特性 private static class Holder{ private static SingletonNest instance=new SingletonNest(); } public static SingletonNest getIn.

/** * 饱汉模式 */ public class SingletonFull { //首先，堵死SingletonFull() private SingletonFull(){} //和饿汉模式相比，这边不需要实例化出来，注意这里的valatile， //valatile private static volatile SingletonFull instance=null; //不建议将synchronized加载方法上，这样会大量损耗性能 .

/** *是否多线程安全：是 * 优点：没有加锁，执行效率会提高。它 基于classloder机制避免了多线程的同步问题 * 缺点：类加载时就初始化，浪费内存。 */ public class Singletonhungry { //设置一个空的构造函数，引用者不能通过构造函数创建一个null对象 private Singletonhungry(){}; //创建一个静态实例，这个类在第一次使用的时候就会被创建 private static Singletonhu.

使用抽象工厂模式一般要满足以下条件。 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。 系统一次只可能消费其中某一族产品，即同族的产品一起使用 抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。 当增加一个新的产品族时不需要修改原代码，满足开闭原则。 其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。 以生产电脑为例子： 当涉及到这种产品族的问题的时候，就需要抽象.

/** * 定义工厂接口 */ public interface FoodFactory { Food makeFood(String name); } public class ChineseFoodFactory implements FoodFactory{ @Override public Food makeFood(String name) { if (name.equals("A")) { return new Chine

简单工厂模式，通常来说这不是一种设计模式，而是大家的一种编程的写法。 /** * 简单工厂模式通常就是这样， * 一个工厂类 XxxFactory，里面有一个静态方法，根据我们不同的参数， * 返回不同的派生自同一个父类（或实现同一接口）的实例对象 * 强调职责单一原则，一个类只提供一种功能， * FoodFactory 的功能就是只要负责生产各种 Food。 * 缺点：如果需要两个或者两个以上的工厂，无能为力了 */ public class FoodFactory { public