首页 > 其他分享 >设计模式04:装饰器模式、享元模式、命令模式、观察者模式

设计模式04:装饰器模式、享元模式、命令模式、观察者模式

时间：2023-10-27 21:11:43浏览次数：31  
标签：享元 String void 模式 class new 设计模式 public name

1.Decorator装饰器模式

 示例代码：

package Decorator09;

/**
 * 装饰器模式
 * 意图：动态的给一个对象添加一些额外的职责。
 * 适用性：
 *      在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
 *      处理那些可以撤销的职责
 */
public class DecoratorPattern {
    public static void main(String[] args) {
        Person zhangsan = new Student("张三");
        zhangsan.Operation();
        System.out.println("--------------------");
//        DecoratorA decoratorA = new DecoratorA(zhangsan);
//        Person zhangsan = new DecoratorA(zhangsan);
        zhangsan = new DecoratorA(zhangsan);
        zhangsan.Operation();
        System.out.println("--------------------");
        zhangsan = new DecoratorB(zhangsan);
        zhangsan.Operation();


    }
}
//Component
abstract class Person{
    protected String name;
    public abstract void Operation();
}
//ConcreteComponent
class Student extends Person{
    public Student(String name){
        this.name=name;
    }

    @Override
    public void Operation() {
        //职责方法
        System.out.println(name+"的职责：学习");
    }
}
//Decorator
abstract class Decorator extends Person{
    protected Person person;
}
class DecoratorA extends Decorator{

    public DecoratorA(Person person){
        this.person = person;
    }
    @Override
    public void Operation() {
        //职责方法
        person.Operation();//原先的职责
        System.out.println("新增职责：扫地");//新增职责
    }
}
class DecoratorB extends Decorator{

    public DecoratorB(Person person){
        this.person = person;
    }
    @Override
    public void Operation() {
        //职责方法
        person.Operation();//原先的职责
        System.out.println("新增职责：唱歌");//新增职责
    }
}

2.Flyweight享元模式

 

示例代码：

package Flyweight10;

/**
 * 享元模式
 * 意图：运用共享技术有效地支持大量细粒度的对象
 *
 */
public class Flyweight {
    public static void main(String[] args) {
        PieceFactory pieceFactory = new PieceFactory();
        //白棋
        Piece whitePiece1 = pieceFactory.getPiece(0);
        whitePiece1.draw(1,3);
    }
}
class PieceFactory{
    private Piece[] pieces = {new WhitePiece(),new BlackPiece()};
    public Piece getPiece(int key){
        if(key==0) return pieces[0];
        else return pieces[1];
    }
}
abstract class Piece{
    protected String color;
    public abstract void draw(int x,int y);
}
class WhitePiece extends Piece{
    public WhitePiece(){
        this.color="white";
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("draw a color: "+color+"piece x: "+x+"y: "+y);
    }
}
class BlackPiece extends Piece{
    public BlackPiece(){
        this.color = "black";
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("draw a color: "+color+"piece x: "+x+"y: "+y);
    }
}

 

package Flyweight10_2;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class FlyweightPattern {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();
        Random random = new Random();
        String[] colors = {"red","blue","green","white","black"};
        for(int i=0;i<10;i++){
            System.out.print("第"+i+"个圆： ");
            int x = random.nextInt(colors.length);
            Shape shape = factory.getShap(colors[x]);
            shape.draw(random.nextInt(2022),random.nextInt(100));
        }
    }
}
//FlyweightFactory
class ShapeFactory{
    private Map<String ,Shape> map = new HashMap<>();

    public Shape getShap(String key){
        if(map.containsKey(key)){
            return map.get(key);
        }else {
            Shape shape = new Circle(key);
            map.put(key, shape);
            return shape;
        }
    }
}
//Flyweight
abstract class Shape{
    protected String color;

