Design Patterns
239 pág.

Design Patterns

DisciplinaEngenharia de Software I7.548 materiais73.384 seguidores
Pré-visualização50 páginas
that they can also be iterated over e.g., using
a for loop. (In Python 3, next() was replaced with __next__().)[2]
[1][1] Gang Of Four
[2] "Python v2.7.1 documentation: The Python Standard Library: 5. Built-in Types" (http:/ / docs. python. org/ library/ stdtypes. html). .
Retrieved 2 May 2011.
External links
\u2022 Object iteration (http:/ / us3. php. net/ manual/ en/ language. oop5. iterations. php) in PHP
\u2022 Iterator Pattern (http:/ / www. dofactory. com/ Patterns/ PatternIterator. aspx) in C#
\u2022 Iterator pattern in UML and in LePUS3 (a formal modelling language) (http:/ / www. lepus. org. uk/ ref/
companion/ Iterator. xml)
\u2022 SourceMaking tutorial (http:/ / sourcemaking. com/ design_patterns/ iterator)
\u2022 Iterator Pattern (http:/ / c2. com/ cgi/ wiki?IteratorPattern)
Mediator pattern 140
Mediator pattern
The mediator pattern defines an object that encapsulates how a set of objects interact. This pattern is considered to
be a behavioral pattern due to the way it can alter the program's running behavior.
Usually a program is made up of a (sometimes large) number of classes. So the logic and computation is distributed
among these classes. However, as more classes are developed in a program, especially during maintenance and/or
refactoring, the problem of communication between these classes may become more complex. This makes the
program harder to read and maintain. Furthermore, it can become difficult to change the program, since any change
may affect code in several other classes.
With the mediator pattern, communication between objects is encapsulated with a mediator object. Objects no
longer communicate directly with each other, but instead communicate through the mediator. This reduces the
dependencies between communicating objects, thereby lowering the coupling.
The essence of the Mediator Pattern is to "Define an object that encapsulates how a set of objects interact. Mediator
promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their
interaction independently. ".[1]
In the following example a mediator object controls the status of three collaborating buttons: for this it contains three
methods (book(),view() and search()) that set the status of the buttons. The methods are called by each
button upon activation (via the execute() method in each of them).
Hence here the collaboration pattern is that each participant (here the buttons) communicates to the mediator its
activity and the mediator dispatches the expected behavior to the other participants.
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
//Colleague interface
interface Command {
 void execute();
//Abstract Mediator
interface IMediator {
 void book();
 void view();
 void search();
 void registerView(BtnView v);
 void registerSearch(BtnSearch s);
Mediator pattern 141
 void registerBook(BtnBook b);
 void registerDisplay(LblDisplay d);
//Concrete mediator
class Mediator implements IMediator {
 BtnView btnView;
 BtnSearch btnSearch;
 BtnBook btnBook;
 LblDisplay show;
 void registerView(BtnView v) {
 btnView = v;
 void registerSearch(BtnSearch s) {
 btnSearch = s;
 void registerBook(BtnBook b) {
 btnBook = b;
 void registerDisplay(LblDisplay d) {
 show = d;
 void book() {
 void view() {
 void search() {
Mediator pattern 142
//A concrete colleague
class BtnView extends JButton implements Command {
 IMediator med;
 BtnView(ActionListener al, IMediator m) {
 med = m;
 public void execute() {
//A concrete colleague
class BtnSearch extends JButton implements Command {
 IMediator med;
 BtnSearch(ActionListener al, IMediator m) {
 med = m;
 public void execute() {;
//A concrete colleague
class BtnBook extends JButton implements Command {
 IMediator med;
 BtnBook(ActionListener al, IMediator m) {
Mediator pattern 143
 med = m;
 public void execute() {;
class LblDisplay extends JLabel {
 IMediator med;
 LblDisplay(IMediator m) {
 super("Just start...");
 med = m;
 setFont(new Font("Arial", Font.BOLD, 24));
class MediatorDemo extends JFrame implements ActionListener {
 IMediator med = new Mediator();
 MediatorDemo() {
 JPanel p = new JPanel();
 p.add(new BtnView(this, med));
 p.add(new BtnBook(this, med));
 p.add(new BtnSearch(this, med));
 getContentPane().add(new LblDisplay(med), "North");
 getContentPane().add(p, "South");
 setSize(400, 200);
 public void actionPerformed(ActionEvent ae) {
 Command comd = (Command) ae.getSource();
 public static void main(String[] args) {
 new MediatorDemo();
Mediator pattern 144
Mediator - defines the interface for communication between Colleague objects
ConcreteMediator - implements the Mediator interface and coordinates communication between Colleague objects.
It is aware of all the Colleagues and their purpose with regards to inter communication.
ConcreteColleague - communicates with other Colleagues through its Mediator
[1][1] Gang Of Four
External links
\u2022 Mediator Design Pattern (http:/ / sourcemaking. com/ design_patterns/ mediator)
Memento pattern
The memento pattern is a software design pattern that provides the ability to restore an object to its previous state
(undo via rollback).
The memento pattern is implemented with two objects: the originator and a caretaker. The originator is some object
that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the
change. The caretaker first asks the originator for a memento object. Then it does whatever operation (or sequence of
operations) it was going to do. To roll back to the state before the operations, it returns the memento object to the
originator. The memento object itself is an opaque object (one which the caretaker cannot, or should not, change).
When using this pattern, care should be taken if the originator may change other objects or resources - the memento
pattern operates on a single object.
Classic examples of the memento pattern include the seed of a pseudorandom number generator (it will always
produce the same sequence thereafter when initialized with the seed state) and the state in a finite state machine.