当前位置： 首页 > news >正文

Java 行为型设计模式一口气讲完！*^____^*

news 2025/4/30 7:02:08

Java 责任链模式

Java设计模式 -责任链模式

责任链模式为请求创建一个接收者对象列表。

这种模式是行为模式。

当使用责任链模式时，通常每个接收器包含对另一个接收器的引用。

如果一个对象不能处理请求，则它将相同的对象传递给下一个接收者，等等。

例子

abstract class Logger {protected Logger nextLogger;public void setNextLogger(Logger nextLogger){this.nextLogger = nextLogger;}public void logMessage(String message){log(message);if(nextLogger !=null){nextLogger.logMessage(message);}}abstract protected void log(String message);  
}
class ConsoleLogger extends Logger {public ConsoleLogger(){}@Overrideprotected void log(String message) {    System.out.println("Console::Logger: " + message);}
}
class EMailLogger extends Logger {public EMailLogger(){}@Overrideprotected void log(String message) {    System.out.println("EMail::Logger: " + message);}
}
class FileLogger extends Logger {public FileLogger(){}@Overrideprotected void log(String message) {    System.out.println("File::Logger: " + message);}
}
public class Main {  private static Logger getChainOfLoggers(){Logger emailLogger = new EMailLogger();Logger fileLogger = new FileLogger();Logger consoleLogger = new ConsoleLogger();emailLogger.setNextLogger(fileLogger);fileLogger.setNextLogger(consoleLogger);return emailLogger;  }public static void main(String[] args) {Logger loggerChain = getChainOfLoggers();loggerChain.logMessage("Null pointer");loggerChain.logMessage("Array Index Out of Bound");loggerChain.logMessage("Illegal Parameters");}
}

上面的代码生成以下结果。

Java 命令模式 

Java设计模式 - 命令模式

命令模式是数据驱动设计模式它是行为模式之一。

请求被作为命令的对象包装传递给invoker对象。

Invoker对象将命令传递到相应的对象并且该对象执行该命令。

例子

import java.util.ArrayList;
import java.util.List;interface Command {void execute();
}class MouseCursor {private int x = 10;private int y = 10;public void move() {System.out.println("Old Position:"+x +":"+y);x++;y++;System.out.println("New Position:"+x +":"+y);}public void reset() {System.out.println("reset");x = 10;y = 10;}
}class MoveCursor implements Command {private MouseCursor abcStock;public MoveCursor(MouseCursor abcStock) {this.abcStock = abcStock;}public void execute() {abcStock.move();}
}class ResetCursor implements Command {private MouseCursor abcStock;public ResetCursor(MouseCursor abcStock) {this.abcStock = abcStock;}public void execute() {abcStock.reset();}
}class MouseCommands {private List<Command> orderList = new ArrayList<Command>();public void takeOrder(Command order) {orderList.add(order);}public void placeOrders() {for (Command order : orderList) {order.execute();}orderList.clear();}
}public class Main {public static void main(String[] args) {MouseCursor cursor = new MouseCursor();MoveCursor moveCursor = new MoveCursor(cursor);ResetCursor resetCursor = new ResetCursor(cursor);MouseCommands commands= new MouseCommands();commands.takeOrder(moveCursor);commands.takeOrder(resetCursor);commands.placeOrders();}
}

上面的代码生成以下结果。

Java 迭代器模式 

Java设计模式 - 迭代器模式

迭代器模式以顺序方式访问集合对象的元素，而不知道其底层表示。

迭代器模式是行为模式之一。

例子

interface Iterator {public boolean hasNext();public Object next();
}
class LetterBag {public String names[] = {"R" , "J" ,"A" , "L"};public Iterator getIterator() {return new NameIterator();}class NameIterator implements Iterator {int index;@Overridepublic boolean hasNext() {if(index < names.length){return true;}return false;}@Overridepublic Object next() {if(this.hasNext()){return names[index++];}return null;}    }
}
public class Main {public static void main(String[] args) {LetterBag bag = new LetterBag();for(Iterator iter = bag.getIterator(); iter.hasNext();){String name = (String)iter.next();System.out.println("Name : " + name);}   }
}

上面的代码生成以下结果。

Java 观察者模式 

Java设计模式 - 观察者模式

观察者模式用于在一个对象被修改时通知其相关对象。

观察者模式是一种行为模式类别。

例子

