一、设计模式

设计模式(Design pattern代表了最佳的实践,通常被有经验的面向对象软件开发人员采用设计模式软件开发人员软件开发过程中面临的一般问题解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样。项目合理地运用设计模式可以完美地解决很多问题,每种模式在现实中都有相应的原理来与之对应,每种模式都描述一个我们周围不断重复发生的问题,以及该问题核心解决方案,这也是设计模式能被广泛应用原因

二、设计模式的六大原则

三、设计模式分类

设计模式常见的有23类,分为创建结构型行为

四、单例设计模式

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。它提供了一种创建对象的最佳方式

这种模式涉及到一个单一的类,该类负责创建自己对象,同时确保只有单个对象创建这个类提供了一种访问唯一对象方式可以直接访问,不需要实例该类的对象。

单例实现方式也有多种,包括:饿汉式、懒汉式、静态内部方式、枚举单例、双重检测锁方式 。

  1. 懒汉

初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能
在设计单例时,首先需要私有化无参构造函数,避免使用 new 创建对象。

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

这种情况如果并发获取对象的时候,因为加了synchronized 锁,会抢夺锁导致一些性能的下降。

  1. 饿汉

初始化时,会立即加载该对象,线程天生安全调用效率高,这种方式比较常用,但容易产生垃圾对象。
基于 classloader 机制避免了多线程同步问题,不过,instance 在类装载时就实例化,虽然导致类装载的原因很多种,在单例模式中大多数都是调用 getInstance() 方法, 但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始instance 显然没有达到 lazy loading效果

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

这种方式在加载时就创建好了对象,相对于上面的懒汉式,性能会更高。但是对于一些不常用的类,在一开始就加载好,浪费内存,容易产生垃圾对象。

  1. 双检锁/双重校验锁 DCL

上面可以看出,使用懒汉式由于在方法上加了synchronized 会导致请求排队,使用饿汉式,又会有可能造成浪费内存产生垃圾对象,带着问题来看下双重校验机制

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
	        if (singleton == null) {  
	            singleton = new Singleton();  
	        }  
        }  
    }  
    return singleton;  
    }  
}

这种形式,在获取对象时先判断有无实例,有的话就直接返回相对于懒汉式消除了锁争夺等待。如果没有实例化,就使用synchronized 锁住当前对象,那么,都锁住为什么里面还要再判断一次是否实例呢,这是因为假如并发两个线程获取对象,都判断为null,那下面就会争夺锁,抢到锁的就可以安心的实例化对象了,当创建好释放锁后,另一个线程走下去再创建对象不就创建重复了嘛,上一个线程已经创建好了呀,所以在这里再判断一次就是为了在刚开始创建对象的时候防止并发重复实例化对象。解决了懒汉式和饿汉式的弊端。

  1. 静态内部

上面双重校验锁机制似乎就已经很好了,但还有没有办法解决懒汉式和饿汉式的弊端呢,那就是静态内部类;
这种方式能达到双检锁方式一样的功效,但实现更简单。对静态域使用延迟初始化,应使用这种方式而不是双检锁方式。这种方式只适用于静态的情况,双检锁方式可在实例域需要延迟初始化时使用。

public class Singleton {  

    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    
    private Singleton (){}  
  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}
  1. 枚举

这种实现方式还没有被广泛采用,但这是实现单例模式的最佳方法,因为枚举本身是单例。它更简洁自动支持序列化机制,绝对防止多次实例化。
这种方式不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。不过,由于 JDK1.5 之后才加入 enum 特性,用这种方式写不免让人感觉生疏,在实际工作中,也很少用。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}
public class Singleton {
	public static Singleton getInstance() {
		return SingletonEnum.INSTANCE.getInstance();
	}

	private static enum SingletonEnum{
		INSTANCE;
		private Singleton instance;

		private SingletonEnum() {
			instance= new Singleton ();
		}
		
