标签：start zed stat nbsp final tst 检查 技术 ora
描述：每个类应该实现单一的职责，否则将其拆分。
描述：开闭原则的补充，子类具体实现基类的抽象方法，子类不应该重写和重载父类具体方法。
描述：开闭原则的基础，面向接口编程，依赖于抽象而不依赖于具体。
描述：每个接口中不存在子类用不到的方法，否则拆分；多个接口方法集合到一个的接口。
描述：一个类对自己依赖的类知道的越少越好。
描述：尽量首先使用合成/聚合的方式，而不是使用继承。
创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
原理：创建一个工厂接口和创建多个工厂实现类，每个具体工厂只能创建一个具体产品类的实例。
原理：创建一个工厂接口和创建多个工厂实现类，每个具体工厂能创建多个具体产品类的实例。
原理：保证在一个JVM中，该对象只有一个实例存在。
3.1 简单的单例模式（线程不安全）（懒汉式）【不可用】
public class SimpleSingleton { private static SimpleSingleton instance = null; private SimpleSingleton() { } public static SimpleSingleton getInstance() { if(instance == null) { instance = new SimpleSingleton(); } return instance; } }
3.2 简单的单例模式（线程安全）（饿汉式）【推荐】
public class SimpleSingleton { private static SimpleSingleton INSTANCE= new SimpleSingleton(); private SimpleSingleton() { } public static SimpleSingleton getInstance() { return INSTANCE; } }
3.3 高效的单例模式（线程安全）（懒汉式）（双重检查）【推荐】
public class HighSingleton { private static HighSingleton instance = null; private HighSingleton() { } public static HighSingleton getInstance() { if(instance == null) { synchronized (HighSingleton.class) { if(instance == null) { instance = new HighSingleton(); } } return instance; } }
3.4 静态内部类的单例模式（线程安全）（类饿汉式）【推荐】
public class Singleton { private Singleton() {} private static class SingletonInstance { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return SingletonInstance.INSTANCE; } }
原理：将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
public class Prototype implements Cloneable, Serializable { private static final long serialVersionUID = 1L; private String str; private SerializableObject obj; /* 浅复制 */ public Object clone() throws CloneNotSupportedException { Prototype proto = (Prototype) super.clone(); return proto; } /* 深复制 */ public Object deepClone() throws IOException, ClassNotFoundException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return ois.readObject(); } }
原理：使用多个简单的对象一步一步构建成一个复杂的对象。
public class Student { String name = null; int age = -1; String sex = null;
public Student(StudentBuild builder) {
this.name = builder.name;
this.age = builder.age;
this.sex = builder.sex;
} }
public class StudentBuilder { String name = null; int age = -1; String sex = null; public StudentBuilder setName(String name) { this.name = name; } public StudentBuilder setAge(int age) { this.age = age; } public StudentBuilder setSex(String sex) { this.sex = sex; } // 建造出Student对象. public Student build() { return new Student(this); } }
结构型模式（5）：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
描述：适配器模式分为类的适配器模式、对象的适配器模式、接口的适配器模式，其他的结构性设计模式依赖于是配置模式（对象的适配器模式）。
public interface ISource { public void mehtod(); }
// 待适配类 public class Source { public void methodOne(){} }
// 目标接口 public interface ITarget { public void methodOne(); public void methodTwo(); }
1.1、类的适配器模式
原理：适配器类需继承待适配类，并实现目标接口。
// 类的适配器类 public class SourceTargetAdapter extends Source implements ITarget { @Override public void methodTwo(){} }
1.2、对象的适配器模式
原理：适配器类持有待适配类的实例对象，并且实现目标接口。
// 对象的适配器类 public class SourceTargetWrapper implements ITarget { private Source source; public SourceTargetWrapper (Source source){ this.source = source; } @Override public void methodOne(){ source.methodOne(); }; @Override public void methodTwo(){} }
1.3、接口的适配器模式
原理：抽象适配器类实现目标接口，其子类实现具体方法。
// 抽象适配器类 public abstract class TargetWrapper implements Target { @Override public void methodOne(){} @Override public void methodTwo(){} }
public class SourceSub extends TargetWrapper { @Override public void methodOne(){} }
原理：在原方法的基础上添加新功能。
// 待装饰类 public class Source implements ISource { @Override public void mehtod(){} }
// 装饰类 public SourceDecorator implements ISource { private ISource source; public SourceDecorator (ISource source) { this.source = source; } @Override public void method(){ // 新增方法 this.newMethod(); // 原始方法 source.method(); } private void newMethod(){} }
原理：使用代理类间接调用待代理类方法。
// 待代理类 public class Source implements ISource { @Override public void mehtod(){} }
// 代理类 public SourceProxy implements ISource { private ISource source; public SourceDecorator (ISource source) { this.source = source; } @Override public void method(){ source.method(); } }
原理：外观类用于管理类与类之间的依赖关系。
public class CPU { public void startUp() {} public void shutDown() {} }
public class Memory { public void startUp() {} public void shutDown() {} }
// 外观类 public class ComputerFacade { private CPU cpu; private Memory memoty; public ComputerFacade (CPU cpu, Memory memoty) { this.cpu = cpu; this.memory = memory; } public void startUp() { cpu.startUp(); memory.startUp(); } public void shutDown() { cpu.shutDown(); memory.shutDown(); } }
原理：把事物和具体实现分开。
public class SourceSubOne implements ISource { @Override public void mehtod(){} }
public class SourceSubTwo implements ISource { @Override public void mehtod(){} }
// 桥接抽象类 public abstract class SourceBridge { private ISource source; public ISource getSource(){ return source; } public void setSource(ISource source){ this.source = source; } public void mehtod(){ source.mehtod(); } }
// 桥接类 public abstract class SourceBridgeSub extends SourceBridge { public void mehtod(){ source.mehtod(); } }
原理：。
原理：。
标签：start zed stat nbsp final tst 检查 技术 ora
原文地址：https://www.cnblogs.com/pascall/p/10181533.html
