class Box<TYPE>{private TYPE value; ...}

Week 7: Enum, Generic Type, Streams, write to file, class diagram/04A. Generic Type Definition [in Class, Attribute, Param, Return]+++

@@ -0,0 +1,264 @@
+We have previously used "generic type definitions", 
+for example, when creating objects from classes 'ArrayList' and 'HashMap', and when writing classes that implement the 'Comparable' interface.
+
+public static void main(String[] args) {
+    // generic type definition: the list can now store
+    // integers
+    ArrayList<Integer> numbers = new ArrayList<>();
+    
+    // two generic type definitions: one for the key
+    // and one for the value
+    HashMap<String, Student> tutors = new HashMap<>();
+}
+ 
+
+
+
+We can also utilise generic type definitions in our own classes and interfaces.
+
+As the name suggests, a 'generic type definition' is a 'type definition'. 
+Normally, we write a variable that gets a value, for example, 
+- when calling a method or
+- when creating an object from a class. 
+
+In a 'type definition', instead, we write 'a variable that gets a type only when it is used'. 
+Thus, we 'generalise the type of the variable' instead of the value.
+
+In practice, this means that we can write a class, 
+for example, whose attributes are of different types when different objects are formed from the class.
+
+
+
+==============================
+
+
+
+Generic Type Definition in Own Class
+A 'generic type' can be defined in our own class by writing the type as a variable in connection with the class definition. 
+Let's look at the class Box, which stores one value:
+
+class Box<TYPE> {
+    private TYPE value;
+
+    public Box(TYPE value) {
+        this.value = value;
+    }
+
+    public TYPE getValue() {
+        return value;
+    }
+
+    public void setValue(TYPE value) {
+        this.value = value;
+    }  
+}
+ 
+
+Instead of defining the type of the stored value, we defined the type with a 'generic type definition'. 
+In this context, the variable 'TYPE' means that we 'define the actual type only when an object is created from the class'. 
+The same type has also been used in 
+- the constructor and 
+- in the class's setting and observation methods.
+
+
+
+
+
+
+Let's look at a few usage cases for the class:
+
+public static void main(String[] args) {
+    // Integer type
+    // create Box object, then put in an Integer
+    Box<Integer> numberBox = new Box<>(15);
+    System.out.println(numberBox.getValue());
+    numberBox.setValue(20 + 30);
+    System.out.println(numberBox.getValue());
+    
+    // String type
+    // create Box object, then put in a String
+    Box<String> wordBox = new Box<>("Java");
+    System.out.println(wordBox.getValue());
+    wordBox.setValue("Hello " + "everyone" + "!!!");
+    System.out.println(wordBox.getValue());
+
+    
+    // Student type
+    // INITIALISE Student object
+    Student s = new Student("Oliver", "oliver@example.com", 15);
+    // then put inside the 'Box' object u create
+    Box<Student> studentBox = new Box<>(s);
+    System.out.println(studentBox.getValue().getName());   
+}
+
+
+The program prints:
+15
+50
+Java
+Hello everyone!!!
+Oliver
+
+
+
+
+===================================================================
+
+
+Although the previous example serves its purpose, 
+the class Box is no more beneficial in practice than a single variable. 
+
+Therefore, let's consider a genuinely more useful case, i.e. a class that combines two values.
+
+class KeyAndValue<KEYTYPE, VALUETYPE> {
+    private KEYTYPE key;
+    private VALUETYPE value;
+
+    // constructor
+    public KeyAndValue(KEYTYPE key, VALUETYPE value) {
+        this.key = key;
+        this.value = value;
+    }
+
+
+
+
+    public KEYTYPE getKey() {
+        return key;
+    }
+
+    public void setKey(KEYTYPE key) {
+        this.key = key;
+    }
+
+
+
+
+    public VALUETYPE getValue() {
+        return value;
+    }
+
+    public void setValue(VALUETYPE value) {
+        this.value = value;
+    }
+}
+ 
+
+The types of values are given only when an object is created from the class:
+public static void main(String[] args) {
+    KeyAndValue<Integer, Double> kv = new KeyAndValue<>(10, 100.0);
+    System.out.println(kv.getKey());
+    System.out.println(kv.getValue());
+}
+
+The program prints:
+10
+100.0
+
+
+
+
+
+
+
+===================================================================
+
+Let's consider 1 more example. 
+
+The class 'Stack' defines a data structure 
+where values are added and removed from the top of the stack. 
+As a point of comparison, you can think of a stack of papers.
+https://ville.utu.fi/static_resources/erkki/stack.png
+
+
+
+We use a list to store the stack's values. 
+We utilise generality again in defining the class, 
+so we can conveniently 'store any type of values in the stack':
+
+class Stack<T> {
+    private ArrayList<T> elements;
+    
+    public Stack() {
+        elements = new ArrayList<>();
+    }
+    
+    // Always add to the end of the list
+    public void add(T element) {
+        elements.add(element);
+    }
+
+
+    // ArrayList remove()
+    // => pops/removes the element => then retrieves it
+    // Likewise, always remove from the end of the list
+    public T remove() {
+        return elements.remove(elements.size() - 1);
+    }
+    
+    public boolean hasElements() {
+        return !elements.isEmpty();
+    }
+}
+ 
+
+
+
+An example of using the Stack class:
+class Stack<T> {
+public static void main(String[] args) {
+    Stack<String> stringStack = new Stack<>();
+    stringStack.add("first");
+    stringStack.add("second");
+    stringStack.add("third");
+    
+    while(stringStack.hasElements()) {
+        System.out.println(stringStack.remove());
+    }
+}
+ 
+
+The program prints:
+third
+second
+first
+
+
+
+
+
+
+=========
+
+
+// recap
+// ArrayList remove()
+// => pops/removes the element => then retrieves it
+
+
+import java.util.ArrayList;
+
+public class Main { 
+  public static void main(String[] args) { 
+    ArrayList<Integer> list = new ArrayList<Integer>(); // Change to Integer type
+    list.add(5);
+    list.add(8);
+    list.add(9);
+    list.add(1);
+    
+    //list.remove(Integer.valueOf(1)); // Remove by object
+    //list.remove(1); // Remove by index
+    
+    System.out.println(list);
+    int element = list.remove(2);
+    System.out.println(element);
+    System.out.println(list);
+  }
+}
+
+
+Output:
+[5, 8, 9, 1]
+9 <= pop/remove idx 2
+[5, 8, 1]
+