对于java中部分设计模式的理解

最新推荐文章于 2024-07-20 15:23:23 发布

Myzhujie

最新推荐文章于 2024-07-20 15:23:23 发布

阅读量295

点赞数 2

文章标签： java 设计模式前端

本文链接：https://blog.csdn.net/Myzhujie/article/details/125966235

版权

本文介绍了Java设计模式的基本概念、作用及其分类，重点讲解了单例模式（包括多种实现方式）、工厂模式、原型模式和代理模式。设计模式为解决软件开发中的常见问题提供了标准化的解决方案，提高了代码的可读性和可维护性。

摘要由CSDN通过智能技术生成

一，什么是设计模式以及它的作用

概念：设计模式指软件开发过程中面临的一般问题的解决方案。

作用：更好的重用代码、可读性提高、保证代码可靠性

对于设计人员，特别是开发人员，往往受限于眼界或经验不能够体会到设计原则的实用性，或者在处理具体问题时，不知道如何把设计原则应用到到设计和代码，因此产生了“模式”。

随着参与的项目越来越多，人们发现：很多问题并不是一个项目中出现的，它会在很多的项目中出现。于是人们就把这些问题总结出来，然后给出了解决这些问题的方案，而这些方案就是一种“模式”。

二，设计模式的分类

设计模式一共23种，分为下面三大类(根据设计模式能干什么进行分类) ：

创建模式：创建一些特殊的对象，或者在特殊要求下创建对象

结构模式：主要利用组合/聚合或者继承，让类与类能够形成某种关联关系--代理

行为模式：刻画了类和对象交换及分配职责的方式

1，单例模式

概念：是一种创建型的设计模式，涉及的是如何创建对象。单例模式的核心：无论使用该类方法多少次，都只产生一个该类对象，可以减少系统内存的消耗。

单例模式的实现方案：

（1），饿汉模式

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

（2），懒汉模式(线程不安全)

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

}

（3），懒汉模式(线程安全但效率低 )

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

（4），双重检验模式(线程安全，且效率高)

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

（5），内部类实现模式

public class Singleton{
    private Singleton(){}
    private static class Inner{
        private static Singleton sing = new Singleton();
    }
   	public static Singleton getInstance(){
        return Inner.sing;
    }
    
}

（6），枚举实现

public class Singleton{
    private Singleton(){}
    private static enum SinEnum{
       	SIN;
        private Singleton sing = new Singleton();
    }
   	public static Singleton getInstance(){
        return SinEnum.SIN.sing;
    }
    
}

2，工厂模式

概念：讲使用者和对象的分离。生产者进行分离。在工厂模式中，几乎都有三种角色，工厂(抽象工厂、具体工厂) 产品(抽象产品、具体产品) 使用者。使用者想要使用产品，不用自己去生产产品，把生产的动作交给工厂去做，使用者只需要从工厂提供产品的位置(方法)去拿就好。

（1），简单工厂模式

顾客需要给出清单——变化点在产品对象上，所以我们会抽象产品，然后通过一个工厂，根据不同的情况产生不同的产品对象

（2），工厂方法模式

根据工厂能产生什么顾客拿什么——工厂可以产生统一品牌的商品，会根据商品去抽象工厂，对每一个产品，提供一个工厂实现类

（3），抽象工厂模式

根据工厂能产生什么顾客拿什么，但是工厂能产生的产品会有多种品牌——超级工厂，可以生产不同品牌的各种产品，抽象出超级工厂，也要抽象出产品，然后根据不同的品牌给出该品牌商品的工工厂实现类

3，原型模式

概念：根据一个已经存在的对象，创建一个和他一样的对象。-- 克隆

浅克隆-- 利用Object中clone()实现

1.让被克隆的类实现Cloneable接口

2.重写clone方法，方法访问修饰符public

3.对象.clone()的方式的到一个一样的对象

浅克隆指，被克隆的对象会产生一个新的，但是对象属性不会产生。

深度克隆

1.克隆对象所涉及的自定义类，需要实现序列化接口

2.在需要克隆的类中，添加一个方法，完成序列化反序列化即可。

4，代理模式

概念：在目标对象执行行为的前后，代理(附加)一些非功能性的逻辑

（1），静态代理

根据目标对象需要代理的行为，抽象出一个接口(包含了需要代理的行为)，目标类和代理类都需要去实现该接口，然后将目标对象注入到代理类中，此时就可以在代理类中调用目标对象的行为，并为止附加非功能性逻辑

（2），动态代理之JDK代理

第一步，实现接口InvocationHandler，然后重写invoke方法，在invoke方法中调用目标对的方法

第二步，提供一个自定义的方法，通过Proxy.newProxyInstance()得到代理对象

（3），动态代理之Cglib代理

第一步，导入Cglib依赖(包)

第二步，实现接口MethodInterceptor，重写intercept方法，在其中完成目标对象的方法调用

