Subida Jaguar

patronesComportamiento/patronChainOfResponsibility/DirectivoPCompra.java

@@ -0,0 +1,15 @@
+package patronChainOfResponsibility;
+
+public class DirectivoPCompra extends PoderDeCompra{
+	private final int PERMISIBLE = 10 * base;
+	@Override
+	public void procesarPeticion(PeticionDeCompra peticion) {
+		if( peticion.getImporte() < PERMISIBLE) {
+			System.out.println("El directivo puede aprobar la cantidad de "+ peticion.getImporte() +" euros.");
+		}else if(sucesor!= null) {
+			sucesor.procesarPeticion(peticion);
+		}
+		
+	}
+
+}

patronesComportamiento/patronChainOfResponsibility/DirectorPCompra.java

@@ -0,0 +1,15 @@
+package patronChainOfResponsibility;
+
+public class DirectorPCompra extends PoderDeCompra{
+	private final int PERMISIBLE = 20 * base;
+	@Override
+	public void procesarPeticion(PeticionDeCompra peticion) {
+		if( peticion.getImporte() < PERMISIBLE) {
+			System.out.println("El director puede aprobar la cantidad de "+ peticion.getImporte()+" euros.");
+		}else if(sucesor!= null) {
+			sucesor.procesarPeticion(peticion);
+		}
+		
+	}
+
+}

patronesComportamiento/patronChainOfResponsibility/Main.java

@@ -0,0 +1,29 @@
+package patronChainOfResponsibility;
+
+public class Main {
+
+	public static void main(String[] args) {
+		DirectivoPCompra directivo = new DirectivoPCompra();
+		DirectorPCompra director = new DirectorPCompra();
+		VicePresidentePCompra vicepresidente = new VicePresidentePCompra();
+		PresidentePCompra presidente = new PresidentePCompra();
+		
+		directivo.setSucesor(director);
+		director.setSucesor(vicepresidente);
+		vicepresidente.setSucesor(presidente);
+		
+		//Hacemos 4 peticiones de compra con diferentes gastos
+		PeticionDeCompra p1 = new PeticionDeCompra(1,700,"Comida");
+		PeticionDeCompra p2 = new PeticionDeCompra(2,8000,"Viaje");
+		PeticionDeCompra p3 = new PeticionDeCompra(3,16000,"Moto");
+		PeticionDeCompra p4 = new PeticionDeCompra(4,22000,"Coche");
+		PeticionDeCompra p5 = new PeticionDeCompra(4,66000,"Yate");
+		
+		//Llamamos a procesarPeticion para averiguar quien puede aprobarla.
+		directivo.procesarPeticion(p1);	
+		directivo.procesarPeticion(p2);
+		directivo.procesarPeticion(p3);
+		directivo.procesarPeticion(p4);
+		directivo.procesarPeticion(p5);		
+	}
+}

patronesComportamiento/patronChainOfResponsibility/PeticionDeCompra.java

@@ -0,0 +1,37 @@
+package patronChainOfResponsibility;
+
+public class PeticionDeCompra {
+	private int numero;
+	private int importe;
+	private String proposito;
+	
+	public PeticionDeCompra(int numero, int importe,String proposito) {
+		this.numero=numero;
+		this.importe = importe;
+		this.proposito=proposito;
+	}
+	
+	public int getNumero() {
+		return numero;
+	}
+	
+	public int getImporte() {
+		return importe;
+	}
+	
+	public String getProposito() {
+		return proposito;
+	}
+	
+	public void setNumero(int numero) {
+		this.numero = numero;
+	}
+	
+	public void setImporte(int importe) {
+		this.importe = importe;
+	}
+	
+	public void setProposito(String proposito) {
+		this.proposito = proposito;
+	}
+}

patronesComportamiento/patronChainOfResponsibility/PoderDeCompra.java

@@ -0,0 +1,13 @@
+package patronChainOfResponsibility;
+
+//Esta clase es el MANEJADOR
+public abstract class PoderDeCompra {
+	protected final int base = 500;
+	protected PoderDeCompra sucesor;
+	
+	public void setSucesor(PoderDeCompra sucesor) {
+		this.sucesor = sucesor;
+	}
+	
+	public abstract void procesarPeticion(PeticionDeCompra peticion);
+}

patronesComportamiento/patronChainOfResponsibility/PresidentePCompra.java

@@ -0,0 +1,19 @@
+package patronChainOfResponsibility;
+
+public class PresidentePCompra extends PoderDeCompra{
+	private final int PERMISIBLE = 60 * base;
+	@Override
+	public void procesarPeticion(PeticionDeCompra peticion) {
+		if( peticion.getImporte() < PERMISIBLE) {
+			System.out.println("El presidente puede aprobar la cantidad de "+ peticion.getImporte()+" euros.");
+		}else{
+			if(sucesor!= null) {
+				sucesor.procesarPeticion(peticion);
+			}else {
+				System.out.println("La cantidad de " + peticion.getImporte() + " euros debe ser aprobada por un equipo de dirección");	
+			}
+		}
+		
+	}
+
+}

patronesComportamiento/patronChainOfResponsibility/VicePresidentePCompra.java

@@ -0,0 +1,16 @@
+package patronChainOfResponsibility;
+
+public class VicePresidentePCompra extends PoderDeCompra{
+	
+	private final int PERMISIBLE = 40 * base;
+	@Override
+	public void procesarPeticion(PeticionDeCompra peticion) {
+		if( peticion.getImporte() < PERMISIBLE) {
+			System.out.println("El vicepresidente puede aprobar la cantidad de "+ peticion.getImporte()+" euros.");
+		}else if(sucesor!= null) {
+			sucesor.procesarPeticion(peticion);
+		}
+		
+	}
+
+}

patronesComportamiento/patronCommand/Interruptor.java

@@ -0,0 +1,21 @@
+package patronCommand;
+
+//es el INVOCADOR
+//tiene 2 instancias de orden concretas almacenadas.
+public class Interruptor {
+	private Orden ordenEncender;
+	private Orden ordenApagar;
+	
+	public Interruptor(Orden ordenEncender, Orden ordenApagar) {
+		this.ordenEncender = ordenEncender;
+		this.ordenApagar = ordenApagar;
+	}
+	
+	public void encender() {
+		ordenEncender.ejecutar();
+	}
+	
+	public void apagar() {
+		ordenApagar.ejecutar();
+	}
+}

patronesComportamiento/patronCommand/Luz.java

