Categoría: Design Patterns Stories

Este ejemplo muestra cómo crear un ejemplo de GUI de Swing y explica por qué es un ejemplo de uso de Observer Design Pattern.

Código completo

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;
 
public class SimpleSwingExample {
 
	public static void main(String[] args) {
		JFrame frame = new JFrame("Frame Title");
		final JTextArea comp = new JTextArea();
		JButton btn = new JButton("click");
		frame.getContentPane().add(comp, BorderLayout.CENTER);
		frame.getContentPane().add(btn, BorderLayout.SOUTH);
 
		btn.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent ae) {
				comp.setText("Button has been clicked");
			}
		});
 
		int width = 300;
		int height = 300;
		frame.setSize(width, height);
 
		frame.setVisible(true);
	}
}

Explicación paso a paso

En primer lugar, necesitamos un contenedor como un marco, una ventana o un applet para mostrar componentes como paneles, botones, áreas de texto, etc.

JFrame frame = new JFrame("Frame Title");

Cree algunos componentes como paneles, botones, áreas de texto, etc.

final JTextArea comp = new JTextArea();
JButton btn = new JButton("click");

Agregue componentes al área de visualización y organice su diseño utilizando los LayoutManagers.

frame.getContentPane().add(comp,BorderLayout.CENTER);
frame.getContentPane().add(btn, BorderLayout.SOUTH);

Adjunte un oyente al componente de botón. La interacción con un componente provoca que se produzca un evento. Para asociar una acción de usuario con un componente, adjunte un escucha.

Aquí el método addActionListener es el método de observador de registro del sujeto. Para obtener un ejemplo completo del patrón de diseño de Observer, vaya al ejemplo de Observer.

btn.addActionListener(new ActionListener(){
       public void actionPerformed(ActionEvent ae){
             comp.setText("Button has been clicked");
       }
});

ActionListener de interfaz pública extiende EventListener

La interfaz de escucha sirve para recibir eventos de acción. La clase (Main, en este caso) que está interesada en procesar un evento de acción implementa esta interfaz, y el objeto creado con esa clase se registra con un componente, utilizando el método addActionListener del componente. Cuando ocurre el evento de acción, se invoca el método actionPerformed de ese objeto.

Muestre el marco.

int width = 300;
int height = 300;
frame.setSize(width, height);
frame.setVisible(true);

Este trabajo está traducido de un sitio web extranjero que utiliza historias antiguas para explicar los patrones de diseño.

1. ¿Qué es el patrón Proxy / Agent?

Estoy demasiado ocupado para responder a su solicitud, así que vaya a mi proxy. El apoderado debe saber lo que puede hacer el delegador. Es decir, tienen la misma interfaz. El apoderado no puede hacer el trabajo, pero el delegador puede hacerlo. ¡Los personajes que no entiendes pueden ser totalmente ignorados!

2. Historia de patrón proxy

Aquí hay una historia divertida que traduje de «Water Margin». Puede que ya no suene gracioso después de que lo traduzca. Pero de cualquier forma, tienes la idea de un patrón de diseño de proxy.

Aquí está la situación:

Algún mal hombre, por las razones que sea, siempre quiere acostarse con la esposa de algún buen hombre. Entre esas esposas, algunas quieren acostarse con esos hombres malos, pero otras no. Los malos no pueden preguntar directamente a esas esposas. Porque no están seguros de si al que le preguntan le gustaría hacer cosas malas. Sería una situación muy mala si juzga mal. Entonces debería haber un agente / apoderado para hacer este tipo de negocios por esos hombres malos.

Tenemos los siguientes roles en esta situación.

CheatingWife / SluttyWife: una interfaz que define lo que suelen hacer, como seducir a los hombres y ser felices con los hombres.
HouseWifeOne: ella es una esposa guarra en casa.
Mike: que quiere acostarse con las esposas de otros hombres.
Agente comercial: realice este tipo de negocios de consultoría.

3. Diagrama de clases de patrón de proxy

4. Código Java

1. Defina el tipo de esposa infiel
2. define una esposa infiel No. 1
3. Defina el mal agente
4. Deja que los hombres malos empiecen a hacer cosas malas.

interface CheatingWife {
	// think about what this kind of women can do
	public void seduceMan(); // such as eye contact with men
 
