Discussion forum unit 6 - Software Engineering 2

1. Question 1: Conduct an internet search and library research of the concept ‘Generics’ or
‘Generic Programming’ and report your findings as the response to this discussion
question. As part of your response you must define what generics are, why it they are
important in OOP and you must provide examples of generics used within an object oriented
program.
Generics in object-oriented programming (OOP) are a powerful tool that allow
programmers to write code that is more reusable, type-safe, and efficient.
What are generics?
Generics are parameterized types, meaning that they can be used with any data type.
This is in contrast to non-generic types, which are specific to a particular data type.
For example, a non-generic ArrayList class can only store objects of type Object. A
generic ArrayList<T> class, on the other hand, can store objects of any type T.
Why are generics important in OOP?
Generics are important in OOP for a number of reasons:
 Reusability: Generic code can be reused with different data types without having
to be rewritten. This can save programmers a lot of time and effort.
 Type safety: Generics help to ensure type safety by preventing programmers from
accidentally mixing up different data types. This can help to prevent bugs and
make code more reliable.
 Efficiency: Generic code can be more efficient than non-generic code because
the compiler can generate specialized code for different data types.
Examples of generics in OOP
 Generic collections: Many common collection classes, such as ArrayList,
HashMap, and LinkedList, are generic. This allows them to be used to store
objects of any type.

2.  Generic methods: Generic methods can be used to implement algorithms that
work with different data types. For example, a generic sort() method could be
used to sort a list of objects of any type.
 Generic interfaces: Generic interfaces can be used to define contracts for generic
classes and methods. For example, the List interface defines a contract for all
generic list classes.
Example of a generic class in Java
public class GenericBox<T> {
private T value;
public GenericBox(T value) {
this.value = value;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
This generic class can be used to store an object of any type T. For example, we could
create a GenericBox<Integer> to store an integer, or a GenericBox<String> to store a
string.
Example of a generic method in Java
public static <T> void swap(GenericBox<T> box1, GenericBox<T> box2) {
T temp = box1.getValue();
box1.setValue(box2.getValue());
box2.setValue(temp);
}
This generic method can be used to swap the values of any two GenericBox objects,
regardless of the type of object they store.

3. Question 2: Conduct an internet search and library research of the concept ‘Open Recursion’
and report your findings as the response to this discussion question. As part of your response
you must define what it is, why it is important in OOP and you must provide examples of how
it can be used with an object oriented program. This assignment is not about a specific
programming language, however you may select a specific object oriented programming
language as an example to illustrate open recursion.
Open recursion in object-oriented programming (OOP) is a technique that allows an
object to call one of its own methods indirectly. This is done by using a special variable
called self or this, which refers to the current object.
Open recursion is important in OOP because it allows programmers to implement
complex algorithms in a modular and reusable way. For example, a recursive tree
traversal algorithm can be implemented as a single method that can be used to traverse
any tree, regardless of its size or structure.
An example in Java
public class Node {
private Node left;
private Node right;
private int value;
public Node(int value) {
this.value = value;
}
public void print() {
System.out.println(value);
if (left != null) {
left.print();
}
if (right != null) {

4. right.print();
}
}
}
This class represents a node in a binary tree. The print() method recursively prints the
values of all the nodes in the tree, starting from the current node.
To use the print() method, we would simply create a new instance of the Node class
and pass in the root node of the tree. The print() method would then recursively print
the values of all the nodes in the tree, starting from the root node.
An example of how to use the print() method
Node root = new Node(10);
root.left = new Node(5);
root.right = new Node(15);
root.print();
Output
10
5
15
Open recursion is a powerful technique that can be used to implement a wide variety of
algorithms in OOP. However, it is important to use it carefully, as it can be easy to write
recursive code that is inefficient or even infinite.
Some more examples of how open recursion can be used in OOP
 To implement a depth-first search algorithm for a graph
 To implement a quicksort algorithm
 To implement a binary search algorithm

5.  To implement a factorial calculator
 To implement a Fibonacci number calculator
Open recursion can also be used to implement complex data structures, such as binary
trees, linked lists, and hash tables.
By understanding the basics of open recursion, OOP programmers can write more
powerful and efficient code.
References
Eckel, B. (2018). Thinking in Java: The definitive introduction to programming in Java (4th
ed.). Addison-Wesley Professional.
Lafore, R. (2002). Data structures and algorithms in Java (2nd ed.). Upper Saddle River,
NJ: Pearson Education
Open recursion. (n.d.). Retrieved October 17, 2023, from
https://en.wikipedia.org/wiki/Open_recursion