菜鸟教程上的设计模式代码合集

/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);
        }
    }
}

/design-pattern/mediator-pattern.html

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