publicabstractclassDuck {
privateFlyBehaviorflyBehavior;
privateQuackBehaviorquackBehavior;
publicvoidperformFly() {
flyBehavior.fly();
    }
publicvoidperformQuack() {
quackBehavior.quack();
    }
publicabstractvoiddisplay();
publicvoidsetFlyBehavior(FlyBehaviorflyBehavior) {
this.flyBehavior=flyBehavior;
    }
publicvoidsetQuackBehavior(QuackBehaviorquackBehavior) {
this.quackBehavior=quackBehavior;
    }
publicDuck() {
    }
}

publicinterfaceFlyBehavior {
publicvoidfly();
}

publicinterfaceQuackBehavior {
publicvoidquack();
}

publicclassFlyWithWingsimplementsFlyBehavior {
@Overridepublicvoidfly() {
System.out.println("I can fly with wings");
    }
}

publicclassQuackimplementsQuackBehavior {
@Overridepublicvoidquack() {
System.out.println("quack...quack");
    }
}

publicclassMallardDuckextendsDuck {
@Overridepublicvoiddisplay() {
System.out.println("I am a com.my.StrategyPattern.Object.MallardDuck!");
    }
publicMallardDuck() {
this.setFlyBehavior(newFlyWithWings());
this.setQuackBehavior(newQuack());
    }
}

publicabstractclassCharacter {
privateWeaponBehaviorweaponBehavior;
publicabstractvoidfight();
publicvoidsetWeapon(WeaponBehaviorweaponBehavior) {
this.weaponBehavior=weaponBehavior;
    }
publicWeaponBehaviorgetWeaponBehavior() {
returnthis.weaponBehavior;
    }
publicCharacter() {
    }
}

publicinterfaceWeaponBehavior {
publicvoiduseWeapon();
}

publicclassKingextendsCharacter {
@Overridepublicvoidfight() {
this.getWeaponBehavior().useWeapon();
    }
publicKing() {
this.setWeapon(newSwordBehavior());
    }
}

publicclassSwordBehaviorimplementsWeaponBehavior {
@OverridepublicvoiduseWeapon() {
System.out.println("I am a saber!");
    }
}

publicclassWeatherDataextendsObservable {
privatefloattemperature;
privatefloathumidtity;
privatefloatpressure;
publicfloatgetTemperature() {
returntemperature;
    }
publicfloatgetHumidtity() {
returnhumidtity;
    }
publicfloatgetPressure() {
returnpressure;
    }
publicvoidsetMessurements(floattemperature, floathumidtity, floatpressure) {
this.temperature=temperature;
this.humidtity=humidtity;
this.pressure=pressure;
messurementsChanged();
    }
publicvoidmessurementsChanged() {
this.setChanged();
this.notifyObservers();
    }
}

publicinterfaceDisplayElement {
publicvoiddisplay();
}

publicclassCurrentConditionsDisplayimplementsDisplayElement, Observer {
privatefloattemperature;
privatefloathumidity;
privatefloatpressure;
privateObservableobservable;
@Overridepublicvoiddisplay() {
System.out.println(StringUtils.join(newString[]{"current condition : temperature is ", String.valueOf(temperature),
"; humidity is ", String.valueOf(humidity)}));
    }
publicCurrentConditionsDisplay(Observableobservable) {
this.observable=observable;
observable.addObserver(this);
    }
@Overridepublicvoidupdate(Observableo, Objectarg) {
if (oinstanceofWeatherData) {
WeatherDataweatherData= (WeatherData) o;
this.temperature=weatherData.getTemperature();
this.humidity=weatherData.getHumidtity();
this.pressure=weatherData.getPressure();
display();
        }
    }
}

publicinterfaceSubject {
publicvoidregistObserver(Observerobserver);
publicvoidremoveObserver(Observerobserver);
publicvoidnotifyObservers();
}