		public Singleton getInstance() {
			return instance;
		}
	}
Singleton s = Singleton.getInstance();

五、工厂方法

工厂方法,使用工厂可以像使用人员屏蔽对象创建的细节使用者无需指定具体的类即可使用功能,达到信息隐蔽的作用,便于后期的维护,修改扩展

在看工厂方法前还有一类是 简单工厂,相当于是一个工厂中有各种产品,创建在一个类中客户无需知道具体产品名称,只需要知道产品类所对应参数即可。但是工厂职责过重,而且当类型过多时不利于系统的扩展维护。
在这里插入图片描述

比如我们在聚合支付的时候有,微信支付支付宝支付,在不同选择获取不同的对象,如果用简单方法来实现的话:

  1. 定义统一支付抽象类定义支付和取消支付抽象方法
public interface PayInterFace {
    //支付
    void pay();
    //取消支付
    void cancelPay();
}
  1. 定义微信支付类
public class WxPay implements PayInterFace {
    @Override
    public void pay() {
        System.out.println("微信支付中...");
    }

    @Override
    public void cancelPay() {
        System.out.println("微信取消支付!");
    }
}
  1. 定义支付宝
public class ZfbPay implements PayInterFace {
    @Override
    public void pay() {
        System.out.println("支付宝支付中...");
    }

    @Override
    public void cancelPay() {
        System.out.println("支付宝取消支付!");
    }
}
  1. 创建简单工厂
public class SimplePayFactory {
    public static PayInterFace getPay(String payType) {
        if (Objects.equals(payType, "wx")) {
            return new WxPay();
        } else if (Objects.equals(payType, "zfb")) {
            return new ZfbPay();
        } else {
            return null;
        }
    }
}
  1. 使用
public class demo {
    public static void main(String[] args) {
        PayInterFace pay = SimplePayFactory.getPay("wx");
        pay.pay();
        pay.cancelPay();
        PayInterFace pay1 = SimplePayFactory.getPay("zfb");
        pay1.pay();
        pay1.cancelPay();
    }
}

在这里插入图片描述

通过传入不同标识获取不同的对象,且无需指定具体对象,让使用者无需关注创建对象的细节,增加对象需要在工厂中添加对应的实例化程序,当类型过多时不利于系统的扩展维护。

那下面来看下工厂方法的做法:

  1. 在上面的基础上,再建立 支付工厂接口:
public interface PayFactory {
    PayInterFace getPay();
}
  1. 建立微信支付工厂
public class WxPayFactory implements PayFactory {
   @Override
   public PayInterFace getPay() {
       return new WxPay();
   }
}
  1. 建立支付宝工厂
public class ZfbPayFactory implements PayFactory {
    @Override
    public PayInterFace getPay() {
        return new ZfbPay();
    }
}
  1. 使用
public class demo {
    public static void main(String[] args) {
        PayInterFace pay = new WxPayFactory().getPay();
        pay.pay();
        pay.cancelPay();

        PayInterFace pay1 = new ZfbPayFactory().getPay();
        pay1.pay();
        pay1.cancelPay();
    }
}

这种方式同样屏蔽了对象建立的细节,且无需指定具体对象,但相对于上面的简单工厂,更易于做扩展比如引入新的支付,只需要创建新的工厂并实现PayFactory 即可,更利于系统的扩展。

六、抽象工厂

上面学习简单工厂工厂方法,下面来看下抽象工厂
抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类每个生成的工厂都能按照工厂模式提供对象。

在上面的场景中,加入支付后需要扣除库存,就需要引入库存工厂,并调用扣除库存的方法,库存工厂和支付工厂貌似不相干,但在抽象工厂中,抽象工厂相当于一个公司库存和支付相当与部门,相对于公司来看,支付和库存都是公司下的部门,是一个整体。所以抽象工厂就是定义一个产品组,可以完成系列过程,而不是单一的活动。

下面使用抽象工厂定义支付后扣除库存的设计:

  1. 定义库存操作接口
public interface RepertoryInterFace {
    void deductRepertory();
}
  1. 苹果为例,定义具体库存为苹果的库存
public class AppleRepertory implements RepertoryInterFace {
    @Override
    public void deductRepertory() {
        System.out.println("苹果库存 扣除库存...");
    }
}
  1. 定义抽象工厂,定义支付和扣库存抽象方法
public interface BuyAbstractFactory {
    //支付
    PayInterFace pay();
    //扣库存
    RepertoryInterFace deductRepertory();
}
  1. 定义抽象工厂实现,这里演示效果,直接采用微信支付对象
public class BuyAbstractFactoryImpl implements BuyAbstractFactory {

