abstract class Creator{
    // Definimos método abstracto
    public abstract Product factoryMethod()
}

public class ConcreteCreator extends Creator{
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

public static void main(String args[]){
    Creator aCreator;
    aCreator = new ConcreteCreator();
    Product producto = aCreator.factoryMethod();
    producto.operacion();
}

/** "Producto" */
class Pizza {
    private String masa = "";
    private String salsa = "";
    private String relleno = "";
 
    public void setMasa(String masa)     { this.masa = masa; }
    public void setSalsa(String salsa)     { this.salsa = salsa; }
    public void setRelleno(String relleno) { this.relleno = relleno; }
}
 
 
/** "Abstract Builder" */
abstract class PizzaBuilder {
    protected Pizza pizza;
 
    public Pizza getPizza() { return pizza; }
 
    public abstract void buildMasa();
    public abstract void buildSalsa();
    public abstract void buildRelleno();
}

 
/** "ConcreteBuilder" */
class HawaiPizzaBuilder extends PizzaBuilder {
    public HawaiPizzaBuilder(){super.pizza = new Pizza();}
    public void buildMasa()   { pizza.setMasa("suave"); }
    public void buildSalsa()   { pizza.setSalsa("dulce"); }
    public void buildRelleno() { pizza.setRelleno("chorizo+alcachofas"); }
}
 
/** "ConcreteBuilder" */
class PicantePizzaBuilder extends PizzaBuilder {
    public PicantePizzaBuilder(){super.pizza = new Pizza();}
    public void buildMasa()   { pizza.setMasa("cocida"); }
    public void buildSalsa()   { pizza.setSalsa("picante"); }
    public void buildRelleno() { pizza.setRelleno("pimienta+salchichón"); }
}
 
 
/** "Director" */
class Cocina {
    private PizzaBuilder pizzaBuilder;
 
    public void setPizzaBuilder(PizzaBuilder pb) { pizzaBuilder = pb; }
    public Pizza getPizza() { return pizzaBuilder.getPizza(); }
 
    public void construirPizza() {
       pizzaBuilder.buildMasa();
       pizzaBuilder.buildSalsa();
       pizzaBuilder.buildRelleno();
    }
}
 
 
/** Un cliente pidiendo una pizza. */
class BuilderExample {
    public static void main(String[] args) {
        Cocina cocina = new Cocina();
        PizzaBuilder hawai_pizzabuilder = new HawaiPizzaBuilder();
        PizzaBuilder picante_pizzabuilder = new PicantePizzaBuilder();
 
        cocina.setPizzaBuilder( hawai_pizzabuilder );
        cocina.construirPizza();
 
        Pizza pizza = cocina.getPizza();
    }
}



/** 
 *  2da opción para el abstract builder quizá más transparente para su uso.
 *  Dentro del crear se llaman los métodos build.
 *  Es válido siempre y cuando no se necesite alterar
 *  el orden del llamado a los "build's".
 */
abstract class OtroPizzaBuilder {
    protected Pizza pizza;
 
    public Pizza getPizza() { return pizza; }
    public void crearNuevaPizza() { 
           pizza = new Pizza(); 
           buildMasa();
           buildSalsa();
           buildRelleno();
    }
 
    public abstract void buildMasa();
    public abstract void buildSalsasasa();
    public abstract void buildRelleno();
}

/** "Director" */
class OtraCocina {
    private OtroPizzaBuilder pizzaBuilder;
 

 
    public void construirPizza() {
       pizzaBuilder.crearNuevaPizza();
       //notar que no se necesita llamar a cada build.
    }
}

public class Singleton {
    private static Singleton INSTANCE = null;

    // Private constructor suppresses 
    private Singleton(){}

    // creador sincronizado para protegerse de posibles problemas  multi-hilo
    // otra prueba para evitar instanciación múltiple 
    private synchronized static void createInstance() {
        if (INSTANCE == null) { 
            INSTANCE = new Singleton();
        }
    }

