欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

【设计模式】

程序员文章站 2022-03-10 17:15:50
软件设计的6大基本原则SOLID1、Single单一性原则一个类只负责一类方法的封装,一个方法只负责单一的功能的封装。该原则是高内聚,低耦合的基础。高内聚指功能相同的方法内聚在同一个类中,共同完成一个功能的代码块聚合在一个方法中;低耦合指一个类之间的方法尽量少的相互调用,修改一个方法不会或者很少的影响另外一个方法。2、Open&Close 开闭原则对扩展开放,对修改关闭。由于旧代码已经经过测试和实践检验,不能对旧代码进行修改,而是只能在旧代码基础上进行扩展,添加新的代码,而非修改...

软件设计的6大基本原则SOLID

1、Single单一性原则

一个类只负责一类方法的封装,一个方法只负责单一的功能的封装。

该原则是高内聚,低耦合的基础。高内聚指功能相同的方法内聚在同一个类中,共同完成一个功能的代码块聚合在一个方法中;低耦合指一个类之间的方法尽量少的相互调用,修改一个方法不会或者很少的影响另外一个方法。

2、Open&Close 开闭原则

对扩展开放,对修改关闭。由于旧代码已经经过测试和实践检验,不能对旧代码进行修改,而是只能在旧代码基础上进行扩展,添加新的代码,而非修改旧的代码。

3、里氏替换原则LSP

父类出现的地方,都可以用子类进行替换。比如MVC模式中,Controller层通过统一的接口调用具体实现类的方法,而非通过具体的实现类。这里所有的父类接口都可以用具体的子类进行替换。

4、Interface接口隔离原则

不同功能之间尽量使用接口隔离,对外不暴露不会使用的接口。

5、依赖倒置原则

高层不依赖于底层模块,而是依赖于其抽象;针对抽象编程,而非针对具体。具体表现之一是:父类按照接口调用子类,而非通过具体类。

6、迪米特法则------最少知道法则

一个类的实体应该尽量少的与另一个类发生联系。

设计模式的分类

构建型:用于构建复杂的对象,比如建造者模式,工厂模式

结构型:关注类和对象的组合,比如适配器模式,外观模式

行为型:关注对象之间的通信,比如观察者模式,迭代器模式

单例模式

在系统中,部分关键资源只能有一份,比如单一日志文件的文件对象,mysql自增主键的主键值分发器,redis连接器等,这时应该使用单例模式

单例模式有两种实现:

1、懒汉模式:第一次使用时创建

2、饿汉模式:类加载时创建

下方是代码:

/**
 * 单例模式 ------> 懒汉实现
 */

public class SingletonLazy {
    private static volatile SingletonLazy instance;
    private SingletonLazy(){

    }

    /**
     * 线程不安全的方法
     * 存在线程安全问题
     * @return
     */
    public static SingletonLazy getInstance1(){
        if (instance == null)
            instance = new SingletonLazy();
        return instance;
    }

    /**
     * 方法加锁,没有线程安全问题
     * 但是synchronized对方法加锁加锁会导致较大的性能开销
     * 使用DCL双重锁定检查
     */
    public static SingletonLazy getInstance2(){
        if (instance == null){
            synchronized(SingletonLazy.class) {
                if (instance == null)
                   instance = new SingletonLazy();
            }
        }
        return instance;
    }





}
/**
 * 饿汉模式:在类加载时就创建单例对象
 * 优点:不涉及线程同步问题,实现简单
 * 缺点:拖慢加载速度,浪费内存(在不用该对象时创建了该对象)
 */
public class SingletonHungry {
    private static SingletonHungry instance = new SingletonHungry();
    private SingletonHungry(){}
    private SingletonHungry getInstance(){
        return instance;
    }
}

工厂模式

工厂模式将对象的创建和对象的使用分离开,使得对象的创建和使用分别更加容易修改而不会影响对方。

1、简单工厂模式