	public void happyWithMan(); // happy what? You know that.
}
 
class HouseWifeOne implements CheatingWife {
 
	public void seduceMan() {
		System.out
				.println("HouseWifeOne secude men, such as making some sexy poses ...");
	}
 
	public void happyWithMan() {
		System.out.println("HouseWifeOne is happy with man ...");
	}
}
 
class BusinessAgent implements CheatingWife {
	private CheatingWife cheatingWife;
 
	public BusinessAgent() {
 
		this.cheatingWife = new HouseWifeOne();
	}
 
	public BusinessAgent(CheatingWife cheatingWife) {
		this.cheatingWife = cheatingWife;
	}
 
	public void seduceMan() {
		this.cheatingWife.seduceMan();
	}
 
	public void happyWithMan() {
		this.cheatingWife.happyWithMan();
	}
 
}
 
// see? it looks that agent/proxy is doing
public class Mike {
 
	public static void main(String[] args) {
		BusinessAgent businessAgent = new BusinessAgent();
		businessAgent.seduceMan();
		businessAgent.happyWithMan();
	}
}

En resumen, Observer Pattern = editor + suscriptor.

El patrón de observador se ha utilizado en el oyente de acciones de la GUI. El ejemplo de Swing GUI muestra cómo funciona el oyente de acción como un observador.

El siguiente es un ejemplo típico sobre cazatalentos. Hay dos roles en este diagrama: HeadHunter y Demandante de empleo. Los solicitantes de empleo se suscriben a un cazatalentos, y el cazatalentos notifica a los solicitantes de empleo cuando hay una nueva oportunidad laboral.

Diagrama de clase

Código Java

Interfaz de sujeto.

public interface Subject {
	public void registerObserver(Observer o);
	public void removeObserver(Observer o);
	public void notifyAllObservers();
}

Interfaz de observador.

public interface Observer {
	public void update(Subject s);
}

La clase HeadHunter implementa Subject.

import java.util.ArrayList;
 
public class HeadHunter implements Subject{
 
	//define a list of users, such as Mike, Bill, etc.
	private ArrayList<Observer> userList;
	private ArrayList<String> jobs;
 
	public HeadHunter(){
		userList = new ArrayList<Observer>();
		jobs = new ArrayList<String>();
	}
 
	@Override
	public void registerObserver(Observer o) {
		userList.add(o);
	}
 
	@Override
	public void removeObserver(Observer o) {}
 
	@Override
	public void notifyAllObservers() {
		for(Observer o: userList){
			o.update(this);
		}
	}
 
	public void addJob(String job) {
		this.jobs.add(job);
		notifyAllObservers();
	}
 
	public ArrayList<String> getJobs() {
		return jobs;
	}
 
	public String toString(){
		return jobs.toString();
	}
}

JobSeeker es un observador.

public class JobSeeker implements Observer {
 
	private String name;
 
	public JobSeeker(String name){
		this.name = name;
	}
	@Override
	public void update(Subject s) {
		System.out.println(this.name + " got notified!");
		//print job list
		System.out.println(s);
	}
}

Punto de partida.

public class Main {
 
	public static void main(String[] args) {
		HeadHunter hh = new HeadHunter();
		hh.registerObserver(new JobSeeker("Mike"));
		hh.registerObserver(new JobSeeker("Chris"));
		hh.registerObserver(new JobSeeker("Jeff"));
 
		//Each time, a new job is added, all registered job seekers will get noticed.
		hh.addJob("Google Job");
		hh.addJob("Yahoo Job");
	}
}

Patrón de observador en JDK

java.util.EventListener

Ejemplo de GUI de swing

El patrón de estrategia también se denomina patrón de política.

Aquí hay una historia sobre el patrón de estrategia. Suponga que Mike a veces acelera cuando conduce, pero no siempre lo hace. Puede ser detenido por un oficial de policía. Es posible que la policía sea muy amable, que lo dejaría ir sin multa o con una simple advertencia. (Llamemos a este tipo de policía «NicePolice».) También es posible que sea atrapado por una policía dura y reciba una multa. (Llamemos a este tipo de policía «HardPolice».) No sabe qué tipo de policía lo detendría, hasta que lo atrapan, es decir, en tiempo de ejecución. Este es el objetivo del patrón de estrategia.