    public static Singleton getInstance() {
        if (INSTANCE == null) createInstance();
        return INSTANCE;
    }
}

import java.util.*;

public abstract class Componente
{
	protected String nombre;
	public Componente (String nombre)
	{
		this.nombre = nombre;
	}
	abstract public void agregar(Componente c);
	abstract public void eliminar(Componente c);
	abstract public void mostrar(int profundidad);
}
class Compuesto extends Componente
{
	private ArrayList<Componente> hijo = new ArrayList<Componente>();
	public Compuesto (String name)
	{
		super(name);
	}
	@Override
	public void agregar(Componente componente)
	{
		hijo.add(componente);
	}
	@Override
	public void eliminar(Componente componente)
	{
		hijo.remove(componente);
	}
	@Override
	public void mostrar(int profundidad)
	{
		System.out.println(nombre + " nivel: " + profundidad);
		for (int i = 0; i < hijo.size(); i++)
			hijo.get(i).mostrar(profundidad + 1);
	}
}
class Hoja extends Componente
{
	public Hoja (String nombre)
	{
		super(nombre);
	}
	public void agregar(Componente c)
	{
		System.out.println("no se puede agregar la hoja");
	}
	public void eliminar(Componente c)
	{
		System.out.println("no se puede quitar la hoja");
	}
	public void mostrar(int depth)
	{
		System.out.println('-' + "" + nombre);
	}
}
public class Client
{
	public static void main(String[] args)
	{
		Compuesto raiz = new Compuesto("root");
		raiz.agregar(new Hoja("hoja A"));
		raiz.agregar(new Hoja("hoja B"));
		Compuesto comp = new Compuesto("compuesto X");
		comp.agregar(new Hoja("hoja XA"));
		comp.agregar(new Hoja("hoja XB"));
		raiz.agregar(comp);
		raiz.agregar(new Hoja("hoja C"));
		Hoja l = new Hoja("hoja D");
		raiz.agregar(l);
		raiz.eliminar(l);
		raiz.mostrar(1);
	}
}

import java.util.*;

class FuenteEvento extends Observable implements Runnable {
    public void run() {
        while (true) {
            String respuesta = new Scanner(System.in).next();
            setChanged();
            notifyObservers(respuesta);
        }
    }
}

import java.util.Observable;
import static java.lang.System.out;

class MiApp {
    public static void main(String[] args) {
        out.println("Introducir Texto >");
        FuenteEvento fuenteEvento = new FuenteEvento();

        fuenteEvento.addObserver( (Observable obj, Object arg) -> {
            out.println("\nRespuesta recibida: " + arg);
        });

        new Thread(fuenteEvento).start();
    }
}

public class Cliente {

    public static void main(String argv[]) {
      Unidad smith  = new Coronel("Smith", null);
      Unidad truman = new Coronel("Truman", "Tomar posición enemiga");
      Unidad ryan   = new Soldado("Ryan");
      Unidad rambo  = new Soldado("Rambo");

      System.out.println(rambo.orden());    // rambo ->

      rambo.establecerMando(truman);
      System.out.println(rambo.orden());    // rambo -> truman

      ryan.establecerMando(rambo);
      System.out.println(ryan.orden());     // ryan -> rambo -> truman
    }
}

/**
 * La clase Unidad representa la clase abstracta manejadora de la cadena de responsabilidad.
 * El servicio delegado en la cadena es la solicitud de una orden al mando directo
 */

public abstract class Unidad {

    /* en el constructor, además de un nombre para la unidad, se inicializa la referencia
       que implementa la cadena de responsabilidad (_mando): en principio no hay sucesor */

    public Unidad(String nombre) { 
        _mando = null; 
        _nombre = nombre;
    }

    public String toString() { return _nombre; }

    // cambia el mando de una unidad (modifica cadena de responsabilidad)

    public void establecerMando(Unidad mando) { _mando = mando; }

    /* comportamiento por defecto de la cadena: delegar en el mando directo o, si se 
       alcanza el final de la cadena, utilizar una resolución por defecto (sin orden) */

    public String orden() {
        return (_mando != null ? _mando.orden() : "(sin orden)"); 
    }

    private Unidad _mando;
    private String _nombre;
}

/**
 * La clase Coronel modifica ligeramente el comportamiento por defecto de la cadena de
 * responsabilidad: si el coronel tiene una orden específica, utiliza ésta para resolver
 * el servicio. Si no tiene una orden específica (_orden==null), emplea el comportamiento
 * convencional de las unidades
 */

public class Coronel extends Unidad {

    // inicializa la parte de unidad e inicializa el estado propio del Coronel (_orden)

    public Coronel(String nombre, String orden) {
      super(nombre);
      _orden = orden;
    }

    /* refinamiento del servicio que utiliza la cadena de responsabilidad, resolviendo
       localmente si tiene órdenes específicas o comportándose convencionalmente en
       caso contrario */

    public String orden()    { return (_orden != null ? _orden : super.orden()); }

    public String toString() { return ("Coronel " + super.toString()); }

    private String _orden;
}

/**
 * Esta clase es una extensión instanciable de la superclase Unidad que respeta el
 * comportamiento por defecto de la cadena de responsabilidad
 */

public class Soldado extends Unidad {

    // el constructor sólo tiene que inicializar la parte correspondiente a la superclase

    public Soldado(String nombre) {
        super(nombre);
    }
    
    public String toString() { return ("Soldado " + super.toString()); }
}