Java常用设计模式简易代码Demo：单例、工厂、代理、模板、观察者、适配器、策略、装饰者

一、单例模式

节省内存。

public class SingleMode {
    private static volatile SingleMode singleMode = null;//懒汉式
    private SingleMode() {
    }
    public static SingleMode getInstance() {
        if (singleMode == null) {
            synchronized (SingleMode.class) {
                if (singleMode == null) {
                    singleMode = new SingleMode();
                }
            }
        }
        return singleMode;
    }
}

二、工厂模式

将创建实例的工作与使用实例的工作分开，用户不再关心对象是如何创建的，只需要知道工厂api就可以得到对象了。

2.1简单工厂：

interface Sender{
    void send();
}
class MailSender implements Sender{
    @Override
    public void send() {
        System.out.println("发送邮件信息！");
    }
}
class SmsSender implements Sender{
    @Override
    public void send() {
        System.out.println("发送短信消息！");
    }
}
class SenderFactory {
    public static Sender newMailSender(){
        return new MailSender();
    }
    public static Sender newSmsSender(){
        return new SmsSender();
    }
}
class FactoryMode{
    public static void main(String[] args) {
        Sender sender = SenderFactory.newMailSender();
        Sender sender1 = SenderFactory.newSmsSender();
        sender.send();
        sender1.send();
    }
}

SenderFactory维护麻烦，不优雅，工厂方法模式优化。

2.2工厂方法模式：

interface Sender{
    void send();
}
class MailSender implements Sender{
    @Override
    public void send() {
        System.out.println("发送邮件信息！");
    }
}
class SmsSender implements Sender{
    @Override
    public void send() {
        System.out.println("发送短信消息！");
    }
}
interface Factory{
    Sender createSender();
}
class MailSenderFactory implements Factory{
    @Override
    public Sender createSender() {
        return new MailSender();
    }
}
class SmsSenderFactory implements Factory{
    @Override
    public Sender createSender() {
        return new SmsSender();
    }
}
class FactoryMethodMode{
    public static void main(String[] args) {
        Sender sender = new MailSenderFactory().createSender();
        Sender sender1 = new SmsSenderFactory().createSender();
        sender.send();
        sender1.send();
    }
}

但是，如果想把Sender分类处理（4G对应一个Sender，5G对应一个Sender）或者实际情况中必须要分类处理呢？抽象工厂模式（工厂方法模式属于抽象工厂，是抽象工厂的一种特例）。

2.3抽象工厂模式：

interface SenderA {
    void send();//4G发送
}
interface SenderB {
    void send();//5G发送
}
class MailSender implements SenderA {
    @Override
    public void send() {
        System.out.println("4G发送邮件信息！");
    }
}
class SmsSender implements SenderA {
    @Override
    public void send() {
        System.out.println("4G发送短信消息！");
    }
}
class NewMailSender implements SenderB {
    @Override
    public void send() {
        System.out.println("5G发送邮件消息！");
    }
}
class NewSmsSender implements SenderB {
    @Override
    public void send() {
        System.out.println("5G发送短信消息！");
    }
}
interface Factory {
    SenderA createSenderA();
    SenderB createSenderB();
}
class MailSenderFactory implements Factory {
    @Override
    public SenderA createSenderA() {
        return new MailSender();
    }
    @Override
    public SenderB createSenderB() {
        return new NewMailSender();
    }
}
class SmsSenderFactory implements Factory {
    @Override
    public SenderA createSenderA() {
        return new SmsSender();
    }
    @Override
    public SenderB createSenderB() {
        return new NewSmsSender();
    }
}
class AbstractFactoryMode {
    public static void main(String[] args) {
        MailSenderFactory mailSenderFactory = new MailSenderFactory();
        SmsSenderFactory smsSenderFactory = new SmsSenderFactory();
        mailSenderFactory.createSenderA().send();
        mailSenderFactory.createSenderB().send();
        smsSenderFactory.createSenderA().send();
        smsSenderFactory.createSenderB().send();
    }
}

三、代理模式

通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,扩展目标对象的功能。

遵循编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需修改,可以通过代理的方式来扩展该方法。

3.1静态代理：

