Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.



Source Code

/**
 * Defines an existing interface that needs adapting
 * 
 * @role __Adaptee
 */
public class Adaptee {
	/* Some adaptee-specific behavior */
	public void specificRequest() {
		// some adaptee specific stuff is going here
	}
}

/**
 * This class adapts the interface of Adaptee to the Target interface
 */

public class Adapter extends Target {
	/** reference to the object being adapted */
	private Adaptee adaptee;

	/**
	 * @param adaptMe
	 *            class to adapt whis this adapter
	 */
	public Adapter(Adaptee adaptMe) {
		this.adaptee = adaptMe;
	}

	/**
	 * Implementation of target method that uses adaptee to perform task
	 */
	public void request() {
		adaptee.specificRequest();
	}

}

/**
 * This class defines domain-specific interface used by client
 * 
 * @role __Target
 */

public abstract class Target {
	/** This method is called by client when he needs some domain-specific stuff */
	public abstract void request();
}
comments powered by Disqus

You might like also

Proxy
Provide a surrogate or placeholder for another object to control access to it. Options are provided to implement all interfaces of the subject class as well as all of the public methods of the subject classSource Code/** * Represents a proxy for Subject */ public class Proxy extends Subject } /** * Represents a real subject */ public class RealSubject extends Subject } /** * Represents a subject * * @role __Subject */ public abstract class Subject …
5269 Days ago
Flyweight
Use sharing to support large numbers of fine-grained objects efficiently.Source Code/** * Declares an interface through which flyweights can receive and act on * extrinsic state. * * @role __Flyweight */ public interface Flyweight /** * Represents extrinsic state of flyweight(s). * * @role __State */ public interface FlyweightContext /** * Implements the Flyweight interface and adds storage for intrinsic state, if * any. Objects of this class must be sharable. Any state it stores must be * intrinsic (independent …
5269 Days ago
Decorator
Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.Source Code/** * Defines the interface for objects that can have responsibilities added to the * dynamically. * * @role __Component */ public abstract class Component /** * Defines an object to which additional responsibilities can be attached. */ public class ConcreteComponent extends Component } /** * Adds responsibilities to the component. */ public class ConcreteDecorator extends Decorator /** * Behavior added by …
5269 Days ago
Bridge
Decouple an abstraction from its implementation so that the two can vary independently.from the gang of the fourSource Code/** * Defines Abstraction interface. Stores reference to implementation. * * @role __Abstraction */ public abstract class Abstraction /** * This sample operation delegates call to particular implementation */ public void someOperation() } /** * Concrete implementation */ public class ConcreteImplementorA extends Implementor } /** * Concrete implementation */ public class ConcreteImplementorB extends Implementor } /** * Defines interface for …
5269 Days ago