@@ -0,0 +1,14 @@
+package patronCommand;
+
+//es la clase RECEPTOR, la luz representa por ejemplo una bombilla
+//tiene los metodos que ejecutan las ordenes
+public class Luz {
+	
+	public void encenderLuz() {
+		System.out.println("La luz esta encendida");
+	}
+	
+	public void apagarLuz() {
+		System.out.println("La luz esta apagada");
+	}
+}

patronesComportamiento/patronCommand/Main.java

@@ -0,0 +1,23 @@
+package patronCommand;
+
+//Esta clase seria el Cliente, que pulsa el interruptor. 
+public class Main {
+
+	public static void main(String[] args) {
+		
+		//instancia del RECEPTOR. 
+		//Llamada bombilla por facilitar entender el programa.
+		Luz bombilla = new Luz();
+		
+		//intancias de las ordenes concretas
+		Orden interruptorUp = new OrdenEncender(bombilla);
+		Orden interruptorDown = new OrdenApagar(bombilla);
+		
+		//instancia del INVOCADOR pasandole las ordenes concretas.
+		Interruptor i = new Interruptor(interruptorUp,interruptorDown);
+		
+		i.encender();
+		i.apagar();
+	}
+
+}

patronesComportamiento/patronCommand/Orden.java

@@ -0,0 +1,5 @@
+package patronCommand;
+
+public interface Orden {
+	void ejecutar();
+}

patronesComportamiento/patronCommand/OrdenApagar.java

@@ -0,0 +1,17 @@
+package patronCommand;
+
+//esta clase es una Orden Concreta. 
+//almacena una instancia del receptor sobre el que invoca la accion. 
+public class OrdenApagar implements Orden{
+	private Luz luz;
+	
+	public OrdenApagar(Luz luz) {
+		this.luz = luz;
+	}
+	
+	@Override
+	public void ejecutar() {
+		luz.apagarLuz();
+	}
+
+}

patronesComportamiento/patronCommand/OrdenEncender.java

@@ -0,0 +1,17 @@
+package patronCommand;
+
+//esta clase es una Orden Concreta. 
+//almacena una instancia del receptor sobre el que invoca la accion. 
+public class OrdenEncender implements Orden{
+	private Luz luz;
+	
+	public OrdenEncender(Luz luz) {
+		this.luz = luz;
+	}
+	
+	@Override
+	public void ejecutar() {
+		luz.encenderLuz();
+	}
+
+}

patronesComportamiento/patronInterpreter/Context.java

@@ -0,0 +1,32 @@
+package patronInterpreter;
+
+//Nuestro contexto es una sentencia del lenguaje a analizar.
+public class Context {
+	 private String input;
+	    private int output;
+
+	    public Context(String input)
+	    {
+	      this.input = input;
+	    }
+
+	    public String getInput()
+	    {
+	      return input;
+	    }
+	    
+	    public void setInput(String input)
+	    {
+	      this.input = input; 
+	    }    
+
+	    public int getOutput()
+	    {
+	      return output;
+	    }
+
+	    public void setOutput(int output)
+	    {
+	      this.output = output;
+	    }    
+}

patronesComportamiento/patronInterpreter/Expression.java

@@ -0,0 +1,38 @@
+package patronInterpreter;
+
+//Esta clase es la encargada de interpretar el contexto.
+public abstract class Expression {
+	public void interpret(Context context)
+    {
+      if (context.getInput().length() == 0) 
+        return;
+
+      if (context.getInput().startsWith(nine()))
+      {
+        context.setOutput(context.getOutput() + (9 * multiplier()));
+        context.setInput(context.getInput().substring(2));
+      }
+      else if (context.getInput().startsWith(four()))
+      {
+        context.setOutput(context.getOutput() + (4 * multiplier()));
+        context.setInput(context.getInput().substring(2));
+      }
+      else if (context.getInput().startsWith(five()))
+      {
+        context.setOutput(context.getOutput() + (5 * multiplier()));
+        context.setInput( context.getInput().substring(1));
+      }
+
+      while (context.getInput().startsWith(one()))
+      {
+        context.setOutput(context.getOutput() + (1 * multiplier()));
+        context.setInput(context.getInput().substring(1));
+      }
+    }
+
+    public abstract String one();
+    public abstract String four();
+    public abstract String five();
+    public abstract String nine();
+    public abstract int multiplier();
+}

patronesComportamiento/patronInterpreter/HundredExpression.java

@@ -0,0 +1,9 @@
+package patronInterpreter;
+
+public class HundredExpression extends Expression{
+	public  String one() { return "C"; }
+    public  String four(){ return "CD"; }
+    public  String five(){ return "D"; }
+    public  String nine(){ return "CM"; }
+    public  int multiplier() { return 100; }
+}

patronesComportamiento/patronInterpreter/Main.java

@@ -0,0 +1,30 @@
+package patronInterpreter;
+
+import java.util.ArrayList;
+
+import java.util.Iterator;
+
+//esta clase seria el cliente
+public class Main {
+
+	public static void main(String[] args) {
+		  String roman = "MCMXXVIII";
+	      Context context = new Context(roman);
+
+	      //Construye el árbol sintáctico
+	      ArrayList<Expression> tree = new ArrayList<Expression>();
+	      tree.add(new ThousandExpression());
+	      tree.add(new HundredExpression());
+	      tree.add(new TenExpression());
+	      tree.add(new OneExpression());
+
+	      // Interpretar: recorre todas las Expresiones del árbol.
+	      for (Iterator it = tree.iterator(); it.hasNext();){
+	    	  Expression exp = (Expression)it.next();
+	    	  exp.interpret(context);
+	      }
+
+	      System.out.println(roman + " = " + Integer.toString(context.getOutput()));
+	}
+}
+

patronesComportamiento/patronInterpreter/OneExpression.java

@@ -0,0 +1,9 @@
+package patronInterpreter;
+
+public class OneExpression extends Expression{
+	public String one() { return "I"; }
+    public String four(){ return "IV"; }
+    public String five(){ return "V"; }
+    public String nine(){ return "IX"; }
+    public int multiplier() { return 1; }
+}

patronesComportamiento/patronInterpreter/TenExpression.java

@@ -0,0 +1,9 @@
+package patronInterpreter;
+
+public class TenExpression extends Expression{
+	 public String one() { return "X"; }
+	 public String four(){ return "XL"; }
+	 public String five(){ return "L"; }
+	 public String nine(){ return "XC"; }
+	 public int multiplier() { return 10; }
+}

patronesComportamiento/patronInterpreter/ThousandExpression.java

@@ -0,0 +1,9 @@
+package patronInterpreter;
+
+public class ThousandExpression extends Expression{
+    public String one() { return "M"; }
+    public String four(){ return " "; }
+    public String five(){ return " "; }
+    public String nine(){ return " "; }
+    public int multiplier() { return 1000; }
+}

