设计模式一:五种构建型模式

设计模式基于六大原则:

  1. 单一职责原则:一个类应该只做一件事,一个类应该只有一个引起它修改的原因。
  2. 开闭原则:一个软件实体如类、模块、函数应该对扩展开发,对修改关闭。
  3. 依赖倒置原则:细节应该依赖于抽象,抽象不应该依赖于细节。把抽象层放在程序设计的高层,并保持稳定,程序的细节变化由底层的实现层来完成。
  4. 里氏替换原则:子类应该可以完全替换父类,也就是说在使用继承时,只扩展新功能,而不要破坏父类原有的功能。
  5. 迪米特原则:又叫最少知道原则,一个类不应该知道自己操作的类的细节,换言之,只和朋友谈话,不和朋友的朋友谈话。
  6. 接口隔离原则:客户端不应依赖它不需要的接口。即如果一个接口实现时,部分方法由于冗余被客户端实现了,则应该将接口拆分,让实现类只依赖自己需要的接口方法。

所有的设计模式都是为了程序能够更好的满足这六大原则,设计模式一共有23种,我们先来学习五种构建性模式,分别是:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

5种构建型模式

工厂方法模式

工厂方法模式规定每个产品都有一个专属工厂,比如苹果有专属的苹果工厂,梨子有专属的梨子工厂,如下所示:

public class AppleFactory{
    public Fruit create(){
        return new Apple();
    }
}

public class PearFactory{
    public Fruit create(){
        return new Pear();
    }
}

public class User{
    private void eat(){
        AppleFactory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.create();
        PearFactory pearFactory = new PearFactory();
        Fruit pear = pearFactory.create();
        apple.eat();
        pear.eat();
    }
}

优点:调用者无需知道工厂的生产细节,当生产过程需要更改时也无需更改调用端;每一个产品对应一个工厂,当产品越来越多时,工厂类也会越来越多,符合单一职责原则,也符合开闭原则。

抽象工厂模式

它是对工厂方法模式的优化,比如提取出工厂接口:


public interface IFactory {
    Fruit create();
}

public class AppleFactory implements IFactory {
    @Override
    public Fruit create(){
        return new Apple();
    }
}


public class PearFactory implements IFactory {
    @Override
    public Fruit create(){
        return new Pear();
    }
}


public class User {
    private void eat(){
        IFactory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.create();
        IFactory pearFactory = new PearFactory();
        Fruit pear = pearFactory.create();
        apple.eat();
        pear.eat();
    }
}

优点:客户端只需要和抽象类IFactory打交道,调用的是其接口中的方法,使用的时候不需要知道是在哪个具体工厂中实现的这些方法,这就使得替换工厂变得非常容易。抽象工厂模式很好的发挥了开闭原则、依赖倒置原则。

缺点:抽象工厂模式太重了,如果IFactory接口需要新增功能,则会影响到所有的具体类。所以抽象工厂模式适用于增加同类工厂这样的横向扩展需求,不适合新增功能这样的纵向扩展。

单例模式

饿汉式写法是线程安全的,懒汉式写法线程不安全,我们可以使用double check的方式保证懒汉式写法线程安全,写法如下:

public class Singleton{
    private volatile static Singleton instance;
    private Singleton(){}

    public static Singleton getInstance(){
        //必须要在外层加判空,要不然每次调用都加锁,影响执行效率
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Instance();
                }
            }
        }
        return instance;
    }
}

饿汉式类加载的时候就创建了对象,需要立即占用内存空间,而懒汉式只有需要使用的时候才会创建对象占用内存控件的。

除了双检锁方式以外,我们还可以使用静态内部类方式保证懒汉式单例的线程安全:

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

那静态内部类的写法是怎么实现懒加载的,又是怎样保证线程安全的呢?Java类的加载过程包括:加载、验证、准备、解析、初始化,在初始化阶段包括为类的静态变量赋初始值和执行静态代码块中的内容,但不会立即加载内部类,内部类在使用时才加载,所以当次Singleton类加载时,SingletonHolder并不会被立即加载,所以不会像饿汉式那样占用内存。另外,Java虚拟机规定,当访问一个类的静态字段时,如果该类尚未初始化,则立即初始化此类。第二个问题的答案是,Java虚拟机的设计是非常稳定的,早已经考虑了多线程并发执行的情况,类加载的过程,通过使用加锁、同步,保证线程安全。

