Structural -- Proxy

--- Subject.java ---

package structural.proxy;

public interface Subject {

void sampleOperation();

}

--- RealSubject.java ---

package structural.proxy;

public class RealSubject implements Subject {

public void sampleOperation() {

}

}

--- Proxy.java ---

package structural.proxy;

public class Proxy implements Subject {

private RealSubject realSubject;

public void sampleOperation() {
realSubject.sampleOperation();
}

}

Structural -- Flyweight

--- Flyweight.java ---

package structural.flyweight;

public interface Flyweight {

void sampleOperation(Context context);

}

--- ConcreteFlyweight.java ---

package structural.flyweight;

public class ConcreteFlyweight implements Flyweight {

public ConcreteFlyweight(Object key) {

}

public void sampleOperation(Context context) {

}

}

--- FlyweightFactory.java ---

package structural.flyweight;

import java.util.HashMap;

public class FlyweightFactory {

private HashMap theFlyweights;

public FlyweightFactory() {
theFlyweights = new HashMap();
}

public Flyweight getConcreteFlyweight(Object key) {
if (theFlyweights.containsKey(key)) {
return (Flyweight) theFlyweights.get(key);
} else {
Flyweight newFlyweight = new ConcreteFlyweight(key);
theFlyweights.put(key, newFlyweight);
return newFlyweight;
}
}

}

--- Context.java ---

package structural.flyweight;

public class Context {

}

Structural -- Facade

--- Subsystem.java ---

package structural.facade;

public class Subsystem {

public void subsystemFunctionality() {

}

}

--- Facade.java ---

package structural.facade;

public class Facade {

private Subsystem mySubsystem;

public void facadeMethod() {

}

}

Structural -- Decorator

--- Component.java ---

package structural.decorator;

public interface Component {

void sampleOperation();

}

--- ConcreteComponent.java ---

package structural.decorator;

public class ConcreteComponent implements Component {

public void sampleOperation() {

}

}

--- Decorator.java ---

package structural.decorator;

public class Decorator implements Component {

private Component component;

public Decorator(Component component) {
this.component = component;
}

public void sampleOperation() {
component.sampleOperation();
}

}

--- ConcreteDecorator.java ---

package structural.decorator;

public class ConcreteDecorator extends Decorator {

public ConcreteDecorator(Component component) {
super(component);
}

public void sampleOperation() {
super.sampleOperation();
}

}

Structural -- Composite

--- Component.java ---

package structural.composite;

public interface Component {

Composite getComposite();

void sampleOperation();

}

--- Composite.java ---

package structural.composite;

import java.util.Vector;
import java.util.Enumeration;

public class Composite implements Component {

private Vector componentVector = new Vector();

public Composite getComposite() {
return this;
}

public void sampleOperation() {
java.util.Enumeration components = components();
while (components.hasMoreElements()) {
((Component) components.nextElement()).sampleOperation();
}
}

public void add(Component component) {
componentVector.addElement(component);
}

public void remove(Component component) {
componentVector.removeElement(component);
}

public Enumeration components() {
return componentVector.elements();
}

}

--- Leaf.java ---

package structural.composite;

public class Leaf implements Component {

public void sampleOperation() {

}

public Composite getComposite() {
return null;
}

}

Structural -- Bridge

--- Abstraction.java ---

package structural.bridge;

public abstract class Abstraction {

private Implementor impl;

public Abstraction(Implementor aImplementor) {
impl = aImplementor;
}

public void someOperation() {
getImplementor().someOperationImpl();
}

public Implementor getImplementor() {
return impl;
}

}

--- RefinedAbstraction.java ---

package structural.bridge;

public class RefinedAbstraction extends Abstraction {

public RefinedAbstraction(Implementor aImplementor) {
super(aImplementor);
}

}

--- Implementor.java ---

package structural.bridge;

public interface Implementor {

void someOperationImpl();

}

--- ConcreteImplementor.java ---

package structural.bridge;

