【设计模式】
软件设计的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发送QQ邮件