publicclassWeatherDataimplementsSubject {
privateList<Observer>observerList;
privatefloattemperature;
privatefloathumidtity;
privatefloatpressure;
publicfloatgetTemperature() {
returntemperature;
    }
publicfloatgetHumidtity() {
returnhumidtity;
    }
publicfloatgetPressure() {
returnpressure;
    }
publicWeatherData() {
observerList=newArrayList<>();
    }
@OverridepublicvoidregistObserver(Observerobserver) {
observerList.add(observer);
    }
@OverridepublicvoidremoveObserver(Observerobserver) {
observerList.remove(observer);
    }
@OverridepublicvoidnotifyObservers() {
for (Observerobserver : observerList) {
observer.update(temperature, humidtity, pressure);
        }
    }
publicvoidsetMessurements(floattemperature, floathumidtity, floatpressure) {
this.temperature=temperature;
this.humidtity=humidtity;
this.pressure=pressure;
messurementsChanged();
    }
publicvoidmessurementsChanged() {
notifyObservers();
    }
}

publicinterfaceObserver {
publicvoidupdate(floattemperature, floathumidity, floatpressure);
}

publicinterfaceDisplayElement {
publicvoiddisplay();
}

publicclassCurrentConditionsDisplayimplementsDisplayElement, Observer {
privateSubjectweatherData;
privatefloattemperature;
privatefloathumidity;
privatefloatpressure;
publicCurrentConditionsDisplay(SubjectweatherData) {
this.weatherData=weatherData;
weatherData.registObserver(this);
    }
@Overridepublicvoidupdate(floattemperature, floathumidity, floatpressure) {
this.temperature=temperature;
this.humidity=humidity;
this.pressure=pressure;
display();
    }
@Overridepublicvoiddisplay() {
System.out.println(StringUtils.join(newString[]{"current condition : temperature is ", String.valueOf(temperature),
"; humidity is ", String.valueOf(humidity)}));
    }
}

publicclassLowerCaseInputStreamextendsFilterInputStream {
publicLowerCaseInputStream(InputStreamin) {
super(in);
    }
@Overridepublicintread() throwsIOException {
intc=super.read();
return (c==-1?c : Character.toLowerCase((char)c));
    }
@Overridepublicintread(byte[] b, intoff, intlen) throwsIOException {
intresult=super.read(b, off, len);
for (inti=off; i<off+result; i++) {
b[i] = (byte)Character.toLowerCase((char)b[i]);
        }
returnresult;
    }
}

publicclassInputTest {
publicstaticvoidmain(String[] args) throwsIOException {
intc;
try {
InputStreamin=newLowerCaseInputStream(newBufferedInputStream(newFileInputStream("D:\\cs_file\\java\\DesignPattern\\test.txt")));
while ((c=in.read()) >=0) {
System.out.print((char)c);
            }
in.close();
        } catch (IOExceptione) {
e.printStackTrace();
        }
    }
}

publicabstractclassBeverage {
Stringdescription="Unknown Beverage";
finalintTALL=0;
finalintGRANDE=1;
finalintVENTI=2;
privateintsize;
publicStringgetDescription() {
returndescription;
    }
publicintgetSize() {
returnthis.size;
    }
publicvoidsetSize(intsize) {
this.size=size;
    }
publicabstractdoublecost();
}

publicabstractclassCondimentDecoratorextendsBeverage{
@OverridepublicabstractStringgetDescription();
@OverridepublicabstractintgetSize();
}

publicclassHouseBlendextendsBeverage{
publicHouseBlend(intsize) {
description=size+" House Blend Coffee";
setSize(size);
    }
@Overridepublicdoublecost() {
return0.89;
    }
}

publicclassSoyextendsCondimentDecorator{
Beveragebeverage;
publicSoy(Beveragebeverage) {
this.beverage=beverage;
    }
@OverridepublicintgetSize() {
returnbeverage.getSize();
    }
@OverridepublicStringgetDescription() {
returnbeverage.getDescription() +", Soy";
    }
@Overridepublicdoublecost() {
intsize=beverage.getSize();
doublecost=beverage.cost();
if (size==beverage.TALL) {
cost+=0.10;
        } elseif (size==beverage.GRANDE) {
cost+=0.15;
        } elseif (size==beverage.VENTI) {
cost+=0.20;
        }
returncost;
    }
}

