java设计模式
一、什么是设计模式
设计模式(Design Pattern)是前辈对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定。而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。
二、OOP七大原则
开闭原则：对扩展开放，对修改关闭
里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立。
依赖倒置原则：要面向接口编程，不要面向实现编程。
单一职责原则：控制类的粒度大小，将对象解耦、提高其内聚性。
接口隔离原则：要为各个类建立他们需要的专用接口。
迪米特法原则：只与你的直接朋友交谈，不跟“陌生人”说话。
合成复用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。
三、工厂模式
核心本质：
- 实例化对象不实用new，用工厂方法代替。
- 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
三种模式：
- 简单工厂模式
- 用来生产同一等级结构中的任意产品(对于增加新的产品，需要改动已有代码) --- 例如：一个工厂生产多种产品
public interface Car { void name(); } public class FaLaLi implements Car { @Override public void name() { System.out.println("法拉利"); } } public class Tesla implements Car { @Override public void name() { System.out.println("特斯拉"); } } //静态工厂 public class CarFactory { //方法一 public static Car getCar(String car) { switch (car){ case "法拉利": return new FaLaLi(); case "特斯拉": return new Tesla(); default: return null; } } //方法二 public static Car getTesla(){ return new Tesla(); } public static Car getFaLaLi(){ return new FaLaLi(); } } public class Consumer { public static void main(String[] args) { //方法一 Car tesla = CarFactory.getCar("特斯拉"); tesla.name(); //特斯拉 Car faLaLi = CarFactory.getCar("法拉利"); faLaLi.name(); //法拉利 //方法二 Car tesla1 = CarFactory.getTesla(); Car faLaLi1 = CarFactory.getFaLaLi(); tesla1.name(); //特斯拉 faLaLi1.name(); //法拉利 } }
- 工厂方法模式
- 用来生产同一等级结构中的固定产品(支持增加任意产品)---例如：一个工厂生产固定产品
//工厂方法模式 public interface CarFactory { Car getCar(); } public class FaLaLiFactory implements CarFactory { @Override public Car getCar() { return new FaLaLi(); } } public class TeslaFactory implements CarFactory { @Override public Car getCar() { return new Tesla(); } } public class Consumer { public static void main(String[] args) { Car faLaLiCar = new FaLaLiFactory().getCar(); Car teslaCar = new TeslaFactory().getCar(); faLaLiCar.name(); teslaCar.name(); } }
- 抽象工厂模式
- 围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
四、抽象工厂模式
- 定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体的类
- 使用场景：
- 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节
- 强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量的重复代码
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体实现
- 优点：
- 具体产品在应用层的代码隔离，无需关心创建的细节
- 将一个系列产品统一到一起创建
- 缺点：
- 规定了所有可能被创建的产品集合，产品族中扩展的产品困难
- 增加了系统的抽象性和理解难度
public interface IphoneProduct { void call(); void sendMs(); } public interface IRouterProduct { void openWifi(); void connectNet(); } public class HuaWeiPhone implements IphoneProduct{ @Override public void call() { System.out.println("华为手机打电话"); } @Override public void sendMs() { System.out.println("华为手机发短信"); } } public class HuaWeiRouter implements IRouterProduct { @Override public void openWifi() { System.out.println("华为路由器打开wifi"); } @Override public void connectNet() { System.out.println("华为路由器连接网络"); } } public class XmPhone implements IphoneProduct { @Override public void call() { System.out.println("小米手机打电话"); } @Override public void sendMs() { System.out.println("小米手机发短信"); } } public class XmRouter implements IRouterProduct { @Override public void openWifi() { System.out.println("小米路由器打开wifi"); } @Override public void connectNet() { System.out.println("小米路由器连接网络"); } } //抽象产品工厂 public interface IProductFactory { // 生产手机 IphoneProduct phoneProduct(); //生产路由器 IRouterProduct routerProduct(); } public class HuaWeiFactory implements IProductFactory { @Override public IphoneProduct phoneProduct() { return new HuaWeiPhone(); } @Override public IRouterProduct routerProduct() { return new XmRouter(); } } public class XmFactory implements IProductFactory { @Override public IphoneProduct phoneProduct() { return new XmPhone(); } @Override public IRouterProduct routerProduct() { return new XmRouter(); } } public static void main(String[] args) { System.out.println("============小米系列产品==============="); //小米工厂 XmFactory xmFactory = new XmFactory(); IphoneProduct xmPhone = xmFactory.phoneProduct(); xmPhone.call(); xmPhone.sendMs(); IRouterProduct xmRouter = xmFactory.routerProduct(); xmRouter.openWifi(); xmRouter.connectNet(); System.out.println("============华为系列产品==============="); //华为工厂 HuaWeiFactory huaWeiFactory = new HuaWeiFactory(); IphoneProduct huaWeiPhone = huaWeiFactory.phoneProduct(); huaWeiPhone.call(); huaWeiPhone.sendMs(); IRouterProduct huaWeiRouter = huaWeiFactory.routerProduct(); huaWeiRouter.openWifi(); huaWeiRouter.connectNet(); } } ============小米系列产品=============== 小米手机打电话 小米手机发短信 小米路由器打开wifi 小米路由器连接网络 ============华为系列产品=============== 华为手机打电话 华为手机发短信 小米路由器打开wifi 小米路由器连接网络
五、建造者模式
- 建造者模式也属于创建模式，它提供了一种创建对象的最佳方式。
- 定义：将一个复杂的对象的创建与它的表示分离，使得同样的架构可以创建不同的对象。
- 主要作用：在用户不知道对象建造过程和细节的情况下就可以直接创建复杂的对象。
- 用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象(把内部的创建过程和细节隐藏起来
//抽象的建造者： 方法 public abstract class Builder { abstract Builder buildA(String msg); //地基 abstract Builder buildB(String msg); //房子 abstract Builder buildC(String msg); //装修 //完工 得到房子 abstract House getHose(); } //房子 public class House { private String buildA; private String buildB; private String buildC; public String getBuildA() { return buildA; } public void setBuildA(String buildA) { this.buildA = buildA; } public String getBuildB() { return buildB; } public void setBuildB(String buildB) { this.buildB = buildB; } public String getBuildC() { return buildC; } public void setBuildC(String buildC) { this.buildC = buildC; } @Override public String toString() { return "House{" + "buildA='" + buildA + '\'' + ", buildB='" + buildB + '\'' + ", buildC='" + buildC + '\'' + '}'; } } //具体建造者 工人 public class Worker extends Builder { private House house; public Worker(){ house = new House(); } @Override Builder buildA(String msg) { house.setBuildA(msg); return this; } @Override Builder buildB(String msg) { house.setBuildB(msg); return this; } @Override Builder buildC(String msg) { house.setBuildC(msg); return this; } @Override House getHose() { return house; } } public class Test { public static void main(String[] args) { Worker worker = new Worker(); // 可根据自己喜好建房子 House hose = worker.buildA("建地基").buildB("搭架构").buildC("装修").getHose(); System.out.println(hose.toString()); } } //House{buildA='建地基', buildB='搭架构', buildC='装修'}