一般建议:对于构建不复杂,加载完成后会立即使用的单例对象,推荐使用饿汉式;对于构建过程耗时较长,并不是所有使用此类都会用到的单例对象,推荐使用懒汉式。

建造者模式

用于创建过程稳定,但配置多变的对象。将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。比如我们要制作一杯珍珠奶茶,它的制作过程稳定,除了必须要知道奶茶的种类和规格外,是否加珍珠和是否加冰是可选的。使用建造者模式Java表示如下:

public class MilkTea {
    private final String type;
    private final String size;
    private final boolean pearl;
    private final boolean ice;

    private MilkTea(Builder builder) {
        this.type = builder.type;
        this.size = builder.size;
        this.pearl = builder.pearl;
        this.ice = builder.ice;
    }

    public String getType() {
        return type;
    }

    public String getSize() {
        return size;
    }

    public boolean isPearl() {
        return pearl;
    }
    public boolean isIce() {
        return ice;
    }

    public static class Builder {

        private final String type;
        private String size = "中杯";
        private boolean pearl = true;
        private boolean ice = false;

        public Builder(String type) {
            this.type = type;
        }

        public Builder size(String size) {
            this.size = size;
            return this;
        }

        public Builder pearl(boolean pearl) {
            this.pearl = pearl;
            return this;
        }

        public Builder ice(boolean cold) {
            this.ice = cold;
            return this;
        }

        public MilkTea build() {
            return new MilkTea(this);
        }
    }
}

优点:不用担心忘了指定某个配置,保证了构建过程是稳定的。在OkHttp、Retrofit等著名框架中都使用到了该模式。

原型模式

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

public class MilkTea {
    public String type;
    public boolean ice;

    public MilkTea clone(){
        MilkTea milkTea = new MilkTea();
        milkTea.type = this.type;
        milkTea.ice = this.ice;
        return milkTea;
    }
}

以上就是原型模式,Java中有一个语法糖,让我们并不需要手写clone方法,这个语法糖就是cloneable接口,我们只要让需要拷贝的类实现此接口即可。


public class MilkTea implements Cloneable{
    public String type;
    public boolean ice;

    @NonNull
    @Override
    protected MilkTea clone() throws CloneNotSupportedException {
        return (MilkTea) super.clone();
    }
}

需要注意的是,Java自带的clone方法是浅拷贝,也就是调用此对象的clone方法,只有基本数据类型的参数会被拷贝一份,非基本类型的对象不会被拷贝一份,而是继续使用传递引得方式。如果需要实现深拷贝,必须自己手动修改clone方法才行。

总结

抽象工厂模式:适合横向增加同类工厂的扩展,不适合纵向增加功能的扩展(线程池ThreadPoolExecutors);

单例模式:适用于全局公用的对象(OKHTTP对象);

建造者模式:使用于构造过程稳定,配置多变的对象(各种Notification、Dialog的创建);

