一、六大涉及原则
1.单一职责原则
它规定一个类应该只有一个发生变化的原因。
实现 多个类实现一个接口，一个实现类一个职责
2.开闭原则
开闭原则规定软件中的对象、类、模块和函数对外扩展应该是开放的，但对于修改是封闭的。
实现，子类继承父类
3.里氏替换原则
子类可以扩展父类的功能，但不能改变父类原有的功能，也就是说，当子类继承父类时，除添加新的方法且完成新增功能外，尽量不要重写父类的方法。
4.迪米特法则原则
又称最少知道原则，是指一个对象类对于其它对象类来说 知道的越少越好。也就是说两个类之间不要有过多耦合关系 保持最少关联性。
5.接口隔离原则
接口隔离原则要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。
6.依赖倒置原则
依赖倒置原则是指在设计代码架构时，高层模块不应该依赖于底层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。
二. 设计模式
1.策略模式
//策略
public interface ISaveData {
void save(Object data);
}
//具体策略1
public class SaveToFile implements ISaveData {
@Override
public void save(Object data) {
System.out.println("数据：" + data + " 保存到文件");
}
}
//具体策略2
public class SaveToMysql implements ISaveData {
@Override
public void save(Object data) {
System.out.println("数据：" + data + " 保存到Mysql");
}
}
//具体策略3
public class SaveToRedis implements ISaveData {
@Override
public void save(Object data) {
System.out.println("数据：" + data + " 保存到Redis");
}
}
//环境
public class SaveClient {
private ISaveData saveData;
public SaveClient(ISaveData saveData){
this.saveData = saveData;
}
public void setSaveData(ISaveData saveData){
this.saveData = saveData;
}
public void save(Object data){
saveData.save(data);
}
}
//客户端调用
public class TestUse {
public static void main(String args[]){
Object data = "数据";
SaveClient client = new SaveClient(new SaveToRedis());
client.save(data);
client.setSaveData(new SaveToFile());
client.save(data);
}
}
运行结果：
数据：数据 保存到Redis
数据：数据 保存到文件
基本代码
`
package code.chapter2.strategy0;
import java.util.Scanner;
public class Test {
public static void main(String[] args){
System.out.println("**********************************************");
System.out.println("《大话设计模式》代码样例");
System.out.println();
Context context;
//由于实例化不同的策略，所以最终在调用
//context.contextInterface()时,所
//获得的结果就不尽相同
context = new Context(new ConcreteStrategyA());
context.contextInterface();
context = new Context(new ConcreteStrategyB());
context.contextInterface();
context = new Context(new ConcreteStrategyC());
context.contextInterface();
System.out.println();
System.out.println("**********************************************");
}
}
//抽象算法类
abstract class Strategy{
//算法方法
public abstract void algorithmInterface();
}
//具体算法A
class ConcreteStrategyA extends Strategy {
//算法A实现方法
public void algorithmInterface() {
System.out.println("算法A实现");
}
}
//具体算法B
class ConcreteStrategyB extends Strategy {
//算法B实现方法
public void algorithmInterface() {
System.out.println("算法B实现");
}
}
//具体算法C
class ConcreteStrategyC extends Strategy {
//算法C实现方法
public void algorithmInterface() {
System.out.println("算法C实现");
}
}
//上下文
class Context {
Strategy strategy;
//初始化时，传入具体的策略对象
public Context(Strategy strategy) {
this.strategy = strategy;
}
//上下文接口
public void contextInterface() {
//根据具体的策略对象，调用其算法的方法
strategy.algorithmInterface();
}
}
`
2.状态模式
//抽象状态
public interface ISaveData {
void save(Object data);
}
//具体状态1
public enum SaveBigData implements ISaveData{
instance;
@Override
public void save(Object data) {
System.out.println("保存到文件:" + data);
}
}
//具体状态2
public enum SaveMiddleData implements ISaveData{
instance;
@Override
public void save(Object data) {
System.out.println("保存到Mysql:" + data);
}
}
//具体状态3
public enum SaveSmallData implements ISaveData{
instance;
@Override
public void save(Object data) {
System.out.println("保存到Redis:" + data);
}
}
//环境（Context）
public class SaveDataController {
private ISaveData saveData;
public void save(String data){
//为了演示，此处的大的数据其实也是很小的
if(data.length()<1<<2)
saveData = SaveSmallData.instance;
else if(data.length()<1<<4)
saveData = SaveMiddleData.instance;
else
saveData = SaveBigData.instance;
saveData.save(data);
}
}
//客户端调用
public class TestUse {
public static void main(String args[]){
String smallData = "小数据";
String middleData = "介于小数据和大数据之间的数据";
String bifgData = "这里就假定这是一个很大很大很大的数据";
SaveDataController saveDataController = new SaveDataController();
saveDataController.save(smallData);
saveDataController.save(middleData);
saveDataController.save(bifgData);
}
}
3.责任链模式
//处理者
public interface Handler {
int handleRequest(int n);
void setNextHandler(Handler next);
}
//第一个具体处理者，处理小于0的
public class Handler1 implements Handler {
private Handler next;
@Override
public int handleRequest(int n) {
if(n<0) return -n;
else{
if(next==null)
throw new NullPointerException("next 不能为空");
return next.handleRequest(n);
}
}
@Override
public void setNextHandler(Handler next) {
this.next = next;
}
}
//第二个具体处理者，处理>=0但小于10的
public class Handler2 implements Handler {
private Handler next;
@Override
public int handleRequest(int n) {
if(n<10) return n*n;
else{
if(next==null)
throw new NullPointerException("next 不能为空");
return next.handleRequest(n);
}
}
@Override
public void setNextHandler(Handler next) {
this.next = next;
}
}
//第三个具体处理者，处理>=0但小于10的
public class Handler3 implements Handler {
private Handler next;
@Override
public int handleRequest(int n) {
if(n<=Integer.MAX_VALUE) return n;
else{
if(next==null)
throw new NullPointerException("next 不能为空");
return next.handleRequest(n);
}
}
@Override
public void setNextHandler(Handler next) {
this.next = next;
}
}
//客户端调用
public class TestUse {
public static void main(String args[]){
Handler h1,h2,h3;
h1 = new Handler1();
h2 = new Handler2();
h3 = new Handler3();
h1.setNextHandler(h2);
h2.setNextHandler(h3);
System.out.println(h1.handleRequest(-1));
System.out.println(h1.handleRequest(5));
System.out.println(h1.handleRequest(9999));
}
}
4. 建造者模式
public class Bike {
private String frame;
private String seat;
public String getFrame() {
return frame;
}
public void setFrame(String frame) {
this.frame = frame;
}
public String getSeat() {
return seat;
}
public void setSeat(String seat) {
this.seat = seat;
}
}
public abstract class Builder {
protected Bike bike=new Bike();
public abstract void buildFrame();
public abstract void buildSeat();
public abstract Bike createBike();
}
public class MobileBuilder extends Builder{
@Override
public void buildFrame() {
bike.setFrame("碳纤维车架");
}
@Override
public void buildSeat() {
bike.setSeat("真皮");
}
@Override
public Bike createBike() {
return bike;
}
}
public class OfoBuilder extends Builder{
@Override
public void buildFrame() {
bike.setFrame("铝合金车架");
}
@Override
public void buildSeat() {
bike.setSeat("橡胶");
}
@Override
public Bike createBike() {
return bike;
}
}
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Bike construct(){
builder.buildFrame();
builder.buildSeat();
return builder.createBike();
}
}
public class Client {
public static void main(String[] args) {
//创建指挥者对象
Director director = new Director(new MobileBuilder());
//让指挥者组装自行车
Bike bike = director.construct();
System.out.println(bike.getFrame());
System.out.println(bike.getSeat());
}
}
结果
碳纤维车架
真皮
Process finished with exit code 0
5. 享元模式
主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。
