QuickCommand quickCloseCommand = new QuickCommand(new Command[]{new LightOffCommand(light), new ComputerOffCommand(computer), new DoorCloseCommand(door)});
controlPanel.setCommands(6, quickOpenCommand);
controlPanel.keyPressed(6);
2、创建扩展了上面抽象类的实体类。Circle、Rectangle、Square
public class Circle extends Shape { public Circle() { type = "Circle"; } @Override public void draw() { Log.e("---", "Inside Circle::draw() method."); } }
3、创建一个类,从数据库获取实体类,并把它们存储在一个 Hashtable 中。ShapeCache
public class ShapeCache { private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>(); public static Shape getShape(String shapeId) { Shape shapeCache = shapeMap.get(shapeId); return (Shape) shapeCache.clone(); } // 对每种形状都运行数据库查询,并创建该形状 // shapeMap.put(shapeKey, shape); // 例如,我们要添加三种形状 public static void loadCache() { Circle circle = new Circle(); circle.setId("1"); shapeMap.put(circle.getId(), circle); Rectangle rectangle = new Rectangle(); rectangle.setId("2"); shapeMap.put(rectangle.getId(), rectangle); Square square = new Square(); square.setId("3"); shapeMap.put(square.getId(), square); } }
2、创建实现接口的实体类。
public class Circle implements Shape { private String color; private int x; private int y; private int radius; public Circle(String color) { this.color = color; } public void setX(int x) { this.x = x; } public void setY(int y) { this.y = y; } public void setRadius(int radius) { this.radius = radius; } @Override public void draw() { Log.e("---", "Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y + ", radius :" + radius); } }
3、创建一个工厂,生成基于给定信息的实体类的对象。
public class ShapeFactory { private static final HashMap<String, Shape> circleMap = new HashMap<String, Shape>(); public static Shape getShape(String color) { Shape shape = circleMap.get(color); if (shape == null) { shape = new Circle(color); circleMap.put(color, shape); Log.e("getShape", "Creating circle of color : " + color); } return shape; } }
4、使用该工厂,通过传递颜色信息来获取实体类的对象。
for (int i = 0; i < 20; i++) { Circle circle = (Circle) ShapeFactory.getShape(getRandomColor()); circle.setX(getRandomX()); circle.setY(getRandomY()); circle.setRadius(100); circle.draw(); }
1、创建桥接实现接口。
public interface DrawAPI { void drawCircle(int radius, int x, int y); }
2、创建实现了 DrawAPI 接口的实体桥接实现类。RedCircle、GreenCircle
public class RedCircle implements DrawAPI { @Override public void drawCircle(int radius, int x, int y) { Log.e("---", "Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", " + y + "]"); } }
3、使用 DrawAPI 接口创建抽象类 Shape。
public abstract class Shape { protected DrawAPI drawAPI; protected Shape(DrawAPI drawAPI) { this.drawAPI = drawAPI; } public abstract void draw(); }
4、创建实现了 Shape 接口的实体类。
public class Circle extends Shape { private int x, y, radius; protected Circle(int x, int y, int radius, DrawAPI drawAPI) { super(drawAPI); this.x = x; this.y = y; this.radius = radius; } @Override public void draw() { drawAPI.drawCircle(radius, x, y); } }
5、使用 Shape 和 DrawAPI 类画出不同颜色的圆。
// 画红圆 Circle circle = new Circle(10, 10, 100, new RedCircle());s circle.draw(); // 画绿圆 Circle circle2 = new Circle(20, 20, 100, new GreenCircle()); circle2.draw();
1、创建中介类。
public class CharRoom { public static void showMessage(User user, String message) { Log.e("---", new Date().toString() + " [" + user.getName() + "] : " + message); } }
2、创建 user 类。
public class User { private String name; public User(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void sendMessage(String message) { // 使用中介类 CharRoom.showMessage(this, message); } }
3、使用 User 对象来显示他们之间的通信。
User jingbin = new User("jingbin"); jingbin.sendMessage("Hi~ youlookwhat!"); //---: Sun Feb 02 08:11:47 GMT+00:00 2020 [jingbin] : Hi~ youlookwhat! User jingbin = new User("youlookwhat"); jingbin.sendMessage("Hi~ jingbin!"); //---: Sun Feb 02 08:11:49 GMT+00:00 2020 [youlookwhat] : Hi~ jingbin!
1、创建一个表达式接口 Expression。
public interface Expression { public boolean interpreter(String content); }
2、创建实现了上述接口的实体类。TerminalExpression、OrExpression、AndExpression。
public class TerminalExpression implements Expression { private String data; public TerminalExpression(String data) { this.data = data; } @Override public boolean interpreter(String content) { // 是包含判断 return content.contains(data); } }
public class OrExpression implements Expression { private Expression expression1; private Expression expression2; public OrExpression(Expression expression1, Expression expression2) { this.expression1 = expression1; this.expression2 = expression2; } @Override public boolean interpreter(String content) { return expression1.interpreter(content) || expression2.interpreter(content); } }
public class AndExpression implements Expression { private Expression expression1; private Expression expression2; public AndExpression(Expression expression1, Expression expression2) { this.expression1 = expression1; this.expression2 = expression2; } @Override public boolean interpreter(String content) { return expression1.interpreter(content) && expression2.interpreter(content); } }
3、使用 Expression 类来创建规则,并解析它们。
/** * 规则:jingbin 和 youlookwhat 是男性 */ public static Expression getMaleExpression() { TerminalExpression jingbin = new TerminalExpression("jingbin"); TerminalExpression youlookwhat = new TerminalExpression("youlookwhat"); return new OrExpression(jingbin, youlookwhat); } /** * 规则:Julie 是一个已婚的女性 */ public static Expression getMarriedWomanExpression() { TerminalExpression julie = new TerminalExpression("Julie"); TerminalExpression married = new TerminalExpression("Married"); return new AndExpression(julie, married); } Expression maleExpression = getMaleExpression(); // jingbin is male: true Log.e("---", "jingbin is male: " + maleExpression.interpreter("jingbin")); Expression womanExpression = getMarriedWomanExpression(); // Julie is married woman: true Log.e("---", "Julie is married woman: " + womanExpression.interpreter("Married Julie"));
21. 责任链模式
责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的链。这种模式给予请求的类型,对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中,通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求,那么它会把相同的请求传给下一个接收者,依此类推。
1、创建抽象的记录器类 AbstractLogger。
public abstract class AbstractLogger { public static int INFO = 1; public static int DEBUG = 2; public static int ERROR = 3; protected int level; // 责任链中的下一个元素 protected AbstractLogger nextLogger; public void setNextLogger(AbstractLogger nextLogger) { this.nextLogger = nextLogger; } public void logMessage(int level, String message) { if (this.level <= level) { write(message); } // 递归效果,不断调用下一级 logMessage if (nextLogger != null) { nextLogger.logMessage(level, message); } } protected abstract void write(String message); }
2、创建扩展了该记录器类的实体类。
public class ConsoleLogger extends AbstractLogger { public ConsoleLogger(int level) { this.level = level; } @Override protected void write(String message) { Log.e("---", "Standard Console::Logger " + message); } }
public class FileLogger extends AbstractLogger { public FileLogger(int level) { this.level = level; } @Override protected void write(String message) { Log.e("---", "File::Logger " + message); } }
public class ErrorLogger extends AbstractLogger { public ErrorLogger(int level) { this.level = level; } @Override protected void write(String message) { Log.e("---", "Error Console::Logger " + message); } }
3、创建不同类型的记录器。赋予它们不同的错误级别,并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。
public static AbstractLogger getChainOfLoggers() { ErrorLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR); FileLogger fileLogger = new FileLogger(AbstractLogger.DEBUG); ConsoleLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO); errorLogger.setNextLogger(fileLogger); fileLogger.setNextLogger(consoleLogger); return errorLogger; } AbstractLogger logger = getChainOfLoggers(); // ---: Standard Console::Logger this is an information. logger.logMessage(AbstractLogger.INFO, "this is an information."); // ---: File::Logger this is a debug level information. // ---: Standard Console::Logger this is a debug level information. logger.logMessage(AbstractLogger.DEBUG, "this is a debug level information."); // ---: Error Console::Logger this is a error level information. // ---: File::Logger this is a error level information. // ---: Standard Console::Logger this is a error level information. logger.logMessage(AbstractLogger.ERROR, "this is a error level information.");
1、定义一个表示元素的接口。
public interface ComputerPart { public void accept(ComputerPartVisitor computerPartVisitor); }
2、创建扩展了上述类的实体类。Keyboard、Monitor、Mouse、Computer
public class Computer implements ComputerPart { private ComputerPart[] parts; public Computer() { this.parts = new ComputerPart[]{new Mouse(), new Keyboard(), new Monitor()}; } @Override public void accept(ComputerPartVisitor computerPartVisitor) { for (ComputerPart part : parts) { part.accept(computerPartVisitor); } computerPartVisitor.visit(this); } }
public class Mouse implements ComputerPart { @Override public void accept(ComputerPartVisitor computerPartVisitor) { computerPartVisitor.visit(this); } }
3、定义一个表示访问者的接口。
public interface ComputerPartVisitor { public void visit(Computer computer); public void visit(Mouse mouse); public void visit(Keyboard keyboard); public void visit(Monitor monitor); }
4、创建实现了上述类的实体访问者。
public class ComputerPartDisplayVisitor implements ComputerPartVisitor { @Override public void visit(Computer computer) { Log.e("---", "Displaying Computer."); } @Override public void visit(Mouse mouse) { Log.e("---", "Displaying Mouse."); } @Override public void visit(Keyboard keyboard) { Log.e("---", "Displaying Keyboard."); } @Override public void visit(Monitor monitor) { Log.e("---", "Displaying Monitor."); } }