interface itf{
	pulic void itf_func()=0;
}

class itf_impl implements itf{
	public void itf_func(){
	}
}

class itf_cls implements itf, others{
	itf itf_var;

	public itf_cls(String args[]){
		itf_var = new itf_impl;
	}

	public void func(){
		itf_var.func();
	}
}

// step1: create interface
public interface Shape{
	void draw();
}

// step2: create concrete class implementing interface
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.");
	}
}

// step3: create factory class generating concrete classes
// according to given info
public class ShapeFactory{
	public Shape getShape(String shapeType){
		if (shapeType == null){
			return null;
		}
		if (shapeType.equalsIgnoreCase("CIRCLE")){
			return new Circle();
		}
		if (shapeType.equalsIgnoreCase("RECTANGLE")){
			return new Rectangle();
		}
		if (shapeType.equalsIgnoreCase("SQUARE")){
			return new Square();
		}
		return null;
	}
}

// usage demo
public class FactoryPatternDemo{
	public static void main(String[] args){
		ShapeFactory shapeFactory = new ShapeFactory();

		Shape circle = shapeFactory.getShape("CIRCLE");
		circle.draw();
		Shape rectangle = shapeFactory.getShape("Rectangle");
		rectangle.draw();
		Shape square = shapeFactory.getShape("square");
		square.draw();
	}
}

// step1: create interface
public interface Shape{
	void draw();
}
public interface Color{
	void fill();
}

// step2: create concrete class implementing interface

// shape classes
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.");
	}
}

// color classes
public Red implements Color{
	@Override
	public void fill(){
		System.out.println("Inside Red::fill() method.");
	}
}
public Green implements Color{
	@Override
	public void fill(){
		System.out.println("Inside Green::fill() method.");
	}
}
public Blue implements Color{
	@Override
	public void fill(){
		System.out.println("Inside Blue::fill() method.");
	}
}

// step3: create abstract class to get factory classes
public abstract class AbstractFactory{
	public abstract Color getColor(String color);
	public abstract Shape getShape(String shape);
}

