Java 行为型设计模式一口气讲完！*^____^*
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(){
}
@Override
protected void log(String message) {
System.out.println("Console::Logger: " + message);
}
}
class EMailLogger extends Logger {
public EMailLogger(){
}
@Override
protected void log(String message) {
System.out.println("EMail::Logger: " + message);
}
}
class FileLogger extends Logger {
public FileLogger(){
}
@Override
protected 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;
@Override
public boolean hasNext() {
if(index < names.length){
return true;
}
return false;
}
@Override
public 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);
}
@Override
public void update() {
System.out.println("Printer: " + subject.getState() );
}
}
class EmailObserver extends Observer{
public EmailObserver(MyValue subject){
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println("Email: "+ subject.getState() );
}
}
class FileObserver extends Observer{
public FileObserver(MyValue subject){
this.subject = subject;
this.subject.attach(this);
}
@Override
public 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;
}
@Override
public 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;
}
@Override
public 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;
}
@Override
public 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;
}
@Override
public String getName() {
return name;
}
@Override
public boolean isNull() {
return false;
}
}
class NullCustomer extends AbstractEmployee {
@Override
public String getName() {
return "Not Available";
}
@Override
public 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{
@Override
public int calculate(int num1, int num2) {
return num1 + num2;
}
}
class MathSubstract implements MathAlgorithm{
@Override
public int calculate(int num1, int num2) {
return num1 - num2;
}
}
class MathMultiply implements MathAlgorithm{
@Override
public 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 method
public final void play(){
//initialize
initialize();
//start
start();
//end
end();
}
}
class Browser extends Software {
@Override
void end() {
System.out.println("Browser Finished!");
}
@Override
void initialize() {
System.out.println("Browser Initialized!.");
}
@Override
void start() {
System.out.println("Browser Started.");
}
}
class Editor extends Software {
@Override
void end() {
System.out.println("Editor Finished!");
}
@Override
void initialize() {
System.out.println("Editor Initialized!");
}
@Override
void 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 {
@Override
public void visit(TreeNode n) {
System.out.println("console:" + n.getName());
}
}
class EmailVisitor implements NodeVisitor {
@Override
public 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();
}
}
上面的代码生成以下结果。
