Structural pattern 3

Structural Pattern - 3
By,
D. B. Naga Muruga,
Dept of Mechanical Engineering,
Sriram Engineering College

Adapter Pattern
Define Adapter pattern
 Convert the existing interfaces to a new interface to achieve compatibility and reusability of the unrelated classes in
one application. Also known as Wrapper pattern.
 The Adapter pattern is used so that two unrelated interfaces can work together. The joining between them is called an
Adapter. This is something like we convert interface of one class into interface expected by the client. We do that using
an Adapter.
 Where to use & benefits
Try to match an interface(WindowAdapter, etc.)
Make unrelated classes work together.
Multiple compatibility.
Increase transparency of classes.
Make a pluggable kit.
Delegate objects.
Highly class reusable.
Achieve the goal by inheritance or by composition
Related patterns include
Proxy, which provides the same interface as its subject, whereas an adapter provides a different interface to the object
it adapts.
Decorator, which focuses on adding new functions to an object, whereas an adapter coordinates two different objects.
Bridge, which tries to separate an interface from its implementation and make an object vary independently, whereas
an adapter tries to change and cooperate the interface of an object.

Example of Adapter pattern
 The famous adapter classes in Java API are
WindowAdapter,ComponentAdapter, ContainerAdapter, FocusAdapter,
KeyAdapter, MouseAdapter and MouseMotionAdapter.
As you know, WindowListner interface has seven methods. Whenever
your class implements such interface, you have to implements all of
the seven methods. WindowAdapter class implements WindowListener
interface and make seven empty implementation. When you class
subclass WindowAdapter class, you may choose the method you want
without restrictions. The following give such an example.

 public interface Windowlistener {
public void windowClosed(WindowEvent e);
public void windowOpened(WindowEvent e);
public void windowIconified(WindowEvent e);
public void windowDeiconified(WindowEvent e);
public void windowActivated(WindowEvent e);
public void windowDeactivated(WindowEvent e);
public void windowClosing(WindowEvent e);
}
public class WindowAdapter implements WindowListner{
public void windowClosed(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowClosing(WindowEvent e){}
}
Here is a test program
import javax.swing.*;
import java.awt.event.*;
class Test extends JFrame {
public Test () {
setSize(200,200);
setVisible(true);
addWindowListener(new Closer());
}
public static void main(String[] args) {
new Test();
}
class Closer extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
}
To reuse classes and make new class compatible with existing ones. For
example, A clean system is already designed, you want to add more job in,
the Extra interface uses adapter pattern to plug in the existing system.
interface Clean {
public void makeClean();
}
class Office implements Clean{
public void makeClean() {
System.out.println("Clean Office");
}
}
class Workshop implements Clean{
System.out.println("Clean Workshop");
}
}
interface Extra extends Clean{
public void takeCare();
}
class Facility implements Extra{
System.out.println("Clean Facility");
}
 public void takeCare() {
System.out.println("Care has been taken");
}
}
 In order to reuse Workshop and Office classes,
we create an adapter interface Extra and
add new job takeCare in the system.
class Test {
static void Jobs (Extra job) {
if (job instanceof Clean)
((Clean)job).makeClean();
if ((Extra)job instanceof Extra)
((Extra)job).takeCare();
}
Extra e = new Facility();
Jobs(e);
Clean c1 = new Office();
Clean c2 = new Workshop();
c1.makeClean();
c2.makeClean();
e.makeClean();
}
}
Output :
Clean Facility
Care has been taken
Clean Office
Clean Workshop
Clean Facility
By composition, we can achieve adapter pattern. It is also called wrapper. For
example, a Data class has already been designed and well tested. You want to
adapt such class to your system. You may declare it as a variable and wrapper
or embed it into your class.
//well-tested class
class Data {
public void add(Info){}
public void delete(Info) {}
public void modify(Info){}
//...
}
//Use Data class in your own class
class AdaptData {
Data data;
public void add(Info i) {
data.add(i);
//more job
}
public void delete(Info i) {
data.delete(i);
//more job
}
public void modify(Info i) {
data.modify(i);
//more job
}
//more stuff here
//...
}