patronesComportamiento/patronIterator/IteradorVector.java

@@ -0,0 +1,28 @@
+package patronIterator;
+
+public class IteradorVector {
+	private int[] datosVector;
+	private int posicion; 
+	
+	public IteradorVector(Vector vector) { 
+		datosVector = vector.getDatos();
+		this.posicion = 0; 
+	} 
+	
+	public boolean hasNext() { 
+		if(posicion < datosVector.length){
+			return true;
+		}
+		return false; 
+	}
+	
+	public Object next(){ 
+		int valor = datosVector[posicion]; 
+		posicion++; 
+		return valor; 
+	}
+	
+	public void reset() {
+		posicion=0;
+	}
+}

patronesComportamiento/patronIterator/Main.java

@@ -0,0 +1,19 @@
+package patronIterator;
+
+public class Main {
+
+	public static void main(String[] args) {
+		
+		//creamos un vector de 5 espacios
+		Vector vector = new Vector(5);
+		//creamos un iterador para dicho vector.
+		IteradorVector iterador = vector.iterador();
+		
+		//mientras queden elementos en el vector por recorrer
+		while(iterador.hasNext()) {
+			System.out.println(iterador.next()); //los muestras
+		}
+		
+		iterador.reset(); //nos devuelve a la primera posicion del vector.
+	}
+}

patronesComportamiento/patronIterator/Vector.java

@@ -0,0 +1,32 @@
+package patronIterator;
+
+public class Vector {
+	public int[] datos; 
+	
+	public Vector(int tamanyo) { 
+		this.datos = new int[tamanyo]; 
+		for(int i = 0; i<datos.length; i++) {
+			datos[i] = i; 
+		}
+	} 
+	
+	public int getValor(int pos) { 
+		return datos[pos]; 
+	} 
+	
+	public void setValor(int pos, int valor) { 
+		datos[pos] = valor; 
+	} 
+	
+	public int dimension() { 
+		return datos.length; 
+	} 
+	
+	public IteradorVector iterador() { 
+		return new IteradorVector(this); 
+	}
+
+	public int[] getDatos() {
+		return datos;
+	}
+}

patronesComportamiento/patronMediator/Colega.java

@@ -0,0 +1,13 @@
+package patronMediator;
+
+public abstract class Colega {
+	
+	protected Mediador mediador;
+	
+	public Colega(Mediador mediador) {
+		this.mediador = mediador;
+	}
+	
+	public abstract void enviarMensaje(String mensaje);
+	public abstract void mensajeRecibido(String mensaje);
+}

patronesComportamiento/patronMediator/ColegaConcreto1.java

@@ -0,0 +1,18 @@
+package patronMediator;
+
+public class ColegaConcreto1 extends Colega{
+
+	public ColegaConcreto1(Mediador mediador) {
+		super(mediador);
+	}
+
+	public void enviarMensaje(String mensaje) {
+		mediador.enviarMensaje(mensaje, this);
+	}
+
+	@Override
+	public void mensajeRecibido(String mensaje) {
+		System.out.println("Colega 1 recibe el mensaje: " + mensaje);
+	}
+
+}

patronesComportamiento/patronMediator/ColegaConcreto2.java

@@ -0,0 +1,18 @@
+package patronMediator;
+
+public class ColegaConcreto2 extends Colega{
+
+	public ColegaConcreto2(Mediador mediador) {
+		super(mediador);
+	}
+
+	public void enviarMensaje(String mensaje) {
+		mediador.enviarMensaje(mensaje, this);		
+	}
+
+	@Override
+	public void mensajeRecibido(String mensaje) {
+		System.out.println("Colega 2 recibe el mensaje: " + mensaje);
+	}
+
+}

patronesComportamiento/patronMediator/Main.java

@@ -0,0 +1,18 @@
+package patronMediator;
+
+public class Main {
+
+	public static void main(String[] args) {
+		MediadorConcreto mediador = new MediadorConcreto();
+		
+		ColegaConcreto1 colega1 = new ColegaConcreto1(mediador);
+		ColegaConcreto2 colega2 = new ColegaConcreto2(mediador);
+		
+		mediador.setColega1(colega1);
+		mediador.setColega2(colega2);
+		
+		colega1.enviarMensaje("Hola,¿que tal?");
+		colega2.enviarMensaje("Bien, aprendiendo este patrón");
+	}
+
+}

patronesComportamiento/patronMediator/Mediador.java

@@ -0,0 +1,5 @@
+package patronMediator;
+
+public interface Mediador {
+	public void enviarMensaje(String mensaje, Colega colega);
+}

patronesComportamiento/patronMediator/MediadorConcreto.java

@@ -0,0 +1,29 @@
+package patronMediator;
+
+public class MediadorConcreto implements Mediador{
+	
+	private ColegaConcreto1 colega1;
+	private ColegaConcreto2 colega2;
+
+	public void setColega1(ColegaConcreto1 colega1) {
+		this.colega1 = colega1;
+	}
+
+	public void setColega2(ColegaConcreto2 colega2) {
+		this.colega2 = colega2;
+	}
+	
+	//este metodo recibiria el mensaje, origen y destino en el caso
+	//de haber mas de 2 colegas.
+	@Override
+	public void enviarMensaje(String mensaje, Colega colega) {
+		if(colega == colega1) {
+			colega2.mensajeRecibido(mensaje);
+		}else if(colega == colega2){
+			colega1.mensajeRecibido(mensaje);
+		}else {
+			System.out.println("El mensaje se perdio");
+		}
+	}
+
+}

patronesComportamiento/patronMemento/Conserje.java

@@ -0,0 +1,18 @@
+package patronMemento;
+
+import java.util.ArrayList;
+
+//es el Cuidador, el que almacena los mementos. 
+public class Conserje {
+	
+	private ArrayList<Memento> mementos = new ArrayList<Memento>();
+	
+	public void addMemento(Memento m) {
+		mementos.add(m);
+	}
+	
+	//Recuperar el memento de una posición. 
+	public Memento getMemento(int i) {
+		return mementos.get(i);
+	}
+}

patronesComportamiento/patronMemento/Main.java

