Overriding and Overloading
practice.

What is the purpose of the "super" keyword in method overloading?

In Java, can a subclass overload a method from its superclass?

What is the result of the following code snippet?

class Parent {
void display() {
System.out.println("Parent");
}
}
class Child extends Parent {
void display() {
System.out.println("Child");
}
}
public class Main {
public static void main(String[] args) {
Parent obj = new Parent();
obj.display();
}
}

In Java, can a method be overloaded by changing only the return type?

What is the purpose of method hiding in Java?

In method overriding, is it mandatory for the method name in the subclass to be the same as the method name in the superclass?

What happens when a subclass tries to override a static method from the superclass in Java?

In method overloading, can methods have the same name and the same parameter types if their access modifiers are different?

What is the purpose of method overriding in Java?

In Java, can a subclass override a protected method from its superclass?

What is output of the program?

class Test{
        public void display(int x, double y){
                System.out.println(x+y);
        } 
        public double display(int p, double q){
                return (p+q);
        }
        public static void main(String args[]){
                Test test = new Test();
                test.display(4, 5.0);
                System.out.println(test.display(4, 5.0));
        }
}

what is the result of the following piece of code:

public class Person{
        public void talk(){
                System.out.print("I am a Person");
        }
}

public class Student extends Person{
        public void talk(){
                System.out.print("I am a Student");
        }
}

public class Test{
        public static void main(String args[]){
                Person p = new Student();
                p.talk();
        }
}

What will be the output?

interface A{
	public void method1();
}
class One implements A{
	public void method1(){
		System.out.println("Class One method1");
	}
}
class Two extends One{
	public void method1(){
		System.out.println("Class Two method1");
	}
}
public class Test extends Two{
	public static void main(String[] args){
		A a = new Two();
		a.method1();
	}
}

What will be the output of the following program code?

class Rectangle{
      public int area(int length, int width){
            return  length*width;
      }
}
class Square extends Rectangle{
      public int area(long length, long width){
            return  (int) Math.pow(length, 2);
      }
}
public class Test{
      public static void main(String args[]){
            Square r = new Square();
            System.out.println(r.area(5 , 4));
      }
}

What will be printed after executing following program code?

class Base{
	int value = 0;
        Base(){
        	addValue();
        }
        void addValue(){
        	value += 10;
        }
        int getValue(){
        	return value;
        }
}
class Derived extends Base{
	Derived(){
		addValue();
	}
	void addValue(){
		value +=  20;
	}
}
public class Test{
	public static void main(String[] args){
		Base b = new Derived();
		System.out.println(b.getValue());
	}
}

What will be the output?

class A{
	static void method(){
		System.out.println("Class A method");
	}
}
class B extends A{
	static void method(){
		System.out.println("Class B method");
	}
}
public class Test{
	public static void main(String args[]){
		A a = new B();
		a.method();
	}
}

____________ method cannot be overridden.

What will be the output?

class A{
      int i = 10;
      public void printValue(){
            System.out.print("Value-A");
      }
}

class B extends A{
      int i = 12;
      public void printValue(){
            System.out.print("Value-B");
      }
}

public class Test{
      public static void main(String args[]){
            A a = new B();
            a.printValue();
            System.out.print(a.i);
      }
}

What is the output for the below code?

public class Test{
      public static void printValue(int i, int j, int k){
            System.out.println("int");
      }

      public static void printValue(byte...b){
            System.out.println("long");
      }

      public static void main(String... args){
            byte b = 9;
            printValue(b,b,b);
      }
}

Determine output:

class A{
      public void printValue(){
            System.out.println("Value-A");
      }
}
class B extends A{
      public void printNameB(){
            System.out.println("Name-B");
      }
}
class C extends A{
      public void printNameC(){
            System.out.println("Name-C");
      }
}

public class Test{
      public static void main (String[] args){
            B b = new B();
            C c = new C();
            newPrint(b);
            newPrint(c);
      }
      public static void newPrint(A a){
            a.printValue();
      }
 }