same method, multiple param nums AND dtypes

Week 5: Class hierarchies/10A. OVERLOADING AND OVERRIDING methods [= same method, multiple param nums AND dtypes]++

@@ -0,0 +1,133 @@
+In Java, there can be SEVERAL VERSIONS of the SAME METHOD. 
+Methods are distinguished by formal PARAMETERS: 
+if two methods have different NUMBERS or TYPES of parameters, 
+both method definitions can co-EXIST in the SAME CLASS.
+
+
+
+For example, the following cases are therefore ALLOWED:
+
+1. Different number of parameters
+public int average(int a, int b) 
+public int average(int a, int b, int c)
+ 
+
+2. Different types of parameters
+public int num(int a) 
+public int num(double a)
+ 
+
+3. Parameters in a different order
+public int average(int a, String b) 
+public int average(String a, int b)
+ 
+
+Only the method name and its parameters are considered for OVERLOADING. 
+Changing the RETURN VALUE or the VISIBILITY WRAPPER DOES NOT OVERLOAD the METHOD, 
+but causes a translation error: 'Duplicate method x in type y'.
+
+
+
+For example, the following method definition will cause a translation error:
+public int average(int a, String b)
+private int average(String a, int b) //change visibility. public -> private
+public String average(int a, String b) //change return dtype. int -> String
+
+
+
+ 
+
+Overloading also works without recovery. 
+As an example, consider the class 'MathHelper', which has two methods for calculating the average. 
+One is given 2 integers as parameters and the other 3 integers:
+class MathHelper {
+    
+    public double average(int num1, int num2) {
+        return (num1 + num2) / 2.0;
+    }
+    
+    public double average(int num1, int num2, int num3) {
+        return (num1 + num2 + num3) / 3.0;
+    }
+}
+
+
+
+ 
+
+Now, when calling a method, the Java COMPILER INFERS the CORRECT METHOD based on the actual parameters in the call. 
+This is sometimes called "STATIC (or COMPILE-TIME) POLYMORPHISM".
+public static void main(String[] args) {
+    MathHelper helper = new MathHelper();
+    System.out.println(helper.average(1,2));
+    System.out.println(helper.average(1,2,3));
+}
+
+Program outputs:
+1.5
+2.0
+ 
+
+
+=====================================================================
+
+
+
+
+
+In inheritance, OVERRIDING is often a natural way to expand a child class.
+For example, consider again the 'Account' class, which has the method deposit(int amount):
+class Account {
+    protected double balance;  
+    
+    public Account(double balance) {
+        this.balance = balance;
+    }
+ 
+    public double getBalance() {
+        return balance;
+    }
+    
+    public void deposit(double amount) {
+        balance += amount;
+    }
+}
+ 
+
+The class 'BonusAccount' inherits the class 'Account', 
+and adds a new overrided version of the method 'deposit', 
+which also gets a 'bonus' added to its parameter:
+class BonusAccount extends Account {
+    // CONSTRUCTOR
+    public BonusAccount(double balance) {
+        super(balance);
+    }
+
+    // OVERRIDED METHOD
+    public void deposit(double amount, double bonus) {
+        super.deposit(amount + bonus);
+    }
+
+}
+
+
+
+ 
+
+Now a client of the BonusAccount class can use BOTH the 
+OVERRIDED version of the method and the ORIGINAL version defined in the PARENT Account class:
+
+public static void main(String[] args) {
+    BonusAccount acc = new BonusAccount(0);
+    acc.deposit(100);
+    System.out.println(acc.getBalance());
+    
+    acc.deposit(100, 50);
+    System.out.println(acc.getBalance());
+}
+ 
+
+Program outputs:
+100.0
+250.0
+