Bridge Pattern
Define bridge pattern
 Decouple an abstraction or interface from its implementation so that the two
can vary independently.
 The Bridge Pattern is used to separate out the interface from its
implementation. Doing this gives the flexibility so that both can vary
independently.
Want to separate abstraction and implementation permanently
Share an implementation among multiple objects
Want to improve extensibility
Hide implementation details from clients

 Abstract Factory, which can be used to create and configure a
particular bridge.
 Adapter, which makes unrelated classes work together, whereas a
bridge makes a clear-cut between abstraction and implementation.

Example of bridge pattern
 If you have a question database, you may want to
develop a program to display it based on the user
selection. The following is a simple example to show how
to use a Bridge pattern to decouple the relationship
among the objects.

 import java.util.*;
//abstraction
interface Question {
public void nextQuestion();
public void priorQuestion();
public void newQuestion(String q);
public void deleteQuestion(String q);
public void displayQuestion();
public void displayAllQuestions();
}
//implementation
class QuestionManager {
protected Question questDB; //instantiate it later
public String catalog;
public QuestionManager(String catalog) {
this.catalog = catalog;
}
public void next() {
questDB.nextQuestion();
}
public void prior() {
questDB.priorQuestion();
}
public void newOne(String quest) {
questDB.newQuestion(quest);
}
public void delete(String quest) {
questDB.deleteQuestion(quest);
}
public void display() {
questDB.displayQuestion();
}
public void displayAll() {
System.out.println("Question Catalog: " + catalog);
questDB.displayAllQuestions();
}
}
//further implementation
class QuestionFormat extends QuestionManager {
public QuestionFormat(String catalog){
super(catalog);
}
public void displayAll() {
System.out.println("n~~~~~~~~~~~~~~~~~~~~~~~~");
super.displayAll();
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
}
}
 //decoupled implementation
class JavaQuestions implements Question {
private List questions = new ArrayList();
private int current = 0;
public JavaQuestions() {
//load from a database and fill in the container
questions.add("What is Java? ");
questions.add("What is an interface? ");
questions.add("What is cross-platform? ");
questions.add("What is UFT-8? ");
questions.add("What is abstract? ");
questions.add("What is Thread? ");
questions.add("What is multi-threading? ");
}
public void nextQuestion() {
if( current <= questions.size() - 1 )
current++;
}
public void priorQuestion() {
if( current > 0 )
current--;
}
public void newQuestion(String quest) {
questions.add(quest);
}
public void deleteQuestion(String quest) {
questions.remove(quest);
}
public void displayQuestion() {
System.out.println( questions.get(current) );
}
public void displayAllQuestions() {
for (String quest : questions) {
System.out.println(quest);
}
}
}
class TestBridge {
QuestionFormat questions = new QuestionFormat("Java Language");
questions.questDB = new JavaQuestions();//can be hooked up with other
question class
//questions.questDB = new CsharpQuestions();
//questions.questDB = new CplusplusQuestions();
questions.display();
questions.next();
questions.newOne("What is object? ");
questions.newOne("What is reference type?");
questions.displayAll();
}
}

 //need jdk1.5 to compile
Output :
What is Java?
~~~~~~~~~~~~~~~~~~~~~~~~
Question Catalog: Java Language
What is Java?
What is an interface?
What is cross-platform?
What is UFT-8?
What is abstract?
What is Thread?
What is multi-threading?
What is object?
What is reference type?
~~~~~~~~~~~~~~~~~~~~~~~~
Note that the JavaQuestion class can be launched independently
and work as its own system. Here we just show you how to use
Bridge pattern to decouple the interface from its implementation.

Composite pattern
Define Composite pattern
 Build a complex object out of elemental objects and itself like a tree structure.
 In developing applications, we come across components which are individual
objects and also can be collection of objects. Composite pattern can represent
both the conditions. In this pattern, you can develop tree structures for
representing part-whole hierarchies.
Want to represent a part-whole relationship like tree folder system
Group components to form larger components, which in turn can be grouped to
form still larger components.

 Decorator, which is often used with composite pattern and with the same