Diagrama de clases de patrones de estrategia

Patrón de estrategia Código Java

Definir una estrategia de interfaz, que tiene un método processSpeeding ()

public interface Strategy {
	//defind a method for police to process speeding case.
	public void processSpeeding(int speed);
}

Ahora tenemos dos tipos de agentes de policía.

public class NicePolice implements Strategy{
	@Override
	public void processSpeeding(int speed) {
		System.out.println("This is your first time, be sure don't do it again!");		
	}
}

public class HardPolice implements Strategy{
	@Override
	public void processSpeeding(int speed) {
		System.out.println("Your speed is "+ speed+ ", and should get a ticket!");
	}
}

Defina una situación en la que se verá involucrado un oficial de policía para procesar el exceso de velocidad.

public class Situation {
	private Strategy strategy;
 
	public Situation(Strategy strategy){
		this.strategy = strategy;
	}
 
	public void handleByPolice(int speed){
		this.strategy.processSpeeding(speed);
	}
}

Finalmente, pruebe el resultado.

public class Main {
	public static void main(String args[]){
		HardPolice hp = new HardPolice();
		NicePolice ep = new NicePolice();
 
		// In situation 1, a hard officer is met
                // In situation 2, a nice officer is met
		Situation s1 = new Situation(hp);
		Situation s2 = new Situation(ep);
 
		//the result based on the kind of police officer.
		s1.handleByPolice(10);
		s2.handleByPolice(10);        
	}
}

La salida es:

Your speed is 10, and should get a ticket!
This is your first time, be sure don't do it again!

Puede comparar este patrón con el patrón de estado que es muy similar. La principal diferencia es que el patrón de estado implica cambiar el comportamiento de un objeto cuando el estado del objeto cambia, mientras que el patrón de estrategia se trata principalmente de usar un algoritmo diferente en una situación diferente.

Patrón de estrategia en JDK

1). Java.util.Collections # sort (List lista, Comparador c)
2). java.util.Arrays # sort (T[], Comparador c)

La clasificar El método utiliza un comparador diferente en diferentes situaciones. Para saber más sobre este método, consulte Comprensión profunda de Arrays.sort ().

Es posible que también desee consultar la diferencia entre comparador y comparable.

El patrón de visitante es un patrón de diseño que se usa comúnmente en el analizador de un compilador, como Eclipse JDT AST Parser.

Básicamente, hay dos interfaces – Visitante y Elemento – en el patrón Visitante.

Historia de patrón de visitante

Supongamos que un visitante por primera vez llega a la ciudad de Nueva York. Quiere visitar la ciudad y la ciudad acepta su visita. Una vez que el visitante comienza a visitar, automáticamente visita todo y no necesita llamar a un método cuando quiere ir a un museo. ¡El viaje es un paquete!

Diagrama de clases de patrón de visitante

Pasos del patrón de visitante

Este diagrama muestra los pasos de la visita.

El proceso de trabajo es como el siguiente:

1. Se crean un visitante FirstTimeVisitor y un elemento City.
2. El programa comienza con «La ciudad acepta un visitante».
3. El método de aceptación en City define que permite que este visitante visite.
4. El visitante aceptado llama a su método sobrecargado «visita» para visitar esta ciudad.

Patrón de visitante código Java

import java.util.ArrayList;
 
interface Visitor {
	public void visit(City city);
	public void visit(Museum museum);
	public void visit(Park park);
}
 
class FirstTimeVisitor implements Visitor {
 
	@Override
	public void visit(City city) {
		System.out.println("I'm visiting the city!");
	}
 
	@Override
	public void visit(Museum museum) {
		System.out.println("I'm visiting the Museum!");
	}
 
	@Override
	public void visit(Park park) {
		System.out.println("I'm visiting the Park!");
	}
}
 
interface Element {
	public void accept(Visitor visitor);
}
 
class City implements Element {
 
	ArrayList<Element> places = new ArrayList<Element>();
 
	public City() {
		places.add(new Museum());
		places.add(new Park());
	}
 
