MITS4002 Object-Oriented Software Development Research Study

Desklib provides solved assignments and past papers to help students succeed.

MITS4002
OBJECT-ORIENTED SOFTWARE
DEVELOPMENT
Research Study
Student Name:
Student ID:
1 | P a g e

Table of Contents
Question 1..................................................................................................................................3
Question 2..................................................................................................................................6
(a)...........................................................................................................................................6
(b)...........................................................................................................................................7
(c)...........................................................................................................................................8
(d)...........................................................................................................................................9
References................................................................................................................................10
List of Figures
Figure 1: Factory Method Example...........................................................................................3
Figure 2: Singleton Example......................................................................................................4
Figure 3: Builder Pattern Example.............................................................................................5
Figure 4: Checkout Class Diagram............................................................................................7
Figure 5: Compute Price Class Diagram....................................................................................7
2 | P a g e

Question 1
Creative design patterns relate to the creation of objects. By creating objects in a very
controlled way, it reduces complexities and uncertainty. The operator "new" is mostly seen as
harmful because objects are dispersed throughout the application. With time, a change in
implementation can be challenging, because classes are closely linked. Creational patterns
address the problem by completely disconnecting the customer from the actual initialization
process.
There are various Creational Design Pattern types –
1. Factory Method
This method is the most commonly used design pattern in Java. It basically defines a
particular interface for the creation of an object but always gives the decision choice
to the subclasses on which of the classes to instantiate first. This design delegates
accountability for initially creating a virtual constructor type from those in the client
to a specific factory class. If an abstract class or an interface change very frequently
then this method is used. It’s used to replace the present implemented design pattern
as it’s adaptable to the new changes.
Figure 1: Factory Method Example
3 | P a g e

2. Singleton Method
This pattern is intended to ensure that only one particular object's instance exists in
the entire Java Virtual Machine and checks the initialization of objects of a specific
class. This class also has a single unified point of access on the object, so that only
that specific object is returned in each successive call to an access point. It’s cheap so
in any case where there are high expenses in creating the resources then this is used.
This pattern increases the overall performance. Classes that give access to the
application configuration.
Figure 2: Singleton Example
4 | P a g e

3. Builder Method
The Builder Design Pattern is also a creative pattern for manufacturing relatively
complex objects. The building pattern can spread the instantiation system using
another object to construct an object as the complicity of developing object increases.
When an object is created in a highly complex system, with many
compulsory parameters then the builder design pattern is used. When the number of
building parameters increases, a huge list of builders is created, then this is used. If
the customer expects various representations of the build object then this method is
used.
Figure 3: Builder Pattern Example
5 | P a g e

Question 2
(a)
For this problem, the best design pattern is the Builder design pattern. The reason for
choosing this design pattern is because it is a creative pattern for manufacturing relatively
complex objects. The building pattern can spread the instantiation system using another
object to construct an object as the complicity of developing object increases. With the help
of the step by step method, this design pattern is used in creating many same representations.
The original Builder Design Pattern adopted by GoF concentrates on abstraction and is quite
good throughout the treatment of complex objects. The constructor is also private to allow the
class only to be accessed by the builder. The builder object is provided as an argument
extracts all the characteristics set in the constructor. This design pattern is best in this case
because it is used in the below-mentioned cases –
 When an object is created in a highly complex system, with many
compulsory parameters.
 When the number of building parameters increases, a huge list of builders is created.
 If the customer expects various representations of the build object.
6 | P a g e

(b)
Checkout
Figure 4: Checkout Class Diagram
Compute Price
Figure 5: Compute Price Class Diagram
7 | P a g e

(c)
The benefits of incorporating the design pattern are as follows:
 If a problem in the analysis stage exists, the design pattern gives you an immediate,
quality solution. Design patterns facilitate design, but intellect still needs to be
applied. One needs to know once the pattern is applicable and how the specialization
in the pattern in the context is concerned. It is much easier to apply design patterns
than to solve first fundamental design problems, but this is yet not algorithmic.
 The fact that the development of software should be more like that of an engineering
discipline is easy. The procedures and methods could make it like a technology
discipline will be much harder to say. The presence of guides describing effective
solutions to common issues is among the characteristics of an engineering discipline.
Once the development of software is fully established as a restraint, the manual of
design patterns could be its main manual.
8 | P a g e

(d)
 Level of Abstractions
The reverse engineering process of the Java is achieved when the exe file classes are
disassembled into secondary assembly code and afterwards assembly code is
decompiled to achieve the high-level abstract concepts of byte code. This abstraction
at a higher level includes important sources of information, including variables,
methods, etc. The significant difference is really the lack of comments compared to
the real source code. The reverse engineering method, however, does not accurately
supply the source code. Many business and free software tools offer disassembly and
decompiled abilities.
 Pattern Composability
Composite patterns enable a tree-like structure and ask for a task from each node of
that same tree structure. It is used when one wants to present the whole part of the
object’s hierarchies. It is also used when one wants the customer to just ignore the
major differences between the individuals & the object’s composition. Then the
customer will behave as if all the objects present in the composite structure are
uniform in nature. One of the major demerits of this security pattern is that it makes
the tree-like structure very much general. The child classes will have to create
methods which are to just empty sometimes.
9 | P a g e

References
Yu, D., Zhang, Y., & Chen, Z. (2015). A comprehensive approach to the recovery of design
pattern instances based on sub-patterns and method signatures. Journal of Systems and
Software, 103, 1-16.
Chihada, A., Jalili, S., Hasheminejad, S. M. H., & Zangooei, M. H. (2015). Source code and
design conformance, design pattern detection from source code by classification approach.
Applied Soft Computing, 26, 357-367.
Hamid, B., Gürgens, S., & Fuchs, A. (2016). Security patterns modeling and formalization
for pattern-based development of secure software systems. Innovations in Systems and
Software Engineering, 12(2), 109-140.
10 | P a g e