publicclassStarbuzzCoffee {
publicstaticvoidmain(String[] args) {
Beveragebeverage=newEspresso(0);
System.out.println(beverage.getDescription() +"$"+beverage.cost());
Beveragebeverage2=newDarkRoast(1);
beverage2=newMocha(beverage2);
beverage2=newMocha(beverage2);
beverage2=newWhip(beverage2);
System.out.println(beverage2.getDescription() +"$"+beverage2.cost());
Beveragebeverage3=newHouseBlend(2);
beverage3=newSoy(beverage3);
beverage3=newMocha(beverage3);
beverage3=newWhip(beverage3);
System.out.println(beverage3.getDescription() +"$"+beverage3.cost());
    }
}

publicabstractclassPizzaStore {
publicPizzaorderPizza(Stringtype) {
Pizzapizza;
pizza=createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
returnpizza;
    }
abstractPizzacreatePizza(Stringtype);
}

publicabstractclassPizza {
Stringname;
Stringdough;
Stringsauce;
ArrayListtoppings=newArrayList();
voidprepare() {
System.out.println("Preparing "+name);
System.out.println("Tossing dough...");
System.out.println("Adding sauce...");
System.out.println("Adding toppings: ");
for (inti=0; i<toppings.size(); i++) {
System.out.println("    "+toppings.get(i));
        }
    }
voidbake() {
System.out.println("Bake for 25 minutes at 350");
    }
voidcut() {
System.out.println("Cutting the pizza into diagonal slices");
    }
voidbox() {
System.out.println("Place pizza in official PizzaStore box");
    }
publicStringgetName() {
returnname;
    }
}

publicclassNYPizzaStoreextendsPizzaStore{
@OverridePizzacreatePizza(Stringtype) {
if ("cheese".equals(type)) {
returnnewNYStyleCheesePizza();
        } elseif ("veggie".equals(type)) {
returnnewNYStyleVeggiePizza();
        } elseif ("clam".equals(type)) {
returnnewNYStyleClamPizza();
        } elseif ("pepperoni".equals(type)) {
returnnewNYStylePepperoniPizza();
        } else {
returnnull;
        }
    }
}

publicclassNYStyleCheesePizzaextendsPizza{
publicNYStyleCheesePizza() {
name="NY Style Sauce and Cheese Pizza";
dough="Thin Crust Dough";
sauce="Marinara Sauce";
toppings.add("Grated Reggiano Cheese");
    }
}

publicclassChocolateBoiler {
privatebooleanempty;
privatebooleanboiled;
privatestaticvolatileChocolateBoilerchocolateBoiler;
privateChocolateBoiler() {
empty=true;
boiled=false;
    }
publicstaticChocolateBoilergetInstance() {
if (chocolateBoiler==null) {
synchronized (ChocolateBoiler.class) {
if (chocolateBoiler==null) {
chocolateBoiler=newChocolateBoiler();
                }
            }
        }
returnchocolateBoiler;
    }
}

publicinterfaceCommand {
publicvoidexecute();
publicvoidundo();
}

publicclassCeilingFan {
publicstaticfinalintHIGH=3;
publicstaticfinalintMEDIUM=2;
publicstaticfinalintLOW=1;
publicstaticfinalintOFF=0;
Stringlocation;
intspeed;
publicCeilingFan(Stringlocation) {
this.location=location;
speed=OFF;
    }
publicvoidhigh() {
speed=HIGH;
System.out.println(location+" ceiling fan is on high");
    }
publicvoidmedium() {
speed=MEDIUM;
System.out.println(location+" ceiling fan is on medium");
    }
publicvoidlow() {
speed=LOW;
System.out.println(location+" ceiling fan is on low");
    }
publicvoidoff() {
speed=OFF;
System.out.println(location+" ceiling fan is off");
    }
publicintgetSpeed() {
returnspeed;
    }
publicStringgetLocation() {
returnlocation;
    }
}