@@ -0,0 +1,23 @@
+package patronMemento;
+
+public class Main {
+
+	public static void main(String[] args) {
+		
+		//instancio la clase que almacenara los mementos.
+		Conserje conserje = new Conserje();	
+		//clase que ira generando los estados.
+		Originador originador = new Originador();
+		
+		originador.setEstado("Estado 1"); //Estamos en Estado 1
+		originador.setEstado("Estado 2"); //Estamos en Estado 2
+		conserje.addMemento(originador.crearMemento()); //Guardamos Estado 2
+		originador.setEstado("Estado 3"); //Estamos en Estado 3
+		conserje.addMemento(originador.crearMemento()); //Estamos en Estado 3
+		originador.setEstado("Estado 4"); //Estamos en Estado 4
+		originador.setMemento(conserje.getMemento(1));//Recuperamos Estado 3
+		
+		System.out.println("El estado actual es: "+ originador.getEstado());
+	}
+
+}

patronesComportamiento/patronMemento/Memento.java

@@ -0,0 +1,14 @@
+package patronMemento;
+
+public class Memento {
+	private String estado;
+
+	public Memento(String estadoParaGuardar) { 
+	 	estado = estadoParaGuardar;
+	 }
+	
+	//metodo para recuperar el estado guardado
+	public String getEstado() { 
+		return estado; 
+		}
+}

patronesComportamiento/patronMemento/Originador.java

@@ -0,0 +1,21 @@
+package patronMemento;
+
+public class Originador {
+	private String estado;
+	
+	public void setEstado(String estado) {
+		this.estado = estado;
+	}
+	
+	public Memento crearMemento() {
+		return new Memento(estado);
+	}
+	
+	public void setMemento(Memento m) {
+		this.estado = m.getEstado();
+	}
+	
+	public String getEstado() {
+		return estado;
+	}
+}

patronesComportamiento/patronObserver/Cliente.java

@@ -0,0 +1,17 @@
+package patronObserver;
+
+//esta clase es el OBSERVADOR
+public class Cliente implements ObservadorIF{
+	
+	String nombre;
+	
+	public Cliente(String nombre){
+		this.nombre=nombre;
+	}
+
+	@Override
+	public void update() {
+		System.out.println(nombre + " recibe notificacion reparación");
+	}
+
+}

patronesComportamiento/patronObserver/Electrodomestico.java

@@ -0,0 +1,34 @@
+package patronObserver;
+import java.util.ArrayList;
+
+//Esta clase es el OBSERVABLE
+public class Electrodomestico implements ObservableIF {
+	
+	ArrayList<ObservadorIF> observadores;
+	
+	public Electrodomestico() {
+		observadores = new ArrayList<>();
+	}
+	
+	public void electrodomesticoArreglado() {
+		notificar();
+	}
+
+	@Override
+	public void addObserver(ObservadorIF o) {
+		observadores.add(o);
+	}
+
+	@Override
+	public void removeObserver(ObservadorIF o) {
+		observadores.remove(o);
+	}
+
+	@Override
+	public void notificar() {
+		for(ObservadorIF o: observadores) {
+			o.update();
+		}
+	}
+
+}

patronesComportamiento/patronObserver/Main.java

@@ -0,0 +1,22 @@
+package patronObserver;
+
+public class Main {
+
+	public static void main(String[] args) {
+		//creo 3 objetos Observadores (Clientes), que recibiran un aviso cuando este reparado su producto.
+		Cliente c1 = new Cliente("Cliente 1");
+		Cliente c2 = new Cliente("Cliente 2");
+		Cliente c3 = new Cliente("Cliente 3");
+	
+		//Por comprobar su correcto funcionamiento se va a crear un unico objeto Observable, que notificara a todos los Observadores.
+		Electrodomestico television = new Electrodomestico();
+		//añado los observadores de television.
+		television.addObserver(c1);
+		television.addObserver(c2);
+		television.addObserver(c3);
+		
+		//llamamos al metodo que disparara el aviso
+		television.electrodomesticoArreglado();
+	}
+
+}

patronesComportamiento/patronObserver/ObservableIF.java

@@ -0,0 +1,9 @@
+package patronObserver;
+
+public interface ObservableIF {
+	
+	public void addObserver(ObservadorIF o);
+	public void removeObserver(ObservadorIF o);
+	public void notificar();
+
+}

patronesComportamiento/patronObserver/ObservadorIF.java

@@ -0,0 +1,7 @@
+package patronObserver;
+
+public interface ObservadorIF {
+	
+	public void update();
+
+}

patronesComportamiento/patronState/Contexto.java

@@ -0,0 +1,17 @@
+package patronState;
+
+public class Contexto {
+	private Estado estado;
+	
+	public void setEstado(Estado estado) {
+		this.estado = estado;
+	}
+	
+	public Estado getEstado() {
+		return this.estado;
+	}
+	
+	public void peticion() {
+		estado.ejecutarOperacion();
+	}
+}

patronesComportamiento/patronState/Estado.java

@@ -0,0 +1,5 @@
+package patronState;
+
+public interface Estado {
+	void ejecutarOperacion();
+}

patronesComportamiento/patronState/EstadoConcretoA.java

@@ -0,0 +1,9 @@
+package patronState;
+
+public class EstadoConcretoA implements Estado{
+	
+	@Override
+	public void ejecutarOperacion() {
+		System.out.println("En estado concreto A");
+	}
+}

patronesComportamiento/patronState/EstadoConcretoB.java

@@ -0,0 +1,10 @@
+package patronState;
+
+public class EstadoConcretoB implements Estado{
+
+	@Override
+	public void ejecutarOperacion() {
+		System.out.println("En estado concreto B");
+	}
+
+}

patronesComportamiento/patronState/Main.java

@@ -0,0 +1,22 @@
+package patronState;
+
+public class Main {
+
+	public static void main(String[] args) {
+		Estado estado = new EstadoConcretoA();
+		Estado estado2 = new EstadoConcretoB();
+		Contexto contexto = new Contexto();
+		
+		//Asignamos a contexto el estado concreto A
+		contexto.setEstado(estado);
+		contexto.peticion();
+		
+		//asignamos a contexto el estado concreto B
+		contexto.setEstado(estado2);
+		contexto.peticion();	
+		
+		/*Como vemos segun el estado en el que se encuentre contexto
+		el metodo peticion(); realiza una accion diferente. */
+	}
+
+}

patronesComportamiento/patronStrategy/Contexto.java

@@ -0,0 +1,17 @@
+package patronStrategy;
+
+public class Contexto {
+	Estrategia estrategia; 
+	
+	public Contexto(Estrategia s) {
+		this.estrategia = s;
+	} 
+	
+	public void setEstrategia(Estrategia s) { 
+		this.estrategia = s; 
+	} 
+	
+	public void ejecutarMetodoEstrategico() { 
+		estrategia.comportamiento(); 
+	}
+}

patronesComportamiento/patronStrategy/Estrategia.java

