Software Development: Creational Patterns and UML Diagram Designs

This report discusses the application of creational design patterns in software development to enhance productivity, focusing on object creation mechanisms and addressing program complexity. It explores various creational patterns like Builder, Singleton, Object Pool, Abstract Factory, Factory, and Prototype, detailing their functionalities and benefits, such as memory management and loose coupling. The report also includes UML diagrams designed using draw.io, illustrating the 'Compute Price' and 'Checkout' processes, showcasing class structures, methods, and data types to clarify system analysis and object-oriented connections. The assessment concludes by emphasizing the role of these patterns in solving software development problems and simplifying complex systems.

Contents
Introduction...........................................................................................................................................2
Q1: Describe how software development productivity can be accomplished by the application of
various Creational Design Patterns........................................................................................................3
Q2: UML diagram.................................................................................................................................5
2.1: Use UML diagram to design Compute Price..............................................................................5
2.2 Use UML diagram to design Checkout........................................................................................5
Conclusion.............................................................................................................................................7
References:............................................................................................................................................8
List of figures
Figure 1: Class 1....................................................................................................................................5
Figure 2: Class 2....................................................................................................................................6

Introduction
The report has the creational pattern which shows the different types of the application which
have the OO design which has to solve the program by class the pattern. There are different
patterns which have different types of application. This deals with the object creation and
also helps to have the focus on the mechanism of the object creation. There are different
types of use case diagram made which will help the user to understand the system analysis
and the object-oriented. There is tool used for the design of the class case diagram is draw.io
tool which is the simplest tool for the diagram to understand and make.

Q1: Describe how software development productivity can be accomplished by the
application of various Creational Design Patterns.
The creational pattern is a way to create the objects, at the time of the instantiate of class.
This helps to create the object. This has the various methods of the object to which they are
created. The word used in the language known as JAVA this have the hard code which does
not have the object creation method, therefore, there is use of creational pattern which will be
done with the help of programming and also there are various methods to call the class or
method through the objects. There is development of the software which uses the SDLC
model and follows all the phases of model to have the best software, therefore, the issues are
rectified by the help of pattern and through the creational patterns because this improves the
complexity of the program. There is use of inheritance in JAVA, therefore, the classes are
called with the help of the objects of the patters and this helps to reduce the complexity
(Sunitha, and Samuel, 2019).
There are various types of creational patterns let us see that to have more skills:
1. Builder Pattern: this pattern is to construct the complex objects with the use of simple
objects and this uses the simple approaches of the design patterns. The objects will be created
into the single-step just like the deserialization of complex object. This provides the various
separation of the object which helps for the representation of objects. It has control on the
process of construction and this also supports the change of the inner representation of object.
2. Singleton Pattern: This has the only one object which provides access in whole program.
The single instance will have only one object and can be used in the other classes. There are
early instantiation and Lazy instantiation which have the two forms of the design patterns.
The early instantiation will be for creation of the object at the time of load. The Lazy
instantiation will be for creation of the object at the time where is it required. This helps to
save the memory by not each request of the object. There is single object which can be used
in the program again and again. This uses the multithread and database creation of the
applications which have to log off with the thread pools or setting of the configurations.
3. Object pool Pattern: this is to reuse the object which is more expensive to create the
objects. The pools of the object have the containers which have the specified amount of the
objects. The object of the pool might not available for the pool to pool it back. It enhances the

performance of the application, have the most effective situation of the rate of initialization of
high class of the object. This has to manage the connection which provides the way to reuse
the object and also helps to share it. This has the application object which required the
expensive to create. There are several clients who might have some resources.
4. Abstract factory method: This has the abstract methods which have different classes and
will have creation of the families through the object and does not have the concrete sub-
classes. There are different levels of the abstract factory than the factory patterns. This
provides the various separation of the object which helps for the representation of objects.
This helps to rectify by the help of pattern and through the creational patterns because this
improves the complexity of the program (Sunitha, and Samuel, 2019).
5. Factory pattern: This has the abstract methods which have different classes and will have
creation of the families through the object and does not have the concrete sub-classes. The
factory patterns have different subclasses of the single classes. This helps to promote the
loose-coupling of the application and the class of the code.
6 Prototype Pattern: This has the clone() method which helps to create the new one object
and also helps to customize it. This helps to reduce the subclassing and complexity of the
created object. The client has to get new objects and the objects can be added and remove
from the program.

Q2: UML diagram
2.1: Use UML diagram to design Compute Price
Figure 1: Class 1
The above diagram has the classes of the JAVA which will have cust, place, bill, and
payment. There are various methods used and data types with the attributes of the respective
classes. This will help to understand the compute price to the user and also will help to
understand the connection between them (Sunitha, and Samuel, 2019).
2.2 Use UML diagram to design Checkout

Figure 2: Class 2
The above diagram has the classes of the JAVA which will have cust, product_name, bill,
and offered. There are various methods used and data types with the attributes of the
respective classes. This will help to understand the compute price to the user and also will
help to understand the connection between them (Sunitha, and Samuel, 2019).

Conclusion
The above report has explained about the creational diagram which will need to have the
pattern to which the problems can be solved. The assessment also has the different question
and that question have answer by the help of class diagram and the diagram is very simple
and easily understandable by the users. There is tool used for the design of the class case
diagram is draw.io tool which is the simplest tool for the diagram to understand and make.

References:
Nanthaamornphong, A. and Leatongkam, A., 2019. Extended ForUML for Automatic
Generation of UML Sequence Diagrams from Object-Oriented Fortran. Scientific
Programming, 2019.
Owens, L., Razet, B., Smith, W.B. and Tanner, T.C., 2019, January. Inter-family
Communication in Hyperledger Sawtooth and Its Application to a Crypto-Asset Framework.
In International Conference on Distributed Computing and Internet Technology (pp. 389-
401). Springer, Cham.
Leng, K., Jing, L., Lin, I.C., Chang, S.H. and Lam, A., 2019. Research on mining
collaborative behaviour patterns of dynamic supply chain network from the perspective of big
data. Neural Computing and Applications, 31(1), pp.113-121.
Sunitha, E.V. and Samuel, P., 2019. Automatic Code Generation From UML State Chart
Diagrams. IEEE Access, 7, pp.8591-8608.
Barakat, N.H., 2019, April. A Framework for integrating software design patterns with game
design framework. In Proceedings of the 2019 8th International Conference on Software and
Information Engineering (pp. 47-50). ACM.
Feitosa, D., Ampatzoglou, A., Avgeriou, P., Chatzigeorgiou, A. and Nakagawa, E.Y., 2019.
What can violations of good practices tell about the relationship between GoF patterns and
run-time quality attributes?. Information and Software Technology, 105, pp.1-16.