	@Override
	public void accept(Visitor visitor) {
		System.out.println("City is accepting visitor.");
		visitor.visit(this);
 
		for (Element e : places) {
			e.accept(visitor);
		}
	}
}
 
class Museum implements Element {
	@Override
	public void accept(Visitor visitor) {
		System.out.println("Museum is accepting visitor.");
		visitor.visit(this);
	}
}
 
class Park implements Element {
	@Override
	public void accept(Visitor visitor) {
		System.out.println("Park is accepting visitor.");
		visitor.visit(this);
	}
 
}
 
public class TestVisitor {
	public static void main(String[] args) {
		FirstTimeVisitor visitor = new FirstTimeVisitor();
		City city = new City();
		city.accept(visitor);
	}
}

Producción:

Patrón de visitante en JDK

javax.lang.model.element.AnnotationValue obviamente use el patrón Visitor, pero no se usa comúnmente en proyectos regulares.

El patrón de diseño de estado es principalmente para cambiar el estado en tiempo de ejecución.

Historia de patrón de estado

Las personas pueden vivir con diferentes estados financieros. Pueden ser ricos o pueden ser pobres. Los dos estados, ricos y pobres, pueden convertirse el uno al otro de vez en cuando. La idea detrás del ejemplo: la gente normalmente trabaja más duro cuando es pobre y juega más cuando es rica. Lo que hacen depende del estado en el que viven. El estado se puede cambiar en función de sus acciones, de lo contrario, la sociedad no es justa.

Diagrama de clases de patrón de estado

Aquí está el diagrama de clases. Puede comparar esto con el patrón de estrategia para comprender mejor la diferencia.

Patrón de estado código Java

El siguiente ejemplo de Java muestra cómo funciona el patrón de estado.

Clases estatales.

package com.programcreek.designpatterns.state;
 
interface State {
	public void saySomething(StateContext sc);
}
 
class Rich implements State{
	@Override
	public void saySomething(StateContext sc) {
		System.out.println("I'm rick currently, and play a lot.");
		sc.changeState(new Poor());
	}
}
 
class Poor implements State{
	@Override
	public void saySomething(StateContext sc) {
		System.out.println("I'm poor currently, and spend much time working.");
		sc.changeState(new Rich());
	}
}

Clase StateContext

package com.programcreek.designpatterns.state;
 
public class StateContext {
	private State currentState;
 
	public StateContext(){
		currentState = new Poor();
	}
 
	public void changeState(State newState){
		this.currentState = newState;
	}
 
	public void saySomething(){
		this.currentState.saySomething(this);
	}
}

Clase principal para pruebas

import com.programcreek.designpatterns.*;
 
public class Main {
	public static void main(String args[]){
		StateContext sc = new StateContext();
		sc.saySomething();
		sc.saySomething();
		sc.saySomething();
		sc.saySomething();
	}
}

Resultado:

I'm poor currently, and spend much time working. 
I'm rick currently, and play a lot.
I'm poor currently, and spend much time working. 
I'm rick currently, and play a lot.

El patrón singleton es uno de los patrones más utilizados en Java. Se utiliza para controlar el número de objetos creados evitando la creación de instancias y modificaciones externas. Este concepto se puede generalizar a sistemas que operan de manera más eficiente cuando solo existe un objeto, o que restringen la instanciación a un cierto número de objetos, tales como:

1. constructor privado: ninguna otra clase puede crear una instancia de un nuevo objeto.
2. referencia privada – sin modificación externa.
3. El método estático público es el único lugar que puede obtener un objeto.

La historia de Singleton

Aquí hay un caso de uso simple. Un país solo puede tener un presidente. Entonces, cuando se necesita un presidente, el único presidente debe ser devuelto en lugar de crear uno nuevo. La getPresident() El método se asegurará de que siempre haya un solo presidente creado.

Diagrama y código de clase

Modo ansioso:

public class AmericaPresident {
	private static final AmericaPresident thePresident = new AmericaPresident();
 
	private AmericaPresident() {}
 
	public static AmericaPresident getPresident() {
		return thePresident;
	}
}

thePresident se declara como final, por lo que siempre contendrá la misma referencia de objeto.

Modo perezoso:

public class AmericaPresident {
	private static AmericaPresident thePresident;
 
	private AmericaPresident() {}
 
