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 class



Source Code

/**
 * Represents a proxy for Subject
 */
public class Proxy extends Subject {
	/**
	 * Holds the subject instance.
	 */
	private Subject subject;

	/** @see patterns.gof.proxy.SubjectsampleMethod() */
	public int sampleMethod() {
		return subject.sampleMethod();
	}
}

/**
 * Represents a real subject
 */

public class RealSubject extends Subject {
	public int sampleMethod() {
		/* something happens here */
		return 0;
	}
}

/**
 * Represents a subject
 * 
 * @role __Subject
 */

public abstract class Subject {
	/**
	 * This is sample method to be called by proxy
	 */
	public abstract int sampleMethod();
}
comments powered by Disqus

You might like also

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 …
5207 Days ago
Adapter
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 } /** * This class adapts the interface of Adaptee to the Target interface */ public class Adapter extends Target /** * Implementation of target method that uses adaptee to perform task */ public void request() } /** …
5207 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 …
5207 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 …
5207 Days ago