import java.util.ArrayList;
import java.util.List;class MyValue {private List<Observer> observers = new ArrayList<Observer>();private int state;public int getState() {return state;}public void setState(int state) {this.state = state;notifyAllObservers();}public void attach(Observer observer){observers.add(observer);    }public void notifyAllObservers(){for (Observer observer : observers) {observer.update();}}   
}
abstract class Observer {protected MyValue subject;public abstract void update();
}
class PrinterObserver extends Observer{public PrinterObserver(MyValue subject){this.subject = subject;this.subject.attach(this);}@Overridepublic void update() {System.out.println("Printer: " + subject.getState() ); }
}
class EmailObserver extends Observer{public EmailObserver(MyValue subject){this.subject = subject;this.subject.attach(this);}@Overridepublic void update() {System.out.println("Email: "+ subject.getState() ); }
}
class FileObserver extends Observer{public FileObserver(MyValue subject){this.subject = subject;this.subject.attach(this);}@Overridepublic void update() {System.out.println("File: " + subject.getState()); }
}public class Main {public static void main(String[] args) {MyValue subject = new MyValue();new FileObserver(subject);new EmailObserver(subject);new PrinterObserver(subject);subject.setState(15);subject.setState(10);}
}

上面的代码生成以下结果。

Java 中介者模式 

Java设计模式 - 中介者模式

中介者模式减少多个对象之间的通信。

此模式提供了一个处理不同类之间的所有通信的中介类。

中介者模式属于行为模式类别。

例子

class Printer {public static void showMessage(Machine user, String message){System.out.println(new java.util.Date().toString()+ " [" + user.getName() +"] : " + message);}
}
class Machine {private String name;public Machine(String name){this.name  = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void sendMessage(String message){Printer.showMessage(this,message);}
}
class Main {public static void main(String[] args) {Machine m1= new Machine("M1");Machine m2 = new Machine("M2");m1.sendMessage("Rebooting");m2.sendMessage("Computing");}
}

Java 解释器模式 

Java设计模式 - 解释器模式

我们通常使用解释器模式来评估语言语法或表达。

这种类型的模式是行为模式之一。

例子

interface Expression {public boolean evaluate(String context);
}class IsInExpression implements Expression {private String data;public IsInExpression(String data) {this.data = data;}@Overridepublic boolean evaluate(String context) {if (context.contains(data)) {return true;}return false;}
}class OrExpression implements Expression {private Expression expr1 = null;private Expression expr2 = null;public OrExpression(Expression expr1, Expression expr2) {this.expr1 = expr1;this.expr2 = expr2;}@Overridepublic boolean evaluate(String context) {return expr1.evaluate(context) || expr2.evaluate(context);}
}class AndExpression implements Expression {private Expression expr1 = null;private Expression expr2 = null;public AndExpression(Expression expr1, Expression expr2) {this.expr1 = expr1;this.expr2 = expr2;}@Overridepublic boolean evaluate(String context) {return expr1.evaluate(context) && expr2.evaluate(context);}
}public class Main {public static void main(String[] args) {Expression select = new IsInExpression("Select");Expression from = new IsInExpression("From");Expression isSelectFrom = new AndExpression(select, from);Expression insert = new IsInExpression("Insert");Expression update = new IsInExpression("Update");Expression isInsertOrUpdate = new OrExpression(insert, update);System.out.println(isSelectFrom.evaluate("Select"));System.out.println(isInsertOrUpdate.evaluate("Insert"));System.out.println(isSelectFrom.evaluate("Select From"));System.out.println(isInsertOrUpdate.evaluate("Update"));}
}

上面的代码生成以下结果。

Java 状态模式 

Java设计模式 - 状态模式

在状态模式中，类行为基于其状态而改变。

状态模式是一种行为模式。

当使用状态模式时，我们创建各种状态对象和上下文对象，其行为随着其状态对象改变而变化。

例子

interface State {public void doAction(Context context);
}class StartState implements State {public void doAction(Context context) {System.out.println("In start state");context.setState(this);}public String toString() {return "Start State";}
}class StopState implements State {public void doAction(Context context) {System.out.println("In stop state");context.setState(this);}public String toString() {return "Stop State";}
}class PlayState implements State {public void doAction(Context context) {System.out.println("In play state");context.setState(this);  }public String toString() {return "Play State";}
}class Context {private State state;public Context() {state = null;}public void setState(State state) {this.state = state;}public State getState() {return state;}
}public class Main {public static void main(String[] args) {Context context = new Context();StartState startState = new StartState();startState.doAction(context);System.out.println(context.getState().toString());PlayState playState = new PlayState();playState.doAction(context);StopState stopState = new StopState();stopState.doAction(context);System.out.println(context.getState().toString());}
}

上面的代码生成以下结果。

Java 空对象模式 

Java设计模式 - 空对象模式

在空对象模式中，创建一个无业务对象，包括 null 对象。

我们使用无业务对象来替换空指针检查。

我们称之为一个无业务的对象Null对象。

Null对象在数据不可用时提供默认行为。

在空对象模式中，我们通常创建一个抽象类来指定各种操作。

Null Object和具体类都将扩展这个抽象类。

Null Object类只提供空逻辑。

例子

abstract class AbstractEmployee {protected String name;public abstract boolean isNull();public abstract String getName();
}
class Programmer extends AbstractEmployee {public Programmer(String name) {this.name = name;    }@Overridepublic String getName() {return name;}@Overridepublic boolean isNull() {return false;}
}
class NullCustomer extends AbstractEmployee {@Overridepublic String getName() {return "Not Available";}@Overridepublic boolean isNull() {return true;}
}
class EmployeeFactory {public static final String[] names = {"Rob", "Joe", "Jack"};public static AbstractEmployee getCustomer(String name){for (int i = 0; i < names.length; i++) {if (names[i].equalsIgnoreCase(name)){return new Programmer(name);}}return new NullCustomer();}
}
public class Main {public static void main(String[] args) {AbstractEmployee emp = EmployeeFactory.getCustomer("Rob");AbstractEmployee emp2 = EmployeeFactory.getCustomer("Bob");AbstractEmployee emp3 = EmployeeFactory.getCustomer("Jack");AbstractEmployee emp4 = EmployeeFactory.getCustomer("Tom");System.out.println(emp.getName());System.out.println(emp2.getName());System.out.println(emp3.getName());System.out.println(emp4.getName());}
}

上面的代码生成以下结果。

Java 策略模式 