publicclassLight {
privateStringlocation;
publicLight(Stringlocation) {
this.location=location;
    }
publicvoidon() {
System.out.println(location+" light is on");
    }
publicvoidoff() {
System.out.println(location+" light is off");
    }
}

publicclassCeilingFanHighCommandimplementsCommand {
CeilingFanceilingFan;
intprevSpeed;
publicCeilingFanHighCommand(CeilingFanceilingFan) {
this.ceilingFan=ceilingFan;
    }
@Overridepublicvoidexecute() {
prevSpeed=ceilingFan.getSpeed();
ceilingFan.high();
    }
@Overridepublicvoidundo() {
if (prevSpeed==CeilingFan.HIGH) {
ceilingFan.high();
        } elseif (prevSpeed==CeilingFan.MEDIUM) {
ceilingFan.medium();
        } elseif (prevSpeed==CeilingFan.LOW) {
ceilingFan.low();
        } elseif (prevSpeed==CeilingFan.OFF) {
ceilingFan.off();
        }
    }
}

publicclassLightOnCommandimplementsCommand {
Lightlight;
publicLightOnCommand(Lightlight) {
this.light=light;
    }
@Overridepublicvoidexecute() {
light.on();
    }
@Overridepublicvoidundo() {
light.off();
    }
}

publicclassMacroCommandimplementsCommand {
Command[] commands;
publicMacroCommand(Command[] commands) {
this.commands=commands;
    }
@Overridepublicvoidexecute() {
for (inti=0; i<commands.length; i++) {
commands[i].execute();
        }
    }
@Overridepublicvoidundo() {
for (inti=0; i<commands.length; i++) {
commands[i].undo();
        }
    }
}

publicclassRemoteControlWithUndo {
Command[] onCommands;
Command[] offCommands;
CommandundoCommand;
publicRemoteControlWithUndo() {
onCommands=newCommand[7];
offCommands=newCommand[7];
CommandnoCommand=newNoCommand();
for (inti=0; i<7; i++) {
onCommands[i] =noCommand;
offCommands[i] =noCommand;
        }
undoCommand=noCommand;
    }
publicvoidsetCommand(intslot, CommandonCommand, CommandoffCommand) {
onCommands[slot] =onCommand;
offCommands[slot] =offCommand;
    }
publicvoidonButtonWasPushed(intslot) {
onCommands[slot].execute();
undoCommand=onCommands[slot];
    }
publicvoidoffButtonWasPushed(intslot) {
offCommands[slot].execute();
undoCommand=offCommands[slot];
    }
publicvoidundoButtonWasPushed() {
undoCommand.undo();
    }
@OverridepublicStringtoString() {
StringBufferstringBuffer=newStringBuffer();
stringBuffer.append("\n------ Remote Control ------\n");
for (inti=0; i<onCommands.length; i++) {
stringBuffer.append("[slot "+i+"] "+onCommands[i].getClass().getName()
+"     "+offCommands[i].getClass().getName() +'\n');
        }
stringBuffer.append("[undo] "+undoCommand.getClass().getName());
returnstringBuffer.toString();
    }
}

publicclassRemoteLoader {
publicstaticvoidmain(String[] args) {
RemoteControlWithUndoremoteControl=newRemoteControlWithUndo();
Lightlight=newLight("Living Room");
TVtv=newTV("Living Room");
Stereostereo=newStereo("Living Room");
Hottubhottub=newHottub();
LightOnCommandlightOn=newLightOnCommand(light);
StereoOnCommandstereoOn=newStereoOnCommand(stereo);
TVOnCommandtvOn=newTVOnCommand(tv);
HottubOnCommandhottubOn=newHottubOnCommand(hottub);
LightOffCommandlightOff=newLightOffCommand(light);
StereoOffCommandstereoOff=newStereoOffCommand(stereo);
TVOffCommandtvOff=newTVOffCommand(tv);
HottubOffCommandhottubOff=newHottubOffCommand(hottub);
Command[] partyOn= {lightOn, stereoOn, tvOn, hottubOn};
Command[] partyOff= {lightOff, stereoOff, tvOff, hottubOff};
MacroCommandpartyOnMacro=newMacroCommand(partyOn);
MacroCommandpartyOffMacro=newMacroCommand(partyOff);
remoteControl.setCommand(0, partyOnMacro, partyOffMacro);
System.out.println(remoteControl);
System.out.println("--- Pushing Macro On ---");
remoteControl.onButtonWasPushed(0);
System.out.println("--- Pushing Macro Off ---");
remoteControl.offButtonWasPushed(0);
    }
}