parent class.
 Flyweight, which is used with composite pattern to share components.
 Iterator, which is used to traverse the composites.
 Visitor, which localizes operations across composite and leaf classes.

Example of composite pattern
 A component has many elements and itself which has many
elements and itself, etc. A file system is a typical example. Directory
is a composite pattern. When you deal with Directory object, if
isFile() returns true, work on file, if isDirectory() returns true, work on
Directory object.

class Directory {
Directory dir;
File[] f;
...
boolean isDirectory() {
return f == null;
}
boolean isFile() {
return f != null;
}
File getFile(int i) {
if (isFile())
return f[i];
return null'
}
Directory getDirectory() {
if (isDirectory())
return dir;
return null;
}
....
}
For example, General Manager may have several employees and some of
employees are Managers which have several employees. To illustrate such issue, we
design a simple Manager class.
class Employee {
String name;
double salary;
Employee(String n, double s){
name = n;
salary = s;
}
String getName() {
return name;
}
double getSalary() {
return salary;
}
public String toString() {
return "Employee " + name;
}
}
class Manager {
Manager mgr;
Employee[] ely;
String dept;
Manager(Manager mgr,Employee[] e, String d ) {
this(e, d);
this.mgr = mgr;
}
Manager(Employee[] e, String d) {
ely = e;
dept =d;
}
String getDept() {
return dept;
}
Manager getManager() {
return mgr;
}
Employee[] getEmployee() {
return ely;
}
public String toString() {
return dept + " manager";
}
}
class Test {
Employee[] e1 = {new Employee("Aaron", 50),
new Employee("Betty", 60)};
Manager m1 = new Manager(e1, "Accounting");
Employee[] e2 = {new Employee("Cathy", 70),
new Employee("Dan", 80),
new Employee("Eliz", 90)};
Manager m2 = new Manager(m1, e2, "Production");
System.out.println(m2);
Employee[] emp = m2.getEmployee();
if (emp != null)
for (int k = 0; k < emp.length; k++)
System.out.println(" "+emp[k]+" Salary: $"+
emp[k].getSalary());
Manager m = m2.getManager();
System.out.println(" " + m);
if (m!= null) {
Employee[] emps = m.getEmployee();
if (emps != null)
for (int k = 0; k < emps.length; k++)
System.out.println(" " + emps[k]+" Salary: $"+
emps[k].getSalary());
}
}
}
Output :
Production manager
Employee Cathy Salary: $70.0
Employee Dan Salary: $80.0
Employee Eliz Salary: $90.0
Accounting manager
Employee Aaron Salary: $50.0
Employee Betty Salary: $60.0

Decorator Pattern
Define decorator pattern
 Attach additional responsibilities or functions to an object dynamically or statically. Also known
as Wrapper.
 The decorator pattern helps to add behavior or responsibilities to an object. This is also called
“Wrapper”. Suppose we have some 6 objects and 2 of them need a special behavior, we can do
this with the help of a decorator.
Provide an alternative to subclassing.
Add new function to an object without affecting other objects.
Make a responsibility easily added and removed dynamically.
More flexibility than static inheritance.
Transparent to the object.

 Adapter pattern, which provides a different interface to the object it adapts,
whereas a decorator changes an object's responsibilities,
 Proxy pattern, which controls access to the object, whereas a decorator
focuses on adding new functions to an object,
 Composite pattern, which aggregates an object, whereas a decorator adds
additional responsibilities to an object, and
 Strategy pattern, which changes the guts of an object, whereas a decorator
changes the skin of an object.
 Facade pattern, which provides a way of hiding a complex class, whereas a
decorator adds function by wrapping a class.

Example of decorator pattern
 A JScrollPane object can be used to decorate a JTextArea object or a
