• RequestDispatcher.forward() vs HttpServletResponse.sendRedirect()
  _______________________________________________________________
  RequestDispatcher.forward()
  _______________________________________________________________

  1.When we use forward method, request is transfer to other resource within the same server.

  2.client or browser is not involved.

  3.When forward is called on requestdispatcher object we pass request and response objects so our old request object is passed on for further processing.

  4.ON browsers url you cant see that address.

  5. forward () method is faster then send redirect.

  _______________________________________________________________
  SendRedirect
  _________________________________________________________________

• 1.request is transfer to another resource to different server for further processing.

• 2.Url is visible on the browser.

• 3.In case of sendRedirect call, old request and response objects are lost because it’s treated as new request by the browser.

• 4.In address bar, we are able to see the new redirected address.

  5.sendRedirect is slower because one extra round trip is required, because completely new request is created and old request object is lost. Two browser request required.

•  

Rules for overriding

• The access level can't be more restrictive than the overridden method's.
• class Car {
      String message = "Car";
      <T> void horn() throws Exception {
          System.out.println(message);
      }
  }
  
  class Mercedez extends Car {
      String message = "child";
       void horn() throws IOException {
          System.out.println(message);
      }
  }
• Compiles  fine
• class Car {
      String message = "Car";
      public void horn() throws Exception {
          System.out.println(message);
      }
  }
  
  class Mercedez extends Car {
      String message = "child";
       private void horn() throws IOException {
          System.out.println(message);
      }
  }
• Not Allowed
• class Car {
      String message = "Car";
       void horn(){
          System.out.println(message);
      }
  }
  
  class Mercedez extends Car {
      String message = "child";
      <T> void horn(){
          System.out.println(message);
      }
  }
• Not Allowed 
• class Car {
      String message = "Car";
      Number horn(){
          return 1;
      }
  }
  
  class Mercedez extends Car {
      String message = "child";
      Integer horn(){
          return 2;
      }
  }
  
  
  public class OverridingWithException {    
      public static void main(String[] args) {
       Car c=new Mercedez();
       System.out.println(c.horn());
      }
  }
• Output: :2
• The access level CAN be less restrictive than that of the overridden method.
• private, static and final methods can't be overridden
• Return type of method is never part of method signature, so only changing the return type of method does not mean overloading
• Overriding method can not throw checked Exception higher in hierarchy than thrown by overridden method.  
• class Car {
      String message = "Car";

• //Overriden method

  
      void horn() throws NoHornException {
          System.out.println(message);
      }
  }
  
  class Mercedez extends Car {
      String message = "child";

• //Overriding method

  
       void horn() throws NoBreakException {
          System.out.println(message);
      }
  }
  class NoHornException extends Exception {
  }
  
  class NoBreakException extends NoHornException {
  }
  
  public class OverridingWithException {    
      public static void main(String[] args) {
        try {
          new Mercedez().horn();
      } catch (NoBreakException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      }
      }
  }
• which overridden method to call based on object type  
• import java.io.FileNotFoundException;
  import java.io.IOException;
  class Parent {
      String message = "parent";
      void say() {
          System.out.println(message);
      }
  }
  
  class Child extends Parent {
      String message = "child";
      void say() {
          System.out.println(message);
      }
  }
  
  public class OverridingWithException {
      public static void main(String[] args) {
          Parent p=new Child();
         
          p.say();
      }
  }
  

  Output is CHILD 

    
• class Car {
      String message = "Car";
      void horn() throws Exception{
          System.out.println(message);
      }
  }
  
  class Mercedez extends Car {
      String message = "child";
       void horn() throws IOException,FileNotFoundException{
          System.out.println(message);
      }
  }
  Compiles fine

• Imagine Base class car references Object of derived class 

  and invokes the method in base class then the call is made 

  and base class method invoked.

  class Car {
      String message = "Car";
      void horn() {
          System.out.println(message);
      }
  }
  
  class Mercedez extends Car {
      String message = "Mercedez ";
      /*void horn() {
          System.out.println(message);
      }*/
  }
  
  
  public class OverridingWithException {  
      public static void main(String[] args) {
          Car yo = new Mercedez();
          yo.horn();
      }
  }
  Output:Car

  But if i uncomment methodin Mercedez then

  Output:Mercedez

_________________________________________________________________________

class Car {
    String message = "Car";
    static void horn() {//NOT ALLOWED
        System.out.println(message);
    }
} 