interface UserDao{
    void save();
}
class UserDaoImpl implements UserDao{
    @Override
    public void save() {
        System.out.println("保存了数据...");
    }
}
class UserDaoImplProxy implements UserDao{
    UserDao userDao;
    public UserDaoImplProxy(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void save() {
        System.out.println("--开启事务");
        userDao.save();
        System.out.println("--关闭事务");
    }
}
class StaticProxyModeMain{//静态代理模式
    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        UserDaoImplProxy userDaoImplProxy = new UserDaoImplProxy(userDao);
        userDaoImplProxy.save();
    }
}

因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.动态代理优化。

3.2JDK动态代理：

代理对象是利用JDK的API,动态的在内存中创建代理对象.

class JdkProxyFactory{
    public static Object getInstance(Object target){
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            //代理对象调用触发invoke()
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("--开启事务");
                Object invoke = method.invoke(target, args);//去调用目标对象方法
                System.out.println("--提交事务");
                return invoke;//方法返回值
            }
        });
        return proxy;//返回代理对象
    }
}
class JdkProxyModeMain{
    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        //动态的在内存中创建代理对象，代理对象和UserDaoImpl一样实现了UserDao接口，即是UserDao接口的实现类
        UserDao proxy = (UserDao) JdkProxyFactory.getInstance(userDao);
        proxy.save();
    }
}

目标对象一定要实现接口,否则不能用JDK动态代理。

3.3cglib子类代理：

在内存中构建一个子类对象从而实现对目标对象功能的扩展.Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类.

引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core-xx.jar即可；

class AdminDao{
    public void save(){
        System.out.println("保存了数据...");
    };
}
class CglibProxyFactory implements MethodInterceptor {
    Object target;
    public CglibProxyFactory(Object target) {
        this.target = target;
    }
    //获取代理对象
    public Object getInstance(){
        Enhancer enhancer = new Enhancer();//1.工具类
        enhancer.setSuperclass(target.getClass());//2.设置父类
        enhancer.setCallback(this);//3.设置回调函数。将当前的工厂对象作为回调对象
        Object obj = enhancer.create();//4.创建子类(代理对象)
        return obj;
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("--开启事务");
        Object returnValue = method.invoke(target, objects);//去调用目标对象方法
        System.out.println("--提交事务");
        return returnValue;
    }
}
class CglibProxyModeMain{
    public static void main(String[] args) {
        AdminDao adminDao = new AdminDao();
        AdminDao proxy = (AdminDao) new CglibProxyFactory(adminDao).getInstance();
        proxy.save();
    }
}

在Spring的AOP编程中:

如果加入容器的目标对象有实现接口,用的JDK代理

如果目标对象没有实现接口,用的Cglib代理

四、模板模式

模板模式主要由抽象模板(Abstract Template)角色和具体模板(Concrete Template)角色组成。

//抽象模板
abstract class OneDay{
    public void getup(){
        System.out.println("起床");
    }
    public void sleep(){
        System.out.println("睡觉了...");
    }
    //具体模板执行流程
    public void dayAll(){
        getup();
        goWork();
        goHome();
        sleep();
    }
    public abstract void goWork();
    public abstract void goHome();
}
class Worker extends OneDay{
    @Override
    public void goWork() {
        System.out.println("骑着小毛驴去上班");
    }
    @Override
    public void goHome() {
        System.out.println("骑着小毛驴回家");
    }
}
class Boss extends OneDay{
    @Override
    public void goWork() {
        System.out.println("开着大奔上班去");
    }
    @Override
    public void goHome() {
        System.out.println("开着大奔回家");
    }
}
class TemplateMethodModeMain{
    public static void main(String[] args) {
        new Boss().dayAll();
        new Worker().dayAll();
    }
}

优点：模板方法所不变的行为搬到超类，去除子类中的重复代码，提供了一个很好了代码复用平台；子类不用关心具体执行流程和公共行为，只需实现要求你实现的方法即可。

缺点：当类的功能越来越多，变得复杂时，抽象类的管理和扩展就变得复杂了。

五、观察者模式

当被观察者状态发生改变时，需要通知相应的观察者，使这些观察者对象能够自动更新。