    @Override
    public PayInterFace pay() {
        return new WxPay();
    }

    @Override
    public RepertoryInterFace deductRepertory() {
        return new AppleRepertory();
    }
}
  1. 使用
public class demo {
    public static void main(String[] args) {
        BuyAbstractFactory factory = new BuyAbstractFactoryImpl();
        factory.pay().pay();
        factory.deductRepertory().deductRepertory();
    }
}

在这里插入图片描述

使用抽象工厂方式,颗粒化程度大,让使用者无需知道整个工作组的对象,即可完成一连串的操作可扩展性,可修改修都很友好

七、原型模式

原型模式(Prototype Pattern)是用于创建重复的对象,同时又能保证性能。它提供了一种创建对象的最佳方式
这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。
例如,一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象,在下一个请求返回它的克隆,在需要的时候更新数据库,以此来减少数据库调用

例如:

创建一个可复制的支付类:

public class WxPay implements Cloneable{
    public WxPay(){
        System.out.println("创建支付对象");
    }
    public WxPay clone() throws CloneNotSupportedException {
        System.out.println("复制对象!");
        return (WxPay) super.clone();
    }
}

使用:

public class demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        WxPay pay = new WxPay();
        WxPay pay1 = pay.clone();
        System.out.println(pay);
        System.out.println(pay1);
    }
}

在这里插入图片描述

可以看到,创建了两个不同的对象,只进行了一次构件函数执行,当直接创建对象的代价比较大时,就可以采用这种模式。

另外,原型拷贝又有浅拷贝深拷贝两个层次,上面的方式就是浅拷贝,只把当前对象做了拷贝,如果对象中有其他对象的引用,就不会进行拷贝,修改任意一个对象中的引用,对其他都会有影响

比如上面的WxPay类做如下修改:

  1. 先定义其他操作类
public class OtherOperation {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
  1. 再修改WxPay类
public class WxPay implements Cloneable {

    private OtherOperation otherOperation = new OtherOperation();

    public WxPay() {
        System.out.println("创建支付对象");
    }

    public WxPay clone() throws CloneNotSupportedException {
        System.out.println("复制对象!");
        return (WxPay) super.clone();
    }

    public OtherOperation getOperation() {
        return otherOperation;
    }

    public String getName() {
        return otherOperation.getName();
    }

}
  1. 演示
public class demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        WxPay pay = new WxPay();
        WxPay pay1 = pay.clone();
        System.out.println(pay);
        System.out.println(pay1);
        System.out.println(pay.getOperation());
        System.out.println(pay1.getOperation());
        pay.getOperation().setName("abc");
        System.out.println(pay1.getOperation().getName());
    }
}

在这里插入图片描述

上面可以看出,WxPay确实是复制出了一个实例,但是WxPay里面的OtherOperation实例没有复制,还只向同一个地址,导致只要修改任意一个对象中的OtherOperation对其他实例都会有影响

上面已经看出默认是浅拷贝,但有的时候,我们又需要其中引用的对象也要为新实例,那怎么做呢,下面就来看下深拷贝的实现方式:

深拷贝实现方式 1:重写 clone 方法来实现深拷贝
深拷贝实现方式 2:通过对象序列化实现深拷贝(推荐)

实现方式 1,重写 clone 方法来实现深拷贝

  1. 修改 OtherOperation类
public class OtherOperation implements Cloneable{
    private String name;

    public OtherOperation clone() throws CloneNotSupportedException {
        System.out.println("复制OtherOperation对象!");
        return (OtherOperation) super.clone();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


  1. 修改WxPay,在clone中再复制OtherOperation ,以达到深拷贝的效果
public class WxPay implements Cloneable {

    private OtherOperation otherOperation = new OtherOperation();

    public WxPay() {
        System.out.println("创建支付对象");
    }

    public WxPay clone() throws CloneNotSupportedException {
        System.out.println("复制对象!");
        WxPay wxPay = (WxPay) super.clone();
        wxPay.otherOperation = otherOperation.clone();
        return wxPay;
    }

    public OtherOperation getOperation() {
        return otherOperation;
    }

    public String getName() {
        return otherOperation.getName();
    }

}
  1. 演示
public class demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        WxPay pay = new WxPay();
        WxPay pay1 = pay.clone();
        System.out.println(pay);
        System.out.println(pay1);
        System.out.println(pay.getOperation());
        System.out.println(pay1.getOperation());
        pay.getOperation().setName("abc");
        System.out.println(pay1.getOperation().getName());
    }
}

