Software Engineering for Students A Programming Approach

12.8 Model, view controller (observer, observable) 157
methods that provide all the functionality of the system. The detailed structure of the
system is hidden from its users. The façade class knows about the structure of the group
of classes and uses them as necessary. However, the classes in the group do not need to
know about the façade class, so any changes to the group do not impact on the users.
12.7 ● Immutable
An immutable object is one that, once created, does not change its state. In the cyberspace
invaders game, there could be objects that do not move and do not change while
the game is in progress. These objects do not change their state (their internal variables).
We can write an Immutable class by providing methods to access the values of
the object, but none to change them. The variables within an immutable class must not
be declared as constants, because they are changed (once) by the constructor method.
12.8 ● Model, view controller (observer, observable)
Many software systems have at their center a model or a simulation of the application of
interest. The simulation consists of objects and a set of rules governing how they interact.
In the cyberspace invaders game, the model consists of such objects as the alien, lasers and
bombs that move and interact according to certain rules. The model ensures that bombs
moves vertically. If a bomb strikes the defender, the user loses and the game is over.
The core model is surrounded by classes that support a user interface. The user interface
consists of two parts: the elements that control the system (inputs) and the elements
that allow us to view information (the outputs). In the game, the user moves the
mouse to move the defender object and can fire a laser by clicking on the mouse button.
These are controls. The screen shows the position of the objects, such as the alien
and a laser. These are outputs (the view).
To summarize, systems often have three components:
■ the model
■ the view
■ the controller.
The MVC pattern recognizes that many systems have this three-part structure –
model, view and controller – and that the software architecture should be explicitly partitioned
in the same way. This has the advantage that the view and/or the control can be
changed without changing the core. For example, the user could control the defender
object with a joystick instead of the mouse, or the display could be sent across the internet
to the screens of multiple players. So, if the system is partitioned, we can easily change
the view or the control or both.
For this pattern to work properly there has to be clear communication between the
three components:
■ when the user alters a control, the model must be told
■ when the model changes, the view must be told.