@@ -0,0 +1,5 @@
+package patronStrategy;
+
+public abstract class Estrategia {
+	public abstract void comportamiento();
+}

patronesComportamiento/patronStrategy/EstrategiaA.java

@@ -0,0 +1,10 @@
+package patronStrategy;
+
+public class EstrategiaA extends Estrategia {
+
+	@Override
+	public void comportamiento() {
+		System.out.println("Se realizara la estrategia A");
+	}
+
+}

patronesComportamiento/patronStrategy/EstrategiaB.java

@@ -0,0 +1,10 @@
+package patronStrategy;
+
+public class EstrategiaB extends Estrategia{
+	
+	@Override
+	public void comportamiento() {
+		System.out.println("Se realizara la estrategia A");
+	}
+
+}

patronesComportamiento/patronStrategy/Main.java

@@ -0,0 +1,21 @@
+package patronStrategy;
+
+public class Main {
+
+	public static void main(String[] args) {
+		
+		//instanciamos la estrategia A
+		Estrategia estrategiaInicial = new EstrategiaA();
+		//se la asignamos al contexto
+		Contexto contexto = new Contexto(estrategiaInicial);
+		
+		contexto.ejecutarMetodoEstrategico();
+		
+		//instancias la estrategia B
+		Estrategia otraEstrategia = new EstrategiaB();
+		//se la asignamos al contexto
+		contexto.setEstrategia(otraEstrategia);
+		
+		contexto.ejecutarMetodoEstrategico();
+	}
+}

patronesComportamiento/patronTemplateMethod/Automovil.java

@@ -0,0 +1,20 @@
+package patronTemplateMethod;
+
+//clase Abstracta
+public abstract class Automovil {
+	public void desplazar() {
+		acelerar();
+		cambiarMarcha();
+		frenar();
+	}
+	private void acelerar() {
+		System.out.println("Acelerando");
+	}
+
+	private void frenar() {
+		System.out.println("Frenando");
+	}
+
+	protected abstract void cambiarMarcha();
+	
+}

patronesComportamiento/patronTemplateMethod/AutomovilAutomatico.java

@@ -0,0 +1,10 @@
+package patronTemplateMethod;
+
+public class AutomovilAutomatico extends Automovil{
+
+	@Override
+	protected void cambiarMarcha() {
+		System.out.println("Cambio de marcha en Automatico");
+	}
+
+}

patronesComportamiento/patronTemplateMethod/AutomovilManual.java

@@ -0,0 +1,10 @@
+package patronTemplateMethod;
+
+public class AutomovilManual extends Automovil{
+
+	@Override
+	protected void cambiarMarcha() {
+		System.out.println("Cambio de marcha en Manual");
+	}
+	
+}

patronesComportamiento/patronTemplateMethod/Main.java

@@ -0,0 +1,17 @@
+package patronTemplateMethod;
+
+public class Main {
+
+	public static void main(String[] args) {
+		Automovil manual = new AutomovilManual();
+		Automovil automatico = new AutomovilAutomatico();
+		
+		manual.desplazar();
+		
+		System.out.println("");
+		
+		automatico.desplazar();
+	
+	}
+
+}

patronesComportamiento/patronVisitor/Main.java

@@ -0,0 +1,23 @@
+package patronVisitor;
+
+public class Main {
+	
+	//Creamos una lista de nodos de tres elementos, una para cada nodo.
+	public static Nodo[] lista = { new NodoA(), new NodoB(), new NodoC() };
+	
+	public static void main(String[] args) {
+		//Creamos los visitantes concretos (las operaciones que tienen los nodos)
+		VisitanteSubir subir = new VisitanteSubir();
+		VisitanteBajar bajar = new VisitanteBajar();
+		
+		/*Recorremos la lista para que acepten el visitante. Esto lo hacemos sin saber
+		que tipo de nodo esta recibiendo, es el visitante concreto el que se encarga de averiguarlo.*/
+		for(int i=0; i<lista.length; i++) { 
+			lista[i].aceptar(subir); //le decimos que procese el visitante subir.
+		}
+		
+		for(int i=0; i<lista.length; i++) { 
+			lista[i].aceptar(bajar); //le decimos que procese el elemento bajar. 
+		}
+	}
+}

patronesComportamiento/patronVisitor/Nodo.java

@@ -0,0 +1,5 @@
+package patronVisitor;
+
+public interface Nodo {
+	public void aceptar(Visitante v);
+}

patronesComportamiento/patronVisitor/NodoA.java

@@ -0,0 +1,12 @@
+package patronVisitor;
+
+public class NodoA implements Nodo{
+	
+	public void aceptar(Visitante v) { 
+		v.visitar(this); 
+	} 
+	
+	public String operacionA() { 
+		return "Operacion A, Nodo A"; 
+	}
+}

patronesComportamiento/patronVisitor/NodoB.java

@@ -0,0 +1,12 @@
+package patronVisitor;
+
+public class NodoB implements Nodo{
+	
+	public void aceptar(Visitante v) { 
+		v.visitar(this); 
+	} 
+	
+	public String operacionB() { 
+		return "Operacion B, Nodo B"; 
+	}
+}

patronesComportamiento/patronVisitor/NodoC.java

@@ -0,0 +1,12 @@
+package patronVisitor;
+
+public class NodoC implements Nodo{
+	
+	public void aceptar(Visitante v) { 
+		v.visitar(this); 
+	} 
+	
+	public String operacionC() { 
+		return "Operacion C, Nodo C"; 
+	}
+}

patronesComportamiento/patronVisitor/Visitante.java

@@ -0,0 +1,8 @@
+package patronVisitor;
+
+//VisitanteNodo
+public interface Visitante {
+	public void visitar(NodoA n); 
+	public void visitar(NodoB n); 
+	public void visitar(NodoC n);
+}

patronesComportamiento/patronVisitor/VisitanteBajar.java

@@ -0,0 +1,21 @@
+package patronVisitor;
+
+//Visitante Concreto
+public class VisitanteBajar implements Visitante{
+
+	@Override
+	public void visitar(NodoA n) {
+		System.out.println("Bajar: " + n.operacionA());
+	}
+
+	@Override
+	public void visitar(NodoB n) {
+		System.out.println("Bajar: " + n.operacionB());
+	}
+
+	@Override
+	public void visitar(NodoC n) {
+		System.out.println("Bajar: " + n.operacionC());
+	}
+
+}

patronesComportamiento/patronVisitor/VisitanteSubir.java