publicinterfaceDuck {
publicvoidquack();
publicvoidfly();
}

publicinterfaceTurkey {
publicvoidgobble();
publicvoidfly();
}

publicclassWildTurkeyimplementsTurkey {
@Overridepublicvoidgobble() {
System.out.println("Gobble gobble");
    }
@Overridepublicvoidfly() {
System.out.println("I am flying a short distance");
    }
}

publicclassMallardDuckimplementsDuck {
@Overridepublicvoidquack() {
System.out.println("Quack");
    }
@Overridepublicvoidfly() {
System.out.println("I am flying");
    }
}

publicclassDuckAdapterimplementsTurkey {
privateDuckduck;
privateRandomrand;
publicDuckAdapter(Duckduck) {
this.duck=duck;
rand=newRandom();
    }
@Overridepublicvoidgobble() {
duck.quack();
    }
@Overridepublicvoidfly() {
// 生成一个随机数，该随机数的范围为[0,5)if (rand.nextInt(5) ==0) {
duck.fly();
        }
    }
}

publicclassTurkeyAdapterimplementsDuck {
Turkeyturkey;
publicTurkeyAdapter(Turkeyturkey) {
this.turkey=turkey;
    }
@Overridepublicvoidquack() {
turkey.gobble();
    }
@Overridepublicvoidfly() {
for (inti=0; i<5; i++) {
turkey.fly();
        }
    }
}

publicclassDuckTestDrive {
publicstaticvoidmain(String[] args) {
MallardDuckduck=newMallardDuck();
WildTurkeyturkey=newWildTurkey();
DuckturkeyAdapter=newTurkeyAdapter(turkey);
System.out.println("The Turkey says...");
turkey.gobble();
turkey.fly();
System.out.println("\nThe Duck says...");
testDuck(duck);
System.out.println("\nThe TurkeyAdapter says...");
testDuck(turkeyAdapter);
    }
staticvoidtestDuck (Duckduck) {
duck.quack();
duck.fly();
    }
}

publicclassEnumerationIteratorimplementsIterator {
Enumerationenumeration;
publicEnumerationIterator(Enumerationenumeration) {
this.enumeration=enumeration;
    }
@OverridepublicbooleanhasNext() {
returnenumeration.hasMoreElements();
    }
@OverridepublicObjectnext() {
returnenumeration.nextElement();
    }
}

publicclassIteratorToEnumerationimplementsEnumeration {
privateIteratoriterator;
publicIteratorToEnumeration(Iteratoriterator) {
this.iterator=iterator;
    }
@OverridepublicbooleanhasMoreElements() {
returniterator.hasNext();
    }
@OverridepublicObjectnextElement() {
returniterator.next();
    }
}

publicclassHomeTheaterFacade {
Amplifieramp;
Tunertuner;
DvdPlayerdvd;
CdPlayercd;
Projectorprojector;
TheaterLightslights;
Screenscreen;
PopcornPopperpopper;
publicHomeTheaterFacade(Amplifieramp, Tunertuner, DvdPlayerdvd, CdPlayercd, Projectorprojector, TheaterLightslights, Screenscreen, PopcornPopperpopper) {
this.amp=amp;
this.tuner=tuner;
this.dvd=dvd;
this.cd=cd;
this.projector=projector;
this.lights=lights;
this.screen=screen;
this.popper=popper;
    }
publicvoidwatchMovie(Stringmovie) {
System.out.println("Get ready to watch a movie...");
popper.on();
popper.pop();
lights.dim(10);
screen.down();
projector.on();
projector.wideScreenMode();
amp.on();
amp.setDvd(dvd);
amp.setSurroundSound();
amp.setVolume(5);
dvd.on();
dvd.play(movie);
    }
publicvoidendMovie() {
System.out.println("Shutting movie theater down...");
popper.off();
lights.on();
screen.up();
projector.off();
amp.off();
dvd.stop();
dvd.eject();
dvd.off();
    }
}