第三步，提供自定义方法，通过工具类获取得到代理对象

5，装饰器模式

概念：对象功能的扩展能够根据需要来动态地实现。

生活场景：星巴克的分店几乎开遍世界各地。它们提供了各式各样的美味咖啡：爱尔兰咖啡、蓝山咖啡、卡布基诺、雀巢。每样咖啡都有自己的描述属性和收费行为。另外它们还提供各种配料：奶、砂糖、冰块、豆浆。不同的咖啡加入不同的配料计算的价格是不一样的。

class Coffee{}  // 咖啡父类
class ACoffee extends Coffee{}  // 爱尔兰
class BCoffee extends Coffee{}  // 蓝山
class KCoffee extends Coffee{}  // 卡布基洛
class ACoffeeSuger extends ACoffee{}  // 爱尔兰 加糖
class ACoffeeMilk extends ACoffee{}  // 爱尔兰 奶
class ACoffeeSugerMilk extends ACoffeeSuger{}  // 爱尔兰 加糖 加奶
class ACoffeeSugerDoubleMilk extends ACoffeeSugerMilk{}  // 爱尔兰 加糖 加双倍奶
class BCoffeeSuger extends BCoffee{}// 蓝山 加糖

1.根据对象抽象一个公共的接口

2.根据接口给出不同的实现类(主料类(主料类产生的对象就是被装饰的对象) 和配料类--装饰类)

3.在配料类中注入被装饰的对象

4.生产咖啡时，先生产主料(被修饰的对象)，然后用配料不断去修饰主料

interface Stuff{ getName  getPrice}
class ACoffee implements Stuff{}  // 爱尔兰
class BCoffee implements Stuff{}  // 蓝山
class KCoffee implements Stuff{}  // 卡布基洛
class Suger implements Stuff{ 注入主料对象  }  // 糖
class Milk implements Stuff{ 注入主料对象 }  // 牛奶
class Ice implements Stuff{ 注入主料对象 }  // 冰块
// 爱尔兰 加糖 加奶
Stuff coffee = new ACoffee();// 爱尔兰
Stuff coffeeAddSuger = new Suger(coffee);  // 爱尔兰 加糖
Stuff coffeeAddSugerAndMilk = new Milk(coffeeAddSuger);// 爱尔兰 加糖 加奶

6，适配器模式

概念：使得原本不兼容的两个接口(功能)可以兼容--搭建了两个接口间的桥梁

例子：我们现在有一台座机，可以通话，有一个照相机，可以进行拍照，能不能有一台设备把两者的功能合一呢？

class Tel{
    public void call(){}
}
class Carame{
    public void make(){}
}
class Phone extends Tel{
    private Carame c = new Carame();
    public void make(){
        c.make();
    }
}

实现适配器的方案，继承或者依赖（推荐使用）

优点：可以让没有任何关联的类，一起运行；

提高了类的复用

灵活性好

缺点：过多的使用适配器，会导致系统非常混乱，不容具体把控

java是单继承，

7，观察者模式

用一下例题来解释：

生活场景：多个代理商代理同一个厂家的商品。不同代理商会在厂家出厂价基础上加上自己的利润，成为批发价。当商品的厂价发生变化时，不同代理商品的价格随之变化。

（1），主题类(由它产生的对象就是被观察的对象) 继承 Observable的类

在主题类，需要针对主题(价格的变化进行关注，设置变化点，然后通知观察者价格有了变化)

public class Product extends Observable {
    private double price;
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
        // 通知观察者注意到主题的变化
        this.setChanged();// 设置变化点
        this.notifyObservers(price);//通知观察者
    }
}

（2），观察者类(由它产生的对象就是观察者) 实现Observer接口

重写update(当主题发生变化时，会调用方法)

public class ProductProxy1 implements Observer {
    private double price;
    /**
     * 当主题类的值发生变化后，会调用该方法
     * @param o 主题对象
     * @param arg 主题更新的值对象
     */
    @Override
    public void update(Observable o, Object arg) {
        double factoryPrice = (double) arg;
        this.price = factoryPrice * 1.5;
    }
    public double getPrice() {
        return price;
    }
}

（3），首先产生主题对象(被观察对象)，产生观察者对象，然后给主题对象设置观察者，最后通过更改主题的值，测试观察者是否有观测到主题值的改变

public class Test {
    public static void main(String[] args) {
        // 产生主题对象  -- 被观察者
        Product product = new Product();
        // 产生观察者
        ProductProxy1 p1 = new ProductProxy1();
        // 给主题对象添加观察者
        product.addObserver(p1);
        // 主题发生变化
        product.setPrice(1000);
        System.out.println("出厂价格："+ product.getPrice() +
                           "\n代理商售卖价格：" + p1.getPrice());
        // 主题发生变化
        product.setPrice(2000);
        System.out.println("出厂价格："+ product.getPrice() + 
                           "\n代理商售卖价格：" + p1.getPrice());
    }
}