public class ConcreteImplementor implements Implementor {

public void someOperationImpl() {

}

}

Structural -- Adapter

--- Adapter.java ---

package structural.adapter;

public class Adapter implements Target {

private Adaptee adaptee;

public Adapter(Adaptee adaptee) {

this.adaptee = adaptee;
}

public void sampleOperation2() {

}

public void sampleOperation1() {
adaptee.sampleOperation1();
}

}

--- Target.java ---

package structural.adapter;

public interface Target {

void sampleOperation1();

void sampleOperation2();

}

--- Adaptee.java ---

package structural.adapter;

public class Adaptee {

public void sampleOperation1() {

}
}

Creational -- Singleton

--- Singleton.java ---

package creational.singleton;

public class Singleton {

private static Singleton instance = null;

protected Singleton() {
}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}

}

OR

package creational.singleton;

public class Singleton {

private static final Singleton INSTANCE = new Singleton();

private Singleton() {
}

}

Creational -- Prototype

--- Prototype.java ---

package creational.prototype;

public interface Prototype {

Prototype createClone();

}

--- ConcretePrototype.java ---

package creational.prototype;

public class ConcretePrototype implements Prototype {

protected ConcretePrototype(ConcretePrototype prototype) {
}

public Prototype createClone() {
return new ConcretePrototype(this);
}
}

Creational -- Factory Method

--- Creator.java ---

package creational.factorymethod;

public abstract class Creator {

public abstract Product factoryMethod();

}

--- ConcreteCreator.java ---

package creational.factorymethod;

public class ConcreteCreator extends Creator {

/* # private ConcreteProduct _concreteProduct; */

public Product factoryMethod() {
return new ConcreteProduct();
}

}

--- Product.java ---

package creational.factorymethod;

public interface Product {

}

--- ConcreteProduct.java ---

package creational.factorymethod;

public class ConcreteProduct implements Product {

public ConcreteProduct() {

}

}

Creational -- Builder

--- Builder.java ---

package creational.builder;

public interface Builder {

Product getResult();

void buildPart();

}

--- ConcreteBuilder.java ---

package creational.builder;

public class ConcreteBuilder implements Builder {

private Product resultProduct;

public Product getResult() {
return resultProduct;
}

public void buildPart() {

}

}

--- Product.java ---

package creational.builder;

public interface Product {

}

--- Director.java ---

package creational.builder;

public class Director {

private Builder theBuilder;

public Director(Builder aBuilder) {
theBuilder = aBuilder;
}

public void construct() {

theBuilder.buildPart();
}

}

--- Client.java ---

package creational.builder;

public class Client {

public void sampleOperation() {
ConcreteBuilder builder = new ConcreteBuilder();
(new Director(builder)).construct();
Product product = builder.getResult();
}

}

Creational -- Abstract Factory

--- AbstractFactory.java ---

package creational.abstractfactory;

public interface AbstractFactory {

AbstractProduct createAbstractProduct();

}

--- ConcreteFactory.java ---

package creational.abstractfactory;

public class ConcreteFactory implements AbstractFactory {

public AbstractProduct createAbstractProduct() {
return new ConcreteProduct();
}

}

--- AbstractProduct.java ---

package creational.abstractfactory;

public interface AbstractProduct {

}

--- ConcreteProduct.java ---

package creational.abstractfactory;

public class ConcreteProduct implements AbstractProduct {

}

Behavioral -- Visitor

--- Visitor.java ---

package behavioral.visitor;

public interface Visitor {

void visitConcreteElement(ConcreteElement Element);

}

--- ConcreteVisitor.java ---

package behavioral.visitor;

public class ConcreteVisitor implements Visitor {

public void visitConcreteElement(ConcreteElement Element) {

}

}

--- Element.java ---

package behavioral.visitor;

public interface Element {

void accept(Visitor visitor);

}

--- ConcreteElement.java ---

package behavioral.visitor;