在这里插入图片描述

可以看到,WxPay 和 OtherOperation 都是新实例。

深拷贝实现方式 2:通过对象序列化实现深拷贝

  1. OtherOperation 实现 Serializable
public class OtherOperation implements  Serializable {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
  1. WxPay 实现Serializable,并提供方法对当前对象进行序列化操作
public class WxPay implements Serializable {

    private OtherOperation otherOperation = new OtherOperation();

    public WxPay() {
        System.out.println("创建支付对象");
    }

    public OtherOperation getOperation() {
        return otherOperation;
    }

    public String getName() {
        return otherOperation.getName();
    }


    public WxPay deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            //序列
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); //当前这个对象以对象流的方式输出
            //反序列
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            return (WxPay) ois.readObject();
        }
        catch (Exception e) {
            return null;
        }
        finally {
            //关闭
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            }
            catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}
  1. 效果
public class demo {
    public static void main(String[] args) throws CloneNotSupportedException {
        WxPay pay = new WxPay();
        WxPay pay1 = pay.deepClone();
        System.out.println(pay);
        System.out.println(pay1);
        System.out.println(pay.getOperation());
        System.out.println(pay1.getOperation());
        pay.getOperation().setName("abc");
        System.out.println(pay1.getOperation().getName());
    }
}

在这里插入图片描述

和上面我们手动的方式是一样的效果。

八、建造者模式

建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。将一个复杂构建与其表示分离,使得同样的构建过程可以创建不同表示。主要解决软件系统中,有时候面临着”一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成;由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定

例如,在游戏场景中,需要构建人物模型可能要先构建头部、再构建身体、然后四肢部分最后才是一个完整的人物,如果都写在一起,肯定会导致代码复杂不易其他开发人员理解,对后期维护扩展难度都大,如果使用构建者模式,便可以将头部、身体、四肢,写在不同的人物实现里面最后由一个构建类去按照一定的顺序加载它们,然后组成了一个更大的复杂的对象,这样便有利于维护扩展。

下面我们借助上面的例子简单用构建者模式实现下

  1. 定义人物对象,这里直接将头、身体、四肢简化属性的形式表达。
@Data
public class Person {
    private String head;
    private String body;
    private String foot;
}
  1. 定义人物构建接口,并定义具体的抽象方法。
public interface PersonBuilder {
	//构建入口
	Person Builder();
	//构建头部
	void builderHead();
	//构建身体
	void builderBody();
	//构建四肢
	void builderFoot();
}
  1. 定义一个男孩人物的具体构建实现
public class BoyBuilder implements PersonBuilder {
    private Person person;

    public BoyBuilder() {
        person = new Person();
    }

    @Override
    public Person Builder() {
        builderHead();
        builderBody();
        builderFoot();
        System.out.println("构建完成!");
        return person;
    }

    @Override
    public void builderHead() {
        System.out.println("开始构建男孩头部...");
        person.setHead("男孩头部信息");
    }

    @Override
    public void builderBody() {
        System.out.println("开始构建男孩身体...");
        person.setBody("男孩身体信息");
    }

    @Override
    public void builderFoot() {
        System.out.println("开始构建男孩四肢...");
        person.setFoot("男孩四肢部分信息");
    }
    
}
  1. 演示
public class demo {

    public static void main(String[] args) {
        PersonBuilder personBuilder = new BoyBuilder();
        Person person = personBuilder.Builder();
        System.out.println(StringFormatter.concat("构建对象:", person.toString()).getValue());
    }
	
}

在这里插入图片描述

上面就是将一个人物的不同部分分别构建(实际中每个小的构建都应该在具体的实现中去表达,这里简化为了一个属性),一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

原文地址:https://blog.csdn.net/weixin_65777087/article/details/134810815

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_49022.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注