JEditorPane object. A window can be decorated with different borders like
BevelBorder, CompoundBorder, EtchedBorder TitledBorder etc. These border
classes working as decorators are provided in Java API.
Decorator pattern can be used in a non-visual fashion. For example,
BufferedInputStream, DataInputStream, and CheckedInputStream are
decorating objects of FilterInputStream class. These decorators are standard
Java API classes.
To illustrate a simple decorator pattern in non-visual manner, we design a
class that prints a number. We create a decorator class that adds a text to
the Number object to indicate that such number is a random number. Of
course we can subclass the Number class to achieve the same goal. But the
decorator pattern provides us an alternative way.

 import java.util.Random;
class Number {
public void print() {
System.out.println(new Random().nextInt());
}
}
class Decorator {
public Decorator() {
System.out.print("Random number: ");//add a description to the number printed
new Number().print();
}
}
class SubNumber extends Number{
public SubNumber() {
super();
System.out.print("Random number: ");
print();
}
}
class Test {
new Decorator();
new SubNumber();
}
}
Output :
Random number: 145265744
Random number: 145265755

Facade Pattern
Define facade pattern
 Make a complex system simpler by providing a unified or general interface, which is a higher layer to
these subsystems.
 Facade as the name suggests means the face of the building. The people walking past the road can
only see this glass face of the building. They do not know anything about it, the wiring, the pipes and
other complexities. The face hides all the complexities of the building and displays a friendly face.
Want to reduce complexities of a system.
Decouple subsystems , reduce its dependency, and improve portability.
Make an entry point to your subsystems.
Minimize the communication and dependency between subsystems.
Security and performance consideration.
Shield clients from subsystem components.
Simplify generosity to specification.

 Abstract Factory, which is often used to create an interface for a
subsystem in an independent way, and can be used as an
alternative way to a facade.
 Singleton, which is often used with a facade.
 Mediator, which is similar to facade, but a facade doesn't define
new functionality to the subsystem.

Example of facade pattern
 JDBC design is a good example of Façade pattern. A database design is
complicated. JDBC is used to connect the database and manipulate data
without exposing details to the clients.
Security of a system may be designed with Façade pattern. Clients'
authorization to access information may be classified. General users may be
allowed to access general information; special guests may be allowed to
access more information; administrators and executives may be allowed to
access the most important information. These subsystems may be generalized
by one interface. The identified users may be directed to the related
subsystems.

 interface General {
public void accessGeneral();
}
interface Special extends General {
public void accessSpecial();
}
interface Private extends General {
public void accessPrivate();
}
class GeneralInfo implements General {
public void accessGeneral() {
//...
}
//...
}
class SpecialInfo implements Special{
public void accessSpecial() {
//...
}
public void accessGeneral() {}
//...
}
class PrivateInfo implements Private, Special {
public void accessPrivate() {
// ...
}
//...
}
// ...
}
//...
}
class Connection {
//...
if (user is unauthorized) throw new Exception();
if (user is general) return new GeneralInfo();
if (user is special) return new SpecialInfo();
if (user is executive) return new PrivateInfo();
//...
}
 The above code example illustrates that the whole system is not
exposed to the clients. It depends on the user classification.
Mr. SudHakar Chavali proposes a better design, similar to the above,
but avoids repeated code. Look at code below.
interface General {
public void accessGeneral();
}
interface Special extends General {
public void accessSpecial();
}
interface Private extends General {
public void accessPrivate();
}
class GeneralInfo implements General {
//...
}
//...
}
class SpecialInfo extends GeneralInfo implements Special{
//...
}
}
class PrivateInfo extends SpecialInfo implements Private {
public void accessPrivate() {
// ...
}
//...
}
To avoid repeated code, SpecialInfo become subclass of GeneralInfo
and PrivateInfo becomes subclass of SpecialInfo. When a person is
exposed to special information, that person is allowed to access
general information also. When a person is exposed to private
information, that person is allowed to access general information and
special information also.

Flyweight Pattern
Define flyweight pattern
 Make instances of classes on the fly to improve performance efficiently, like individual
characters or icons on the screen.
 The pattern here states about a mechanism by which you can avoid creating a large