// step4: create factory classes extending abstract factory
// class
public class ShapeFactory extends AbstractFactory{
	@Override
	public Shape getShape(String shapeType){
		if (shapeType == null){
			return null
		}
		if (shapeType.equalsIgnoreCase("CIRCLE"){
			return new Circle();
		}
		if (shapeType.equalsIgnoreCase("Rectangle"){
			return new Rectangle();
		}
		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 getColor(String color){
		if (color == null){
			return null;
		}
		if (color.equalsIgnoreCase("RED"){
			return new Red();
		}
		if (color.equalsIgnoreCase("Green"){
			return new Green();
		}
		if (color.equalsIgnoreCase("blue"){
			return new Blue();
		}

		return null;
	}
}

// step5: create factory producer
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;
	}
}

// step6: demo
public class AbstractFactoryPatternDemo{
	public static void main(String[] args){
		
		// use shape cluster only
		AbstractFactory shapeFactory = FactoryProducer.getFactory("SHPAE");
		Shape circle = shapeFactory.getShape("CIRCLE");
		circle.draw();
		Shape rectangle = shapeFactory.getShape("RECTANGLE");
		rectangle.draw();
		Shape square = shapeFactory.getShape("SQUARE");
		square.draw();

		//use color cluster only
		AbstractFactory colorFactory = FactoryProducer.getFactory("color");
		Color red = colorFactory.getColor("RED");
		red.fill();
		Color green = colorFactory.getColor("green");
		green.fill();
		Color blue = colorFactory.getColor("blue");
		blue.fill();
	}
}

// step1: create singleton class
public class SingleObject{

	// create object as soon as class is loaded. It's okay
	// to move creating to `getInstance()`
	private static SingleObject instance = new SingleObject();

	// private construction method, so this class won't be
	// instantiated
	private SingleObject(){};

	public static SingleObject getInstance(){
		return instance;
	}

	public void showMessage(){
		System.out.println("hello world");
	}
}

// step2: test demo
public class SingletonPatternDemo{
	public static void main(String[] args){

		// private construction method, so `new SingleObject()`
		// is illegal
		SingleObject object = SingleObject.getInstance();
		object.showMessage();
	}
}

// step1
public interface Item{
	public String name();
	public Packing packing();
	public float price();
}
public interface Packing{
	public String pack();
}

// step2
public class Wrapper implements Packing{
	@Override
	public String pack(){
		return "Wrapper";
	}
}
public class Bottle implements Packing{
	@Override
	public String pack(){
		return "Bottle";
	}
}

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

// step4
public class VegBurger extends Buger{
	@Override
	public float price(){
		return 25.0f;
	}
	@Override
	public String name(){
		return "Veg Burger";
	}
}
public class ChickenBurger extends Burger{
	@Override
	public float price(){
		return 50.5f;
	}
	@Override
	public String name(){
		return "Chicken Burger";
	}
}
public class Coke extends ColdDrink{
	@Override
	public float price(){
		return 30.0f;
	}
	@Override
	public String name(){
		return "Coke";
	}
}
public class Pepsi extends ColdDrink{
	@Override
	public float price(){
		return 35.0f;
	}
	@Override
	public String name(){
		return "Pepsi";
	}
}

// step5
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.0f;
		for (Item item: items){
			cost += item.price();
		}
		return cost;
	}
	public void showItem(){
		for (Item item: items){
			System.out.print("Item: " + item.name());
			System.out.print(", Packing: " + item.packing().pack());
			System.out.println(", Price: " + item.price());
		}
	}
}

// step6
public class MealBuilder{
	public Meal prepareVegMeal(){
		Meal meal = new Meal();
		meal.addItem(new VegBurger());
		meal.addItem(new Coke());
		return meal;
	}
	public Meal parpareNonVegMeal(){
		Meal meal = new Meal();
		meal.addItem(new ChickenBuger());
		meal.addItem(new Pepsi());
		return meal;
	}
}

// step7
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("\n\nNon-Veg Meal");
		nonVegMeal.showItems();
		System.out.println("Total Cost: " + nonVegMeal.getCost());
	}
}

// step1: create an abstract class implementing Cloneable
// interface
public abstract class Shape implements Cloneable{
	// Java中已经同原型模式融为一体
	// 实现`Cloneable`接口实现浅拷贝，深拷贝则是通过实现
	// `Serializable`读取二进制流
	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;
	}
}

// step2: create a concrete class extending the abstract
// class
public class Rectangle extends Shape{
	public Rectangle(){
		tpye = "Rectangle";
	}
	@Override
	public void draw(){
		System.out.println("Inside Rectangle::draw() method.");
	}
}
public class Square extends SHape{
	public Square(){
		type = "Sqaure";
	}
	@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.");
	}
}

// step3: creat a class to store the implements
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();
	}
	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);
	}
}

// step4: test demo
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("2");
		System.out.println("shape: " + clonedShape3.getType());
	}
}

// step1: create interfaces
public interface MediaPlayer{
	public void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer{
	public void playVlc(String fileName);
	public void playMp4(String fileName);
}

// step2:
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){
	}
}
public class Mp4Player implements AdvancedMediaPlayer{
	@Override
	public void playVlc(String fileName){
	}
	@Override
	public void playMp4(String fileName){
		System.out.println("Playing mp4 file. Name: " + fileName);
	}
}

// step3: create adapter class
public class MediaAdapter implements MediaPlayer{
	AdvancedMediaPlayer advancedMusicPlayer;

	// construction method
	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")){
			advancedMusciPlayer.playMp4(fileName);
		}
	}
}

// step4:
public class AudioPlayer implements MediaPlayer{
	MediaPlayer mediaAdapter;

	@Override
	public void play(String audioType, String fileName){
		if(audioType.equalsIgnoreCase("mp3")){
			System.out.println("Playing mp3 file. Name: " + fileName);
		}else if(audioType.equalsIgnoreCase("vlc") ||
			audioType.equalsIgnoreCase("mp4")){
			mediaAdapter = new MediaAdatper(audioType);
			mediaAdapter.play(audioType, fileName);
		}else{
			System.out.println("Invalid media. " +
				audioType + " format not supported.");
		}
	}
}

