Java 六种常见的设计模式：单例，工厂，策略，模板方法，适配器，代理

目录

1. 单例模式 SingletonPattern

1.1 什么是单例模式

1.2 简单示例代码

2. 工厂模式 FactoryMethod

2.1 什么是工厂模式

2.2 简单示例代码

3. 策略模式 StrategyMethod

3.1 什么是策略模式

3.2 示例代码

4. 模板方法模式 TemplateMethod

4.1 什么是模板方法模式

4.2 示例代码

5. 适配器模式 AdapterMethod

5.1 什么是适配器模式

5.2 示例代码

6. 代理模式 ProxyMethod

6.1 什么是代理模式

6.2 示例代码

---

【写在前面】

此文是学习笔记。今天复习了Java的设计模式，所以另起该文，动手做练习。如侵请告知，会删。

背景知识：

设计模式是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结。

使用设计模式，是为了可重用代码，让代码更容易被他人理解，保证代码可靠性。

设计模式使代码编制真正工程化，是软件工程的基石。

1. 单例模式 SingletonPattern

1.1 什么是单例模式

属于创建型模式。

单例模式确保某一个类只要一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式只因在有真正的单一实例的需求时才可使用。

1.2 简单示例代码

package com.designmode.demo;

public class SingletonMode {
    private static final SingletonMode singletonMode = new SingletonMode();

    //构造函数，private, 限制了不能通过new直接产生一个实例
    private SingletonMode(){
    }

    public synchronized static SingletonMode getInstance(){
        return singletonMode;
    }

    public void test(){
        System.out.println("我是单例模式：" + getInstance());
    }

}

package com.designmode.demo;

public class MyDemo {
    public static void main(String[] args) {
        //单例模式，直接通过类名调用方法生成实例，再通过实例调用其他方法
        SingletonMode.getInstance().test();
    }
}

运行结果： 

我是单例模式：com.designmode.demo.SingletonMode@2503dbd3

Process finished with exit code 0

2. 工厂模式 FactoryMethod

2.1 什么是工厂模式

属于创建型模式。

工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

目的是定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

2.2 简单示例代码

package com.designmode.demo;

public interface SportsInterface {
    public void like();
    public void notLike();
}

package com.designmode.demo;

public class BasketBall implements SportsInterface{
    @Override
    public void like() {
        System.out.println("我喜欢打篮球！");
    }

    @Override
    public void notLike() {
        System.out.println("我不喜欢打篮球！");
    }
}

package com.designmode.demo;

public class Running implements SportsInterface{
    @Override
    public void like() {
        System.out.println("我喜欢跑步！");
    }

    @Override
    public void notLike() {
        System.out.println("我不喜欢跑步！");
    }
}

package com.designmode.demo;

public class FactoryMode {
    public static SportsInterface checkSports(Class clazz) {
        SportsInterface sport = null;

        try {
            sport = (SportsInterface) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sport;
    }
}

package com.designmode.demo;

public class MyDemo {
    public static void main(String[] args) {

        //工厂模式
        SportsInterface basketBall = FactoryMode.checkSports(BasketBall.class);
        SportsInterface running = FactoryMode.checkSports(Running.class);
        basketBall.like();
        basketBall.notLike();
        running.like();
        running.notLike();
    }
}

 运行结果：

我喜欢打篮球！
我不喜欢打篮球！
我喜欢跑步！
我不喜欢跑步！

Process finished with exit code 0

 

3. 策略模式 StrategyMethod

3.1 什么是策略模式

是行为型模式。

策略模式定义额一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。

需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口。

然后设计一个抽象类（可有可无，属于辅助类），提供辅助函数。

最后设计实现类。

3.2 示例代码

package com.designmode.demo;

public interface StrategyInterface {
    public void operate();
}

package com.designmode.demo;

public class StrategyDemo1 implements StrategyInterface{
    @Override
    public void operate() {
        System.out.println("我是策略1");
    }
}

package com.designmode.demo;

public class StrategyDemo1 implements StrategyInterface{
    @Override
    public void operate() {
        System.out.println("我是策略1");
    }
}

package com.designmode.demo;

public class Context {
    private StrategyInterface strategy;

    public Context(StrategyInterface strategy){
        this.strategy = strategy;
    }

    public void setStrategy(StrategyInterface strategy){
        this.strategy = strategy;
    }