number of object instances to represent the entire system.
Need to instantiate a large amount of small and fine-grained classes.
Need icons to represent object.
An object extrinsic state can be shared by classes.
Reduce the number of objects created, decrease memory footprint and increase
performance.
Increase runtime cost associated with transferring, finding, or computing extrinsic data.

 Composite, which supports recursive structures, whereas an
flyweight is often applied on it.
 Factory Method, which produces specific object upon requirement,
whereas an flyweight uses it to reduce objects.
 State, which allows an object to alter its behavior when its internal
state is changed, whereas a flyweight is best implemented on it.
 Strategy, which allows an algorithm vary independently to suit its
needs, whereas a flyweight is based on such strategy.

Example of flyweight pattern
 In order to share an object, we may declare an interface and an
intrinsic state through which flyweights can receive and act on it. If
you want to show a file system with folders to show the directories
or subdirectories, you don't need to load all the files or directories at
one loading time. You may show the upper level folders first. If the
user clicks a folder, then load its subdirectories and files. The shared
trigger is mouse-clicked. The composite pattern may be combined
to define the flyweight system.

 class Folder {
void draw(..) {}
}
class FolderFactory {
...
if (selected) {
return aFolder;
else
return aFile;
...
}
...
To show how to use flyweight to reduce object creation, we will make a
program to draw 1000 circles with 6 different colors. Before we customize it
to a flyweight design, it is coded as follows:
import java.awt.*;
import java.awt.Color;
import javax.swing.event.*;
class Test extends JFrame{
private static final Color colors[] = { Color.red, Color.blue,
Color.yellow, Color.orange,
Color.black, Color.white };
private static final int WIDTH_ = 400,
HEIGHT = 400,
NUMBER_OF_CIRCLES = 1000;
public Test() {
Container contentPane = getContentPane();
JButton button = new JButton("Draw Circle");
final JPanel panel = new JPanel();
contentPane.add(panel, BorderLayout.CENTER);
contentPane.add(button, BorderLayout.SOUTH);
setSize(WIDTH,HEIGHT);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
Graphics g = panel.getGraphics();
for(int i=0; i < NUMBER_OF_CIRCLES; ++i) {
g.setColor(getRandomColor());
int r = getRandomR();
g.drawOval(getRandomX(), getRandomY(), r, r);
}
}
});
}
 private int getRandomX() {
return (int)(Math.random()*WIDTH );
}
private int getRandomY() {
return (int)(Math.random()*HEIGHT);
}
private int getRandomR() {
return (int)(Math.random()*(HEIGHT/10));
}
private Color getRandomColor() {
return colors[(int)(Math.random()*colors.length)];
}
Test test = new Test();
}
}
Copy, paste above code, and run it to see the functionality.
Output :

 Note that the above program doesn't take advantage of reusability of OOP.