 Java设计模式 - 战略模式

在策略模式中，可以在运行时更改算法。

策略模式是一种行为模式。

在策略模式中，我们创建表示各种算法的对象和运行算法的上下文对象。

策略对象更改上下文对象上的算法。

例子

interface MathAlgorithm {public int calculate(int num1, int num2);
}
class MathAdd implements MathAlgorithm{@Overridepublic int calculate(int num1, int num2) {return num1 + num2;}
}
class MathSubstract implements MathAlgorithm{@Overridepublic int calculate(int num1, int num2) {return num1 - num2;}
}
class MathMultiply implements MathAlgorithm{@Overridepublic int calculate(int num1, int num2) {return num1 * num2;}
}
class MathContext {private MathAlgorithm algorithm;public MathContext(MathAlgorithm strategy){this.algorithm = strategy;}public int execute(int num1, int num2){return algorithm.calculate(num1, num2);}
}
public class Main {public static void main(String[] args) {MathContext context = new MathContext(new MathAdd());    System.out.println("10 + 5 = " + context.execute(10, 5));context = new MathContext(new MathSubstract());    System.out.println("10 - 5 = " + context.execute(10, 5));context = new MathContext(new MathMultiply());    System.out.println("10 * 5 = " + context.execute(10, 5));}
}

上面的代码生成以下结果。

Java 模板方法模式 

Java设计模式 - 模板方法模式

在模板模式中，父抽象类公开几个抽象方法供子类实现。在父抽象类中有另一个方法或几个方法使用抽象方法来实现业务逻辑。

抽象方法通常用于父类所需的每个步骤。

例如，为了使用新的软件，我们需要下载，安装，配置和运行。如果我们要使用模板模式来编码逻辑，我们将创建一个父类如下。

abstract class UseSoftware{abstract void download();abstract void install();abstract void configuration();abstract void run();public void useNewSoftware(){download();install();configuration();run();   }
}

对于使用不同的软件，我们只需要从上面的抽象类继承并提供详细的实现。

模板模式是一种行为模式。

例子

abstract class Software {abstract void initialize();abstract void start();abstract void end();//template methodpublic final void play(){//initializeinitialize();//startstart();//endend();}
}
class Browser extends Software {@Overridevoid end() {System.out.println("Browser Finished!");}@Overridevoid initialize() {System.out.println("Browser Initialized!.");}@Overridevoid start() {System.out.println("Browser Started.");}
}
class Editor extends Software {@Overridevoid end() {System.out.println("Editor Finished!");}@Overridevoid initialize() {System.out.println("Editor Initialized!");}@Overridevoid start() {System.out.println("Editor Started!");}
}
public class Main {public static void main(String[] args) {Software s1 = new Browser();s1.play();s1 = new Editor();s1.play();    }
}

上面的代码生成以下结果。

Java 访问者模式

Java设计模式 - 访问者模式

在访问者模式中，元素对象接受访问者对象，而访问者对象处理元素对象上的操作。

此模式是一种行为模式。

通过这种方式，可以从不同的访问者改变元素的执行算法。

例子

class TreeNode {private String name;public TreeNode(String name) {this.name = name;}public String getName() {return name;}public void accept(NodeVisitor v) {v.visit(this);}
}
interface NodeVisitor {public void visit(TreeNode n);
}
class ConsoleVisitor implements NodeVisitor {@Overridepublic void visit(TreeNode n) {System.out.println("console:" + n.getName());}
}class EmailVisitor implements NodeVisitor {@Overridepublic void visit(TreeNode n) {System.out.println("email:" + n.getName());}
}public class Main {public static void main(String[] args) {TreeNode computer = new TreeNode("w3cschool.cn");computer.accept(new ConsoleVisitor());computer.accept(new EmailVisitor());}
}

上面的代码生成以下结果。

console:w3cschool.cn

email:w3cschool.cn

Java MVC模式

Java设计模式 - MVC模式

MVC 模式表示模型 - 视图 - 控制器模式。

从名称我们可以看到，MVC模式涉及三个部分:

