Object Oriented Design Patterns in Java

This article discusses creational design patterns and their five major types including abstract factory, singleton, builder, factory method and prototyping. It also explores the implementation of Strategy Design Pattern in Java for Shopping Cart security and checkout. The article provides code snippets and examples for better understanding.

Running head: OBJECT ORIENTED DESIGN PATTERNS IN JAVA
Object Oriented Design Patterns in Java
Name
Institution
Date

OBJECT ORIENTED DESIGN PATTERNS 2
Question 1
Creational Design Patterns
As outlined by Smith (2015), creational patterns are meant to abstract the operation
behind creation of class objects. Similarly, he emphasizes that they are used to engage a user in a
disguise regarding objects creation, composition and their representation. Creation pattern are
known to encapsulate cognition around choosing concrete classes implemented referred to the
approach of objects creation through interfaces. The pattern allows for flexibleness performing
activities ranging from creation of different object types, an engaging responsibility to create as
well as determining how and when to create the objects. As such, creational patterns have been
divided into five major types including abstract factory, singleton, builder, factory method and
prototyping (Gamma 1999). The pattern can well be attributed to creating a maze game which
involves objectives including finding an exit from the maze, solving troubles as well as creating
maps.
Abstract factory is credited to various advantages such as isolating concrete objects.
Secondly, it provides easy exchange in intersection of families, with a concrete factory being
created only once in a singleton as well as alteration of a family of products, hence, the instance
of factory. Lastly it encourages products to consistency. Nevertheless, abstract factory poses
various cons including trouble to support fresh types of products such as widgets, thus requires
extension of interface. Secondly, apart from being a singleton it doesn’t allow clients to know the
type of produced intersection, hence, need for multicasting (Smith 2015). Creation of concrete
products are commonly done using factory methods if not by prototyping. Factories can be
extended through parameterized creation of a product. The latter is used to specify a type of

OBJECT ORIENTED DESIGN PATTERNS 3
object intended for creation in class identifiers, data type as well as other features that can
discover products.
A motivation behind it includes a system for software able to maintain numerous files to
a client. For instance, essential abstraction constitutes of a document and applications structure.
There are five participants of factory method namely product which defines an interface
regarding the objectives intended for creation. A concrete product can be used to implement the
product interface. Thirdly, a creator holds the factory method hence returning a product.
Similarly, it may determine default execution, hence, returns a default concrete product object. A
distinction between the factory method and abstract factory is that, whereas the latter conforms
to a double value in abstraction, the former’s use of interfaces otherwise or an abstract class
doesn’t recognize the specific concrete class to be returned. Therefore, the factory method has
been attributed to pros including having a user code that is freed from classes for particular
software. Additionally, it offers a fleece to continue sub classing. Nevertheless, a con draw to it
claims that users are mandated to create a subclass to merely create concrete product objects.
Singletons ascertains that a created class only contains a single instance which is can be
globally accessed. Therefore, developers are required to use Singleton strictly for class that can
only have one instance so as to fend off need for passing parameters of the object. It participates
being static thus, defines operations which allow users to access distinct instance and is
responsible for making the instance.

OBJECT ORIENTED DESIGN PATTERNS 4
Question 2
Design Problem 1
ComputePrice Method
Using Strategy Design Pattern to Implement Compute Price
As depicted by the class codes below on how to implement a ShoppingCart, it uses the
Strategy Pattern simple techniques where one object instructs another to perform the task.
public class ItemCart
{
public ItemCart(String theCode) {
Code = theCode; // assume "1234" -> Bacon
}
public ItemCart(SaveItem theItem) {
MappingItemStore(theItem);
}
// declaring the props: Code, Name, Quantity, Cost
public void Preparation() {
if(theQuantity > 0) {
// Alert and return when operation is invalid
// The one time call in each item
}
// Sample. Calling back from the database.
var theItem = new SaveItem { Code = theCode, Name =
"Bacon", Cost = 2.49, Tax = 0 /* etc */ }

OBJECT ORIENTED DESIGN PATTERNS 5
MappingItemStore(theItem);
Quantity = 1;
}
public void UpdatingTheQuantity(int theQuantity) {
Quantity = theQuantity;
Cost = Cost * Quantity;
}
private void MappingItemStore(SaveItem theItem) {
Code = theItem.Code;
Name = theItem.Name;
Cost = CalculatingCost(theItem.Cost, theItem.Tax);
}
private static double ComputePrice(double theCost, double
theTax) {
// If tax > 0, apply it to cost
// if (theCost + theTax > 26) && (theCost + theTax < 50)){
Return iChipKart = T-Shirt;
} else if (theCost + theTax > 26 && (theCost + theTax < 50)){
Return iChipKark = Backpack;
} else if (theCost + theTax > 100){
Return iChipKark = portableDisk;
// else return cost as is
}
}
}