public class ConcreteElement implements Element {

public void accept(Visitor visitor) {
visitor.visitConcreteElement(this);
}

}

Behavioral -- Template Method

--- AbstractClass.java ---

package behavioral.templatemethod;

public abstract class AbstractClass {

public abstract void primitiveOperation();

public void templateMethod() {
// something happens here...
primitiveOperation();
// ...
// later we need another step
// ...
}
}

--- ConcreteClass.java ---

package behavioral.templatemethod;

public class ConcreteClass extends AbstractClass {

public void primitiveOperation() {

}

}

Behavioral -- Strategy

--- Strategy.java ---

package behavioral.strategy;

public interface Strategy {

void strategyOperation();

}

--- ConcreteStrategy.java ---

package behavioral.strategy;

public class ConcreteStrategy implements Strategy {

public void strategyOperation() {

}

}

--- Context.java ---

package behavioral.strategy;

public class Context {

private Strategy myStrategy;

public Context(Strategy strategy) {
myStrategy = strategy;
}

public void contextRequest() {
myStrategy.strategyOperation();
}

}

Behavioral -- State

--- State.java ---

package behavioral.state;

public interface State {

void sampleOperation();

}

--- ConcreteState.java ---

package behavioral.state;

public class ConcreteState implements State {

public void sampleOperation() {

}

}

--- Context.java ---

package behavioral.state;

public class Context {

private State state;

public void sampleOperation() {
state.sampleOperation();
}

public void setState(State state) {
this.state = state;
}

}

Behavioral -- Observer

--- Observer.java ---

package behavioral.observer;

public interface Observer {

void update();

}

--- ConcreteObserver.java ---

package behavioral.observer;

public class ConcreteObserver implements Observer {

public void update() {

}

}

--- Subject.java ---

package behavioral.observer;

public interface Subject {

void attach(Observer observer);

void detach(Observer observer);

void inform();

}

--- ConcreteSubject.java ---

package behavioral.observer;

import java.util.Vector;
import java.util.Enumeration;

public class ConcreteSubject implements Subject {

private Vector observersVector = new Vector();

public void attach(Observer observer) {
observersVector.addElement(observer);
}

public void detach(Observer observer) {
observersVector.removeElement(observer);
}

public void inform() {
Enumeration enumeration = observers();
while (enumeration.hasMoreElements()) {
((Observer) enumeration.nextElement()).update();
}
}

public Enumeration observers() {
return ((Vector) observersVector.clone()).elements();
}

}

Behavioral -- Memento

--- Memento.java ---

package behavioral.memento;

public interface Memento {

}

--- ConcreteMemento.java ---

package behavioral.memento;

public class ConcreteMemento implements Memento {

public ConcreteMemento(Originator originator) {

}

}

--- Originator.java ---

package behavioral.memento;

public class Originator {

/* # private Memento _memento; */

public void setMemento(Memento memento) {
if (memento instanceof ConcreteMemento) {

}
}

public Memento createMemento() {
return new ConcreteMemento(this);
}

}

Behavioral -- Mediator

--- Mediator.java ---

package behavioral.mediator;

public interface Mediator {

void changed(Colleague colleague);

}

--- ConcreteMediator.java ---

package behavioral.mediator;

public class ConcreteMediator implements Mediator {

private ConcreteColleague aConcreteColleague;

public void changed(Colleague colleague) {

}

public void setConcreteColleague(ConcreteColleague colleague) {
aConcreteColleague = colleague;
}

}

--- Colleague.java ---

package behavioral.mediator;

public abstract class Colleague {

private Mediator theMediator;

public Colleague(Mediator aMediator) {
theMediator = aMediator;
}

protected Mediator getMediator() {
return theMediator;
}

}

--- ConcreteColleague.java ---

package behavioral.mediator;

public class ConcreteColleague extends Colleague {

public ConcreteColleague(Mediator aMediator) {
super(aMediator);
}

public void sampleOperation() {
getMediator().changed(this);
}

}