publicclassDvdPlayer {
privateStringmovie;
publicvoidon() {
System.out.println("Top-O-Line DVD Player on");
    }
publicvoidplay(Stringmovie) {
this.movie=movie;
System.out.println("Top-O-Line DVD Player playing \""+movie+"\"");
    }
publicvoidstop() {
System.out.println("Top-O-Line DVD Player stopped \""+movie+"\"");
    }
publicvoideject() {
System.out.println("Top-O-Line DVD Player eject");
    }
publicvoidoff() {
System.out.println("Top-O-Line DVD Player off");
    }
}

publicabstractclassCaffeineBeverageWithHook {
voidprepareRecipe() {
boilWater();
brew();
pourInCup();
if (customerWantsCondiments()) {
addCondiments();
        }
    }
abstractvoidbrew();
abstractvoidaddCondiments();
voidboilWater() {
System.out.println("Boiling water");
    }
voidpourInCup() {
System.out.println("Pouring into cup");
    }
booleancustomerWantsCondiments() {
returntrue;
    }
}

publicclassCoffeeWithHookextendsCaffeineBeverageWithHook {
@Overridevoidbrew() {
System.out.println("Dripping Coffee through filter");
    }
@OverridevoidaddCondiments() {
System.out.println("Adding Sugar and Milk");
    }
@OverridebooleancustomerWantsCondiments() {
Stringanswer=getUserInput();
if (answer.toLowerCase().startsWith("y")) {
returntrue;
        } else {
returnfalse;
        }
    }
privateStringgetUserInput() {
Stringanswer=null;
System.out.println("Would you like milk and sugar with your coffee (y/n)? ");
BufferedReaderin=newBufferedReader(newInputStreamReader(System.in));
try {
answer=in.readLine();
        } catch (IOExceptionioe) {
System.out.println("IO error trying to read your answer");
        }
if (answer==null) {
return"no";
        }
returnanswer;
    }
}

publicinterfaceMenu {
publicIteratorcreateIterator();
}

publicinterfaceIteratorextendsjava.util.Iterator {
booleanhasNext();
Objectnext();
}

publicclassPancakeHouseMenuimplementsMenu{
ArrayList<MenuItem>menuItems;
publicPancakeHouseMenu() {
menuItems=newArrayList<>();
addItem("K&B's Pancake Breakfast", "Pancakes with scrambled eggs, and toast", true, 2.99);
addItem("Regular Pancake Breakfast", "Pancakes with fried eggs, sausage", false, 2.99);
addItem("Blueberry Pancakes", "Pancakes made with fresh blueberries", true, 3.49);
addItem("Waffles", "Waffles, with your choice of blueberries or strawberries", true, 3.59);
    }
publicvoidaddItem(Stringname, Stringdescription, booleanvegetarian, doubleprice) {
MenuItemmenuItem=newMenuItem(name, description, vegetarian, price);
menuItems.add(menuItem);
    }
@OverridepublicIteratorcreateIterator() {
returnnewPancakeHouseIterator(menuItems);
    }
}

publicclassPancakeHouseIteratorimplementsIterator {
ArrayList<MenuItem>items;
intposition=0;
publicPancakeHouseIterator(ArrayList<MenuItem>items) {
this.items=items;
    }
@OverridepublicObjectnext() {
MenuItemmenuItem=items.get(position);
position=position+1;
returnmenuItem;
    }
@OverridepublicbooleanhasNext() {
if (position>=items.size()) {
returnfalse;
        } else {
returntrue;
        }
    }
}