// step5: test demo
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");
	}
}

// step1
public interface DrawAPI{
	public void drawCircle(int radius, int x, int y);
}

// step2
public class RecCircle implements DrawAPI{
	@Override
	public void drawCircle(int radius, int x, int y){
		System.out.println("Drawing Circle[color: red, radius: "
			+ radius + ", x: " + x +", y: " + 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: " + y + "]");
	}
}

// step3
public abstract class Shape{
	protected DrawAPI drawAPI;
	protected Shape(DrawAPI drawAPI){
		this.drawAPI = drawAPI;
	}
	public abstract void draw();
}

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

// step5: test demo
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();
	}
}

// step1: create a class which will be impose criteria on
public class Person{
	private String name;
	private String gender;
	pirvate 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;
	}
}

// step2: create an interface for criteria
import java.util.List;
public interface Criteria{
	public List<Person> meetCriteria(List<Person> persons);
}

// step3: creat 
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<Peron>();
		for(Person person : persons){
			if(person.getGender().equalsIgnoreCase("MALE"){
				malePersons.add(Person);
			}
		}
		return malePersons;
	}
}
public class CriteriaFemale implements Criteria{
	@Override
	public List<Person> meetCriteria(List<Person> persons){
		List<Person> femalePerson = new ArrayList<Person>();
		for(Person person: persons){
			if(person.getGender.equalsIgnoreCase("Female"){
				femalePersons.add(person);
			}
		}
		return femalePersons;
	}
}
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")){
				singlePerson.add(person);
			}
		}
		return singlePersons;
	}
}
public class AndCriteria implements Criteria{
	pirvate 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);
	}
}
public class OrCriteria implements Criteria{
	pirvate Criteria criteria;
	private Criteria otherCriteria;
	public Criteria(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 = criteria.meetCriteria(persons);
		for(Person person: otherCriteriaItems){
			if(!firstCriteriaItems.contains(person)){
				firstCriteriaItems.add(person);
			}
		}
		return firstCriteriaItems;
	}
}

// step4: test demo
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("\nFemales: ");
		printPersons(female.meetCriteria(persons));

		System.out.println("\nSingle Males: ");
		printPersons(singleMale.meetCriteria(persons));

		System.out.println("\nSingle 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()
				+" ]");
		}
	}
}

// step1: create a class containing a list of Self
import java.util.ArrayList;
import java.util.List;
public class Employee{
	pirvate String name;
	pirvate String dept;
	private int salary'
	private List<Employee> subordinates;

	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 + "]");
	}
}

// step2: test demo
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 saleExecutive1 = new Employee("Richard", "Sales", 10000);
		Employee saleExecutive2 = new Employee("Rob", "Sales", 10000);
		CEO.add(headSales);
		CEO.add(headMarketing);
		headSales.add(saleExecutive1)
		headSales.add(saleExecutive2);
		headMarketing.add(clerk1);
		headMarketing.add(clerk2);

		System.out.println(CEO);
		for(Employee  headEmployee: CEO.getSubordinates()){
			System.out.println(headEmployee);
			for(Employee employee: headEmployee.getSubordinates()){
				System.out.println(employee);
			}
		}
	}
}

// step1
public interface Shape{
	void draw();
}

// step2
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: Cirlce");
	}
}

// step3
public abstract class ShapeDecorator implements Shape{
	protected Shape decoratedShape;
	public ShapeDecorator(Shape decoratedShape){
		this.decoratedShape = decoratedShape;
	}
	public void draw(){
		decoratedShape.draw();
	}
}

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

// step5: demo
public class DecoratorPatternDemo{
	public static void main(String[] args){
		Shape circle = new Circle();
		Shape redCircle = new RedShapeDecorator(new Circle());
		Shape redRectangle = new RedShapeDecorator(new Rectangle());
		System.out.println("Circle with normal border");
		circle.draw();
		System.out.println("\nCircle of red border");
		redCircle.draw();
		System.out.println("\nRectangle of red border");
		redRectangle.draw();
	}
}