@@ -0,0 +1,21 @@
+package patronVisitor;
+
+//Visitante Concreto
+public class VisitanteSubir implements Visitante {
+
+	@Override
+	public void visitar(NodoA n) {
+		System.out.println("Subir: " + n.operacionA());
+	}
+
+	@Override
+	public void visitar(NodoB n) {
+		System.out.println("Subir: " + n.operacionB());
+	}
+
+	@Override
+	public void visitar(NodoC n) {
+		System.out.println("Subir: " + n.operacionC());
+	}
+
+}

patronesCreacion/patronAbstractFactory/AbstractFactory.java

@@ -0,0 +1,5 @@
+package patronAbstractFactory;
+
+public interface AbstractFactory {
+	public Boton crearBoton();
+}

patronesCreacion/patronAbstractFactory/Boton.java

@@ -0,0 +1,5 @@
+package patronAbstractFactory;
+
+public interface Boton {
+	public void pintar();
+}

patronesCreacion/patronAbstractFactory/BotonLinux.java

@@ -0,0 +1,8 @@
+package patronAbstractFactory;
+
+public class BotonLinux implements Boton{
+	@Override
+	public void pintar() {
+		System.out.println("Soy un boton de Linux");		
+	}
+}

patronesCreacion/patronAbstractFactory/BotonWindows.java

@@ -0,0 +1,10 @@
+package patronAbstractFactory;
+
+public class BotonWindows implements Boton{
+
+	@Override
+	public void pintar() {
+		System.out.println("Soy un boton de Windows");		
+	}
+
+}

patronesCreacion/patronAbstractFactory/Cliente.java

@@ -0,0 +1,8 @@
+package patronAbstractFactory;
+
+public class Cliente {
+	public Cliente(AbstractFactory fabrica) {
+		Boton boton = fabrica.crearBoton();
+		boton.pintar();
+	}
+}

patronesCreacion/patronAbstractFactory/FabricaLinux.java

@@ -0,0 +1,10 @@
+package patronAbstractFactory;
+
+public class FabricaLinux implements AbstractFactory{
+
+	@Override
+	public Boton crearBoton() {
+		return new BotonLinux();
+	}
+
+}

patronesCreacion/patronAbstractFactory/FabricaWindows.java

@@ -0,0 +1,10 @@
+package patronAbstractFactory;
+
+public class FabricaWindows implements AbstractFactory{
+
+	@Override
+	public Boton crearBoton() {
+		return new BotonWindows();
+	}
+
+}

patronesCreacion/patronAbstractFactory/Main.java

@@ -0,0 +1,28 @@
+package patronAbstractFactory;
+
+/*Permite trabajar con objetos de distintas familias (proporcionando una interfaz) de manera que las familias 
+ * no se mezclen entre sí y haciendo transparente el tipo de familia concreta que se esté usando. */
+
+public class Main {
+
+	public static void main(String[] args) {
+		//en este caso la fabrica dependeria del sistema operativo.
+		//mirariamos el sistema y devuelve 0 si es windows, o 1 si es linux.
+		
+		int sistema = 0;
+		Cliente c1 = new Cliente(crearFabrica(sistema));
+		
+		sistema = 1;
+		Cliente c2 = new Cliente(crearFabrica(sistema));
+
+	}
+
+	private static AbstractFactory crearFabrica(int sistema) {		
+		if(sistema==0) {
+			return new FabricaWindows();
+		}else {
+			return new FabricaLinux();
+		}
+	}
+
+}

patronesCreacion/patronBuilder/Cliente.java

@@ -0,0 +1,5 @@
+package patronBuilder;
+
+public class Cliente {
+
+}

patronesCreacion/patronBuilder/Cocina.java

@@ -0,0 +1,23 @@
+package patronBuilder;
+
+//Seria el Director en el esquema del patron.
+public class Cocina {
+	private ConstructorPizzas cP;
+	
+	public void setConstructorPizzas(ConstructorPizzas cP) {
+		this.cP=cP;
+	}
+	
+	public Pizza getPizza() {
+		return cP.getPizza();
+	}
+	
+	//Este metodo llama a los constructores que van haciendo la pizza
+	//parte por parte
+	public void construirPizza() {
+		cP.crearNuevaPizza();
+		cP.construirMasa();
+		cP.construirSalsa();
+		cP.construirRelleno();
+	}
+}

patronesCreacion/patronBuilder/ConstructorPizzaHawai.java

@@ -0,0 +1,20 @@
+package patronBuilder;
+
+public class ConstructorPizzaHawai extends ConstructorPizzas {
+
+	@Override
+	public void construirMasa() {
+		pizza.setMasa("suave");
+	}
+
+	@Override
+	public void construirSalsa() {
+		pizza.setSalsa("dulce");		
+	}
+
+	@Override
+	public void construirRelleno() {
+		pizza.setRelleno("Piña y Jamon");	
+	}
+
+}

patronesCreacion/patronBuilder/ConstructorPizzaPicante.java

@@ -0,0 +1,19 @@
+package patronBuilder;
+
+public class ConstructorPizzaPicante extends ConstructorPizzas{
+
+	@Override
+	public void construirMasa() {
+		pizza.setMasa("fuerte");
+	}
+
+	@Override
+	public void construirSalsa() {
+		pizza.setSalsa("picante");		
+	}
+
+	@Override
+	public void construirRelleno() {
+		pizza.setRelleno("ternera y verduras");	
+	}
+}

patronesCreacion/patronBuilder/ConstructorPizzas.java

@@ -0,0 +1,18 @@
+package patronBuilder;
+
+public abstract class ConstructorPizzas {
+	protected Pizza pizza;
+	
+	public Pizza getPizza() {
+		return pizza;
+	}
+	
+	public void crearNuevaPizza() {
+		pizza = new Pizza();
+	}
+	
+	//Los siguientes metodos los implementara cada constructor segun el tipo de pizza
+	public abstract void construirMasa();
+	public abstract void construirSalsa();
+	public abstract void construirRelleno();
+}

patronesCreacion/patronBuilder/Main.java

@@ -0,0 +1,26 @@
+package patronBuilder;
+
+public class Main {
+
+	public static void main(String[] args) {
+		Cocina cocina = new Cocina();
+		ConstructorPizzas cPH = new ConstructorPizzaHawai();
+		ConstructorPizzas cPP = new ConstructorPizzaPicante();
+		
+		//el cliente seria al que se le pregunta que pizza quiere, y se llamaria
+		//a la cocina para que la prepare. por simplificar codigo se hara aqui.
+		
+		cocina.setConstructorPizzas(cPH);
+		cocina.construirPizza();
+		
+		Pizza pizza = cocina.getPizza();
+		pizza.dimeIngredientes();
+		
+		cocina.setConstructorPizzas(cPP);
+		cocina.construirPizza();
+		
+		Pizza pizza2 = cocina.getPizza();
+		pizza2.dimeIngredientes();
+	
+	}
+}

