/design-pattern/factory-pattern.html
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(" Inside Rectangle::draw() method. ");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println(" Inside Square::draw() method. ");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println(" Inside Circle::draw() method. ");
}
}
public class ShapeFactory {
// 使用 getShape 方法获取形状类型的对象 None
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase(" CIRCLE ")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase(" RECTANGLE ")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase(" SQUARE ")) {
return new Square();
}
return null;
}
}
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
// 获取 Circle 的对象，并调用它的 draw 方法 None
Shape shape1 = shapeFactory.getShape(" CIRCLE ");
// 调用 Circle 的 draw 方法 None
shape1.draw();
// 获取 Rectangle 的对象，并调用它的 draw 方法 None
Shape shape2 = shapeFactory.getShape(" RECTANGLE ");
// 调用 Rectangle 的 draw 方法 None
shape2.draw();
// 获取 Square 的对象，并调用它的 draw 方法 None
Shape shape3 = shapeFactory.getShape(" SQUARE ");
// 调用 Square 的 draw 方法 None
shape3.draw();
}
}
/design-pattern/abstract-factory-pattern.html
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(" Inside Rectangle::draw() method. ");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println(" Inside Square::draw() method. ");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println(" Inside Circle::draw() method. ");
}
}
public interface Color {
void fill();
}
public class Red implements Color {
@Override
public void fill() {
System.out.println(" Inside Red::fill() method. ");
}
}
public class Green implements Color {
@Override
public void fill() {
System.out.println(" Inside Green::fill() method. ");
}
}
public class Blue implements Color {
@Override
public void fill() {
System.out.println(" Inside Blue::fill() method. ");
}
}
public abstract class AbstractFactory {
public abstract Color getColor(String color);
public abstract Shape getShape(String shape);
}
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase(" CIRCLE ")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase(" RECTANGLE ")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase(" SQUARE ")) {
return new Square();
}
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType) {
return null;
}
@Override
public Color getColor(String color) {
if (color == null) {
return null;
}
if (color.equalsIgnoreCase(" RED ")) {
return new Red();
} else if (color.equalsIgnoreCase(" GREEN ")) {
return new Green();
} else if (color.equalsIgnoreCase(" BLUE ")) {
return new Blue();
}
return null;
}
}
public class FactoryProducer {
public static AbstractFactory getFactory(String choice) {
if (choice.equalsIgnoreCase(" SHAPE ")) {
return new ShapeFactory();
} else if (choice.equalsIgnoreCase(" COLOR ")) {
return new ColorFactory();
}
return null;
}
}
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
// 获取形状工厂 None
AbstractFactory shapeFactory = FactoryProducer.getFactory(" SHAPE ");
// 获取形状为 Circle 的对象 None
Shape shape1 = shapeFactory.getShape(" CIRCLE ");
// 调用 Circle 的 draw 方法 None
shape1.draw();
// 获取形状为 Rectangle 的对象 None
Shape shape2 = shapeFactory.getShape(" RECTANGLE ");
// 调用 Rectangle 的 draw 方法 None
shape2.draw();
// 获取形状为 Square 的对象 None
Shape shape3 = shapeFactory.getShape(" SQUARE ");
// 调用 Square 的 draw 方法 None
shape3.draw();
// 获取颜色工厂 None
AbstractFactory colorFactory = FactoryProducer.getFactory(" COLOR ");
// 获取颜色为 Red 的对象 None
Color color1 = colorFactory.getColor(" RED ");
// 调用 Red 的 fill 方法 None
color1.fill();
// 获取颜色为 Green 的对象 None
Color color2 = colorFactory.getColor(" Green ");
// 调用 Green 的 fill 方法 None
color2.fill();
// 获取颜色为 Blue 的对象 None
Color color3 = colorFactory.getColor(" BLUE ");
// 调用 Blue 的 fill 方法 None
color3.fill();
}
}
/design-pattern/singleton-pattern.html
public class SingleObject {
// 创建 SingleObject 的一个对象 None
private static SingleObject instance = new SingleObject();
// 让构造函数为 private，这样该类就不会被实例化 None
private SingleObject() {
}
// 获取唯一可用的对象 None
public static SingleObject getInstance() {
return instance;
}
public void showMessage() {
System.out.println(" Hello World! ");
}
}
public class SingletonPatternDemo {
public static void main(String[] args) {
// 不合法的构造函数 None
// 编译时错误：构造函数 SingleObject() 是不可见的 None
// SingleObject object = new SingleObject(); None
// 获取唯一可用的对象 None
SingleObject object = SingleObject.getInstance();
// 显示消息 None
object.showMessage();
}
}
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}
public class Singleton {
private volatile static Singleton singleton;
private Singleton() {
}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {
}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
/design-pattern/builder-pattern.html
public interface Item {
public String name();
public Packing packing();
public float price();
}
public interface Packing {
public String pack();
}
public class Wrapper implements Packing {
@Override
public String pack() {
return " Wrapper ";
}
}
public class Bottle implements Packing {
@Override
public String pack() {
return " Bottle ";
}
}
public abstract class Burger implements Item {
@Override
public Packing packing() {
return new Wrapper();
}
@Override
public abstract float price();
}
public abstract class ColdDrink implements Item {
@Override
public Packing packing() {
return new Bottle();
}
@Override
public abstract float price();
}
public class VegBurger extends Burger {
@Override
public float price() {
return 25 .0 f;
}
@Override
public String name() {
return " Veg Burger ";
}
}
public class ChickenBurger extends Burger {
@Override
public float price() {
return 50 .5 f;
}
@Override
public String name() {
return " Chicken Burger ";
}
}
public class Coke extends ColdDrink {
@Override
public float price() {
return 30 .0 f;
}
@Override
public String name() {
return " Coke ";
}
}
public class Pepsi extends ColdDrink {
@Override
public float price() {
return 35 .0 f;
}
@Override
public String name() {
return " Pepsi ";
}
} import java.util.ArrayList;
import java.util.List;
public class Meal {
private List<Item> items = new ArrayList<Item>();
public void addItem(Item item) {
items.add(item);
}
public float getCost() {
float cost = 0 .0 f;
for (Item item : items) {
cost += item.price();
}
return cost;
}
public void showItems() {
for (Item item : items) {
System.out.print(" Item : " + item.name());
System.out.print(" , Packing : " + item.packing().pack());
System.out.println(" , Price : " + item.price());
}
}
}
public class MealBuilder {
public Meal prepareVegMeal() {
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}
public Meal prepareNonVegMeal() {
Meal meal = new Meal();
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
return meal;
}
}
public class BuilderPatternDemo {
public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();
Meal vegMeal = mealBuilder.prepareVegMeal();
System.out.println(" Veg Meal ");
vegMeal.showItems();
System.out.println(" Total Cost: " + vegMeal.getCost());
Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
System.out.println("
Non-Veg Meal ");
nonVegMeal.showItems();
System.out.println(" Total Cost: " + nonVegMeal.getCost());
}
}
/design-pattern/prototype-pattern.html
public abstract class Shape implements Cloneable {
private String id;
protected String type;
abstract void draw();
public String getType() {
return type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
public class Rectangle extends Shape {
public Rectangle() {
type = " Rectangle ";
}
@Override
public void draw() {
System.out.println(" Inside Rectangle::draw() method. ");
}
}
public class Square extends Shape {
public Square() {
type = " Square ";
}
@Override
public void draw() {
System.out.println(" Inside Square::draw() method. ");
}
}
public class Circle extends Shape {
public Circle() {
type = " Circle ";
}
@Override
public void draw() {
System.out.println(" Inside Circle::draw() method. ");
}
} import java.util.Hashtable;
public class ShapeCache {
private static Hashtable<String, Shape> shapeMap
= new Hashtable<String, Shape>();
public static Shape getShape(String shapeId) {
Shape cachedShape = shapeMap.get(shapeId);
return (Shape) cachedShape.clone();
}
// 对每种形状都运行数据库查询，并创建该形状 None
// shapeMap.put(shapeKey, shape); None
// 例如，我们要添加三种形状 None
public static void loadCache() {
Circle circle = new Circle();
circle.setId(" 1 ");
shapeMap.put(circle.getId(), circle);
Square square = new Square();
square.setId(" 2 ");
shapeMap.put(square.getId(), square);
Rectangle rectangle = new Rectangle();
rectangle.setId(" 3 ");
shapeMap.put(rectangle.getId(), rectangle);
}
}
public class PrototypePatternDemo {
public static void main(String[] args) {
ShapeCache.loadCache();
Shape clonedShape = (Shape) ShapeCache.getShape(" 1 ");
System.out.println(" Shape : " + clonedShape.getType());
Shape clonedShape2 = (Shape) ShapeCache.getShape(" 2 ");
System.out.println(" Shape : " + clonedShape2.getType());
Shape clonedShape3 = (Shape) ShapeCache.getShape(" 3 ");
System.out.println(" Shape : " + clonedShape3.getType());
}
}
/design-pattern/adapter-pattern.html
public interface MediaPlayer {
public void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer {
public void playVlc(String fileName);
public void playMp4(String fileName);
}
public class VlcPlayer implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
System.out.println(" Playing vlc file. Name: " + fileName);
}
@Override
public void playMp4(String fileName) {
// 什么也不做 None
}
}
public class Mp4Player implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
// 什么也不做 None
}
@Override
public void playMp4(String fileName) {
System.out.println(" Playing mp4 file. Name: " + fileName);
}
}
public class MediaAdapter implements MediaPlayer {
AdvancedMediaPlayer advancedMusicPlayer;
public MediaAdapter(String audioType) {
if (audioType.equalsIgnoreCase(" vlc ")) {
advancedMusicPlayer = new VlcPlayer();
} else if (audioType.equalsIgnoreCase(" mp4 ")) {
advancedMusicPlayer = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase(" vlc ")) {
advancedMusicPlayer.playVlc(fileName);
} else if (audioType.equalsIgnoreCase(" mp4 ")) {
advancedMusicPlayer.playMp4(fileName);
}
}
}
public class AudioPlayer implements MediaPlayer {
MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
// 播放 mp3 音乐文件的内置支持 None
if (audioType.equalsIgnoreCase(" mp3 ")) {
System.out.println(" Playing mp3 file. Name: " + fileName);
}
// mediaAdapter 提供了播放其他文件格式的支持 None
else if (audioType.equalsIgnoreCase(" vlc ")
|| audioType.equalsIgnoreCase(" mp4 ")) {
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType, fileName);
} else {
System.out.println(" Invalid media. " +
audioType + " format not supported ");
}
}
}
public class AdapterPatternDemo {
public static void main(String[] args) {
AudioPlayer audioPlayer = new AudioPlayer();
audioPlayer.play(" mp3 ", " beyond the horizon.mp3 ");
audioPlayer.play(" mp4 ", " alone.mp4 ");
audioPlayer.play(" vlc ", " far far away.vlc ");
audioPlayer.play(" avi ", " mind me.avi ");
}
}
/design-pattern/bridge-pattern.html
public interface DrawAPI {
public void drawCircle(int radius, int x, int y);
}
public class RedCircle implements DrawAPI {
@Override
public void drawCircle(int radius, int x, int y) {
System.out.println(" Drawing Circle[ color: red, radius: "
+ radius + " , x: " + x + " , " + y + " ] ");
}
}
public class GreenCircle implements DrawAPI {
@Override
public void drawCircle(int radius, int x, int y) {
System.out.println(" Drawing Circle[ color: green, radius: "
+ radius + " , x: " + x + " , " + y + " ] ");
}
}
public abstract class Shape {
protected DrawAPI drawAPI;
protected Shape(DrawAPI drawAPI) {
this.drawAPI = drawAPI;
}
public abstract void draw();
}
public class Circle extends Shape {
private int x, y, radius;
public Circle(int x, int y, int radius, DrawAPI drawAPI) {
super(drawAPI);
this.x = x;
this.y = y;
this.radius = radius;
}
public void draw() {
drawAPI.drawCircle(radius, x, y);
}
}
public class BridgePatternDemo {
public static void main(String[] args) {
Shape redCircle = new Circle(100, 100, 10, new RedCircle());
Shape greenCircle = new Circle(100, 100, 10, new GreenCircle());
redCircle.draw();
greenCircle.draw();
}
}
/design-pattern/filter-pattern.html
public class Person {
private String name;
private String gender;
private String maritalStatus;
public Person(String name, String gender, String maritalStatus) {
this.name = name;
this.gender = gender;
this.maritalStatus = maritalStatus;
}
public String getName() {
return name;
}
public String getGender() {
return gender;
}
public String getMaritalStatus() {
return maritalStatus;
}
} import java.util.List;
public interface Criteria {
public List<Person> meetCriteria(List<Person> persons);
} import java.util.ArrayList;
import java.util.List;
public class CriteriaMale implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> malePersons = new ArrayList<Person>();
for (Person person : persons) {
if (person.getGender().equalsIgnoreCase(" MALE ")) {
malePersons.add(person);
}
}
return malePersons;
}
} import java.util.ArrayList;
import java.util.List;
public class CriteriaFemale implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> femalePersons = new ArrayList<Person>();
for (Person person : persons) {
if (person.getGender().equalsIgnoreCase(" FEMALE ")) {
femalePersons.add(person);
}
}
return femalePersons;
}
} import java.util.ArrayList;
import java.util.List;
public class CriteriaSingle implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> singlePersons = new ArrayList<Person>();
for (Person person : persons) {
if (person.getMaritalStatus().equalsIgnoreCase(" SINGLE ")) {
singlePersons.add(person);
}
}
return singlePersons;
}
} import java.util.List;
public class AndCriteria implements Criteria {
private Criteria criteria;
private Criteria otherCriteria;
public AndCriteria(Criteria criteria, Criteria otherCriteria) {
this.criteria = criteria;
this.otherCriteria = otherCriteria;
}
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
return otherCriteria.meetCriteria(firstCriteriaPersons);
}
} import java.util.List;
public class OrCriteria implements Criteria {
private Criteria criteria;
private Criteria otherCriteria;
public OrCriteria(Criteria criteria, Criteria otherCriteria) {
this.criteria = criteria;
this.otherCriteria = otherCriteria;
}
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);
for (Person person : otherCriteriaItems) {
if (!firstCriteriaItems.contains(person)) {
firstCriteriaItems.add(person);
}
}
return firstCriteriaItems;
}
} import java.util.ArrayList;
import java.util.List;
public class CriteriaPatternDemo {
public static void main(String[] args) {
List<Person> persons = new ArrayList<Person>();
persons.add(new Person(" Robert ", " Male ", " Single "));
persons.add(new Person(" John ", " Male ", " Married "));
persons.add(new Person(" Laura ", " Female ", " Married "));
persons.add(new Person(" Diana ", " Female ", " Single "));
persons.add(new Person(" Mike ", " Male ", " Single "));
persons.add(new Person(" Bobby ", " Male ", " Single "));
Criteria male = new CriteriaMale();
Criteria female = new CriteriaFemale();
Criteria single = new CriteriaSingle();
Criteria singleMale = new AndCriteria(single, male);
Criteria singleOrFemale = new OrCriteria(single, female);
System.out.println(" Males: ");
printPersons(male.meetCriteria(persons));
System.out.println("
Females: ");
printPersons(female.meetCriteria(persons));
System.out.println("
Single Males: ");
printPersons(singleMale.meetCriteria(persons));
System.out.println("
Single Or Females: ");
printPersons(singleOrFemale.meetCriteria(persons));
}
public static void printPersons(List<Person> persons) {
for (Person person : persons) {
System.out.println(" Person : [ Name : " + person.getName()
+ " , Gender : " + person.getGender()
+ " , Marital Status : " + person.getMaritalStatus()
+ " ] ");
}
}
}
/design-pattern/composite-pattern.html
import java.util.ArrayList;
import java.util.List;
public class Employee {
private String name;
private String dept;
private int salary;
private List<Employee> subordinates;
// 构造函数 None
public Employee(String name, String dept, int sal) {
this.name = name;
this.dept = dept;
this.salary = sal;
subordinates = new ArrayList<Employee>();
}
public void add(Employee e) {
subordinates.add(e);
}
public void remove(Employee e) {
subordinates.remove(e);
}
public List<Employee> getSubordinates() {
return subordinates;
}
public String toString() {
return (" Employee :[ Name : " + name
+ " , dept : " + dept + " , salary : "
+ salary + " ] ");
}
}
public class CompositePatternDemo {
public static void main(String[] args) {
Employee CEO = new Employee(" John ", " CEO ", 30000);
Employee headSales = new Employee(" Robert ", " Head Sales ", 20000);
Employee headMarketing = new Employee(" Michel ", " Head Marketing ", 20000);
Employee clerk1 = new Employee(" Laura ", " Marketing ", 10000);
Employee clerk2 = new Employee(" Bob ", " Marketing ", 10000);
Employee salesExecutive1 = new Employee(" Richard ", " Sales ", 10000);
Employee salesExecutive2 = new Employee(" Rob ", " Sales ", 10000);
CEO.add(headSales);
CEO.add(headMarketing);
headSales.add(salesExecutive1);
headSales.add(salesExecutive2);
headMarketing.add(clerk1);
headMarketing.add(clerk2);
// 打印该组织的所有员工 None
System.out.println(CEO);
for (Employee headEmployee : CEO.getSubordinates()) {
System.out.println(headEmployee);
for (Employee employee : headEmployee.getSubordinates()) {
System.out.println(employee);
}
}
}
}
/design-pattern/decorator-pattern.html
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(" Shape: Rectangle ");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println(" Shape: Circle ");
}
}
public abstract class ShapeDecorator implements Shape {
protected Shape decoratedShape;
public ShapeDecorator(Shape decoratedShape) {
this.decoratedShape = decoratedShape;
}
public void draw() {
decoratedShape.draw();
}
}
public class RedShapeDecorator extends ShapeDecorator {
public RedShapeDecorator(Shape decoratedShape) {
super(decoratedShape);
}
@Override
public void draw() {
decoratedShape.draw();
setRedBorder(decoratedShape);
}
private void setRedBorder(Shape decoratedShape) {
System.out.println(" Border Color: Red ");
}
}
public class DecoratorPatternDemo {
public static void main(String[] args) {
Shape circle = new Circle();
ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
// Shape redCircle = new RedShapeDecorator(new Circle()); None
// Shape redRectangle = new RedShapeDecorator(new Rectangle()); None
System.out.println(" Circle with normal border ");
circle.draw();
System.out.println("
Circle of red border ");
redCircle.draw();
System.out.println("
Rectangle of red border ");
redRectangle.draw();
}
}
/design-pattern/facade-pattern.html
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println(" Rectangle::draw() ");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println(" Square::draw() ");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println(" Circle::draw() ");
}
}
public class ShapeMaker {
private Shape circle;
private Shape rectangle;
private Shape square;
public ShapeMaker() {
circle = new Circle();
rectangle = new Rectangle();
square = new Square();
}
public void drawCircle() {
circle.draw();
}
public void drawRectangle() {
rectangle.draw();
}
public void drawSquare() {
square.draw();
}
}
public class FacadePatternDemo {
public static void main(String[] args) {
ShapeMaker shapeMaker = new ShapeMaker();
shapeMaker.drawCircle();
shapeMaker.drawRectangle();
shapeMaker.drawSquare();
}
}
/design-pattern/flyweight-pattern.html
public interface Shape {
void draw();
}
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() {
System.out.println(" Circle: Draw() [Color : " + color
+ " , x : " + x + " , y : " + y + " , radius : " + radius);
}
} import java.util.HashMap;
public class ShapeFactory {
private static final HashMap<String, Shape> circleMap = new HashMap<>();
public static Shape getCircle(String color) {
Circle circle = (Circle) circleMap.get(color);
if (circle == null) {
circle = new Circle(color);
circleMap.put(color, circle);
System.out.println(" Creating circle of color : " + color);
}
return circle;
}
}
public class FlyweightPatternDemo {
private static final String colors[] =
{" Red ", " Green ", " Blue ", " White ", " Black "};
public static void main(String[] args) {
for (int i = 0; i < 20; ++i) {
Circle circle =
(Circle) ShapeFactory.getCircle(getRandomColor());
circle.setX(getRandomX());
circle.setY(getRandomY());
circle.setRadius(100);
circle.draw();
}
}
private static String getRandomColor() {
return colors[(int) (Math.random() * colors.length)];
}
private static int getRandomX() {
return (int) (Math.random() * 100);
}
private static int getRandomY() {
return (int) (Math.random() * 100);
}
}
/design-pattern/proxy-pattern.html
public interface Image {
void display();
}
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName) {
this.fileName = fileName;
loadFromDisk(fileName);
}
@Override
public void display() {
System.out.println(" Displaying " + fileName);
}
private void loadFromDisk(String fileName) {
System.out.println(" Loading " + fileName);
}
}
public class ProxyImage implements Image {
private RealImage realImage;
private String fileName;
public ProxyImage(String fileName) {
this.fileName = fileName;
}
@Override
public void display() {
if (realImage == null) {
realImage = new RealImage(fileName);
}
realImage.display();
}
}
public class ProxyPatternDemo {
public static void main(String[] args) {
Image image = new ProxyImage(" test_10mb.jpg ");
// 图像将从磁盘加载 None
image.display();
System.out.println(" ");
// 图像不需要从磁盘加载 None
image.display();
}
}
/design-pattern/chain-of-responsibility-pattern.html
public abstract class AbstractLogger {
public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;
protected int level;
// 责任链中的下一个元素 None
protected AbstractLogger nextLogger;
public void setNextLogger(AbstractLogger nextLogger) {
this.nextLogger = nextLogger;
}
public void logMessage(int level, String message) {
if (this.level <= level) {
write(message);
}
if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
abstract protected void write(String message);
}
public class ConsoleLogger extends AbstractLogger {
public ConsoleLogger(int level) {
this.level = level;
}
@Override
protected void write(String message) {
System.out.println(" Standard Console::Logger: " + message);
}
}
public class ErrorLogger extends AbstractLogger {
public ErrorLogger(int level) {
this.level = level;
}
@Override
protected void write(String message) {
System.out.println(" Error Console::Logger: " + message);
}
}
public class FileLogger extends AbstractLogger {
public FileLogger(int level) {
this.level = level;
}
@Override
protected void write(String message) {
System.out.println(" File::Logger: " + message);
}
}
public class ChainPatternDemo {
private static AbstractLogger getChainOfLoggers() {
AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
errorLogger.setNextLogger(fileLogger);
fileLogger.setNextLogger(consoleLogger);
return errorLogger;
}
public static void main(String[] args) {
AbstractLogger loggerChain = getChainOfLoggers();
loggerChain.logMessage(AbstractLogger.INFO, " This is an information. ");
loggerChain.logMessage(AbstractLogger.DEBUG,
" This is a debug level information. ");
loggerChain.logMessage(AbstractLogger.ERROR,
" This is an error information. ");
}
}
/design-pattern/command-pattern.html
public interface Order {
void execute();
}
public class Stock {
private String name = " ABC ";
private int quantity = 10;
public void buy() {
System.out.println(" Stock [ Name: " + name + " ,
Quantity:" + quantity + " ]bought " ) ;
}
public void sell() {
System.out.println(" Stock [ Name: " + name + " ,
Quantity:" + quantity + " ]sold " ) ;
}
}
public class BuyStock implements Order {
private Stock abcStock;
public BuyStock(Stock abcStock) {
this.abcStock = abcStock;
}
public void execute() {
abcStock.buy();
}
}
public class SellStock implements Order {
private Stock abcStock;
public SellStock(Stock abcStock) {
this.abcStock = abcStock;
}
public void execute() {
abcStock.sell();
}
} import java.util.ArrayList;
import java.util.List;
public class Broker {
private List<Order> orderList = new ArrayList<Order>();
public void takeOrder(Order order) {
orderList.add(order);
}
public void placeOrders() {
for (Order order : orderList) {
order.execute();
}
orderList.clear();
}
}
public class CommandPatternDemo {
public static void main(String[] args) {
Stock abcStock = new Stock();
BuyStock buyStockOrder = new BuyStock(abcStock);
SellStock sellStockOrder = new SellStock(abcStock);
Broker broker = new Broker();
broker.takeOrder(buyStockOrder);
broker.takeOrder(sellStockOrder);
broker.placeOrders();
}
}
/design-pattern/interpreter-pattern.html
public interface Expression {
public boolean interpret(String context);
}
public class TerminalExpression implements Expression {
private String data;
public TerminalExpression(String data) {
this.data = data;
}
@Override
public boolean interpret(String context) {
if (context.contains(data)) {
return true;
}
return false;
}
}
public 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 interpret(String context) {
return expr1.interpret(context) || expr2.interpret(context);
}
}
public 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 interpret(String context) {
return expr1.interpret(context) && expr2.interpret(context);
}
}
public class InterpreterPatternDemo {
// 规则：Robert 和 John 是男性 None
public static Expression getMaleExpression() {
Expression robert = new TerminalExpression(" Robert ");
Expression john = new TerminalExpression(" John ");
return new OrExpression(robert, john);
}
// 规则：Julie 是一个已婚的女性 None
public static Expression getMarriedWomanExpression() {
Expression julie = new TerminalExpression(" Julie ");
Expression married = new TerminalExpression(" Married ");
return new AndExpression(julie, married);
}
public static void main(String[] args) {
Expression isMale = getMaleExpression();
Expression isMarriedWoman = getMarriedWomanExpression();
System.out.println(" John is male? " + isMale.interpret(" John "));
System.out.println(" Julie is a married women? "
+ isMarriedWoman.interpret(" Married Julie "));
}
}
/design-pattern/iterator-pattern.html
public interface Iterator {
public boolean hasNext();
public Object next();
}
public interface Container {
public Iterator getIterator();
}
public class NameRepository implements Container {
public String names[] = {" Robert ", " John ", " Julie ", " Lora "};
@Override
public Iterator getIterator() {
return new NameIterator();
}
private 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 IteratorPatternDemo {
public static void main(String[] args) {
NameRepository namesRepository = new NameRepository();
for (Iterator iter = namesRepository.getIterator(); iter.hasNext(); ) {
String name = (String) iter.next();
System.out.println(" Name : " + name);
}
}
}
import java.util.Date;
public class ChatRoom {
public static void showMessage(User user, String message) {
System.out.println(new Date().toString()
+ " [ " + user.getName() + " ] : " + message);
}
}
public class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public User(String name) {
this.name = name;
}
public void sendMessage(String message) {
ChatRoom.showMessage(this, message);
}
}
public class MediatorPatternDemo {
public static void main(String[] args) {
User robert = new User(" Robert ");
User john = new User(" John ");
robert.sendMessage(" Hi! John! ");
john.sendMessage(" Hello! Robert! ");
}
}
/design-pattern/memento-pattern.html
public class Memento {
private String state;
public Memento(String state) {
this.state = state;
}
public String getState() {
return state;
}
}
public class Originator {
private String state;
public void setState(String state) {
this.state = state;
}
public String getState() {
return state;
}
public Memento saveStateToMemento() {
return new Memento(state);
}
public void getStateFromMemento(Memento Memento) {
state = Memento.getState();
}
} import java.util.ArrayList;
import java.util.List;
public class CareTaker {
private List<Memento> mementoList = new ArrayList<Memento>();
public void add(Memento state) {
mementoList.add(state);
}
public Memento get(int index) {
return mementoList.get(index);
}
}
public class MementoPatternDemo {
public static void main(String[] args) {
Originator originator = new Originator();
CareTaker careTaker = new CareTaker();
originator.setState(" State #1 ");
originator.setState(" State #2 ");
careTaker.add(originator.saveStateToMemento());
originator.setState(" State #3 ");
careTaker.add(originator.saveStateToMemento());
originator.setState(" State #4 ");
System.out.println(" Current State: " + originator.getState());
originator.getStateFromMemento(careTaker.get(0));
System.out.println(" First saved State: " + originator.getState());
originator.getStateFromMemento(careTaker.get(1));
System.out.println(" Second saved State: " + originator.getState());
}
}
/design-pattern/observer-pattern.html
import java.util.ArrayList;
import java.util.List;
public class Subject {
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();
}
}
}
public abstract class Observer {
protected Subject subject;
public abstract void update();
}
public class BinaryObserver extends Observer {
public BinaryObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println(" Binary String: "
+ Integer.toBinaryString(subject.getState()));
}
}
public class OctalObserver extends Observer {
public OctalObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println(" Octal String: "
+ Integer.toOctalString(subject.getState()));
}
}
public class HexaObserver extends Observer {
public HexaObserver(Subject subject) {
this.subject = subject;
this.subject.attach(this);
}
@Override
public void update() {
System.out.println(" Hex String: "
+ Integer.toHexString(subject.getState()).toUpperCase());
}
}
public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();
new HexaObserver(subject);
new OctalObserver(subject);
new BinaryObserver(subject);
System.out.println(" First state change: 15 ");
subject.setState(15);
System.out.println(" Second state change: 10 ");
subject.setState(10);
}
}
/design-pattern/state-pattern.html
public interface State {
public void doAction(Context context);
}
public class StartState implements State {
public void doAction(Context context) {
System.out.println(" Player is in start state ");
context.setState(this);
}
public String toString() {
return " Start State ";
}
}
public class StopState implements State {
public void doAction(Context context) {
System.out.println(" Player is in stop state ");
context.setState(this);
}
public String toString() {
return " Stop State ";
}
}
public class Context {
private State state;
public Context() {
state = null;
}
public void setState(State state) {
this.state = state;
}
public State getState() {
return state;
}
}
public class StatePatternDemo {
public static void main(String[] args) {
Context context = new Context();
StartState startState = new StartState();
startState.doAction(context);
System.out.println(context.getState().toString());
StopState stopState = new StopState();
stopState.doAction(context);
System.out.println(context.getState().toString());
}
}
/design-pattern/null-object-pattern.html
public abstract class AbstractCustomer {
protected String name;
public abstract boolean isNil();
public abstract String getName();
}
public class RealCustomer extends AbstractCustomer {
public RealCustomer(String name) {
this.name = name;
}
@Override
public String getName() {
return name;
}
@Override
public boolean isNil() {
return false;
}
}
public class NullCustomer extends AbstractCustomer {
@Override
public String getName() {
return " Not Available in Customer Database ";
}
@Override
public boolean isNil() {
return true;
}
}
public class CustomerFactory {
public static final String[] names = {" Rob ", " Joe ", " Julie "};
public static AbstractCustomer getCustomer(String name) {
for (int i = 0; i < names.length; i++) {
if (names[i].equalsIgnoreCase(name)) {
return new RealCustomer(name);
}
}
return new NullCustomer();
}
}
public class NullPatternDemo {
public static void main(String[] args) {
AbstractCustomer customer1 = CustomerFactory.getCustomer(" Rob ");
AbstractCustomer customer2 = CustomerFactory.getCustomer(" Bob ");
AbstractCustomer customer3 = CustomerFactory.getCustomer(" Julie ");
AbstractCustomer customer4 = CustomerFactory.getCustomer(" Laura ");
System.out.println(" Customers ");
System.out.println(customer1.getName());
System.out.println(customer2.getName());
System.out.println(customer3.getName());
System.out.println(customer4.getName());
}
}
/design-pattern/strategy-pattern.html
public interface Strategy {
public int doOperation(int num1, int num2);
}
public class OperationAdd implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
public class OperationSubstract implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
public class OperationMultiply implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 * num2;
}
}
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int num1, int num2) {
return strategy.doOperation(num1, num2);
}
}
public class StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println(" 10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationSubstract());
System.out.println(" 10 - 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationMultiply());
System.out.println(" 10 * 5 = " + context.executeStrategy(10, 5));
}
}
/design-pattern/template-pattern.html
public abstract class Game {
abstract void initialize();
abstract void startPlay();
abstract void endPlay();
// 模板 None
public final void play() {
// 初始化游戏 None
initialize();
// 开始游戏 None
startPlay();
// 结束游戏 None
endPlay();
}
}
public class Cricket extends Game {
@Override
void endPlay() {
System.out.println(" Cricket Game Finished! ");
}
@Override
void initialize() {
System.out.println(" Cricket Game Initialized! Start playing. ");
}
@Override
void startPlay() {
System.out.println(" Cricket Game Started. Enjoy the game! ");
}
}
public class Football extends Game {
@Override
void endPlay() {
System.out.println(" Football Game Finished! ");
}
@Override
void initialize() {
System.out.println(" Football Game Initialized! Start playing. ");
}
@Override
void startPlay() {
System.out.println(" Football Game Started. Enjoy the game! ");
}
}
public class TemplatePatternDemo {
public static void main(String[] args) {
Game game = new Cricket();
game.play();
System.out.println();
game = new Football();
game.play();
}
}
/design-pattern/visitor-pattern.html
public interface ComputerPart {
public void accept(ComputerPartVisitor computerPartVisitor);
}
public class Keyboard implements ComputerPart {
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public class Monitor implements ComputerPart {
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public class Mouse implements ComputerPart {
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}
public class Computer implements ComputerPart {
ComputerPart[] parts;
public Computer() {
parts = new ComputerPart[]{new Mouse(), new Keyboard(), new Monitor()};
}
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
for (int i = 0; i < parts.length; i++) {
parts[i].accept(computerPartVisitor);
}
computerPartVisitor.visit(this);
}
}
public interface ComputerPartVisitor {
public void visit(Computer computer);
public void visit(Mouse mouse);
public void visit(Keyboard keyboard);
public void visit(Monitor monitor);
}
public class ComputerPartDisplayVisitor implements ComputerPartVisitor {
@Override
public void visit(Computer computer) {
System.out.println(" Displaying Computer. ");
}
@Override
public void visit(Mouse mouse) {
System.out.println(" Displaying Mouse. ");
}
@Override
public void visit(Keyboard keyboard) {
System.out.println(" Displaying Keyboard. ");
}
@Override
public void visit(Monitor monitor) {
System.out.println(" Displaying Monitor. ");
}
}
public class VisitorPatternDemo {
public static void main(String[] args) {
ComputerPart computer = new Computer();
computer.accept(new ComputerPartDisplayVisitor());
}
}
/design-pattern/mvc-pattern.html
public class Student {
private String rollNo;
private String name;
public String getRollNo() {
return rollNo;
}
public void setRollNo(String rollNo) {
this.rollNo = rollNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class StudentView {
public void printStudentDetails(String studentName, String studentRollNo) {
System.out.println(" Student: ");
System.out.println(" Name: " + studentName);
System.out.println(" Roll No: " + studentRollNo);
}
}
public class StudentController {
private Student model;
private StudentView view;
public StudentController(Student model, StudentView view) {
this.model = model;
this.view = view;
}
public void setStudentName(String name) {
model.setName(name);
}
public String getStudentName() {
return model.getName();
}
public void setStudentRollNo(String rollNo) {
model.setRollNo(rollNo);
}
public String getStudentRollNo() {
return model.getRollNo();
}
public void updateView() {
view.printStudentDetails(model.getName(), model.getRollNo());
}
}
public class MVCPatternDemo {
public static void main(String[] args) {
// 从数据库获取学生记录 None
Student model = retrieveStudentFromDatabase();
// 创建一个视图：把学生详细信息输出到控制台 None
StudentView view = new StudentView();
StudentController controller = new StudentController(model, view);
controller.updateView();
// 更新模型数据 None
controller.setStudentName(" John ");
controller.updateView();
}
private static Student retrieveStudentFromDatabase() {
Student student = new Student();
student.setName(" Robert ");
student.setRollNo(" 10 ");
return student;
}
}
/design-pattern/business-delegate-pattern.html
public interface BusinessService {
public void doProcessing();
}
public class EJBService implements BusinessService {
@Override
public void doProcessing() {
System.out.println(" Processing task by invoking EJB Service ");
}
}
public class JMSService implements BusinessService {
@Override
public void doProcessing() {
System.out.println(" Processing task by invoking JMS Service ");
}
}
public class BusinessLookUp {
public BusinessService getBusinessService(String serviceType) {
if (serviceType.equalsIgnoreCase(" EJB ")) {
return new EJBService();
} else {
return new JMSService();
}
}
}
public class BusinessDelegate {
private BusinessLookUp lookupService = new BusinessLookUp();
private BusinessService businessService;
private String serviceType;
public void setServiceType(String serviceType) {
this.serviceType = serviceType;
}
public void doTask() {
businessService = lookupService.getBusinessService(serviceType);
businessService.doProcessing();
}
}
public class Client {
BusinessDelegate businessService;
public Client(BusinessDelegate businessService) {
this.businessService = businessService;
}
public void doTask() {
businessService.doTask();
}
}
public class BusinessDelegatePatternDemo {
public static void main(String[] args) {
BusinessDelegate businessDelegate = new BusinessDelegate();
businessDelegate.setServiceType(" EJB ");
Client client = new Client(businessDelegate);
client.doTask();
businessDelegate.setServiceType(" JMS ");
client.doTask();
}
}
/design-pattern/composite-entity-pattern.html
public class DependentObject1 {
private String data;
public void setData(String data) {
this.data = data;
}
public String getData() {
return data;
}
}
public class DependentObject2 {
private String data;
public void setData(String data) {
this.data = data;
}
public String getData() {
return data;
}
}
public class CoarseGrainedObject {
DependentObject1 do1 = new DependentObject1();
DependentObject2 do2 = new DependentObject2();
public void setData(String data1, String data2) {
do1.setData(data1);
do2.setData(data2);
}
public String[] getData() {
return new String[]{do1.getData(), do2.getData()};
}
}
public class CompositeEntity {
private CoarseGrainedObject cgo = new CoarseGrainedObject();
public void setData(String data1, String data2) {
cgo.setData(data1, data2);
}
public String[] getData() {
return cgo.getData();
}
}
public class Client {
private CompositeEntity compositeEntity = new CompositeEntity();
public void printData() {
for (int i = 0; i < compositeEntity.getData().length; i++) {
System.out.println(" Data: " + compositeEntity.getData()[i]);
}
}
public void setData(String data1, String data2) {
compositeEntity.setData(data1, data2);
}
}
public class CompositeEntityPatternDemo {
public static void main(String[] args) {
Client client = new Client();
client.setData(" Test ", " Data ");
client.printData();
client.setData(" Second Test ", " Data1 ");
client.printData();
}
}
/design-pattern/data-access-object-pattern.html
public class Student {
private String name;
private int rollNo;
Student(String name, int rollNo) {
this.name = name;
this.rollNo = rollNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRollNo() {
return rollNo;
}
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
} import java.util.List;
public interface StudentDao {
public List<Student> getAllStudents();
public Student getStudent(int rollNo);
public void updateStudent(Student student);
public void deleteStudent(Student student);
} import java.util.ArrayList;
import java.util.List;
public class StudentDaoImpl implements StudentDao {
// 列表是当作一个数据库 None
List<Student> students;
public StudentDaoImpl() {
students = new ArrayList<Student>();
Student student1 = new Student(" Robert ", 0);
Student student2 = new Student(" John ", 1);
students.add(student1);
students.add(student2);
}
@Override
public void deleteStudent(Student student) {
students.remove(student.getRollNo());
System.out.println(" Student: Roll No " + student.getRollNo()
+ " , deleted from database ");
}
// 从数据库中检索学生名单 None
@Override
public List<Student> getAllStudents() {
return students;
}
@Override
public Student getStudent(int rollNo) {
return students.get(rollNo);
}
@Override
public void updateStudent(Student student) {
students.get(student.getRollNo()).setName(student.getName());
System.out.println(" Student: Roll No " + student.getRollNo()
+ " , updated in the database ");
}
}
public class DaoPatternDemo {
public static void main(String[] args) {
StudentDao studentDao = new StudentDaoImpl();
// 输出所有的学生 None
for (Student student : studentDao.getAllStudents()) {
System.out.println(" Student: [RollNo : "
+ student.getRollNo() + " , Name : " + student.getName() + " ] ");
}
// 更新学生 None
Student student = studentDao.getAllStudents().get(0);
student.setName(" Michael ");
studentDao.updateStudent(student);
// 获取学生 None
studentDao.getStudent(0);
System.out.println(" Student: [RollNo : "
+ student.getRollNo() + " , Name : " + student.getName() + " ] ");
}
}
/design-pattern/front-controller-pattern.html
public class HomeView {
public void show() {
System.out.println(" Displaying Home Page ");
}
}
public class StudentView {
public void show() {
System.out.println(" Displaying Student Page ");
}
}
public class Dispatcher {
private StudentView studentView;
private HomeView homeView;
public Dispatcher() {
studentView = new StudentView();
homeView = new HomeView();
}
public void dispatch(String request) {
if (request.equalsIgnoreCase(" STUDENT ")) {
studentView.show();
} else {
homeView.show();
}
}
}
public class FrontController {
private Dispatcher dispatcher;
public FrontController() {
dispatcher = new Dispatcher();
}
private boolean isAuthenticUser() {
System.out.println(" User is authenticated successfully. ");
return true;
}
private void trackRequest(String request) {
System.out.println(" Page requested: " + request);
}
public void dispatchRequest(String request) {
// 记录每一个请求 None
trackRequest(request);
// 对用户进行身份验证 None
if (isAuthenticUser()) {
dispatcher.dispatch(request);
}
}
}
public class FrontControllerPatternDemo {
public static void main(String[] args) {
FrontController frontController = new FrontController();
frontController.dispatchRequest(" HOME ");
frontController.dispatchRequest(" STUDENT ");
}
}
/design-pattern/intercepting-filter-pattern.html
public interface Filter {
public void execute(String request);
}
public class AuthenticationFilter implements Filter {
public void execute(String request) {
System.out.println(" Authenticating request: " + request);
}
}
public class DebugFilter implements Filter {
public void execute(String request) {
System.out.println(" request log: " + request);
}
}
public class Target {
public void execute(String request) {
System.out.println(" Executing request: " + request);
}
} import java.util.ArrayList;
import java.util.List;
public class FilterChain {
private List<Filter> filters = new ArrayList<Filter>();
private Target target;
public void addFilter(Filter filter) {
filters.add(filter);
}
public void execute(String request) {
for (Filter filter : filters) {
filter.execute(request);
}
target.execute(request);
}
public void setTarget(Target target) {
this.target = target;
}
}
public class FilterManager {
FilterChain filterChain;
public FilterManager(Target target) {
filterChain = new FilterChain();
filterChain.setTarget(target);
}
public void setFilter(Filter filter) {
filterChain.addFilter(filter);
}
public void filterRequest(String request) {
filterChain.execute(request);
}
}
public class Client {
FilterManager filterManager;
public void setFilterManager(FilterManager filterManager) {
this.filterManager = filterManager;
}
public void sendRequest(String request) {
filterManager.filterRequest(request);
}
}
public class InterceptingFilterDemo {
public static void main(String[] args) {
FilterManager filterManager = new FilterManager(new Target());
filterManager.setFilter(new AuthenticationFilter());
filterManager.setFilter(new DebugFilter());
Client client = new Client();
client.setFilterManager(filterManager);
client.sendRequest(" HOME ");
}
}
/design-pattern/service-locator-pattern.html
public interface Service {
public String getName();
public void execute();
}
public class Service1 implements Service {
public void execute() {
System.out.println(" Executing Service1 ");
}
@Override
public String getName() {
return " Service1 ";
}
}
public class Service2 implements Service {
public void execute() {
System.out.println(" Executing Service2 ");
}
@Override
public String getName() {
return " Service2 ";
}
}
public class InitialContext {
public Object lookup(String jndiName) {
if (jndiName.equalsIgnoreCase(" SERVICE1 ")) {
System.out.println(" Looking up and creating a new Service1 object ");
return new Service1();
} else if (jndiName.equalsIgnoreCase(" SERVICE2 ")) {
System.out.println(" Looking up and creating a new Service2 object ");
return new Service2();
}
return null;
}
} import java.util.ArrayList;
import java.util.List;
public class Cache {
private List<Service> services;
public Cache() {
services = new ArrayList<Service>();
}
public Service getService(String serviceName) {
for (Service service : services) {
if (service.getName().equalsIgnoreCase(serviceName)) {
System.out.println(" Returning cached " + serviceName + " object ");
return service;
}
}
return null;
}
public void addService(Service newService) {
boolean exists = false;
for (Service service : services) {
if (service.getName().equalsIgnoreCase(newService.getName())) {
exists = true;
}
}
if (!exists) {
services.add(newService);
}
}
}
public class ServiceLocator {
private static Cache cache;
static {
cache = new Cache();
}
public static Service getService(String jndiName) {
Service service = cache.getService(jndiName);
if (service != null) {
return service;
}
InitialContext context = new InitialContext();
Service service1 = (Service) context.lookup(jndiName);
cache.addService(service1);
return service1;
}
}
public class ServiceLocatorPatternDemo {
public static void main(String[] args) {
Service service = ServiceLocator.getService(" Service1 ");
service.execute();
service = ServiceLocator.getService(" Service2 ");
service.execute();
service = ServiceLocator.getService(" Service1 ");
service.execute();
service = ServiceLocator.getService(" Service2 ");
service.execute();
}
}
/design-pattern/transfer-object-pattern.html
public class StudentVO {
private String name;
private int rollNo;
StudentVO(String name, int rollNo) {
this.name = name;
this.rollNo = rollNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRollNo() {
return rollNo;
}
public void setRollNo(int rollNo) {
this.rollNo = rollNo;
}
} import java.util.ArrayList;
import java.util.List;
public class StudentBO {
// 列表是当作一个数据库 None
List<StudentVO> students;
public StudentBO() {
students = new ArrayList<StudentVO>();
StudentVO student1 = new StudentVO(" Robert ", 0);
StudentVO student2 = new StudentVO(" John ", 1);
students.add(student1);
students.add(student2);
}
public void deleteStudent(StudentVO student) {
students.remove(student.getRollNo());
System.out.println(" Student: Roll No "
+ student.getRollNo() + " , deleted from database ");
}
// 从数据库中检索学生名单 None
public List<StudentVO> getAllStudents() {
return students;
}
public StudentVO getStudent(int rollNo) {
return students.get(rollNo);
}
public void updateStudent(StudentVO student) {
students.get(student.getRollNo()).setName(student.getName());
System.out.println(" Student: Roll No "
+ student.getRollNo() + " , updated in the database ");
}
}
public class TransferObjectPatternDemo {
public static void main(String[] args) {
StudentBO studentBusinessObject = new StudentBO();
// 输出所有的学生 None
for (StudentVO student : studentBusinessObject.getAllStudents()) {
System.out.println(" Student: [RollNo : "
+ student.getRollNo() + " , Name : " + student.getName() + " ] ");
}
// 更新学生 None
StudentVO student = studentBusinessObject.getAllStudents().get(0);
student.setName(" Michael ");
studentBusinessObject.updateStudent(student);
// 获取学生 None
studentBusinessObject.getStudent(0);
System.out.println(" Student: [RollNo : "
+ student.getRollNo() + " , Name : " + student.getName() + " ] ");
}
}
/design-pattern/design-pattern-resources.html
