第一章 单一职责原则
单一职责原则:要求一个接口或类只有一个原因引起变化，也就是一个接口或类只有一个职责，它就负责一件事情
完美的设计: 一个类实现了两个接口，把两个职责融合在一个类中。
不好的设计:
好的设计:
- 接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化
第二章 里氏替换原则: 如果子类有必要拥有父类的所有方法。那就继承父类，如果有些方法用得到，有些方法用不到，那就别继承了
只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何错误或异常，使用者可能根本就不需要知道是父类还是子类。
但是，反过来就不行了，有子类出现的地方，父类未必就能适应
1.子类必须完全实现父类的方法
注意:如果子类不能完整地实现父类的方法，或者父类的某些方法在子类中已经发
生“畸变”，则建议断开父子继承关系，采用依赖、聚集、组合等关系代替继承
例如:有很多枪可以继承枪的接口,但如果是玩具枪就不适合继承枪的接口,因为它不能杀人,脱离了正常的业务逻辑,应该把玩具枪独立出来,脱离继承
2.子类可以有自己的个性
在项目中，采用里氏替换原则时，尽量避免子类的“个性”，一旦子类有“个性”，这个子
类和父类之间的关系就很难调和了，把子类当做父类使用，子类的“个性”被抹杀——委屈了
点；把子类单独作为一个业务来使用，则会让代码间的耦合关系变得扑朔迷离——缺乏类替
换的标准。
第三章 依赖倒置原则:
● 高层模块不应该依赖低层模块，两者都应该依赖其抽象；
● 抽象不应该依赖细节；
● 细节应该依赖抽象
就是面向接口编程
稳定性较高的设计，在周围环境频繁变化的时候，依然可以做到“我自岿然不动
依赖倒置原则的本质就是通过抽象（接口或抽象类）使各个类或模块的实现彼此独立不互相影响，实现模块间的松耦合
一个类公开的public属性或方法越多，修改时涉及的面也就越大，变更引起的风险扩散也就越大。
因此，为了保持朋友类间的距离，在设计时需要反复衡量：是否还可以再减少public方法和属性，
是否可以修改为private、package-private（包类型，在类、方法、变量前不加访问权限，则默认为包类型）、protected等访问权限，是否可以加上final关键字等
第四章接口隔离原则: 接口尽量细化，同时接口中的方法尽量少
第五章 迪米特法则: 高内聚低耦合
第六章 开闭原则: 对扩展开放,对修改关闭
第八章 工厂模式
建立人类的实现类
public class BlackHuman implements Human {
public void getColor(){
System.out.println("黑色人种的皮肤颜色是黑色的！");
}
public void talk() {
System.out.println("黑人会说话，一般人听不懂。");
}
}
public class WhiteHuman implements Human {
public void getColor(){
System.out.println("白色人种的皮肤颜色是白色的！");
}
public void talk() {
System.out.println("白色人种会说话，一般都是但是单字节。");
}
}
建立抽象类
public abstract class AbstractHumanFactory {
public abstract <T extends Human> T createHuman(Class<T> c);
}
建立工厂类,通过名称的选择,利用反射构建类
public class HumanFactory extends AbstractHumanFactory {
public <T extends Human> T createHuman(Class<T> c) {
//定义一个生产的人种
Human human = null;
try {
//产生一个人种
human = (T) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
System.out.println("人种生成错误！");
}
return (T) human;
}
}
使用:
public class NvWa {
public static void main(String[] args) {
//声明阴阳八卦炉
AbstractHumanFactory YinYangLu = new HumanFactory();
//女娲第一次造人，火候不足，于是白人产生了
System.out.println("--造出的第一批人是白色人种--");
Human whiteHuman = YinYangLu.createHuman(WhiteHuman.class);
whiteHuman.getColor();
whiteHuman.talk();
//女娲第二次造人，火候过足，于是黑人产生了
System.out.println("
--造出的第二批人是黑色人种--");
Human blackHuman = YinYangLu.createHuman(BlackHuman.class);
blackHuman.getColor();
blackHuman.talk();
//第三次造人，火候刚刚好，于是黄色人种产生了
System.out.println("
--造出的第三批人是黄色人种--");
Human yellowHuman = YinYangLu.createHuman(YellowHuman.class);
yellowHuman.getColor();
yellowHuman.talk();
}
}
- 比较通用的工厂模式
1.定义产品抽象类,抽象类可以定义公共方法
public abstract class Product {
//产品类的公共方法
public void method1() {
//业务逻辑处理
}
//抽象方法
public abstract void method2();
}
2.具体产品类
public class ConcreteProduct1 extends Product {
public void method2() {
//业务逻辑处理
}
}
public class ConcreteProduct2 extends Product {
public void method2() {
//业务逻辑处理
}
}
3.抽象创建工厂
public abstract class Creator {
/*
* 创建一个产品对象，其输入参数类型可以自行设置
* 通常为String、Enum、Class等，当然也可以为空
*/
public abstract <T extends Product> T createProduct(Class<T> c);
}
4.具体的工厂类
public class ConcreteCreator extends Creator {
public <T extends Product> T createProduct(Class<T> c) {
Product product = null;
try {
product = (Product) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
//异常处理
}
return (T) product;
}
}
5.使用
public class Client {
public static void main(String[] args) {
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
/*
* 继续业务处理
*/
}
}
好处:
1.易于扩展,如果有新增功能,直接加上实现类,然后从工厂方法获取即可
2.屏蔽产品类,产品如何变化,调用者都不需要关心,如jdbc如果要从oracle切换到mysql只需要修改驱动类的名称即可
- 工厂模式扩展:
1.缩小为简单工厂
public class HumanFactory {
public static <T extends Human> T createHuman(Class<T> c) {
//定义一个生产出的人种
Human human = null;
try {
//产生一个人种
human = (Human) Class.forName(c.getName()).newInstance();
} catch (Exception e) {
System.out.println("人种生成错误！");
}
return (T) human;
}
}
使用方法
public class NvWa {
public static void main(String[] args) {
//女娲第一次造人，火候不足，于是白色人种产生了
System.out.println("--造出的第一批人是白色人种--");
Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
whiteHuman.getColor();
whiteHuman.talk();
//女娲第二次造人，火候过足，于是黑色人种产生了
System.out.println("
--造出的第二批人是黑色人种--");
Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
blackHuman.getColor();
blackHuman.talk();
//第三次造人，火候刚刚好，于是黄色人种产生了
System.out.println("
--造出的第三批人是黄色人种--");
Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
yellowHuman.getColor();
yellowHuman.talk();
}
}
变化点:去掉继承抽象类，并在createHuman前增加static关键字；工厂类发生变化，也同时引起了调用者NvWa的变化
2.升级为多个工厂类:为每个产品增加一个工厂
public abstract class AbstractHumanFactory {
public abstract Human createHuman();
}
public class BlackHumanFactory extends AbstractHumanFactory {
public Human createHuman() {
return new BlackHuman();
}
}
public class YellowHumanFactory extends AbstractHumanFactory {
public Human createHuman() {
return new YellowHuman();
}
}
使用方法
public class NvWa {
public static void main(String[] args) {
//女娲第一次造人，火候不足，于是白色人种产生了
System.out.println("--造出的第一批人是白色人种--");
Human whiteHuman = (new WhiteHumanFactory()).createHuman();
whiteHuman.getColor();
whiteHuman.talk();
//女娲第二次造人，火候过足，于是黑色人种产生了
System.out.println("
--造出的第二批人是黑色人种--");
Human blackHuman = (new BlackHumanFactory()).createHuman();
blackHuman.getColor();
blackHuman.talk();
//第三次造人，火候刚刚好，于是黄色人种产生了
System.out.println("
--造出的第三批人是黄色人种--");
Human yellowHuman = (new YellowHumanFactory()).createHuman();
yellowHuman.getColor();
yellowHuman.talk();
}
}
- 延迟加载工厂类
public class ProductFactory {
private static final Map<String, Product> prMap = new HashMap();
public static synchronized Product createProduct(String type) throws Exception {
Product product = null;
//如果Map中已经有这个对象
if (prMap.containsKey(type)) {
product = prMap.get(type);
} else {
if (type.equals("Product1")) {
product = new ConcreteProduct1();
} else {
product = new ConcreteProduct2();
}
//同时把对象放到缓存容器中
prMap.put(type, product);
}
return product;
}
}
通过定义一个Map容器，容纳所有产生的对象，如果在Map容器中已经有的对象，则直接取出返回；
如果没有，则根据需要的类型产生一个对象并放入到Map容器中，以方便下次调用
延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断
Map中已有的对象数量来实现，这样的处理是非常有意义的，例如JDBC连接数据库，都会
要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量
第九章 抽象工厂模式
Java的典型类图，一个接口，多个抽象类，然后是N个实现类
抽象工厂模式的通用类图:
public abstract class AbstractProductA {
//每个产品共有的方法
public void shareMethod() {
}
//每个产品相同方法，不同实现
public abstract void doSomething();
}
public class ProductA1 extends AbstractProductA {
public void doSomething() {
System.out.println("产品A1的实现方法");
}
}
public class ProductA2 extends AbstractProductA {
public void doSomething() {
System.out.println("产品A2的实现方法");
}
}
public abstract class AbstractProductB {
//每个产品共有的方法
public void shareMethod() {
}
//每个产品相同方法，不同实现
public abstract void doSomething();
}
public class ProductB1 extends AbstractProductB {
public void doSomething() {
System.out.println("产品B1的实现方法");
}
}
public class ProductB2 extends AbstractProductB {
public void doSomething() {
System.out.println("产品B2的实现方法");
}
}
public abstract class AbstractCreator {
//创建A产品家族
public abstract AbstractProductA createProductA();
//创建B产品家族
public abstract AbstractProductB createProductB();
}
public class Creator1 extends AbstractCreator {
//只生产产品等级为1的A产品
public AbstractProductA createProductA() {
return new ProductA1();
}
//只生产产品等级为1的B产品
public AbstractProductB createProductB() {
return new ProductB1();
}
}
public class Creator2 extends AbstractCreator {
//只生产产品等级为2的A产品
public AbstractProductA createProductA() {
return new ProductA2();
}
//只生产产品等级为2的B产品
public AbstractProductB createProductB() {
return new ProductB2();
}
}
public class Client {
public static void main(String[] args) {
//定义出两个工厂
AbstractCreator creator1 = new Creator1();
AbstractCreator creator2 = new Creator2();
//产生A1对象
AbstractProductA a1 = creator1.createProductA();
//产生A2对象
AbstractProductA a2 = creator2.createProductA();
//产生B1对象
AbstractProductB b1 = creator1.createProductB();
//产生B2对象
AbstractProductB b2 = creator2.createProductB();
/*
* 然后在这里就可以为所欲为了...
*/
}
}
在场景类中，没有任何一个方法与实现类有关系，对于一个产品来说，我们只要知道它
的工厂方法就可以直接产生一个产品对象，无须关心它的实现类
第十章 模板方法模式
public abstract class AbstractClass {
//基本方法
protected abstract void doSomething();
//基本方法
protected abstract void doAnything();
//模板方法
public void templateMethod() {
/*
* 调用基本方法，完成相关的逻辑
*/
this.doAnything();
this.doSomething();
}
}
public class ConcreteClass1 extends AbstractClass {
//实现基本方法
protected void doAnything() {
//业务逻辑处理
}
protected void doSomething() {
//业务逻辑处理
}
}
public class ConcreteClass2 extends AbstractClass {
//实现基本方法
protected void doAnything() {
//业务逻辑处理
}
protected void doSomething() {
//业务逻辑处理
}
}
public class Client {
public static void main(String[] args) {
AbstractClass class1 = new ConcreteClass1();
AbstractClass class2 = new ConcreteClass2();
//调用模板方法
class1.templateMethod();
class2.templateMethod();
}
}
模板方法模式的优点:
封装不变部分，扩展可变部分
提取公共部分代码，便于维护
行为由父类控制，子类实现
使用场景:
● 多个子类有公有的方法，并且逻辑基本相同时。
● 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
● 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。
通过父类中定义钩子函数,约束父类的行为,在子类中重写父类方法就可以改变模板中的行为
public abstract class HummerModel {
/*
* 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正
* 是要能够发动起来，那这个实现要在实现类里了
*/
protected abstract void start();
//能发动，还要能停下来，那才是真本事
protected abstract void stop();
//喇叭会出声音，是滴滴叫，还是哔哔叫
protected abstract void alarm();
//引擎会轰隆隆的响，不响那是假的
protected abstract void engineBoom();
//那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑
final public void run() {
//先发动汽车
this.start();
//引擎开始轰鸣
this.engineBoom();
//要让它叫的就是就叫，喇嘛不想让它响就不响
if(this.isAlarm()){
this.alarm();
}
//到达目的地就停车
this.stop();
}
//钩子方法，默认喇叭是会响的
protected boolean isAlarm(){
return true;
}
}
public class HummerH1Model extends HummerModel {
private boolean alarmFlag = true; //要响喇叭
protected void alarm() {
System.out.println("悍马H1鸣笛...");
}
protected void engineBoom() {
System.out.println("悍马H1引擎声音是这样的...");
}
protected void start() {
System.out.println("悍马H1发动...");
}
protected void stop() {
System.out.println("悍马H1停车...");
}
protected boolean isAlarm() {
return this.alarmFlag;
}
//要不要响喇叭，是由客户来决定的
public void setAlarm(boolean isAlarm){
this.alarmFlag = isAlarm;
}
}
第11章 建造者模式
通过传入的顺序决定汽车的功能
public abstract class CarModel {
//这个参数是各个基本方法执行的顺序
private ArrayList<String> sequence = new ArrayList<String>();
//模型是启动开始跑了
protected abstract void start();
//能发动，还要能停下来，那才是真本事
protected abstract void stop();
//喇叭会出声音，是滴滴叫，还是哔哔叫
protected abstract void alarm();
//引擎会轰隆隆地响，不响那是假的
protected abstract void engineBoom();
//那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑
final public void run() {
//循环一边，谁在前，就先执行谁
for (int i = 0; i < this.sequence.size(); i++) {
String actionName = this.sequence.get(i);
if (actionName.equalsIgnoreCase("start")) {
this.start(); //启动汽车
} else if (actionName.equalsIgnoreCase("stop")) {
this.stop(); //停止汽车
} else if (actionName.equalsIgnoreCase("alarm")) {
this.alarm(); //喇叭开始叫了
} else if (actionName.equalsIgnoreCase("engine boom")) {
//如果是engine boom关键字
this.engineBoom(); //引擎开始轰鸣
}
}
}
//把传递过来的值传递到类内
final public void setSequence(ArrayList sequence) {
this.sequence = sequence;
}
}
实现类:
public class BenzModel extends CarModel {
protected void alarm() {
System.out.println("奔驰车的喇叭声音是这个样子的...");
}
protected void engineBoom() {
System.out.println("奔驰车的引擎是这个声音的...");
}
protected void start() {
System.out.println("奔驰车跑起来是这个样子的...");
}
protected void stop() {
System.out.println("奔驰车应该这样停车...");
}
}
public class BMWModel extends CarModel {
protected void alarm() {
System.out.println("宝马车的喇叭声音是这个样子的...");
}
protected void engineBoom() {
System.out.println("宝马车的引擎是这个声音的...");
}
protected void start() {
System.out.println("宝马车跑起来是这个样子的...");
}
protected void stop() {
System.out.println("宝马车应该这样停车...");
}
}
这样两个汽车就能根据不同的顺序执行
public class Client {
public static void main(String[] args) {
/*
* 客户告诉XX公司，我要这样一个模型，然后XX公司就告诉我老大
* 说要这样一个模型，这样一个顺序，然后我就来制造
*/
BenzModel benz = new BenzModel();
//存放run的顺序
ArrayList<String> sequence = new ArrayList<String>();
sequence.add("engine boom"); //客户要求，run的时候先发动引擎
sequence.add("start"); //启动起来
sequence.add("stop"); //开了一段就停下来
//我们把这个顺序赋予奔驰车
benz.setSequence(sequence);
benz.run();
}
}
如果某一天说要做出启动顺序不同的奔驰车,可以直接修改sequence即可,可以满足不同的需求
- 通用源码
产品类:
public class Product {
public void doSomething(){
//独立业务处理
}
}
抽象建造者
public abstract class Builder {
//设置产品的不同部分，以获得不同的产品
public abstract void setPart();
//建造产品
public abstract Product buildProduct();
}
具体建造者
public class ConcreteProduct extends Builder {
private Product product = new Product();
//设置产品零件
public void setPart(){
/*
* 产品类内的逻辑处理
*/
}
//组建一个产品
public Product buildProduct() {
return product;
}
}
导演类
public class Director {
private Builder builder = new ConcreteProduct();
//构建不同的产品
public Product getAProduct(){
builder.setPart();
/*
* 设置不同的零件，产生不同的产品
*/
return builder.buildProduct();
}
}
使用场景:
相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式
多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式
产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适
第十二章 代理模式
通用源码
public interface Subject {
//定义一个方法
public void request();
}
public class RealSubject implements Subject {
//实现方法
public void request() {
//业务逻辑处理
}
}
public class Proxy implements Subject {
//要代理哪个实现类
private Subject subject = null;
//默认被代理者
public Proxy(){
this.subject = new Proxy();
}
public Proxy(Subject _subject){
this.subject = _subject;
}
//通过构造函数传递代理者
public Proxy(Object...objects ){
}
//实现接口中定义的方法
public void request() {
this.before();
this.subject.request();
this.after();
}
//预处理
private void before(){
//do something
}
//善后处理
private void after(){
//do something
}
}
你要代理谁就产生该代理的实例，然后把被代理者传递进来
给代理类增加一个接口
public interface IProxy {
//计算费用
public void count();
}
public class GamePlayerProxy implements IGamePlayer,IProxy {
private IGamePlayer gamePlayer = null;
//通过构造函数传递要对谁进行代练
public GamePlayerProxy(IGamePlayer _gamePlayer){
this.gamePlayer = _gamePlayer;
}
//代练杀怪
public void killBoss() {
this.gamePlayer.killBoss();
}
//代练登录
public void login(String user, String password) {
this.gamePlayer.login(user, password);
}
//代练升级
public void upgrade() {
this.gamePlayer.upgrade();
this.count();
}
//计算费用
public void count(){
System.out.println("升级总费用是：150元");
}
}
只要在代理类中增加实现计费的接口,就可以对用户进行计费
动态代理:动态代理是在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。
第13章 原型模式
不通过new关键字来产生一个对象，而是通过对象复制来实现的模式就叫做原型模式
使用场景:
资源优化场景
性能和安全要求的场景
一个对象多个修改者的场景
注意:拷贝的时候构造函数不会被执行
第14章 中介者模式
加入了一个中介者作为三个模块的交流核心
MVC框架中的C就是一个中介,将M和V隔离开,协调M和V工作
第15章 命令模式
public abstract class Command {
//把三个组都定义好，子类可以直接使用
protected RequirementGroup rg = new RequirementGroup(); //需求组
protected PageGroup pg = new PageGroup(); //美工组
protected CodeGroup cg = new CodeGroup(); //代码组
//只有一个方法，你要我做什么事情
public abstract void execute();
}
public class AddRequirementCommand extends Command {
//执行增加一项需求的命令
public void execute() {
//找到需求组
super.rg.find();
//增加一份需求
super.rg.add();
//给出计划
super.rg.plan();
}
}
public class DeletePageCommand extends Command {
//执行删除一个页面的命令
public void execute() {
//找到页面组
super.pg.find();
//删除一个页面
super.rg.delete();
//给出计划
super.rg.plan();
}
}
public class Invoker {
//什么命令
private Command command;
//客户发出命令
public void setCommand(Command command){
this.command = command;
}
//执行客户的命令
public void action(){
this.command.execute();
}
}
public class Client {
public static void main(String[] args) {
//定义我们的接头人
Invoker xiaoSan = new Invoker(); //接头人就是小三
//客户要求增加一项需求
System.out.println("------------客户要求增加一项需求---------------");
//客户给我们下命令来
Command command = new AddRequirementCommand();
//接头人接收到命令
xiaoSan.setCommand(command);
//接头人执行命令
xiaoSan.action();
}
}
第16章 责任链模式