面向对象原则
1. 单一指责原则 (Single responsibility principle,SRP)
一个类应该仅有一个引起它变化的原因。
2. 开闭原则 (Open Closed Principle,OCP)
一个类应该对外扩展开放,对修改关闭。
3. 里氏替换原则 (Liskov Substitution Principle,LSP)
子类型能够替换掉它们的父类型。
4. 依赖倒置原则 (Dependency Inversion Principle,DIP)
要依赖于抽象,不要依赖于具体类,要做到依赖倒置,应该做到:
1. 高层模块不应该依赖底层模块,二者都应该依赖于抽象。
2. 抽象不应该依赖于具体实现,具体实现应该依赖于抽象。
5. 接口隔离原则 (Interface Segregation Principle,ISP)
不应该强迫客户依赖于他们不用的方法。
6. 迪米特法则(Principle of Least Knowledge,PLK)
一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
7. 合成复用原则(Composite Reuse Principle,CRP)
尽量首先使用合成/聚合的方式,而不是使用继承。
其他原则
- 面向接口编程
- 一个类需要的数据应该隐藏在类的内部
- 类之间应该零耦合,或者只有传导耦合,换句话说,类之间要么没关系,要么只使用另一个类的接口提供的操作
- 在水平方向上尽可能统一地分布系统功能
设计模式的分类
总体来说设计模式分为三大类:
创建型模式,共五种:单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1. 单例模式
1. 懒汉式
在需要的时候才创建实例。
public class Singleton {
private Singleton() {}//构造函数私有化
private static Singleton instance = null;//实例私有化
public static Singleton getInstance() {
//实例不存在,则创建
if(instance == null) {
//懒汉式单例线程不安全,加上同步后创建实例
synchronized (Singleton.class) {
//双重检查锁定
if(instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
2. 饿汉式
在创建类的同时创建好实例。
public class Singleton {
private Singleton() {}//构造函数自由化
private static final Singleton instance = new Singleton();//实例私有化
//获取实例的方法
public static Singleton getInstance() {
return instance;
}
}
2. 工厂方法模式
1. 工厂方法模式(Factory Method)
- 一个抽象产品类,多个具体产品类(继承自抽象产品类)
- 一个抽象工厂接口,多个具体工厂类(实现抽象工厂接口),各个具体工厂类用于创建不同的具体产品实例
- 具体产品角色通过创建不同的具体工厂实例,获取不同的具体产品
//抽象产品类
abstract class Product {
public Product() {}
}
//具体产品类A
public class ProductA extends Product {
public ProductA() {
System.out.println("ProductA created");
}
}
//具体产品类B
public class ProductB extends Product {
public ProductB() {
System.out.println("ProductB created");
}
}
//抽象工厂接口
interface Factory {
Product createProduct();
}
//具体工厂类A
public class FactoryA implements Factory {
@Override
public ProductA createProduct() {
return new ProductA();
}
}
//具体工厂类B
public class FactoryB implements Factory {
@Override
public ProductB createProduct() {
return new ProductB();
}
}
//具体产品
public class Client {
public static void main(String[] args) {
FactoryA fa = new FactoryA();
ProductA pa = fa.createProduct();
FactoryB fb = new FactoryB();
ProductB pb = fb.createProduct();
}
}
2. 简单工厂模式(Simple Factory Method)
- 一个抽象产品类,多个具体产品类(继承自抽象产品类)
- 一个具体工厂类,用于创建具体产品实例
- 具体产品角色通过创建具体工厂实例,调用其内部方法,得到具体产品实例
//抽象产品类
abstract class Product {
public Product() {}
}
//具体产品类A
public class ProductA extends Product {
public ProductA() {
System.out.println("ProductA created");
}
}
//具体产品类B
public class ProductB extends Product {
public ProductB() {
System.out.println("ProductB created");
}
}
//具体工厂类
public class Factory {
public Product createProduct(int type) {
switch(type) {
case 1:
return new ProductA();
case 2:
return new ProductB();
default:
return null;
}
}
}
//具体产品
public class Client {
public static void main(String[] args) {
Factory factory = new Factory();
Product pa = factory.createProduct(1);
Product pb = factory.createProduct(2);
}
}