1.设计模式概述
什么是设计模式
- 设计模式是前辈对于代码开发经验的总结，是解决特定问题的一系列套路，它不是语法规定，而是一套用来提高代码可复用性，可维护性，可读性，稳健性以及安全性的解决方案。
- Gof（四人帮）合作出版了《设计模式：可复用面向对象软件的基础》一书，收纳了23种设计模式，从此树立了软件设计模式领域的里程碑，人称[Gof模式]
学习设计模式的意义
-
设计模式的本质是面向对象设计原则的实际应用，是对类封装，继承和多态以及类的关联关系和组合关系的充分理解
-
正确使用设计模式具有以下优点：
- 可以提高程序员的思维能力，编程能力和设计能力
- 使程序设计更加标准化，代码编织更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期
- 使设计的代码可重用性高，可读性强，可靠性高，灵活性好，可维护性强。
GoF23
- GoF23
- 一种思维，一种态度，一种进步
- 创建型模式：
- 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
- 结构型模式：
- 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
- 行为型模式：
- 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式
2.OOP七大原则
- 开闭原则：对外扩展，对修改关闭
- 里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立
- 依赖倒置原则：要面向接口编程，不要面向实现编程
- 单一职责原则：控制类的粒度大小、将对象解耦、提高其内聚性
- 接口隔离原则：要为各个类建立它们需要的专用接口
- 迪米特原则：只与你的直接朋友交谈，不跟“陌生人”说话
- 合成复用原则：尽量先使用组合或者聚合等关联关系实现，其次才考虑使用继承关系来实现
3.工厂模式
-
作用
- 实现了创建者和调用者的分离
- 详细分类：
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
-
核心本质
- 实例化对象不使用new，用工厂方法代替
- 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类的解耦
-
三种模式：
- 简单工厂模式
- 用来生产同一等级结构中的任意产品（对于增加新的产品，需要求购已有的代码）
- 工厂方法模式
- 用来生产同一等级结构中的固定产品（支持增加任意产品）
- 抽象工厂模式
- 围绕一个超级工厂创建其他的工厂。该超级工厂又称为其他工厂的工厂
- 简单工厂模式
简单工厂模式（静态工厂模式）
public interface Car {
public void name();
}
/**
* 静态工厂模式
*
* 增加一个新的产品，如果你不修改代码，是做不到的
*/
public class CarFactory {
public static Car getCar(String car){
if (car.equals("五菱")){
return new Wuling();
}else if (car.equals("特斯拉")){
return new Tesla();
}else {
return null;
}
}
}
public class Consumer {
public static void main(String[] args) {
Car car = CarFactory.getCar("五菱");
Car car1 = CarFactory.getCar("特斯拉");
car.name();
car1.name();
}
}
public class Tesla implements Car{
@Override
public void name() {
System.out.println("特斯拉");
}
}
public class Wuling implements Car{
@Override
public void name() {
System.out.println("五菱宏光");
}
}
工厂方法模式
public interface Car {
public void name();
}
public interface CarFactory {
Car getCar();
}
public class Consumer {
public static void main(String[] args) {
Car car = new WulingFactory().getCar();
Car car1 = new TeslaFactory().getCar();
car.name();
car1.name();
}
}
public class Tesla implements Car {
@Override
public void name() {
System.out.println("特斯拉");
}
}
public class TeslaFactory implements CarFactory{
@Override
public Car getCar() {
return new Tesla();
}
}
public class Wuling implements Car {
@Override
public void name() {
System.out.println("五菱宏光");
}
}
public class WulingFactory implements CarFactory{
@Override
public Car getCar() {
return new Wuling();
}
}
4.抽象工厂模式
-
定义：抽象工厂模式义工了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类
-
使用场景：
- 客户端（应用层）不依赖于产品类实例如何被创建，实现等细节
- 强调一系列相关的产品对象（属于同一产品等级）一起使用创建对象需要大量的重复代码
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现
-
优点：
- 具体产品在应用层的代码隔离，无需关心细节的创建
- 将一个系列的产品统一到一起创建
-
缺点：
- 规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难；
- 增加了系统的抽象性和理解难度
public class Client {
public static void main(String[] args) {
System.out.println("==========小米系列产品===================");
//小米工厂
XiaomiFactory xiaomiFactory=new XiaomiFactory();
IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
iphoneProduct.call();
iphoneProduct.sendMessage();
IRouterProduct iRouterProduct = xiaomiFactory.iRouterProduct();
iRouterProduct.setting();
iRouterProduct.wifi();
System.out.println("==========华为系列产品===================");
//华为工厂
HuaweiFactory huaweiFactory = new HuaweiFactory();
IphoneProduct iphoneProduct1 = huaweiFactory.iphoneProduct();
iphoneProduct1.call();
iphoneProduct1.sendMessage();
IRouterProduct iRouterProduct1 = huaweiFactory.iRouterProduct();
iRouterProduct1.setting();
iRouterProduct1.wifi();
}
}
public class HuaweiFactory implements IProductFactory{
@Override
public IphoneProduct iphoneProduct() {
return new HuaweiPhone();
}
@Override
public IRouterProduct iRouterProduct() {
return new HuaweiRouter();
}
}
public class HuaweiPhone implements IphoneProduct{
@Override
public void start() {
System.out.println("华为手机开启");
}
@Override
public void shutdown() {
System.out.println("华为手机关机");
}
@Override
public void sendMessage() {
System.out.println("华为手机发信息");
}
@Override
public void call() {
System.out.println("华为手机打电话");
}
}
public class HuaweiRouter implements IRouterProduct{
@Override
public void start() {
System.out.println("华为路由器开启");
}
@Override
public void shutdown() {
System.out.println("华为路由器关闭");
}
@Override
public void wifi() {
System.out.println("华为路由器wifi");
}
@Override
public void setting() {
System.out.println("华为路由器设置");
}
}
public interface IphoneProduct {
public void start();
public void shutdown();
public void sendMessage();
public void call();
}
public interface IProductFactory {
IphoneProduct iphoneProduct();
IRouterProduct iRouterProduct();
}
public interface IRouterProduct {
public void start();
public void shutdown();
public void wifi();
public void setting();
}
public class XiaomiFactory implements IProductFactory{
@Override
public IphoneProduct iphoneProduct() {
return new XiaomiPhone();
}
@Override
public IRouterProduct iRouterProduct() {
return new XiaomiRouter();
}
}
public class XiaomiPhone implements IphoneProduct{
@Override
public void start() {
System.out.println("小米手机开启");
}
@Override
public void shutdown() {
System.out.println("小米手机关机");
}
@Override
public void sendMessage() {
System.out.println("小米手机发信息");
}
@Override
public void call() {
System.out.println("小米手机打电话");
}
}
public class XiaomiRouter implements IRouterProduct{
@Override
public void start() {
System.out.println("小米路由器开启");
}
@Override
public void shutdown() {
System.out.println("小米路由器关闭");
}
@Override
public void wifi() {
System.out.println("小米路由器wifi");
}
@Override
public void setting() {
System.out.println("小米路由器设置");
}
}
- 小结
- 简单工厂模式（静态工厂模式）
- 虽然从某种程度上不符合设计原则，但实际使用最多
- 工厂方法模式
- 不修改已有类的前提下，通过增加新的工厂类实现拓展
- 抽象工厂模式
- 不可以增加产品，可以增加产品族
- 简单工厂模式（静态工厂模式）
6.建造者模式
-
建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式。
-
定义：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
-
主要作用：在用户不知道 对象的建造过程的细节 的情况下就可以直接创建复杂的对象
-
用户只需要给出指定复杂的对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
- 角色分析
public abstract class Builder {
abstract void builderA();//地基
abstract void builderB();//钢筋工程
abstract void builderC();//铺电线
abstract void builderD();//粉刷
abstract Product getProduct();//得到产品
}
//指挥：核心。负责指挥构建一个工程，工程如何构建，由它来决定
public class Director {
//指挥工人按照顺序建造房子
public Product build(Builder builder){
builder.builderA();
builder.builderB();
builder.builderC();
builder.builderD();
return builder.getProduct();
}
}
//产品 房子
public class Product {
private String buildA;
private String buildB;
private String buildC;
private String buildD;
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;
}
public String getBuildD() {
return buildD;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return "Product{" +
"buildA='" + buildA + '\'' +
", buildB='" + buildB + '\'' +
", buildC='" + buildC + '\'' +
", buildD='" + buildD + '\'' +
'}';
}
}
public class Test {
public static void main(String[] args) {
//指挥
Director director = new Director();
//指挥具体的工人完成 产品
Product build = director.build(new Worker());
System.out.println(build.toString());
}
}
//具体建造者 工人
public class Worker extends Builder{
private Product product;
public Worker() {
product=new Product();
}
@Override
void builderA() {
product.setBuildA("地基");
System.out.println("地基");
}
@Override
void builderB() {
product.setBuildB("钢筋工程");
System.out.println("钢筋工程");
}
@Override
void builderC() {
product.setBuildC("铺电线");
System.out.println("铺电线");
}
@Override
void builderD() {
product.setBuildD("粉刷");
System.out.println("粉刷");
}
@Override
Product getProduct() {
return product;
}
}
- 上面示例是Builder模式的常规用法，导演类Director在Builder模式中具有很重要的作用，它用作于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下，需要简化系统结构，可以把Director和抽象建造者结合
public abstract class Builder {
abstract Builder builderA(String msg);//汉堡包
abstract Builder builderB(String msg);//可乐
abstract Builder builderC(String msg);//薯条
abstract Builder builderD(String msg);//甜点
abstract Product getProduct();//获得套餐
}
//产品 套餐
public class Product {
private String buildA="汉堡包";
private String buildB="可乐";
private String buildC="薯条";
private String buildD="甜点";
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;
}
public String getBuildD() {
return buildD;
}
public void setBuildD(String buildD) {
this.buildD = buildD;
}
@Override
public String toString() {
return "Product{" +
"buildA='" + buildA + '\'' +
", buildB='" + buildB + '\'' +
", buildC='" + buildC + '\'' +
", buildD='" + buildD + '\'' +
'}';
}
}
public class Test {
public static void main(String[] args) {
//服务员
Worker worker = new Worker();
//链式编程`:在原来基础上，可以自由组合，如果不组合，也会有默认的套餐
Product product = worker.builderA("全家桶")
.builderB("咖啡").getProduct();
System.out.println(product);
}
}
//服务员
public class Worker extends Builder{
private Product product;
public Worker() {
product= new Product();
}
@Override
Builder builderA(String msg) {
product.setBuildA(msg);
return this;
}
@Override
Builder builderB(String msg) {
product.setBuildB(msg);
return this;
}
@Override
Builder builderC(String msg) {
product.setBuildC(msg);
return this;
}
@Override
Builder builderD(String msg) {
product.setBuildD(msg);
return this;
}
@Override
Product getProduct() {
return product;
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