OBJECT ORIENTED DESIGN PATTERNS 6
Second Implementation of Strategy Pattern for computePrice in Shopping Cart.
public class SCart {
List<String> theItems;
double allTotal;
public SCart(){
theItems = new ArrayList<String>();
}
public void appendItems(String theItem){
theItems.append(theItem);
}
public void removeItems(String theItem){
theItems.remove(theItem);
}
public void getNumberOfItems(){
System.out.println(theItems.size());
}
public String getItemName(int theIndex){
return theItems.get(theIndex);
}
public void computePrice(){
total = 0;
for(String var1: theItems){
if (var1.equals("")){
total += 3.0;
}else if (var1.equals("")){
total += 5.0;
}else if (var1.equals("")){
total += 2.50;
}
}

OBJECT ORIENTED DESIGN PATTERNS 7
System.out.println(allTotal);
}
}
Third Implementation of Strategy Pattern for computePrice in Shopping Cart.
public class SCart {
protected Dictionary<Product, int> theItems;
// throwing a list of products List<Product>
public void AppendItem( Product freshItem ) {
if ( ! theItems.Contains(freshItem) ) // SRP in action
theItems.Append(freshItem);
theItems[freshItem].count++;
}
public decimal totalOfCart() {
foreach ( thing in theItems ) {
allTotal += theItems[thing].GetPrice * theItems[thing].count;
}
}
// code in "cart"/"shopping" terminology. aka Domain Specific
Language - DSL.
public string Receipt() { return this.ToString(); }
public override string ToString() {
string indivd = "";
foreach ( thing in theItems ) {
indivd += theItems[thing].ToString() + "\n"; // SRP in
action
}
indivd += "\n\n Total: " + totalOfCart();
return indivd;
}
}

OBJECT ORIENTED DESIGN PATTERNS 8
public class SCart {
private final List<Item> theItems;
public SCart() {
theItems = new ArrayList<Item>();
}
public void appendItem(Item theItem) {
theItems.append(theItem);
}
public double computeCost() {
double allTotal = 0.0;
for (Item theItem : theItems) {
total += theItem.getPrice();
}
return allTotal;
}
public boolean payUp(MethodOfPay theMethod) {
double totalCost = computeCost();
return theMethod.payUp(totalCost);
}
}
Design Problem 2
CheckOut
Using Strategy Design Pattern to Implement “checkOut” method in Shopping Cart
Code 1
import java.util.*;
public class Checkout {
private Set<CheckoutStrategy> strategies = new HashSet<>();
public static Map<String, Double> PRICE_MAP = new HashMap<>();
static {

OBJECT ORIENTED DESIGN PATTERNS 9
PRICE_MAP.put("Shirt", 0.25);
PRICE_MAP.put("Backpack", 0.6);
}
public Checkout() {
this.strategies.add(new SummingStrategy());
}
public Checkout(CheckoutStrategy discountStrategy) {
this();
this.strategies.add(discountStrategy);
}
public double calculateTotal(List<String> strings) {
double[] result = new double[1];
for (CheckoutStrategy strategy : strategies) {
strategy.calculateTotal(strings, result);
}
return result[0];
}
}
Code 2
import java.util.List;
public interface CheckoutStrategy {
void calculateTotal(List<String> strings, double[] result);
}
Code 3
import java.util.List;
import static Checkout.PRICE_MAP;
public class SummingStrategy implements CheckoutStrategy {
@Override

OBJECT ORIENTED DESIGN PATTERNS 10
public void calculateTotal(List<String> items, double[] result) {
result[0] = items.stream().mapToDouble(PRICE_MAP::get).sum();
}
}
Code 4
import Checkout;
import java.util.List;
public class DiscountStrategy implements CheckoutStrategy {
@Override
public void calculateTotal(List<String> items, double[] result) {
ItemCounter counter = items.stream().collect(ItemCounter::new,
ItemCounter::accept, ItemCounter::combine);
double appleDiscount = (counter.counts[ItemCounter.SHIRT_INDEX] /
2) * Checkout.PRICE_MAP.get("Shirt");
double orangeDiscount =(counter.counts[ItemCounter.BACKPACK_INDEX]
/ 3) * Checkout.PRICE_MAP.get("Orange");
result[0] -= shirtDiscount;
result[0] -= backpackDiscount;
}
Code 5
class ItemCounter {
static final int SHIRT_INDEX = 0;
static final int BACKPACK_INDEX = 1;
private int[] counts = new int[2];
public void accept(String item) {
switch (item) {
case "Shirt":
counts[SHIRT_INDEX]++;
break;

OBJECT ORIENTED DESIGN PATTERNS 11
case "Backpack":
counts[SHIRT_INDEX]++;
break;
}
}
public void combine(ItemCounter other) {
this.counts[SHIRT_INDEX] += other.getCounts()[SHIRT_INDEX];
this.counts[SHIRT_INDEX] += other.getCounts()[BACKPACK_INDEX];
}
public int[] getCounts() {
return counts;
}
}
}
Using Strategy Design Pattern to Implement Security in Shopping Cart
As shown by the pay method, the subroutine takes a single parameter related to checkout
method, hence, the alternative object as defined. As such, the process follows definition of the
MethodOfPay implemented as an interface. The reason for the latter was for the ability of the
strategy pattern to enable decision at the time of running the application. The concrete type
works towards making payment by passing it into the shopping cart as implemented earlier.
public interface MethodOfPay {
public boolean payUp(double theAmount);
}
The below object of payment is concrete as is implemented as Visa.

