设计模式---05.访问者模式

访问者模式

访问者模式是一种对象和对象的访问者分开的一种设计模式,在一个对象稳定的情况下,使用访问者模式可以更好的扩展对数据的访问。 相当于是我们在对象里面安插了一个“眼”,这个眼能够被外面实现,然后能拿到当前对象的各个属性。

阅读更多

设计模式--04.装饰者模式

在23种设计模式中,装饰者模式在游戏开发的过程中,使用的很是频繁。因为这个设计模式,把所有的业务的逻辑封装的对应的实体类中,从而为主流程减负了。首先看下一个应用场景

装饰者模式的应用

我们都知道有一款经典游戏90坦克,这个游戏中,玩家坦克来操作坦克打击AI敌人,在没打死一个红色坦克就会掉下来一个装备,这个装备可以提升移动速度,增加攻击力。

阅读更多

设计模式--03.观察者模式

观察者模式

观察者模式是一个消息的派发的模式,是把被观察者的状态能够及时的通知给观察者。

比如一个超市的打折了,需要把消息通知给每一个超市的顾客,这样就可以把超市作为一个被观察者,而顾客是观察者。

实现逻辑

观察者模式实现的类图如下:

观察者模式

实现步骤:

  1. 定义一个Observer接口,约束观察者(顾客)需要实现的方法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

    public interface Observer {
    void reciveMessage(double price);
    }

    public class CusmtomerObserver1 implements Observer {
    @Override
    public void reciveMessage(double price) {

    System.out.println("CusmtomerObserver1 收到了价格消息:" + price);
    }
    }

    public class CusmtomerObserver2 implements Observer {
    @Override
    public void reciveMessage(double price) {

    System.out.println("CusmtomerObserver2 收到了价格消息:" + price);
    }
    }

  2. 实现被观察对象的方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    public class MarketSubject {
    private double price;
    public double getPrice() {
    return price;
    }

    public void setPrice(double price) {
    this.price = price;
    notifyObserver(price);
    }

    private ArrayList<Observer> observerList=new ArrayList<>();
    public void addObserver(Observer observer){
    observerList.add(observer);
    }

    public void removeObserver(Observer observer){
    observerList.remove(observer);
    }

    public void notifyObserver(double price){
    for (Observer ob : observerList) {
    ob.reciveMessage(price);
    }
    }
    }

  3. 实现方法的注册和通知

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class ObserverMain {
    public static void main(String[] args) {
    MarketSubject marketSubject=new MarketSubject();
    marketSubject.addObserver(new CusmtomerObserver1());
    marketSubject.addObserver(new CusmtomerObserver2());
    marketSubject.setPrice(100d);

    }
    }

    运行结果:

1
2
CusmtomerObserver1 收到了价格消息:100.0
CusmtomerObserver2 收到了价格消息:100.0
阅读更多

设计模式--02.命令模式

命令模式

命令模式是把对象的操作方法分成一个命令,分别去执行。在分布式环境中,熔断和降级组件使用的设计模式就是命令模式。

为了了解什么是设计模式,可以类比下设计一个万能遥控器的设置,遥控器只负责一个方法的调用,真正的方法实现都在对应的电器上面。

使用的时候,只需要对对应的命令和实体进行注册下就可以了。具体的设计类图如下:

IO

具体实现代码分下面几个步骤:

  1. 定义实体方法的约束,也就是当前类实体有哪些方法,比如控制灯和电视,都有开和关的方法

    1
    2
    3
    4
    5
    6
    7
    public interface CommandObj {

    void on() ;

    void off();
    }

  2. 定义对应的类实体具体的实现方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class Light implements CommandObj {
    public void on(){
    System.out.println("打开电灯。。。");
    }

    public void off(){
    System.out.println("关闭电灯。。。");
    }
    }

    public class TV implements CommandObj{
    public void on(){
    System.out.println("打开电视。。。");
    }

    public void off(){
    System.out.println("关闭电视。。。");
    }

    }

  3. 定义一个命令执行的约束,来约束所有的Command的执行者需要实现的方法

    此处需要注意,在是实现了同一个CommandObj接口的实体,不需要Command的约束,为了Demo的完整性,把Commad接口加上。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    public interface Command {
    void execute();
    }

    public class WrapperOffCommand implements Command {
    CommandObj commandObj;

    public WrapperOffCommand(CommandObj commandObj){
    this.commandObj = commandObj;
    }

    @Override
    public void execute() {
    commandObj.off();
    }
    }

    public class WrapperOnCommand implements Command {
    CommandObj commandObj;

    public WrapperOnCommand(CommandObj commandObj){
    this.commandObj = commandObj;
    }

    @Override
    public void execute() {
    commandObj.on();
    }
    }

  4. 实现Controller的方法,即控制器本身

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    public class RemoteController {
    ConcurrentHashMap<String,Command> onCommands;
    ConcurrentHashMap<String,Command> offCommands;

    public RemoteController(){
    this.onCommands = new ConcurrentHashMap<>();
    this.offCommands = new ConcurrentHashMap<>();
    }

    public void registerCommand(String key, Command onCommand, Command offCommand){
    onCommands.put(key,onCommand);
    offCommands.put(key,offCommand);
    }

    // 按下开按钮
    public void onButtonPressed(String key){
    onCommands.get(key).execute();
    }

    // 按下关按钮
    public void offButtonPressed(String key){
    offCommands.get(key).execute();
    }
    }

  5. 控制器的使用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
       public static void main(String[] args) {
    CommandObj light = new Light();
    CommandObj tv = new TV();

    Command lightOn = new WrapperOnCommand(light);
    Command lightOff = new WrapperOffCommand(light);
    Command TVOn = new WrapperOnCommand(tv);
    Command TVOff = new WrapperOffCommand(tv);


    RemoteController remoteController = new RemoteController();
    //注册对应的命令
    remoteController.registerCommand(RemoteTypeEnum.Light.toString(), lightOn, lightOff);
    //注册对应的命令
    remoteController.registerCommand(RemoteTypeEnum.TV.toString(), TVOn, TVOff);


    remoteController.onButtonPressed(RemoteTypeEnum.Light.toString());
    remoteController.offButtonPressed(RemoteTypeEnum.Light.toString());
    remoteController.onButtonPressed(RemoteTypeEnum.TV.toString());
    remoteController.offButtonPressed(RemoteTypeEnum.TV.toString());
    }

阅读更多

设计模式--01.单例模式

在程序设计中,需要保证一个只有一个对象实例,就是所谓的单例模式。在java中,有很多单例模式的实现,这篇博客是对这几种单例模式的优缺点进行分析和优化:

饿汉模式


所谓饿汗模式,就是优先创建对象,对象在类加载的时候就已经创建好了,具体的代码如下:


    private static Singleton01 instance = new Singleton01();

    public static Singleton01 getInstance() {
        return instance;
    }

`

饿汗模式优点是代码简单,由于是在类加载的时候就已经创建好了对象,所以不存在线程安全的问题。

缺点是:有的类在没有使用的时候就已经创建了对象,产生了多余的垃圾对象。


懒汉模式


阅读更多