class Mercedez extends Car {
    String message = "Mercedez ";
    /*void horn() {
        System.out.println(message);
    }*/
}


public class OverridingWithException {  
    public static void main(String[] args) {
        Car yo = new Mercedez();
        yo.horn();
    }
}

class Animal {
   public void eat() {
    System.out.println("Generic Animal Eating Generically");
 }
}
class Horse extends Animal {
    public void eat() {
       System.out.println("Horse eating hay, oats, "
                                + "and horse treats");
    }
    public void fight() { }
   }
}

Overriding Puzzle
class Animal {
public void eat() {
System.out.println("Generic Animal Eating Generically");
}
}
class Horse extends Animal {
public void eat() {
System.out.println("Horse eating hay, oats, "
+ "and horse treats");
}
public void fight(String weapon) { 

}
}

public class TestA {
public static void main(String[] args) {
Animal a=new Animal();
a.eat();
Animal aObj=new Horse();
aObj.fight("Nails");//Compiler Error it looks for the reference Animal for definition of fight() and it wont get So Error

Horse h=new Horse();
h.fight("Nails");//Allowed
}
}

Overriding method can not throw checked Exception higher in hierarchy than thrown by overridden method.  

Lets take one example

class Car
{
 public void accelarate() throws Exception
 {
  //Throw exception
  
 }
}
class Mercedez extends Car
{
 public void accelarate(){  //No exceptions
  
 }
 
}
public class OverridingWithException extends Animal{

 public static void main(String[] args) {
Car c=new Mercedez();
Mercedez carObj=new Mercedez();
carObj.accelarate();//THis is fine
c.accelarate();//Will throw exception. 
//since the derived class Mercedez does not thorws exception it is not valid
 }

}

If class Mercedez defines a method throws 

checked Exception not defined by class Car

Then it is not allowed. 

import java.io.FileNotFoundException;
import java.io.IOException;

class Car
{//Overriden method
 public void accelarate() throws FileNotFoundException
 {
  //Throw exception
  
 }
}
class Mercedez extends Car
{
 //Overriding method
 public void accelarate() throws IOException{  //No exceptions
  
 }
 
} 

import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ReflectPermission;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Supplier;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;

import javax.swing.JApplet;
//import sun.reflect.CallerSensitive;
//import sun.reflect.Reflection;


class Driver
{
 
String name;

public String getName() {
 return name;
}

public void setName(String name) {
 this.name = name;
}

}
class Car
{
 
String name;

public String getName() {
 return name;
}

public void setName(String name) {
 this.name = name;
}

}

public class MyLogger {//extends java.util.logging.Logger {
/*
 protected MyLogger(String name, String resourceBundleName) {
  super(name, resourceBundleName);
  // TODO Auto-generated constructor stub
 }
 
  /*******Function print array basically gets the name of methods present in the class using 

Element.getClass().getMethods().

After getting name of it uses method.invoke function to invoke the getter methods.

In this way we access getter methods.
    
 
  // generic method printArray                         
 public  < E > void printArray( List inputArray )
 {
  // Display array elements   

  for ( E element : inputArray ){    
    Method[] methods= element.getClass().getMethods();
    for(Method method:methods)
    {String name=method.getName();
     if (name.startsWith("get") && !name.equalsIgnoreCase("getClass")) {
       try {

     try {
      
      System.out.println("%%"+method.invoke(element,null) );
     } catch (IllegalAccessException | InvocationTargetException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
        } catch (IllegalArgumentException e) {
     // TODO Auto-generated catch block
         e.printStackTrace();
        }/* catch (IllegalAccessException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }*/
     }
    }
  }

   // System.out.println();
   }
    public static void main(String[] args) {
     MyLogger myObj=new MyLogger();
     String s[]=new String[]{"Suresh","Chaudhari"};
     List driverList=new ArrayList();
     Driver drr=new Driver();
     drr.setName("YUI");
     Driver dr2=new Driver();
     dr2.setName("raman");
     driverList.add(drr);
     driverList.add(dr2);
     
     List carList=new ArrayList();
     Car cr1=new Car();
     cr1.setName("D");
     Car cr2=new Car();
     cr2.setName("R");
     carList.add(cr1);
     carList.add(cr2);
     
     //myObj.printArray(s);
     myObj.printArray(driverList);
     myObj.printArray(carList);
 }

}