patronesCreacion/patronBuilder/Pizza.java

@@ -0,0 +1,32 @@
+package patronBuilder;
+
+//Es el Producto en el esquema del patrón.
+public class Pizza {
+	private String masa;
+	private String salsa;
+	private String relleno;
+	
+	public Pizza() {
+		masa="";
+		salsa="";
+		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;
+	}
+
+	public void dimeIngredientes() {
+		System.out.println("Soy una pizza con masa "+ masa);
+		System.out.println("Tengo de salsa "+ salsa);
+		System.out.println("y mi relleno es "+ relleno + "\n");
+	}
+}

patronesCreacion/patronFactoria/Electrodomestico.java

@@ -0,0 +1,17 @@
+package patronFactoria;
+
+public abstract class Electrodomestico {
+	String modelo;
+	String marca;
+	String color;
+	int precio;
+	
+	public Electrodomestico(String modelo) {
+		this.modelo=modelo;
+	}
+	
+	public void mensajePantalla(){
+		System.out.println("Soy un electrodomestico");
+	}
+	
+}

patronesCreacion/patronFactoria/FactoriaElectrodomesticos.java

@@ -0,0 +1,20 @@
+package patronFactoria;
+
+public class FactoriaElectrodomesticos implements FactoriaIF {
+
+	@Override
+	public Electrodomestico crearElectrodomestico(String nombre,String modelo) {
+		if(nombre.equalsIgnoreCase("television")){
+			return new Television(modelo); 
+		}else if(nombre.equalsIgnoreCase("lavadora")) {
+			return new Lavadora(modelo);
+		}else if(nombre.equalsIgnoreCase("horno")) {
+			return new Horno(modelo);
+		}else if(nombre.equalsIgnoreCase("microondas")) {
+			return new Microondas(modelo);
+		}	
+		return null;
+		
+	}
+
+}

patronesCreacion/patronFactoria/FactoriaIF.java

@@ -0,0 +1,5 @@
+package patronFactoria;
+
+public interface FactoriaIF {
+	public Electrodomestico crearElectrodomestico(String nombre,String modelo);
+}

patronesCreacion/patronFactoria/Horno.java

@@ -0,0 +1,12 @@
+package patronFactoria;
+
+public class Horno extends Electrodomestico{
+	
+	public Horno(String modelo){
+		super(modelo);
+	}
+	
+	public void mensajePantalla(){
+		System.out.println("Soy un horno");
+	}
+}

patronesCreacion/patronFactoria/Lavadora.java

@@ -0,0 +1,14 @@
+package patronFactoria;
+
+public class Lavadora extends Electrodomestico{
+
+	
+	public Lavadora(String modelo){
+		super(modelo);
+	}
+	
+	public void mensajePantalla(){
+		System.out.println("Soy una lavadora");
+	}
+	
+}

patronesCreacion/patronFactoria/Main.java

@@ -0,0 +1,31 @@
+package patronFactoria;
+
+public class Main {
+
+	public static void main(String[] args) {
+		
+		System.out.println("Demostración Patron factoría. ");
+		System.out.println("Puedes crear una Television/Lavadora/Horno/Microondas.\n");
+		FactoriaElectrodomesticos fabrica = new FactoriaElectrodomesticos();
+		
+		System.out.println("Usuario introduce que quiere una Television ........");
+		Electrodomestico e1 = fabrica.crearElectrodomestico("television", "tele123");
+		
+		System.out.println("Usuario introduce que quiere una Lavadora ..........");
+		Electrodomestico e2 = fabrica.crearElectrodomestico("lavadora", "lavadora123");
+		
+		System.out.println("Usuario introduce que quiere un Horno ..............");
+		Electrodomestico e3 = fabrica.crearElectrodomestico("horno", "Horno123");
+		
+		System.out.println("Usuario introduce que quiere un Microondas .........");
+		Electrodomestico e4 = fabrica.crearElectrodomestico("microondas", "microondas123");
+
+		System.out.println("\nSe muestra por pantalla que es cada uno de los objetos creados");
+		e1.mensajePantalla();
+		e2.mensajePantalla();
+		e3.mensajePantalla();
+		e4.mensajePantalla();
+		
+	}
+
+}

patronesCreacion/patronFactoria/Microondas.java

@@ -0,0 +1,14 @@
+package patronFactoria;
+
+public class Microondas extends Electrodomestico{
+
+	
+	public Microondas(String modelo){
+		super(modelo);
+	}
+	
+	public void mensajePantalla(){
+		System.out.println("Soy un microondas");
+	}
+	
+}

patronesCreacion/patronFactoria/Television.java

@@ -0,0 +1,13 @@
+package patronFactoria;
+
+public class Television extends Electrodomestico{
+	
+	public Television(String modelo){
+		super(modelo);
+	}
+	
+	public void mensajePantalla(){
+		System.out.println("Soy una television");
+	}
+	
+}

patronesCreacion/patronPrototype/Circulo.java

@@ -0,0 +1,9 @@
+package patronPrototype;
+
+public class Circulo extends Figura{
+
+	public Circulo(String nombre) {
+		super(nombre);
+	}
+	
+}

patronesCreacion/patronPrototype/Cuadrado.java

@@ -0,0 +1,9 @@
+package patronPrototype;
+
+public class Cuadrado extends Figura{
+
+	public Cuadrado(String nombre) {
+		super(nombre);
+	}
+
+}

patronesCreacion/patronPrototype/Figura.java

@@ -0,0 +1,22 @@
+package patronPrototype;
+
+public class Figura implements Prototype{
+	private String nombre;
+	
+	public Figura(String nombre) {
+		this.nombre=nombre;
+	}
+	
+	public String getNombre() {
+		return nombre;
+	}
+	
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+	
+	@Override
+	public Figura clone() {
+		return new Figura(this.nombre);
+	} 
+}

patronesCreacion/patronPrototype/Main.java

