内容参考:菜鸟教程
单例模式
1:单例类只能有一个实例
2:单例类必须自己创建自己的唯一实例
3:单例类必须给其使用着提供这一实例
懒汉式
懒加载初始化,多线线程业务下需要加锁synchronized
加锁之后效率就会降低,建议不要在多线程业务中使用
public class SingleDemo {
private static SingleDemo demo;
// 私有化无参构造,只能在当前类中使用
private SingleDemo() {}
public static synchronized SingleDemo getInstance() {
if (demo == null) {
return new SingleDemo();
}
return demo;
}
}
public class SingleDemo {
private static SingleDemo demo;
// 私有化无参构造,只能在当前类中使用
private SingleDemo() {}
public static SingleDemo getInstance() {
if (demo == null) {
return new SingleDemo();
}
return demo;
}
}
饿汉式
非懒加载,线程安全
效率高,易产生垃圾
public class SingleDemo {
// 类加载时初始化
private static SingleDemo demo = new SingleDemo();
// 私有化无参构造,只能在当前类中使用
private SingleDemo(){}
public static SingleDemo getInstance(){
return demo;
}
}
双检锁/双重校验锁
懒加载,线程安全,在多线程情况下也能保持高效
public class SingleDemo {
private static SingleDemo demo;
// 无参构造私有化,只能在当前类中使用
private SingleDemo() {}
public static SingleDemo getInstance() {
// 如果不是null,直接返回对象
if (demo== null) {
synchronized (SingleDemo.class) {
// 如果不是null,直接返回对象
if (demo== null) {
demo= new SingleDemo();
}
}
}
return demo;
}
}
总结:将对象私有化,外部使用该对象时,只能通过静态方法来使用
工厂模式
主要解决接口选择的问题,前提是有明确的条件
以系统支付为例:
1:创建支付接口
public interface IPayService {
void pay(String payType);
}
2:创建支付业务类,并实现支付接口
public class AliPayService implements IPayService {
@Override
public void pay(String payType) {
System.out.println("支付宝支付");
}
}
public class WechatPayService implements IPayService {
@Override
public void pay(String payType) {
System.out.println("微信支付");
}
}
public class OtherPayService implements IPayService {
@Override
public void pay(String payType) {
System.out.println("其他支付");
}
}
3:创建工厂类
public class PayFactoryBean {
public static IPayService getPay(String payType) {
if (StringUtils.isEmpty(payType)) {
throw new RuntimeException("支付方式非法");
}
if (payType.equals(PayConstant.ALI_PAY)) {
return new AliPayService();
} else if (payType.equals(PayConstant.WECHAT_PAY)) {
return new WechatPayService();
} else if (payType.equals(PayConstant.OTHER_PAY)) {
return new OtherPayService();
}
return null;
}
public static void main(String[] args) {
PayBean payBean = new PayBean();
IPayService pay = getPay("WECHAT_PAY");
if (pay != null) {
pay.pay(payBean);
}else {
System.out.println("支付方式非法");
}
}
}
结构
总结:正常的一个接口,多个实现。通过工厂类进行标识、类名等方式判断并返回对应的实现类,然后处理业务,在外界看来,只要满足条件即可执行对应业务
适配器模式
是作为两个不兼容的接口之间的桥梁
主要解决在软件系统中,常常要将一些"现存的对象"放到新的环境中,而新环境要求的接口是现对象不能满足的。
业务感觉好乱,建议没必要不要使用,不要过多使用
以支付为例:
1:创建接口,对内适配的调用接口
public interface AdapterPayService {
void pay(String payType, String amount);
}
2:创建接口,不同的支付接口
public interface PayService {
/**
* 微信支付
* @param amount
*/
void wechatPay(String amount);
/**
* 支付宝支付
* @param amount
*/
void aliPay(String amount);
/**
* 其他支付
* @param amount
*/
void otherPay(String amount);
}
3:实现2的接口
public class AliPayService implements PayService {
@Override
public void wechatPay(String amount) {}
// 只处理当前实现类单一业务接口
@Override
public void aliPay(String amount) {
System.out.println("阿里支付:"+amount);
}
@Override
public void otherPay(String amount) {}
}
public class OtherPayService implements PayService {
@Override
public void wechatPay(String amount) {}
@Override
public void aliPay(String amount) {}
@Override
public void otherPay(String amount) {
System.out.println("其他支付:"+amount);
}
}
public class WechatPayService implements PayService {
@Override
public void wechatPay(String amount) {
System.out.println("微信支付:"+amount);
}
@Override
public void aliPay(String amount) {}
@Override
public void otherPay(String amount) {}
}
3:创建实现AdapterPayService 的适配器类
public class AdapterPayServiceImpl implements AdapterPayService {
private PayService payService;
// 适配选择
public AdapterPayServiceImpl(String payType){
if (payType.equals(PayConstant.OTHER_PAY)){
payService = new OtherPayService();
}else if (payType.equals(PayConstant.WECHAT_PAY)){
payService = new WechatPayService();
}else if (payType.equals(PayConstant.ALI_PAY)){
payService = new AliPayService();
}
}
// 适配调用
@Override
public void pay(String payType, String amount) {
if (payType.equals(PayConstant.OTHER_PAY)){
payService.otherPay(amount);
}else if (payType.equals(PayConstant.WECHAT_PAY)){
payService.wechatPay(amount);
}else if (payType.equals(PayConstant.ALI_PAY)){
payService.aliPay(amount);
}
}
}
4:创建一个对外访问的类,实现AdapterPayService
public class AdapterPayServiceImpl2 implements AdapterPayService {
AdapterPayService adapterPayService;
@Override
public void pay(String payType, String amount) {
adapterPayService = new AdapterPayServiceImpl(payType);
adapterPayService.pay(payType,amount);
}
public static void main(String[] args) {
AdapterPayServiceImpl2 adapterPayServiceImpl2 = new AdapterPayServiceImpl2();
adapterPayServiceImpl2.pay("WECHAT_PAY","100元");
adapterPayServiceImpl2.pay("ALI_PAY","10元");
adapterPayServiceImpl2.pay("OTHER_PAY","101元");
}
}
总结:感觉和工厂模式业务逻辑是一致的,但是比工厂模式复杂且代码多,且不易维护。两个接口多个实现,再创建一个类似工厂的对外适配器
中介者模式
把对象要做的事情交给中介来处理,
用来降低多个对象和类之间的通信复杂性
用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
主要解决:对象与对象之间存在大量的关联关系,这样势必会导致系统的结构变得很复杂,同时若一个对象发生改变,我们也需要跟踪与之相关联的对象,同时做出相应的处理。
结构:
1:创建中介类
public class MediatorDemo {
public static void sayHello(String userName,String tall){
System.out.println(userName+":"+tall);
}
}
2:创建对象
public class MediatorBean {
private String userName;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public MediatorBean(String userName){
this.userName = userName;
}
public void sayHello(String tall){
MediatorDemo.sayHello(userName,tall);
}
public static void main(String[] args) {
MediatorBean zz = new MediatorBean("郑州");
MediatorBean rz = new MediatorBean("汝州");
zz.sayHello("你好!汝州");
rz.sayHello("你好!郑州");
}
}
总结:就是对象要干的事交给中介(通用的类)来处理