class PersonContainer<T extends Person>

Week 7: Enum, Generic Type, Streams, write to file, class diagram/07A. Generics and Class Hierarchies

@@ -0,0 +1,117 @@
+The use of 'generic type definitions' in classes naturally LIMITS the FUNCTIONALITY OF METHODS that use type definitions. 
+Since the 'generic type' can be anything when an object is created from a class, 
+we can't use through a variable of the type 'anything other than the features defined in the Object class'.
+=????????
+
+=> because Java doesn't know what T actually is at compile time, 
+=> you can't assume specific behavior (like calling .length() or + operations) unless explicitly told.
+VS
+=> In Java, all classes inherit from 'Object'. 
+=> So if you have a generic type T, Java treats it as if it were an 'Object' 
+=> — meaning you can only safely call methods defined in 'Object', such as:
+.toString()
+.equals()
+.hashCode()
+=> You cannot assume anything more specific (like .compareTo(), .length(), +, etc.) unless you bound the generic type to a dtype u want.
+
+
+
+
+The following code, for example, would give a compilation error:
+
+
+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;
+    }
+    
+    public void isValueLongerThanZero() {
+        // This gives a compilation error, because the method
+        // length() is not in all classes
+        if (value.length() > 0) {
+            System.out.println("Longer than 0!");
+        }
+    }
+}
+ 
+
+THE CODE GIVES A COMPILATION ERROR:
+The method length() is undefined for the type TYPE
+ 
+
+
+==================================================================================
+
+
+
+
+
+However, we can LIMIT the DEFINITION of the generic type by using the 'extends' keyword.
+
+For example, the following 'generic definition' indicates that the 'implementing type' must inherit the class 'Person':
+
+class PersonContainer<T extends Person> {
+    private T person;
+    
+    public PersonContainer(T person) {
+        this.person = person;
+    }
+    
+    public String giveName() {
+        // Now this works, because T inherits 'Person'
+        return person.getName();
+    }
+    
+    public String giveEmail() {
+        return person.getEmail();
+    }
+}
+
+
+
+
+
+
+The type to be inherited can also be an 'interface', even though the keyword 'extends' is still used, confusingly.
+
+For example, types implementing the 'Comparable interface '
+naturally have the method compareTo in use. 
+Note that the generic definition T is also repeated in the name of the interface:
+
+class Comparator<T extends Comparable<T>> {
+    public Comparator() {}
+    
+    public T giveGreater(T element1, T element2) {
+        if (element1.compareTo(element2) < 0) {
+            return element2;
+        } 
+        else {
+            return element1;
+        }
+    }
+}
+
+
+
+
+
+
+==================================================================================
+
+
+Generics also involves other issues not covered in this section, 
+such as statically, generically typed methods or wildcard characters. 
+You can read more about these in Oracle's tutorial:
+https://docs.oracle.com/javase/tutorial/java/generics/index.html
+
+