@@ -0,0 +1,30 @@
+package patronPrototype;
+
+public class Main {
+
+	public static void main(String[] args) {
+		Figura circulo;
+		Figura circulo2;
+		
+		Figura cuadrado;
+		Figura cuadrado2;
+		
+		//creo circulo, y creo circulo2 que sera un clone de circulo
+		circulo = new Circulo("Circulo1");
+		circulo2 = circulo.clone();
+		
+		//creo cuadrado, y creo cuadrado2 que sera un clone de cuadrado
+		cuadrado = new Cuadrado("Cuadrado1");
+		cuadrado2 = cuadrado.clone();
+		
+		//llegado aqui ya puedo modificar el nombre de las figuras 2 sin alterar el de las figuras originales. 
+		circulo2.setNombre("Circulo2");
+		cuadrado2.setNombre("Cuadrado2");
+		
+		System.out.println("La figura se llama: "+ circulo.getNombre());
+		System.out.println("La figura se llama: "+ circulo2.getNombre());
+		System.out.println("La figura se llama: "+ cuadrado.getNombre());
+		System.out.println("La figura se llama: "+ cuadrado2.getNombre());
+	}
+
+}

patronesCreacion/patronPrototype/Prototype.java

@@ -0,0 +1,5 @@
+package patronPrototype;
+
+public interface Prototype{
+	public Object clone();
+}

patronesCreacion/patronSingleton/Main.java

@@ -0,0 +1,22 @@
+package patronSingleton;
+
+public class Main {
+	    
+	    public static void main(String [] args) {
+	    	
+	        Singleton s = Singleton.getSingleton(); //Permitido
+	       
+	        Singleton s2 = Singleton.getSingleton(); //No permitido
+	                
+	        //otra opcion es la inicializacion bajo demanda, en la que el 
+	        //singleton se instancia solo, y el mismo controla que no pueda
+	        //haber mas.
+	        
+	        
+	        Singleton1 sin1 = Singleton1.getInstancia();
+	        sin1.mostrarMensaje();
+	        // Singleton1 sin2 = new Singleton1(); 
+	        //Esta linea da error por no estar visible el constructor. 
+	    }
+
+}

patronesCreacion/patronSingleton/Singleton.java

@@ -0,0 +1,18 @@
+package patronSingleton;
+
+public class Singleton {
+	
+	private static Singleton instancia = null;
+	
+	private Singleton() {}
+	
+    public static Singleton getSingleton() {
+        	if (instancia==null) {
+                System.out.println("Se genero una instancia de Singleton");
+                  instancia = new Singleton();
+             }else {
+                System.out.println("No se puede generar otra instancia de Singleton");
+            }
+    	return instancia;
+    }
+}

patronesCreacion/patronSingleton/Singleton1.java

@@ -0,0 +1,16 @@
+package patronSingleton;
+
+public class Singleton1 {
+	private static Singleton1 instancia = new Singleton1();
+	
+	//Constructor privado no permite que se genere un constructor por defecto.
+	private Singleton1() {}
+	
+	public static Singleton1 getInstancia() {
+		return instancia;
+	}
+	
+    public void mostrarMensaje() {
+    	System.out.println("\nSoy la instancia de Singleton1");
+    }
+}

patronesEstructurales/patronAdapter/Guitarra.java

@@ -0,0 +1,6 @@
+package patronAdapter;
+
+public abstract class Guitarra {
+	abstract public void encenderGuitarra();
+	abstract public void apagarGuitarra();
+}

patronesEstructurales/patronAdapter/GuitarraAcustica.java

@@ -0,0 +1,13 @@
+package patronAdapter;
+
+//Esta es la clase adaptada o Adaptable
+public class GuitarraAcustica {
+
+	public void tocarGuitarra() {
+		System.out.println("Se esta tocando la guitarra");		
+	}
+
+	public void dejarGuitarra() {
+		System.out.println("Se ha dejado de tocar la guitarra");			
+	}
+}

patronesEstructurales/patronAdapter/GuitarraElectrica.java

@@ -0,0 +1,19 @@
+package patronAdapter;
+
+public class GuitarraElectrica extends Guitarra{
+
+	public GuitarraElectrica() {
+		
+	}
+	
+	@Override
+	public void encenderGuitarra() {
+		System.out.println("Se ha encendido la guitarra");		
+	}
+
+	@Override
+	public void apagarGuitarra() {
+		System.out.println("Se ha apagado la guitarra");		
+	}
+
+}

patronesEstructurales/patronAdapter/GuitarraElectricaAcustica.java

@@ -0,0 +1,19 @@
+package patronAdapter;
+
+//Esta es la clase Adaptador.
+
+public class GuitarraElectricaAcustica extends Guitarra{
+	
+	GuitarraAcustica acustica = new GuitarraAcustica();
+
+	@Override
+	public void encenderGuitarra() {
+		acustica.tocarGuitarra();
+	}
+
+	@Override
+	public void apagarGuitarra() {
+		acustica.dejarGuitarra();
+	}
+
+}

patronesEstructurales/patronAdapter/Main.java

@@ -0,0 +1,20 @@
+package patronAdapter;
+
+public class Main {
+	
+	public static void main(String[] args) {
+		
+		//creamos una Guitarra Electrica sin necesidad de nada Especial
+		Guitarra guitarraE = new GuitarraElectrica();
+		guitarraE.encenderGuitarra();
+		guitarraE.apagarGuitarra();
+		
+		//Si queremos una Guitarra Acustica no podemos 
+		//Tenemos que crear una clase adaptador
+		Guitarra guitarraEA = new GuitarraElectricaAcustica();
+		//esta clase sera la encargada de llamar a los metodos de la clase adaptable (GuitaraAcustica)
+		guitarraEA.encenderGuitarra(); //llama a tocarGuitarra();
+		guitarraEA.apagarGuitarra(); //llama a dejarGuitarra();
+		
+	}
+}

patronesEstructurales/patronBridge/Abstraccion.java

@@ -0,0 +1,6 @@
+package patronBridge;
+
+public interface Abstraccion {
+	public void Operacion(); 
+	//Como puede ser encender/apagar el interruptor
+}

patronesEstructurales/patronBridge/AbstraccionRefinada.java

@@ -0,0 +1,14 @@
+package patronBridge;
+
+public class AbstraccionRefinada implements Abstraccion{
+	private Implementador implementacion;
+	
+	public AbstraccionRefinada(Implementador implementacion) {
+		this.implementacion=implementacion;
+	}
+	
+	public void Operacion() {
+		implementacion.OperacionImplementada();
+	}
+
+}

patronesEstructurales/patronBridge/Implementador.java

@@ -0,0 +1,5 @@
+package patronBridge;
+
+public interface Implementador {
+	public abstract void OperacionImplementada();
+}

patronesEstructurales/patronBridge/ImplementadorConcretoA.java

@@ -0,0 +1,9 @@
+package patronBridge;
+
+public class ImplementadorConcretoA implements Implementador{
+
+	@Override
+	public void OperacionImplementada() {
+		System.out.println("Operacion Implementador A");
+	}
+}