设计模式的理解及应用

﹏ヽ暗。殇╰゛Y 2023-09-27 10:14 47阅读 0赞

\*\*

### 设计模式是什么？它是用来干什么的？我们为什么要学习设计模式？怎样学习设计模式？ ###

\*\*  
\*\*

### 1.设计模式是什么？ ###

\*\*  
设计模式是一种解决方案！  
具体来讲，设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案！！这些方案是众多前辈经的知识和经验的总结！！

\*\*

### 2.我们为什么要学习设计模式？ ###

\*\*  
（1）重用代码（2）代码易读性（3）代码可靠性（4）安全性（5）稳健性

\*\*

### 3.设计模式用来干什么的？ ###

\*\*  
（1）开发人员的共同平台（2）最佳的实践

\*\*

### 4.设计模式的分类： ###

\*\*  
**（1）创建型模式:（这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。）**

单例模式, 工厂模式, 抽象工厂模式, 建造者模式, 原型模式

**结构型模式:（这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。）**

适配器模式, 桥接模式, 装饰模式, 组合模式, 外观模式, 享元模式, 代理模式  
**行为型模式:（这些设计模式特别关注对象之间的通信。）**

模板方法模式, 命令模式, 迭代器模式, 观察者模式, 中介者模式, 备忘录模式, 解释器模式, 状态模式, 策略模式, 职责链模式, 访问者模式

\*\*

### 5.设计模式的原则 ###

\*\*

（1）开闭原则：对扩展开放，对修改关闭  
（2）里氏替换原则：继承必须确保超类所拥有的的性质在子类中仍然成立，相当于是对开闭原则的补充，以内开闭原则的关键步骤是抽象化，而基类和子类的继承关系就是抽象化的具体实现。  
（3）依赖倒转原则：要面向接口编程，依赖于抽象而不依赖于具体。  
（4）接口隔离原则：我们要为各个类建立他们所需要的专用接口，实现解耦，避免高耦合！  
（5）迪米特法则（最少知道原则）：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。举个例子：在生活中，只有你的直接朋友进行交流，而不与陌生人说话。  
（6）合成复用原则：尽量先试用组合或者聚合等关联关系实现，其次才考虑利用继承关系来实现。  
（7）职责原则：控制类的粒度大小, 将对象解耦, 提高其内聚性。

\*\*

### 6.进行各类模式的探究： ###

\*\*  
（1）工厂模式：  
核心本质：实例化对象不适用于new,因此选择工厂方法代替，实现类与创建对象进行统一控制和管理，从而实现调用者与实现类解耦！

三种模式：简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）！

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();
        }
    }

工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品），相当于简单工厂模式的plus版，但增加了许多代码量！！  
抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

// 手机产品接口
    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方法**

\*\*

### 2.建造者模式 ###

\*\*  
建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。

解决问题面向对象：在解决软件系统中，优势对一个复杂对象的创建工作，通常是由各个部分的子对象用一定的算法构成，由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法却要保持相对稳定。  
举例说明：例如我们要去汉堡店，通常汉堡、可乐、炸鸡等是不变的，但是其互相组合确实千变万化的，这也是所谓的各种全家桶、节日桶、类型的套餐。

建造者模式下：  
建造者：创建和提供实例，  
导演者：管理建造出来的实例的依赖关系。  
具体实例代码：https://www.runoob.com/design-pattern/builder-pattern.html

实际开发案例：  
需要生成的产品对象有复杂的内部结构  
当一些基本部件不会变, 而其组合经常变化的时候  
需要生成的对象内部属性本身相互依赖

\*\*

### 3.单例模式 ###

\*\*  
单例模式最大的特点就是：构造器私有。

单例模式在我看我开来其实就是对于单例模式的实体类而言，只能有唯一实例，而且并且给其他对象仅提供这一实例！！

public class SingleObject {
        
     
       //创建 SingleObject 的一个对象
       private static SingleObject instance = new SingleObject();
     
       //让构造函数为 private，这样该类就不会被实例化
       private SingleObject(){
        }
     
       //获取唯一可用的对象
       public static SingleObject getInstance(){
        
          return instance;
       }
     
       public void showMessage(){
        
          System.out.println("Hello World!");
       }
    }

主要分为懒汉式加载和饿汉式加载  
所谓懒汉式架子就是

public class Singleton {
          
        private static Singleton instance;  
        private Singleton (){
        }  
      
        public static Singleton getInstance() {
          
            if (instance == null) {
          
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

饿汉式加载：

public class Singleton {
          
        private static Singleton instance = new Singleton();  
        private Singleton (){
        }  
        public static Singleton getInstance() {
          
        return instance;  
        }  
    }

二者的区别懒汉式只在首次使用该对象的时候才会创建，存在线程安全问题，饿汉式加载在类加载的时候就开始初始化，浪费内存！！

应用场景：  
网站在线人数的统计  
配置文件访问类  
最贴近的就会Spring创建的bean对象的单例模式。  
计时器：

package com.day20220919;
    
    import java.util.concurrent.atomic.AtomicLong;
    
    public class Counter {
        
    
        private Counter(){
        
            System.out.println("init...");
        }
    
        private static class CounterHolder{
        
            private static final Counter counter = new Counter();
        }
    
    
        public static final Counter getInstance(){
        
            return CounterHolder.counter;
        }
    
        private AtomicLong online = new AtomicLong();
    
        public long getOnline(){
        
            return online.get();
        }
    
        public long add(){
        
            return online.incrementAndGet();
        }
    }

模拟不同时间段用户查看网站时的在线人数：

package com.day20220919;
    
    public class Test {
        
    
        public static void main(String[] args) {
        
    
            Counter counter = Counter.getInstance();
            for (int i = 0; i < 100; i++) {
        
                new Thread(()->{
                    counter.add();
                    System.out.println(counter.getOnline());
                }).start();
            }
        }
    }

关于单例模式，具体大家可以看看这篇文章：  
https://blog.csdn.net/zouliping123456/article/details/79858576

未完，待续！！！！！