// step1
public interface Shape{
	void draw();
}
// step2
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()");
	}
}
// step3
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();
	}
}
// step4
public class FacadePatternDemo{
	public static void main(String[] args){
		ShapeMaker shapeMaker = new ShapeMaker();
		shapeMaker.drawCircle();
		shapeMaker.drawRectangle();
		shapeMaker.drawSquare();
	}
}

// step1
public interface Shape{
	void draw();
}

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

// step3
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 cirle;
	}
}

// step4
public class FlyweightPatternDemo{
	pirvate 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(getRamdonColor());
			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);
	}
}

// step1
public interface Image{
	void dispaly();
}

// step2
publi class RealImage implements Image{
	private String fileName;

	public RealImage(String fileName){
		this.filName = fileName;
		loadFromDisk(fileName);
	}
	@Ovrride
	public void display(){
		System.out.println("Displaying " + fileName);
	}
	private void loadFromDisk(String fileName){
		System.out.println("Loading " + fileName);
	}
}

// step3
public class ProxyImage implements Image{
	private RealImage realImage;
	private String fileName;

	public ProxyImage(String fileName){
		this.fileName = fileName;
		// it won't load image until display-method is
		// called
	}
	@Override
	public void display(){
		if(realImage = Null){
			realImage = new RealImage(fileName);
		}
		realImage.display();
	}
}

// step4
public class ProxyPatternDemo{
	public static void main(String[] args){
		Image image = new ProxyImage("test_10mb.jpg");
		image.display();
	}
}

// step1
public abstract class AbstractLogger{
	public static int INFO = 1;
	public static int DEBUG = 2;
	public static int ERROR = 3'
	protected int level;
	protected AbstractLogger nextLogger;

	public void setNextLogger(AbstractLogger nextLogger){
		this.nextLogger = nextLogger;
	}
	public void logMessage(int level, String Message){
		if(this.level <= level){
			write(message);
		}
		if(nextLogger != null){
			nextLogger.logMessage(level, message);
		}
	}
	abstract protected void write(String message);
}

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

// step3
public class ChainPatternDemo{
	private static AbstractLogger getChainOfLogger(){
		AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
		AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG):
		AbstractLogger console.Logger = new ConsoleLogger(AbstractLogger.INFO0;
		errorLogger.setNextLogger(fileLogger);
		fileLogger.setNextLogger(consoleLogger);
		return errorLogger;
	}
	public static void main(String[] args){
		AbstractLogger loggerChain = getChainLoggers();
		loggerChain.logMessage(AbstractLogger.INFO,
			"this is an information");
		loggerChain.logMessage(AbstractLogger.DEBUG,
			"this is a debug level infomation");
		loggerChain.logMessage(AbstractLogger.ERROR,
			"this is an error infomation");
	}
}

// step1
public interface Order{
	void execute();
}

// step2
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 seel(){
		System.out.println("Stock [Name: " + name
			+ ", Quantity: " + quantity + "] sold");
	}
}

// step2
public class BuyStock implements Order{
	private Stock abcStock;
	public BuyStock(Stock abcStock){
		this.abcStock = abcStock;
	}
	public void execute（）{
		abcStock.but();
	}
}
public class SellStock implements Order{
	private Stock abcStock;
	public SellStock(Stock abcStock){
		this.abcStock = abcStock;
	}
	pubic void execute(){
		abcStock.sell();
	}
}

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

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

// step1
public interface Expression{
	public boolean interpret(String context);
}

// step2
public class TerminalExpression implements Expression{
	private String data;
	public TerminalExpression(String data){
		this.data = data;
	}
	@Overide
	public boolean interpret(String context){
		if(context.contain(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);
	}
}

// step3
public class InterpreterPatternDemo{
	public static Expression getMaleExpression(){
		Expression robert = new TerminalExpression("Robert");
		Expression john = new TerminalExpression("John");
		return new OrExpression(robert, john);
	}
	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?"
			+ is MarriedWoman.interpret("Married Julie"));
	}
}