	public static AmericaPresident getPresident() {
		if (thePresident == null) {
			thePresident = new AmericaPresident();
		}
		return thePresident;
	}
}

Patrón Singleton utilizado en la biblioteca de soporte de Java

java.lang.Runtime#getRuntime() es un método de uso frecuente de la biblioteca estándar de Java. getRunTime() devuelve el objeto de tiempo de ejecución asociado con la aplicación Java actual.

class Runtime {
	private static Runtime currentRuntime = new Runtime();
 
	public static Runtime getRuntime() {
		return currentRuntime;
	}
 
	private Runtime() {}
 
	//... 
}

Aquí hay un ejemplo simple de uso getRunTime(). Lee una página web en un sistema Windows.

Process p = Runtime.getRuntime().exec(
		"C:/windows/system32/ping.exe programcreek.com");
//get process input stream and put it to buffered reader
BufferedReader input = new BufferedReader(new InputStreamReader(
		p.getInputStream()));
 
String line;
while ((line = input.readLine()) != null) {
	System.out.println(line);
}
 
input.close();

Producción:

Pinging programcreek.com [198.71.49.96] with 32 bytes of data:
Reply from 198.71.49.96: bytes=32 time=53ms TTL=47
Reply from 198.71.49.96: bytes=32 time=53ms TTL=47
Reply from 198.71.49.96: bytes=32 time=52ms TTL=47
Reply from 198.71.49.96: bytes=32 time=53ms TTL=47

Ping statistics for 198.71.49.96:
    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
    Minimum = 52ms, Maximum = 53ms, Average = 52ms

Otra implementación del patrón singleton

Como el constructor privado no protege de la creación de instancias a través de la reflexión, Joshua Bloch (Effective Java) propone una mejor implementación de Singleton. Si no está familiarizado con Enum, aquí es un buen ejemplo de Oracle.

public enum AmericaPresident{
	INSTANCE;
 
	public static void doSomething(){
		//do something
	}
}

* Gracias al comentario de Dan.

El patrón de adaptador se usa con frecuencia en los marcos de Java modernos.

Entra en su lugar cuando desea usar una clase existente y su interfaz no coincide con la que necesita, o desea crear una clase reutilizable que coopere con clases no relacionadas con interfaces incompatibles.

1. Historia del patrón de adaptador

La idea del adaptador se puede demostrar con el siguiente ejemplo simple. El propósito del problema de muestra es adaptar una naranja como una manzana.

En el diagrama inferior, el adaptador contiene una instancia de Orange y amplía Apple. Parece ser que después de que un objeto Orange obtiene una máscara adaptadora, ahora actúa como un objeto Apple.

2. Diagrama de clases de adaptadores

3. Código Java de patrón de adaptador

class Apple {
	public void getAColor(String str) {
		System.out.println("Apple color is: " + str);
	}
}
 
class Orange {
	public void getOColor(String str) {
		System.out.println("Orange color is: " + str);
	}
}
 
class AppleAdapter extends Apple {
	private Orange orange;
 
	public AppleAdapter(Orange orange) {
		this.orange = orange;
	}
 
	public void getAColor(String str) {
		orange.getOColor(str);
	}
}
 
public class TestAdapter {
	public static void main(String[] args) {
		Apple apple1 = new Apple();
		Apple apple2 = new Apple();
		apple1.getAColor("green");
 
		Orange orange = new Orange();
 
		AppleAdapter aa = new AppleAdapter(orange);
		aa.getAColor("red");
	}
 
}

De hecho, esta probablemente sea la idea más simple sobre el patrón de adaptador. Es posible que se utilice un adaptador de doble vía con más frecuencia. Para hacer un adaptador de doble canal, el adaptador requiere implementar dos interfaces y contiene las dos instancias. Sigue siendo una idea sencilla.

4. Patrón de adaptador utilizado en Java SDK

java.io.InputStreamReader (InputStream) (devuelve un lector)
java.io.OutputStreamWriter (OutputStream) (devuelve un escritor)

En un marco realmente grande, la idea puede no ser muy evidente. Por ejemplo, cómo se utiliza la idea del adaptador en Eclipse no es tan fácil de descubrir. Esta es una publicación sobre cómo se usa en Eclipse Runtime.