We will customize it and make a Circle object, so the Circle object can be
reused.
class Circle {
private Color color;
public Circle(Color color) {
this.color = color;
}
public void draw(Graphics g, int x, int y, int r) {
g.setColor(color);
g.drawOval(x, y, r, r);
}
}
Then we rewrite the program. It is possible for people to rewrite with Circle
object in the following way:
import java.awt.*;
class Test extends JFrame{
private static final int WIDTH = 400,
HEIGHT = 400,
public Test() {
setSize(WIDTH ,HEIGHT);
setVisible(true);
Circle circle = new Circle(getRandomColor());
circle.draw(g, getRandomX(), getRandomY(), getRandomR());//1000
object created.
}
}
});
}
 private int getRandomX() {
}
}
}
}
}
}
From the above code, you may note that 1000 circle object has been created.
It is memory consuming.
To improve it, we will create a CircleFactory class to customize it by using
flyweight design pattern. Since we just draw circle with different colors, we
can store color info in a hashmap. If a circle has been drawn, the new circle
will be checked with color. If the circle with the same color has been found in
the hashmap, the circle will share the instance which is picked up from the
hashmap instead of creating a new one. We will reuse the object with
different state, that is to say we will share the instance and draw the circle
with different start position and radius on the fly.
class CircleFactory {
//store color
private static final HashMap circleByColor = new HashMap();
public static Circle getCircle(Color color) {
Circle circle = (Circle)circleByColor.get(color);
if(circle == null) {
circle = new Circle(color);
circleByColor.put(color, circle);
System.out.println("Creating " + color + " circle");//see how many
objects we create on command line
}
return circle;
}
}
So our test program will be coded as follows:
import java.awt.*;
import java.util.HashMap;

 class Test extends JFrame{
private static final int WIDTH = 400,
HEIGHT = 400,
public Test() {
setSize(WIDTH,HEIGHT);
setVisible(true);
Circle circle = CircleFactory.getCircle(getRandomColor());
circle.draw(g, getRandomX(),
getRandomY(),getRandomR());
//Since we have 6 different colors, we have 6 objects
created.
}
}
});
}
}
private int getRandomX() {
}
}
}
}
}
 class CircleFactory {
private static final HashMap circleByColor = new HashMap();
public static Circle getCircle(Color color) {
Circle circle = (Circle)circleByColor.get(color);
if(circle == null) {
circle = new Circle(color);
circleByColor.put(color, circle);
System.out.println("Creating " + color + " circle");
}
return circle;
}
}
class Circle {
private Color color;
public Circle(Color color) {
this.color = color;
}
public void draw(Graphics g, int x, int y, int r) {
g.setColor(color);
g.drawOval(x, y, r, r);
}
}
Copy, paste above code and run it. You will see the printout from the
command line, that you only have 6 objects created, not 1000 objects
because you only have 6 colors. Such a big reduction of object
creation will improve your program performance dramatically.
Output :
Creating java.awt.Color[r=255,g=0,b=0] circle

 Flyweight design is effective with instantiating a large amount of small and fine-
grained classes by combining with factory design pattern.
If you have jdk1.5 installed, you may need to use a tool to check if you save the
memory by running your commands as follows:
C:> java -Dcom.sun.management.jmxremote Test
And open another console as follows:
C:> jconsole
The jconsole tool will hook up your program Test to give your statistic numbers
about your program, such as threads, heap, memory, VM, etc.
String class is designed with Flyweight design pattern. It has similar structure as above
example. When you create a string constant, such constant is stored in a pool. When
the second string is created, it will be checked to see if it has been created. If it is true,
the second string instance will be picked up from the string pool instead of creating a
new one. This is why the following code makes sense, but bothers many people.
String s1 = "hello";
String s2 = "hello"; //store in a string pool.
String s3 = new String("hello");
System.out.println(s1==s2); //true, share the same memmory address
System.out.println(s1==s3); //false

Proxy Pattern
Define proxy pattern
 Use a simple object to represent a complex one or provide a placeholder for another object to
control access to it.
 The proxy pattern is used when you need to represent a complex with a simpler one. If creation
of object is expensive, its creation can be postponed till the very need arises and till then, a
simple object can represent it. This simple object is called the “Proxy” for the complex object
If creating an object is too expensive in time or memory.
Postpone the creation until you need the actual object.
Load a large image (time consuming).
Load a remote object over network during peak periods.
Access right is required to a complex system.

 Adapter pattern, which provides a different interface to the
object it adapts, whereas a proxy provides the same interface as
its subject, and
 Decorator pattern, which focuses on adding new functions to an
object, whereas a proxy controls access to the object.

Example of proxy pattern
 When loading a large image, you may create some light object to
represent it until the image is loaded completely. Usually a proxy
object has the same methods as the object it represents. Once the
object is loaded, it passes on the actual object. For example,

 abstract class Graphic {
public abstract void load();
public abstract void draw();
...
}
class Image extends Graphic{
public void load() {
...
}
public void draw() {
...
}
...
}
class ImgProxy extends Graphic {
public void load() {
if(image == null) {
image = new Image(filename);
}
...
public void draw() {
...
}
...
}

Structural pattern 3

More Related Content

What's hot (20)

Similar to Structural pattern 3 (20)

More from Naga Muruga (20)

Recently uploaded (20)

Structural pattern 3