文章参考:设计模式

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Java设计模式是一套经过总结和整理的编程思想,用于解决软件开发中常见的问题。《Java设计模式:23种设计模式全面解析(超级详细)》是一本详细介绍这23种设计模式的书籍,它可以帮助读者深入理解每种设计模式的原理和用法。 这本书分为23个章节,每个章节介绍一种设计模式。每个章节都从问题的背景出发,描述该设计模式的目标和应用场景。然后,通过实例代码和图形示意来展示如何使用该设计模式解决问题。 书中详细介绍了创建设计模式、结构设计模式和行为设计模式。在创建设计模式方面,包括单例模式、工厂模式、抽象工厂模式、建造者模式和原模式等。结构设计模式包括适配器模式、装饰器模式、代理模式、组合模式和桥接模式等。行为设计模式包括策略模式、观察者模式、迭代器模式、命令模式和模板方法模式等。 每个设计模式都有其特定的使用场景和适用性,读者可以根据自己的需求选择合适的设计模式来解决问题。通过学习这本书,读者可以深入理解设计模式的原理和思想,并且能够应用到实际的软件开发中。 总的来说,《Java设计模式:23种设计模式全面解析(超级详细)》是一本对于Java开发者来说非常有价值的书籍。它通过详细的示例和解释,帮助读者深入理解23种设计模式的使用方法,使读者能够灵活地应用设计模式解决实际开发中遇到的问题。无论是初学者还是有一定经验的开发者,都可以从这本书中受益匪浅。 ### 回答2: 《Java设计模式:23种设计模式全面解析(超级详细)》是一本介绍Java设计模式的全面解析书籍。设计模式是软件工程领域中的一种解决问题的思维方式和经验总结,能够提供可复用的解决方案。这本书详细介绍了23种经典的设计模式,包括创建、结构和行为三种类模式。 在创建设计模式方面,书中包含了单例模式、原模式、工厂方法模式、抽象工厂模式、建造者模式。这些模式都是用来创建对象的,通过不同的实现方式能够灵活地创建对象,并且符合原则,如单一职责原则、开闭原则等。 在结构设计模式方面,书中介绍了适配器模式、装饰器模式、代理模式、外观模式等。这些模式通过组合不同的类和对象,来解决不同类间关系的问题,增加了程序的可扩展性和灵活性。 在行为设计模式方面,书中讲解了观察者模式、模板方法模式、策略模式、命令模式等。这些模式着重于对象之间的通信和协作,通过定义不同的行为和规则,让对象能够更好地进行交互,降低了对象间的耦合度。 此外,书中还介绍了其他几种分类的设计模式,如迭代器模式、访问者模式、备忘录模式等,这些模式在特定的应用场景中发挥着重要作用。 总的来说,《Java设计模式:23种设计模式全面解析(超级详细)》是一本详细介绍了Java设计模式的书籍,对于想深入了解和应用设计模式的Java开发人员来说,是一本很好的资料,能够帮助他们理解,并在实际项目中应用这些经典的设计模式。 ### 回答3: Java设计模式是一套被广泛应用于软件设计的规范和经验总结。设计模式可以提供可重用和可维护的代码,能够帮助开发人员解决常见的软件设计问题。 Java设计模式一共有23种,分为创建模式、结构模式和行为模式三个类别。 创建模式包括单例模式、工厂模式、抽象工厂模式、建造者模式和原模式。单例模式确保一个类只有一个实例,工厂模式将对象的创建委托给工厂类,抽象工厂模式允许客户端使用抽象接口来创建一组相关对象,建造者模式通过一步步构建复杂对象,原模式通过克隆已有对象来创建新对象。 结构模式包括适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。适配器模式将一个类的接口转换成客户端期望的接口,桥接模式将抽象和实现分离,组合模式将对象组合成树形结构以表示“部分-整体”的层次结构,装饰器模式动态地给对象添加职责,外观模式为多个子系统提供一个统一的接口,享元模式共享对象以减少内存的使用,代理模式为其他对象提供一个代理以控制对这个对象的访问。 行为模式包括模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式和访问者模式。模板方法模式定义了一个操作中的算法骨架,而将一些步骤延迟到子类中实现,命令模式将请求封装成对象,迭代器模式提供一种方法来顺序访问聚合对象的元素,观察者模式定义对象之间的一对多依赖关系,中介者模式定义了一个封装一组对象交互的对象,备忘录模式在不破坏封装的前提下捕获一个对象的内部状态,解释器模式为语言创建解释器,状态模式允许一个对象在其内部状态改变时改变其行为,策略模式定义了一系列算法,职责链模式将请求的发送者和接收者解耦,访问者模式将算法与数据结构分离开来。 这些设计模式在实际的软件开发中有着广泛的应用,对于提高代码的可重用性、可维护性和可扩展性都具有很好的作用。了解和熟练运用这些设计模式,对于Java开发人员来说是非常重要的。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值