//被观察者通用接口
interface Observable {
    void addObserver(Observer observer);//添加观察者
    void removeObServer(Observer observer);//移除观察者
    void notifyAllObserver();//通知所有观察者
}
class Weather implements Observable {
    private List<Observer> list = new ArrayList<>();
    private double temperature;
    public void setTemperature(double temperature) {
        this.temperature = temperature;
    }
    @Override
    public void addObserver(Observer observer) {
        list.add(observer);
    }
    @Override
    public void removeObServer(Observer observer) {
        list.remove(observer);
    }
    @Override
    public void notifyAllObserver() {
        for (Observer observer : list) {
            observer.update(temperature);
        }
    }
}
//观察者通用接口
interface Observer {
    void update(double temperature);
}
class Person implements Observer{
    @Override
    public void update(double temperature) {
        System.out.println("温度更新了，当前温度值："+temperature+"，快回家收衣服啊...");
    }
}
class Dog implements Observer{
    @Override
    public void update(double temperature) {
        System.out.println("温度更新了，当前温度值："+temperature+"，天气好热，找个大树乘凉去...");
    }
}
class ObserverModeMain{
    public static void main(String[] args) {
        Weather weather = new Weather();
        weather.addObserver(new Person());
        weather.addObserver(new Dog());
        weather.setTemperature(38D);
        weather.notifyAllObserver();
    }
}

六、适配器模式

Target（目标抽象类DC5Adapter）：目标抽象类定义客户所需接口，可以是一个抽象类或接口，也可以是具体类。

Adapter（适配器类ChinaDC5Adapter）：适配器可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配，适配器类是适配器模式的核心，在对象适配器中，它通过继承Target并关联一个Adaptee对象使二者产生联系。

Adaptee（适配者类AC220）：适配者即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类一般是一个具体类，包含了客户希望使用的业务方法，在某些情况下可能没有适配者类的源代码。

class AC220{
    private final int output = 220;
    public int outputAC(){
        return output;
    }
}
//适配通用接口
interface DC5Adapter{
    int outputDC5();
}
//中国的手机适配器
class ChinaDC5Adapter implements DC5Adapter{
    private AC220 ac = new AC220();
    @Override
    public int outputDC5() {
        int i = ac.outputAC();
        System.out.println("适配前，电压："+i);
        int dc = i / 44;
        System.out.println("适配后，电压为："+dc);
        return dc;
    }
}
class AdapterModeMain{
    public static void main(String[] args) {
        //适配器对象
        DC5Adapter dc5Adapter = new ChinaDC5Adapter();
        int i = dc5Adapter.outputDC5();
    }
}

七、策略模式

环境类(Context):用来操作策略的上下文环境。

抽象策略类(Strategy):策略的抽象

具体策略类(ConcreteStrategy):具体的策略实现，每一种出行方式的具体实现。

//策略通用接口
interface Operation{
    void execute(int i, int j);
}
//策略实现类
class Add implements Operation{
    @Override
    public void execute(int i, int j) {
        int result = i+j;
        System.out.println("加法结果："+result);
    }
}
class Sub implements Operation{
    @Override
    public void execute(int i, int j) {
        int result = i -j;
        System.out.println("减法结果："+result);
    }
}
//上下文环境类
class Context{
    Operation operation;
    public Context(Operation operation) {
        this.operation = operation;
    }
    public void executeStrategy(int i, int j){
        operation.execute(i, j);//调用的是实现类的具体实现
    }
}
class StrategyModeMain{
    public static void main(String[] args) {
        int i=10,j=20;
        new Context(new Add()).executeStrategy(i,j);
        new Context(new Sub()).executeStrategy(i,j);
    }
}

优点：策略实现类可灵活实现。缺点：策略实现类繁多且需要开发者全部了解，维护麻烦。

八、装饰者模式

扩展对象的功能，是继承关系的一个替代。装饰模式可以在不创造更多子类的情况下，将对象的功能加以扩展。即扩展对象功能但不使用继承。

interface Animal{
    void function();
}
class Cat implements Animal{
    @Override
    public void function() {
        System.out.println("我会吃饭睡觉...");
    }
}
class Decorator implements Animal{
    Animal animal;//组合模式
    public Decorator(Animal animal) {
        this.animal = animal;
    }
    @Override
    public void function() {
        animal.function();//实际调用的是实现类方法
    }
}
class CatDecorator extends Decorator{
    public CatDecorator(Animal animal) {
        super(animal);
    }
    @Override
    public void function() {
        super.function();
        System.out.println("我还会抓老鼠...");
    }
}
class DecoratorModeMain{
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println("装饰前：");
        cat.function();
        CatDecorator catDecorator = new CatDecorator(cat);
        System.out.println("装饰后：");
        catDecorator.function();
    }
}