    public void operate(){
        this.strategy.operate();
    }
}

package com.designmode.demo;

public class MyDemo {
    public static void main(String[] args) {
        //策略模式
        Context context;
        context = new Context(new StrategyDemo1());
        context.operate();

        context = new Context(new StrategyDemo2());
        context.operate();
    }
}

运行结果：

我是策略1
我是策略2

Process finished with exit code 0

4. 模板方法模式 TemplateMethod

4.1 什么是模板方法模式

是行为型模式。

模板方法，是类的行为模式。准备一个抽象类，将部分逻辑以具体的方法以及具体的构造函数的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。

不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。

目的是定义一个操作中的算法的骨架，将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

4.2 示例代码

package com.designmode.demo;

public abstract class BMWModel {
    public abstract void start();

    public abstract void alarm();

    public abstract void stop();

    public void run(){
        this.start();
        this.alarm();
        this.stop();
    }
}

package com.designmode.demo;

public class BMWModel1 extends BMWModel{
    @Override
    public void start() {
        System.out.println("宝马1启动~");
    }

    @Override
    public void alarm() {
        System.out.println("宝马1鸣笛~");
    }

    @Override
    public void stop() {
        System.out.println("宝马1停止~");
    }
}

package com.designmode.demo;

public class BMWModel2 extends BMWModel{
    @Override
    public void start() {
        System.out.println("宝马2启动~");
    }

    @Override
    public void alarm() {
        System.out.println("宝马2鸣笛~");
    }

    @Override
    public void stop() {
        System.out.println("宝马2停止~");
    }
}

package com.designmode.demo;

public class MyDemo {
    public static void main(String[] args) {

        //模板方法模式
        BMWModel bmw1 = new BMWModel1();
        bmw1.run();

        BMWModel bmw2 = new BMWModel2();
        bmw2.run();
    }
}

运行结果：

宝马1启动~
宝马1鸣笛~
宝马1停止~
宝马2启动~
宝马2鸣笛~
宝马2停止~

Process finished with exit code 0

5. 适配器模式 AdapterMethod

5.1 什么是适配器模式

是结构型模式。

适配器模式的核心是，当你想实现一个接口但又不想实现所有接口方法，只想去实现一部分方法是就用默认的适配器模式。

该方法在接口和具体实现类之间添加了一个抽象类，用抽象类去空实现目标接口的所有方法。而具体的实现类只需要覆盖其需要完成的方法即可。

目的是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

5.2 示例代码

package com.designmode.demo;

public interface LanguageInterface {
    public abstract void speakChinese();
    public abstract void speakEnglish();
    public abstract void speakGerman();
}

package com.designmode.demo;

public class Language implements LanguageInterface{
    @Override
    public void speakChinese() {
    }

    @Override
    public void speakEnglish() {
    }

    @Override
    public void speakGerman() {
    }
}

package com.designmode.demo;

public class ChineseSpeaking extends Language{
    public void speakChinese(){
        System.out.println("我是中国人，我会说中文！");
    }
}

package com.designmode.demo;

public class MyDemo {
    public static void main(String[] args) {

        //适配器模式
        LanguageInterface chinese = new ChineseSpeaking();
        chinese.speakChinese();
    }
}

运行结果：

我是中国人，我会说中文！

Process finished with exit code 0

6. 代理模式 ProxyMethod

6.1 什么是代理模式

是结构型模式。

代理模式中，一个类代表另一个类的功能。创建具有现有对象的对象，以便向外界提供功能接口。

目的是为其他对象提供一种代理以控制对这个对象的访问。

6.2 示例代码

//定义接口
public interface BuyHouse {
    void buyHouse();
}

 //定义被代理类，实现接口
public class HouseBuyer implements BuyHouse{
    @Override
    public void buyHouse() {
        System.out.println("我是买房者，我要买房");
    }
}
 

//定义代理类，也实现接口
public class HouseProxy implements BuyHouse{
    private BuyHouse buyHouse;
 
    public HouseProxy(BuyHouse buyHouse){
        this.buyHouse = buyHouse;
    }
 
    @Override
    public void buyHouse() { //重写接口中的方法，在接口方法原来的内容基础加上一些代理动作
        System.out.println("买房前准备");
        buyHouse.buyHouse();
        System.out.println("买房后售后");
    }
}

package com.designmode.demo;

public class MyDemo {
    public static void main(String[] args) {

        //代理模式
        BuyHouse buyHouse = new HouseBuyer(); //声明接口，但new被代理类的实例，下面要传入代理中
        HouseProxy houseProxy = new HouseProxy(buyHouse);
        houseProxy.buyHouse();
    }
}

运行结果：

买房前准备
我是买房者，我要买房
买房后售后

Process finished with exit code 0