reusable method for SUPERCLASS n SUBCLASSES, ArrayList, SUPERCLASS METHOD

Week 6: Methods of OO Programming/09 Polymorphism+++

@@ -0,0 +1,285 @@
+Polymorphism may sound like a complex term, but in practice, it is a rather simple concept of object-oriented programming. 
+It means that the SAME OBJECT can be REFERENCED BY using DIFFERENT TYPE VARIABLES.
+
+Since ALL CLASSES in Java INHERIT (directly or indirectly) class 'Object', an 'Object' type variable CAN REFERENCE ANY OBJECT in Java:
+
+public static void main(String[] args) {
+    Object string = "Hi all!";
+    Object student = new Student("1234", "Sarah Student", 4);
+    Object list = new ArrayList<Integer>();
+}
+ 
+
+
+================================================================
+
+Then why wont we use 'Object' type variables only?
+The 'TYPE' of the VARIABLE DEFINES WHAT MEMBERS CAN BE REFERENCED using that variable. 
+Since there is only a handful of methods defined in the class 'Object' (for example 'toString' and 'equals'), 
+we can only REFERENCE THOSE METHODS when the type of the variable is Object.
+
+
+public static void main(String[] args) { 
+    Object string = "Hi all!"; 
+    Object student = new Student("1234", "Sarah Student", 4); 
+    Object list = new ArrayList<Integer>();
+    
+    System.out.println(string.toString());
+    System.out.println(student.toString());
+    System.out.println(list.toString());
+}
+
+Program output
+Hi all!
+Sarah Student (1234), 4 op.
+[]
+
+
+
+ 
+
+Even if your Student/Opiskelija class/object has other methods, 
+trying to reference ur other/custom methods provides an error message, 
+if the members are not declared in the 'variable type class':
+******************************************
+=> WHAT DOES THIS MEAN???????
+*******TO CLARIFY**************
+=> members (of a class) = 1. variables/fields, 2. methods/fns
+=> members not declared => variable, method not declared in the 'reference type' class (i.e. the 'Object' class over here)
+=> 'variable type class' = class/type for a variable
+eg
+Animal animal = new Dog();
+Animal = class/type = 'variable type class'
+animal = variable
+compiler knows 'animal' is an Animal object
+compiler does not know 'animal' is a Dog object
+
+******************************************
+
+
+Object student = new Opiskelija("1234", "Sarah Student", 4);
+// getName method is not defined in 'Object' class
+// even if actual object of 'Student/Opiskelija' class contains the 'getName' method => we still get compiler error
+String name = student.getName(); 
+
+ 
+Program produces a compiler error
+The method getName() is 'undefined' for the type Object
+
+
+
+
+================================================================
+
+
+
+Why Polymorphism?
+Since an object can be REFERENCED BY its OWN TYPE variables and by ALL SUPERTYPE VARIABLES, 
+we can for example write a method that works on several different 'type objects'.
+******************************************
+=> WHAT DOES THIS MEAN???????
+reference type vs actual object type
+eg
+class Animal { }
+class Dog extends Animal { }
+// => dog is of type Dog, so you can call all methods defined in Dog.
+Dog dog = new Dog();      // Own type
+
+// => animal is of type Animal, but holds a Dog. You can only access methods declared in Animal.
+Animal animal = new Dog(); // Supertype reference
+
+// => obj is of type Object, but holds a Dog. Again, limited to Object methods unless cast.
+Object obj = new Dog();   // Also a supertype (since Object is the root)
+
+
+So the same 'Dog' object can be referenced by :
+Its OWN TYPE : Dog
+ANY SUPERTYPE : Animal, Object
+
+
+
+
+
+
+
+
+
+=> also what does type object/s mean?
+=>'type object' = 1 method work on objects of different classes, as long as related thru inheritance
+=> so method allows supertype OR subtypes
+eg
+class Animal {
+    void makeSound() {
+        System.out.println("Some sound");
+    }
+}
+
+class Dog extends Animal {
+    @Override
+    void makeSound() {
+        System.out.println("Bark!");
+    }
+}
+
+class Cat extends Animal {
+    @Override
+    void makeSound() {
+        System.out.println("Meow!");
+    }
+}
+
+
+public class Test {
+    public static void main(String[] args) {
+    // 1 ...OTHER CODE...
+
+    
+    // 3 calling the method
+    //Even though the method expects an Animal, it can accept any subclass (Dog, Cat) because they are subtypes of Animal.
+    //polymorphism = one interface, many forms
+    letAnimalMakeSound(new Dog());   // Bark!
+    letAnimalMakeSound(new Cat());   // Meow!
+    letAnimalMakeSound(new Animal()); // Some sound
+    }
+
+    
+    // 2 THEN DEFINE REUSABLE METHOD ACROSS CLASSES
+    void letAnimalMakeSound(Animal animal) {
+        animal.makeSound();
+    }
+}
+    
+
+******************************************
+
+
+
+Let's consider a class hierarchy presented last week. 
+We have a class 'Person' which is inherited by classes 'Student' and 'Teacher'. Here are summaries of the classes:
+
+class Person {
+    private String name;
+    private String email;
+
+    public Person(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}
+
+
+
+class Teacher extends Person {
+    private int hours;
+
+    public Teacher(String name, String email, int hours) {
+        super(name, email);
+        this.hours = hours;
+    }
+
+    public int getHours() {
+        return hours;
+    } 
+}
+
+
+
+class Student extends Person {
+    private int credits;
+
+    public Student(String name, String email, int credits) {
+        super(name, email);
+        this.credits = credits;
+    }
+
+    public int getCredits() {
+        return credits;
+    } 
+}
+ 
+
+
+
+THEN
+
+
+
+Now we can write a method that receives a 'Person' type object as an ARGUMENT. 
+The method outputs the email address of the person.
+=> 'outputEmail method' below
+
+In addition to 'Person' type objects, the method can receive 'Student' and 'Teacher' type objects as ARGUMENTS. 
+This is due to the fact that students and teachers are also persons in our class hierarchy.
+
+public class Test {
+    public static void main(String[] args) {
+       Person person = new Person("Eric Example", "eric@example.com");
+       outputEmail(person);
+       
+       Teacher teacher = new Teacher("Tim Teacher", "tim@example.com", 25);
+       outputEmail(teacher);
+       
+       Student student = new Student("Sarah Student", "sarah@example.com", 241);
+       outputEmail(student);
+    }
+
+    // DEFINE REUSABLE METHOD ACROSS CLASSES HERE
+    public static void outputEmail(Person person) {
+        System.out.println(person.getEmail());
+    }
+}
+
+Program output
+eric@example.com
+tim@example.com
+sarah@example.com
+
+
+
+ VS
+ 
+
+Similarly, we could create a 'Person' type list and save 'Person, Teacher and Student' objects into it:
+
+Person person = new Person("Eric Example", "eric@example.com");
+Teacher teacher = new Teacher("Tim Teacher", "tim@example.com", 25);
+Student student = new Student("Sarah Student", "sarah@example.com", 241);
+  
+ArrayList<Person> persons = new ArrayList<>();
+persons.add(person));
+persons.add(teacher);
+persons.add(student);
+ 
+
+
+
+VS
+
+
+
+Now we can iterate the list and call the method 'getName' for all objects. 
+Again, it does not matter if the type of the object is Person, Teacher, or Student; 
+they all have the getName method.
+=> BECAUSE 'getName' WAS DEFINED IN THE PARENT CLASS 'Person'
+
+for (Person p : persons) {
+    System.out.println(p.getName());
+}
+ 
+
+Program output
+Eric Example
+Tim Teacher
+Sarah Student
+
+
+
+