Java设计原则和设计模式

1. 设计原则

1.1 单一职责原则

• 一个类只应该只负责一个职责，如果很简单的需求可以允许一个类的每个方法符合单一职责原则
• 提高类的可读性、可维护性，降低变更引起的风险

1.2 接口隔离原则

• 客户端不应该依赖它不需要的接口，即一个类对另外一个类的依赖应该建立在最小的接口上

1.3 依赖倒转（倒置）原则

• 高层模块不应该依赖底层模块，二者都应该依赖各自的抽象
• 抽象不应该依赖细节，细节应该依赖抽象
• 依赖倒置的中心思想是面向接口编程
• 依赖传递的三种方式：接口传递 、构造方法传递、setter方式传递

public class DependecyInversion {
	public static void main(String[] args) {
		Person person = new Person();
		person.getInfo(new WeChat());
	}
}
interface Receiver {
	String receive();
}
class Person {
	public void getInfo(Receiver receiver) {//接口传递
		System.out.println(receiver.receive());
	}
}
class WeChat implements Receiver {
	public String receive() {
		return "微信。。。。";
	}
}

public class DependecyInversion {
	public static void main(String[] args) {
		Person person = new Person(new WeChat());
		person.getInfo();
	}
}
interface Receiver {
	String receive();
}
class Person {
	private Receiver receiver;
	public Person(Receiver receiver) {//构造器传递
		this.receiver = receiver;
	}
	public void getInfo() {
		System.out.println(receiver.receive());
	}
}
class WeChat implements Receiver {
	public String receive() {
		return "微信。。。。";
	}
}

public class DependecyInversion {
	public static void main(String[] args) {
		Person person = new Person();
		person.setReceiver(new WeChat());
		person.getInfo();
	}
}
interface Receiver {
	String receive();
}
class Person {
	private Receiver receiver;
	public Receiver getReceiver() {
		return receiver;
	}
	public void setReceiver(Receiver receiver) {//setter传递
		this.receiver = receiver;
	}
	public void getInfo() {
		System.out.println(receiver.receive());
	}
}
class WeChat implements Receiver {
	public String receive() {
		return "微信。。。。";
	}
}

1.4 里氏替换原则

• 在使用继承时，子类尽量不要重写父类的方法
• 继承会让耦合性增强，在适当情况下可以通过聚合、组合、依赖的关系来解决

1.5 开闭原则

• 开闭原则是编程当中最基础、最重要的设计原则
• 一个软件实体如类、模块和函数应该对扩展开放、对修改关闭。用抽象构建框架，用实现扩展细节
• 当软件需要变化时，尽量通过扩展软件实体的行为，而不是修改已有的代码

1.6 迪米特法则（最少知道原则）

• 一个对象应该对其他对象保持最少的了解
• 只与直接的朋友进行通信，直接的朋友包括出现在 成员变量、方法参数、方法返回值 的类

1.7 合成复用原则

• 尽量使用合成 \ 聚合的方式，而不是继承

2. 设计模式

• 创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式
• 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
• 行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式

2.1 单例模式

• 采用一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得该对象实例的静态方法
• 单例模式保证在系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例提高性能
• 频繁进行创建和销毁的对象、创建对象时耗时过多或资源过多，但又经常使用，比如工具类、数据源、session工厂等

public class EagerSingleton {//饿汉式
        //私有构造器
	private EagerSingleton() {}
	private final static EagerSingleton INSTANCE = new EagerSingleton();
	public static EagerSingleton getInstance() {
		return INSTANCE;
	}
	public static void main(String[] args) {
		EagerSingleton instance = EagerSingleton.getInstance();
		EagerSingleton instance2 = EagerSingleton.getInstance();
		System.out.println(instance == instance2);//true
	}
}

public class DoubleCheckLazySingleton {//双重检查懒汉式
        //volatile防止指令重排
	private static volatile DoubleCheckLazySingleton singleton;
	private DoubleCheckLazySingleton() {}
	public static DoubleCheckLazySingleton getInstance() {
		if (singleton == null) {
			synchronized (DoubleCheckLazySingleton.class) {
				if (singleton == null) {
					singleton = new DoubleCheckLazySingleton();
				}
			}
		}
		return singleton;
	}
}

public class StaticInnerClassSingleton {//静态内部类实现单例模式
	private StaticInnerClassSingleton() {}
	private static class SingletonInstance {
		private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
	}
	public static StaticInnerClassSingleton getInstance() {
		return SingletonInstance.INSTANCE;
	}
}

enum Singleton {//枚举实现单例
        //不仅可以避免多线程同步问题，而且可以防止反序列化重新创建新的对象
	INSTANCE;
}
public class Test33 {
	public static void main(String[] args) {
		Singleton s = Singleton.INSTANCE;
		Singleton s2 = Singleton.INSTANCE;
		System.out.println(s == s2);//true
	}
}