学习设计模式的意义
设计模式：是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案
设计模式的本质：是面向对象设计原则的实际运用，是对类的封装、继承性和多态性以及类的关联关系和组合关系的充分理解
设计模式的基本要素：模式名称、问题、解决方案、效果
分类
GoF 23（一种思维，一种态度，一种进步）
创建型模式：（描述怎样去创建一个对象，创建和使用分离）
- 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 5种
结构性模式：（描述如何将类或对象安照某种类型组成更大的结构）
- 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式，代理模式 7种
行为型模式：（描述类和对象如何可以相互协作，完成单个类无法完成的任务）
- 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式 11种
OOP（面向对象）七大原则
**开闭原则：**对扩展开放，对修改关闭（当需求改变的时候，尽量去扩展，而不要去修改源代码）
里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立（尽量不重写父类的方法）
**依赖倒置原则：**要面向接口编程，不要面向实现编程
**单一职责原则：**控制粒度的大小，将对象解耦，提高其内聚性（保证一个对象（方法）不应该做太多的事，原子性，单一的方法做单一的事情）
接口隔离原则：要为各个类建立它们需要的专门接口
迪米特法则：只与你的直接朋友交谈，不跟“陌生人”讲话（降低类之间的耦合性，提高模块之间的独立性）
合成服用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现
单例模式
核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
饿汉式单例模式：
//饿汉式单例
public class Hungry {
//单例模式核心思想：构造器私有
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
DCL懒汉式单例模式：
package com.zht.single;
//懒汉式单例
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName());
}
private volatile static LazyMan LazyMan;
// 双重检测锁模式和懒汉式单例 DCL 懒汉式
public static LazyMan getInstance(){
if (LazyMan==null){
synchronized (LazyMan.class){
if (LazyMan==null){
LazyMan = new LazyMan();//不是一个原子性
/*
new一个对象的操作
1.分配内存空间
2.执行构造方法
3.把这个对象指向这个空间
123
132 线程A
线程B //此时B进来会认为LazyMan不为null
直接返回 此时lazyMan 还没有构造
为了避免指令重排
*/
}
}
}
return LazyMan;
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
反射 可以破坏这种单例模式
package com.zht.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
//懒汉式单例
//道高一尺，魔高一丈
public class LazyMan {
private static boolean qinjiang = false;
private LazyMan(){
if (qinjiang == false){
qinjiang = true;
}else{
throw new RuntimeException("不要试图使用反射破坏异常");
}
// synchronized (LazyMan.class){
// if(LazyMan!=null){
// throw new RuntimeException("不要试图使用反射破坏异常");
// }
// }
// System.out.println(Thread.currentThread().getName());
}
private volatile static LazyMan LazyMan;
// 双重检测锁模式和懒汉式单例 DCL 懒汉式
public static LazyMan getInstance(){
if (LazyMan==null){
synchronized (LazyMan.class){
if (LazyMan==null){
LazyMan = new LazyMan();//不是一个原子性
/*
new一个对象的操作
1.分配内存空间
2.执行构造方法
3.把这个对象指向这个空间
123
132 线程A
线程B //此时B进来会认为LazyMan不为null
直接返回 此时lazyMan 还没有构造
为了避免指令重排
*/
}
}
}
return LazyMan;
}
//反射！
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
// LazyMan instance = LazyMan.getInstance();
Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
qinjiang.setAccessible(true);
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//得到构造器方法
declaredConstructor.setAccessible(true);//无视构造器是私有方法
LazyMan instance1 = declaredConstructor.newInstance();
qinjiang.set(instance1,false);
LazyMan instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}
静态内部类
package com.zht.single;
// 静态内部类
public class Holder {
private Holder(){
}
public static Holder getInstance(){
return InnerClass.HOLDER;
}
public static class InnerClass{
private static final Holder HOLDER = new Holder();
}
}
单例不安全，因为有反射
枚举 ：不支持反射
package com.zht.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public enum EnumSingle {
INSTANCE;
public EnumSingle getInstance(){
return INSTANCE;
}
}
class Test{
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumSingle instance1 = EnumSingle.INSTANCE;
// Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
// 枚举没有无参构造，只有有参构造
Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
declaredConstructor.setAccessible(true);
EnumSingle instance2 = declaredConstructor.newInstance();
}
}
枚举没有无参构造，只有有参构造
工厂设计模式
作用：
-
实现了创建者和调用者的分离
-
详细分类
-
简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
-
工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
-
抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
工厂设计模式的原则（OOP七大原则）：
- 开闭原则：一个软件的实体应当对扩展开放，对修改关闭
- 依赖倒转原则：要针对接口编程，不要针对实现编程
- 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信
核心本质：
- 实例化对象不使用new，用工厂方法代替 factory
- 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦
简单工厂模式（静态工厂模式）
用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
public interface Car {
void name();
}
public class WuLing 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){
if(car.equals("wuling")){
return new WuLing();
}else if(car.equals("tesila")){
return new Tesla();
}else {
return null;
}
}
// 方法二：
public static Car geyWuling(){
return new WuLing();
}
public static Car geyTesla(){
return new Tesla();
}
}
public class Consumer {
public static void main(String[] args) {
// 接口，所有的实现类
// Car car = new WuLing();
// Car car1 = new Tesla();
// 2、使用工厂创建
Car car = CarFactory.getCar("wuling");
Car car1 = CarFactory.getCar("tesila");
car.name();
car1.name();
}
}
弊端：
增加一个新的产品，做不到不修改代码。
工厂方法模式
用来生产同一等级结构中的固定产品（支持增加任意产品)
public interface Car {
void name();
}
public class WuLing implements Car {
@Override
public void name() {
System.out.println("五菱宏光");
}
}
public class Tesla implements Car {
@Override
public void name() {
System.out.println("特斯拉");
}
}
// 工厂方法模式
public interface CarFactory {
Car getCar();
}
public class WulingFactory implements CarFactory{
@Override
public Car getCar() {
return new WuLing();
}
}
public class TeslaFactory implements CarFactory{
@Override
public Car getCar() {
return new Tesla();
}
}
public class Consumer {
public static void main(String[] args) {
Car car = new WulingFactory().getCar();
Car car1 = new TeslaFactory().getCar();
car.name();
car1.name();
Car car2 = new MoBaiFactory().getCar();
car2.name();
}
}
对比简单工厂模式
1、结构复杂度：simple>method
2、代码复杂度：simple>method
3、编程复杂度：simple>method
4、管理上的复杂度：simple>method
根据设计原则，使用工厂方法模式；根据实际业务，使用简单工厂模式
抽象工厂模式
围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂
定义：
抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们的具体的类（针对整个产品族，产品等级数量相对固定的产品族）
适用场景：
-
客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
-
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
-
提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于
// 手机产品接口 public interface IphoneProduct { void start(); void shutdown(); void callup(); void sendSMS(); } // 小米手机 public class XiaomiPhone implements IphoneProduct{ @Override public void start() { System.out.println("开启小米手机"); } @Override public void shutdown() { System.out.println("关闭小米手机"); } @Override public void callup() { System.out.println("小米手机打电话"); } @Override public void sendSMS() { System.out.println("小米手机发短信"); } } // 华为手机 public class HuaweiPhone implements IphoneProduct{ @Override public void start() { System.out.println("开启华为手机"); } @Override public void shutdown() { System.out.println("关闭华为手机"); } @Override public void callup() { System.out.println("华为手机打电话"); } @Override public void sendSMS() { System.out.println("华为手机发短信"); } } // 路由器产品接口 public interface IRouterProduct { void start(); void shutdown(); void openWifi(); void setting(); } // 小米路由器 public class XiaomiRouter implements IRouterProduct{ @Override public void start() { System.out.println("启动小米路由器"); } @Override public void shutdown() { System.out.println("关闭小米路由器"); } @Override public void openWifi() { System.out.println("打开小米Wi-Fi"); } @Override public void setting() { 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 openWifi() { System.out.println("打开华为Wi-Fi"); } @Override public void setting() { System.out.println("华为设置"); } } // 抽象产品工厂 public interface IProductFactory { // 生产手机 IphoneProduct iphoneProduct(); // 生产路由器 IRouterProduct irouterProduct(); } public class XiaomiFactory implements IProductFactory{ @Override public IphoneProduct iphoneProduct() { return new XiaomiPhone(); } @Override public IRouterProduct irouterProduct() { return new XiaomiRouter(); } } public class HuaweiFactory implements IProductFactory{ @Override public IphoneProduct iphoneProduct() { return new HuaweiPhone(); } @Override public IRouterProduct irouterProduct() { return new HuaweiRouter(); } } public class Client { public static void main(String[] args) { System.out.println("小米系列产品--------------------"); // 小米工厂 XiaomiFactory xiaomiFactory = new XiaomiFactory(); IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct(); iphoneProduct.callup(); iphoneProduct.sendSMS(); IRouterProduct iRouterProduct = xiaomiFactory.irouterProduct(); iRouterProduct.openWifi(); System.out.println("华为系列产品--------------------"); // 华为工厂 HuaweiFactory huaweiFactory = new HuaweiFactory(); iphoneProduct = huaweiFactory.iphoneProduct(); iphoneProduct.callup(); iphoneProduct.sendSMS(); iRouterProduct = huaweiFactory.irouterProduct(); iRouterProduct.openWifi(); } }
优点
具体产品在应用层的代码隔离，无需关心创建的细节
将一个系列的产品统一到一起创建
缺点：
规定了所有可能被创建的产品集合，产品族中扩展新的产品困难；
增加了系统的抽象性和理解难度
工厂模式小结
简单工厂模式：虽然某种程度上不符合设计原则，但实际使用最多
工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展
抽象工厂模式：不可以增加产品，可以增加产品族
应用场景
- jdk中calendar的getInstance方法
- JDBC中的Connection对象的获取
- Spring中的IOC容器创建管理bean对象
- 反射中Class对象的newInstance方法
建造者模式
它提供一种创建对象的最佳方式
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
主要作用：在用户不知道 对象的建造过程和细节的情况下就可以直接创建复杂的对象。
用户只需要给出指定复杂对象的类型和内容。建造者牧师负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
例如：
- 工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
- 汽车购买者（用户）：你只需要说出你想要的型号（对象的类型和内容），然后直接购买就可以使用了（不需要知道汽车怎么组装的）
427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