OBJECT ORIENTED DESIGN PATTERNS 12
public class Visa implements MethodOfPay {
private final String title;
private final String noOfCard;
private final Date expiry;
public Visa(String title, String noOfCard, Date expiry) {
super();
this.title = title;
this.noOfCard = noOfCard;
this.expiry = expiry;
}
@Override
public boolean payUp(double theAmount) {
// Opening connection to Mastercard
// Verifying connection
// Paybill using these details
return true; // if payment goes through
}
}
The below security object of payment is concrete as is implemented as MasterCard.
public class TheMasterCard implements MethodOfPay {
private final String title;
private final String noOfCard;
private final Date expiry;
public TheMasterCard(String title, String noOfCard, Date expiry) {
super();
this.title = title;
this.noOfCard = noOfCard;
this.expiry = expiry;
}
@Override
public boolean payUp(double theAmount) {
// Opening connection to Mastercard
// Verifying connection
// Paybill using these details
return true; // if payment goes through
}
}
The below security object of payment is concrete as is implemented as Visa.

OBJECT ORIENTED DESIGN PATTERNS 13
@Test
public void payUpThroughVisa() {
SCart theInstance = new SCart();
Item one = new Item("milk", 2.43);
theInstance.appendItem(one);
Item two = new Item("sugar", 5.99);
theInstance.appendItem(two);
Date theDateOfExp = getTheDateofExp();
MethodOfPay visa1 = new Visa("JohnDoe", "abcdefghijklmnop",theDateOfExp);
boolean theResult = theInstance.payUp(visa1);
affirmTruth(theResult);
}
private Date getTheDateofExp () {
Calendar theCal = Calendar.getInstance();
theCal.clear();
theCal.set(2018, Calendar.OCTOBER,9);
return theCal.getTime();
}
As depicted by the code above, it is used to create the checkOut after adding in the
shopping cart a number of items. The newly created MethodOfPayment is made as a kind of
Visa object, hence, put in to the checkOut (MethodOfPayment theMethod) subroutine. The latter
makes the core subject of this paper’s enquiry. Alternatively, a MasterCard object could have
been created and directly implemented by replacing it for Visa. Therefore, a Strategy Pattern’s
definition is used in java Spring as the entirely used technology as shown below:
@Component
public class SpringCart{
private final List<Item> theItems;
@Autowired
@Qualifier("Visa")
private MethodOfPayment theMethod;
public SpringCart() {
theItems = new ArrayList<Item>();
}

OBJECT ORIENTED DESIGN PATTERNS 14
public void appendItem(Item theItem) {
theItems.add(theItem);
}
public double computeCost() {
double theTotal = 0.0;
for (Item theItem : theItems) {
theTotal += theItem.getPrice();
}
return total;
}
public boolean payUp() {
double theCost = computeCost();
return method.payUp(theCost);
}
}
In the above code, a differentiation is made amid it and the demonstrated implementation
of the Visa class, equally interposed using Spring. The latter class is loaded up using the
annotation @Autowired and makes the strategy pattern most popular.
References

OBJECT ORIENTED DESIGN PATTERNS 15
Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Design Patterns :
Elements of Reusable Object-Oriented Software, Addison Wesley, 1995.
Smith, Ben. Object-Oriented Programming. Advanced ActionScript 3. Apress,
pp63-69, 2015 .