Behavioral -- Iterator

--- Iterator.java ---

package behavioral.iterator;

public interface Iterator {

Object currentItem();

boolean isDone();

Object next();

Object first();
}

--- ConcreteIterator.java ---

package behavioral.iterator;

public class ConcreteIterator implements Iterator {

private ConcreteAggregate theAggregate;

public ConcreteIterator(ConcreteAggregate aggregate) {
theAggregate = aggregate;
}

public Object next() {
return null;
}

public boolean isDone() {
return false;
}

public Object first() {
return null;
}

public Object currentItem() {
return null;
}

}

--- Aggregate.java ---

package behavioral.iterator;

public interface Aggregate {

Iterator iterator();

}

--- ConcreteAggregate.java ---

package behavioral.iterator;

public class ConcreteAggregate implements Aggregate {

public Iterator iterator() {
return new behavioral.iterator.ConcreteIterator(this);
}

}

Behavioral -- Interpreter

--- AbstractExpression.java ---

package behavioral.interpreter;

public abstract class AbstractExpression {

public abstract void interpret(Context context);

}

--- NonterminalExpression.java ---

package behavioral.interpreter;

public class NonterminalExpression extends AbstractExpression {

/* # private AbstractExpression _abstractExpression; */

public void interpret(Context context) {

}

}

--- TerminalExpression.java ---

package behavioral.interpreter;

public class TerminalExpression extends AbstractExpression {

public void interpret(Context context) {

}

}

--- Context.java ---

package behavioral.interpreter;

public class Context {

public Context() {

}

}

Behavioral -- Command

--- Command.java ---

package behavioral.command;

public interface Command {

void execute();

}

--- ConcreteCommand.java ---

package behavioral.command;

public class ConcreteCommand implements Command {

private Receiver myReceiver;

public ConcreteCommand(Receiver receiver) {
this.myReceiver = receiver;
}

public void execute() {
myReceiver.action();
}

}

--- Receiver.java ---

package behavioral.command;

public class Receiver {

public void action() {

}

}

Behavioral -- Chain of Responsibility

Here are the sample java codes:

--- Handler.java ---

package behavioral.chainofresponsibility;

public class Handler {

private Handler successor;

public void handleRequest() {
if (successor != null) {
successor.handleRequest();
}
}

public void setSuccessor(Handler successor) {
this.successor = successor;
}

public Handler getSuccessor() {
return successor;
}

}

--- ConcreteHandler.java ---

package behavioral.chainofresponsibility;

public class ConcreteHandler extends Handler {

public void handleRequest() {
if (getSuccessor() != null) {
getSuccessor().handleRequest();
}
}

}

ExperimentGetEnv

Another recent Java program that prints out things I might need someday...

-----CODE START-----

package scratch;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class ExperimentGetEnv {

public static void main(String[] args) {

Map map = System.getenv();
Set keySet = map.entrySet();

Iterator it = keySet.iterator();
while (it.hasNext()) {
 Map.Entry mapEntry = (Map.Entry) it.next();
 String key = (String) mapEntry.getKey();
 String value = (String) mapEntry.getValue();
 System.out.println(key + "=" + value);
}

}

}

-----CODE END-----

And of course the output on my Mac mini.

-----OUTPUT START-----
SECURITYSESSIONID=5073e0
USER=sporadic235
JAVA_MAIN_CLASS_215=scratch.ExperimentGetEnv
HOME=/Users/sporadic235
JAVA_MAIN_CLASS_206=org.eclipse.core.launcher.Main
PATH=/usr/bin:/bin:/usr/sbin:/sbin
SHELL=/bin/bash
__CF_USER_TEXT_ENCODING=0x1F5:0:0
APP_ICON_206=../Resources/Eclipse.icns
-----OUTPUT END-----

Introduction

This blog will be updated as soon as I find time figuring out how to outline stuff that I have encountered in developing web applications.

The format will be Q&A type. Programming languages will be Java and Visual Basic.