    public abstract void draw(int x,int y);
}
//ConcreteFlyweight
class Circle extends Shape{
    public Circle(String color){
        System.out.println("create circle color: "+ color);
        this.color = color;
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("draw a color: "+color+" circle x: "+x+" y: "+y);
    }
}

 

3.Command命令模式

 

示例代码：

package Command11;

/**
 * 命令模式：
 * 意图：将一个请求封装为对象，从而使得可以用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。
 * 适用于：
 *      抽象出待执行的动作以参数化某对象
 *      在不同时刻指定、排列和执行请求
 *      支持取消操作
 *      支持修改日志
 *      用构建在原语操作上的高层操作构造一个系统
 */
public class CommandPattern {
    public static void main(String[] args) {
        Tv tv = new Tv();//接收者
        Command onCommand = new OnCommand(tv);//命令对象 开机命令
        Command offCommand = new OffCommand(tv);//命令对象 关机命令
        Invoker invoker = new Invoker();//请求者
        invoker.setCommand(onCommand);//请求者设置开机命令
        invoker.call();//请求者请求命令
        System.out.println("--------------------");
        invoker.setCommand(offCommand);//请求者设置关机命令
        invoker.call();//请求者请求命令
    }
}
//请求者：执行命令
class Invoker{
    private Command command;
    public void setCommand(Command command){
        this.command = command;
    }
    public void call(){
        //调用
        command.Execute();
    }
}
interface Command{
    public void Execute();

}
class OnCommand implements Command{
    private Tv tv;
    public OnCommand(Tv tv){
        this.tv = tv;
    }

    @Override
    public void Execute() {
        tv.OnAction();
    }
}
class OffCommand implements Command{
    private Tv tv;
    public OffCommand(Tv tv){
        this.tv = tv;
    }

    @Override
    public void Execute() {
        tv.OffAction();
    }
}
//Receiver
class Tv {
    public void OnAction(){
        System.out.println("开机...");
    }
    public void OffAction(){
        System.out.println("关机...");
    }
}

 

4.Observer观察者模式

 

示例代码：

package Observer12;

import java.util.ArrayList;
import java.util.List;

/**
 * 观察者模式：
 * 意图： 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新
 * 适用于：
 *      当一个对象的改变需要同时改变其他对象，而且不知道有多少个对象有待改变
 */
public class ObserverPattern {
    public static void main(String[] args) {
        Subject subjectA = new ConcreteSubject("目标A");
        Observer observerB = new ConcreteObserver("张三",subjectA);
        Observer observerC = new ConcreteObserver("李四",subjectA);
        Observer observerD = new ConcreteObserver("王五",subjectA);
//        System.out.println("目标A的状态改变后...");
        subjectA.setState("已更新...");
//        subjectA.Notify();
        subjectA.setState("停更了...");
    }
}
//目标接口
interface Subject{
    public void Attach(Observer observer);
    public void Detach(Observer observer);
    //状态改变后，通知所有观察者
    public void Notify();

    public void setState(String state);
    public String getState();
}
class ConcreteSubject implements Subject{
    private String name;
    private String state;
    private List<Observer> observerList;
    public ConcreteSubject(String name){
        this.name=name;
        state="未更新";
        observerList = new ArrayList<Observer>();
    }