  • Model（模型）- 模型表示携带数据的对象。它也可以具有逻辑来更新控制器，如果其数据改变。

  • View（视图）- 视图表示模型包含的数据的可视化。通常它有UI逻辑。

  • Controller（控制器） - 控制器引用模型和视图。它控制数据流进入模型对象，并在数据更改时更新视图。它保持视图和模型分开。

例子

class Employee {private String id;private String name;public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}class EmployeeView {public void printEmployeeDetails(String name, String no) {System.out.println("Employee: ");System.out.println("Name: " + name);System.out.println("ID: " + no);}
}class EmployeeController {private Employee model;private EmployeeView view;public EmployeeController(Employee model, EmployeeView view) {this.model = model;this.view = view;}public void setEmployeeName(String name) {model.setName(name);}public String getEmployeeName() {return model.getName();}public void setEmployeeId(String rollNo) {model.setId(rollNo);}public String getEmployeeId() {return model.getId();}public void updateView() {view.printEmployeeDetails(model.getName(), model.getId());}
}public class Main {public static void main(String[] args) {Employee model = new Employee();model.setName("Tom");model.setId("1");EmployeeView view = new EmployeeView();EmployeeController controller = new EmployeeController(model, view);controller.updateView();controller.setEmployeeName("New Name");controller.updateView();}
}

上面的代码生成以下结果。

 


http://www.mrgr.cn/news/26427.html

相关文章：

  • django-admin自定义功能按钮样式
  • 大模型→世界模型下的「认知流形」本质·下
  • 【隐私保护】如何找出CLS方案的创新之处？
  • IDEA测试类启动报 “java: 常量字符串过长” 解决办法
  • 【JUC并发编程系列】深入理解Java并发机制：Synchronized机制深度剖析、HotSpot下的并发奥秘(四、synchronized 原理分析)
  • C++ | Leetcode C++题解之第403题青蛙过河
  • 【ShuQiHere】从插入排序到归并排序：探究经典排序算法的魅力与实战应用
  • Android双屏异显的使用相关
  • 优化冒泡排序算法
  • 性能测试：Locust使用介绍(五)
  • 北大阿里：新出炉的LLM偏好对齐方法综述
  • StreamReader 和 StreamWriter提供自动处理字符编码的功能
  • 【Java】StringUtils 工具类常用的方法
  • 使用firmware
  • Adobe After Effects AE专业特效制作软件 多版本安装包下载
  • Anaconda 安装与使用教程
  • static 初始化报错
  • 可变剪切：基因表达的神奇开关（MISO）
  • 基于python+django+vue的社区爱心养老管理系统
  • 学习笔记-Golang中的Context