有一个工厂,通过静态方法传入参数,返回不同的商品;这些商品是同一类,继承同一个接口。

package factory;
//公共接口

public interface Pay {
    /**
     * 统一下单接口
     */
    void unifiedorder();
}

商品1:阿里pay

package factory;

public class AliPay implements Pay {

    @Override
    public void unifiedorder() {
        System.out.println("支付宝统一下单");
    }
}

商品2:微信pay

package factory;

public class WechatPay implements Pay {
    @Override
    public void unifiedorder() {
        System.out.println("微信支付统一下单接口");
    }
}

工厂:

public class SimplePayFactory {
    public static Pay createPay(String payType){
        if (payType == null) return null;
        if (payType.equalsIgnoreCase("WECHAT PAY"))
            return new WechatPay();
        else if (payType.equalsIgnoreCase("ALI PAY"))
            return new AliPay();
        //需要扩展时,需要修改代码,添加更多if
        return null;
    }

}

简单工厂模式的缺点:在添加产品时需要修改工厂的代码;工厂的负担过重,商品生产全部集中在工厂中。

2、工厂方法模式

在简单工厂的基础上,将工厂也抽象出来,出现了多个工厂建造不同类的产品,这些工厂也继承同一个接口。带来的好处是:在添加工厂时,不需要修改原有的代码;

商品同上

工厂的接口及其实现:

package factory.method;

import factory.Pay;

public interface PayFactory {
    Pay getPay();
}
package factory.method;

import factory.AliPay;
import factory.Pay;

public class AliPayFactory implements PayFactory{

    @Override
    public Pay getPay() {
        return new AliPay();
    }
}
package factory.method;

import factory.AliPay;
import factory.Pay;

public class AliPayFactory implements PayFactory{

    @Override
    public Pay getPay() {
        return new AliPay();
    }
}

调用:

package factory.method;

import factory.Pay;
import factory.simple.SimplePayFactory;

public class Main {
    static public void main(String[] arg){
        PayFactory payFactory = new AliPayFactory();
        Pay pay = payFactory.getPay();
        pay.unifiedorder();
    }
}

抽象方法模式的缺点:当增加商品时,仍然需要修改代码。

3、抽象工厂方法模式

添加一个统一的建造工厂的工厂,利用简单工厂模式生产不同的工厂;这些工厂也同样继承了同样的接口,能够用同样的接口生产商品;每一个工厂可以生产多种商品,这些商品实现同一种接口

建造工厂的工厂:

package factory.abstractf;

public class FactoryProducer {
    static OrderFactory getFactory(String type){
        if (type.equalsIgnoreCase("wechat"))
            return new WechatOrderFactory();
        else if (type.equalsIgnoreCase("ali"))
            return new AliOrderFactory();
        return null;
    }
}

工厂的接口(工厂生产2中产品,Pay和Refund)

package factory.abstractf;

import factory.Pay;
import factory.Refund;

public interface OrderFactory {
    Pay getPay();
    Refund getRefund();
}

工厂的实现

package factory.abstractf;

import factory.Pay;
import factory.Refund;

public class AliOrderFactory implements OrderFactory{
    @Override
    public Pay getPay() {
        return null;
    }

    @Override
    public Refund getRefund() {
        return null;
    }
}
package factory.abstractf;

import factory.Pay;
import factory.Refund;

public class WechatOrderFactory implements OrderFactory {
    @Override
    public Pay getPay() {
        return null;
    }

    @Override
    public Refund getRefund() {
        return null;
    }
}

商品的接口

package factory;

public interface Pay {
    /**
     * 统一下单接口
     */
    void unifiedorder();
}
package factory;

public interface Refund {
    void unifiedrefund();
}

商品的实现有:AliPay、AliRefund、WechatPay、WechatRefund

*********************************************************************************

未完待续

*********************************************************************************

本文地址:https://blog.csdn.net/WilliamCode/article/details/110533132

相关标签: java 设计模式