    @Override
    public void Attach(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void Detach(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void Notify() {
        for (Observer observer: observerList) {
            observer.update();
        }
    }

    @Override
    public void setState(String state) {
        this.state=state;
        System.out.println(name+"的状态发生变化，变化后状态为： "+state);
        Notify();
    }

    @Override
    public String getState() {
        return this.state;
    }
}
//观察者接口
interface Observer{
    public void update();
}
class ConcreteObserver implements Observer{
    private String state;
    private String name;
    //指明目标
    private Subject subject;

    public ConcreteObserver(String name,Subject subject){
        this.state=subject.getState();
        this.name=name;
        this.subject = subject;
        subject.Attach(this);
    }

    @Override
    public void update() {
        System.out.println(name+"收到通知");
        state = subject.getState();
        System.out.println(name+"改变后的状态: "+state);
    }
}

 

标签：享元,String,void,模式,class,new,设计模式,public,name
From： https://www.cnblogs.com/hmy22466/p/17793153.html

相关文章

  • 软考上午05设计模式-行为型
    责任链模式：意图：使多个对象都有机会处理请求，避免请求的发送者和接受者有耦合关系。将这些对象连成一条链适用：多个的对象可以处理一个请求，具体哪个处理在运行时确定在不明确指明接收者的情况下向多个对象中的一个提交请求可处理一个请求的对象......
  • API - 几种API接口模式 - RESTful、WebSocket、GraphQL、gRPC、Webhook
    总结TODO.....当思考使用哪种API接口时，你将会面临一个重要的决策。RESTful、GraphQL、gRPC、WebSocket和Webhook是当前流行的几种API接口模式。在本文中，我们将介绍这些接口的特点、用途和比较，帮助你选择最适合你应用程序需求的接口。引言随着现代应用程序的复杂性和用户期望的......
  • 行为型模式(一) 责任链模式
    责任链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象能够处理它为止。角色：抽象处理者具体处理者客户端fromabcimportABCMeta,abstractmethodclassManager(metaclass=ABCMeta......
  • 设计模式-策略模式
    参考：https://blog.51cto.com/u_16125162/6329805定义:策略模式(StrategyPattern)：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。是一种对象行为型模式。打个比方说，我们出门的时候会选择不同的出行方式，比如骑自行车、坐公交、坐火车、坐飞机、坐火箭等等，这些出行方......
  • 单例模式-双重校验锁
    参考；https://blog.csdn.net/weixin_44471490/article/details/108929289双重校验锁饿汉模式是不需要加锁来保证单例的，而懒汉模式虽然节省了内存，但是却需要使用锁来保证单例，因此，双重校验锁就是懒汉模式的升级版本。普通懒汉式publicclassSingleton{ privatestatic......
  • 小端模式和大端模式——踩坑记录
    大端小端1前言在做项目时，需要将报文发送给硬件端，报文打包我都是用的大端写入Bytebuf(使用的netty)，老大审查代码时，说我写错了，说硬件那边要求是小端传输。不过改成小端写入也容易，重要的是牢记这个知识点。于是趁这个机会复习一下大端和小端。2概念大端(Big-Endian)和小端(Litt......
  • uniapp的easycom模式
    uniapp的easycom模式，无需import和注册components，即可在页面使用固定目录下的组件。这个目的是简化引用，其实还挺坑的。1.直接使用组件，全局又搜索不到引用，第一感觉让人摸不着头脑2.不引用组件，文件下放了多个组件，不知道到底使用了哪个3.进行组件优化，要删除或提取某些组件的时......
  • 【编程开发指南】「设计模式系列」一起来学编程界的“兵法”设计模式（序章）
    设计模式是什么设计模式是一种被广泛应用于软件开发中的技术，它可以帮助开发人员更好地组织和管理代码，提高代码的可读性和可维护性。本文将介绍设计模式的概念、分类和应用场景。设计模式的概念设计模式是一种被反复使用的代码设计经验，它可以解决特定问题的通用解决方案。设计模式不......
  • 软件设计之抽象工厂模式
    类图代码packagetest;importjava.util.Scanner;publicclasstest3{publicstaticvoidmain(String[]args){Factorysfactory=null;ProductAproductA=null;ProductBproductB=null;System.out.println("请输入你想要的......
  • 设计模式—创建型模式之单例模式
    设计模式—创建型模式之单例模式介绍单例模式说明：一个单一的类，负责创建自己的对象，同时确保系统中只有单个对象被创建。单例模式特点：某个类只能有一个实例；（构造器私有）它必须自行创建这个实例；（自己编写实例化逻辑）它必须自行向整个系统提供这个实例；（对外提供实例化方法）单例模式......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99