Method overriding in java

Answer 1

WHAT IS A CONSTRUCTOR

"It is a special type of method same name as class name that determines how an object is initialized when it's created".

what is constructor in java

Like other methods, we can also define constructor Method in our java program but unlike other methods, we cannot call a constructor directly; Java called constructor automatically when an object has created. When we use new keyword to create an object of a class, java does three thing;

Allocates memory for the object.

Initialize that object instance variable, with their initial value or to a default.

Call the constructor Method of the class.

If a class doesn't have defined any constructor method, we will still create an object of that class but we have to set instance variable or call other methods that object needs to initialize itself to that object afterward.

By defining constructor method in our own classes, we can set initial values of instance variable, call method based on those variable or call methods on other objects, or calculate initial properties of our object. We can also overload constructor, as we would regular methods, to create an object that has specific properties based on the argument we give to new.

BASIC CONSTRUCTOR

by defining a constructor looks like a regular method, with 2 basic difference.

Constructor and class name are always same.

It doesn't have any return type

For example, in the below table a simple class person, with a constructor that initializes it's instance variable based on the argument to new. The class also includes a method for the object to introduce itself, and a main() method to test each of these class.

class Person

{

String name;

int age;

Person (String n, int a)

{

name = n;

age = a;

}

void printPerson ()

{

System.out.print("Hi, I am " +name);

System.out.println(" I am "+ age + " years old.");

}

public static void main(String args[])

{

Person p;

p = new Person ("Ajab", 20);

p.printPerson();

p = new Person ("Rizwan", 30);

p.printPerson();

The output of the program is given below:

Hi, I am Ajab. I am 20 years old.

Hi, I am Rizwan. I am 30 years old

CONSTRUCTOR OVERLOADING

like other methods, constructor can also take different number and types of parameters, enabling us to create our objects with exactly the properties you want it to have, or for it to be able to calculate properties from different kinds of input.

constructor overloading in Java

For example, the MyRectone class in the given table creates a MyRectone Constructor and passing different parameter instead of creating different methods for the given arguments.

class MyRectone

{

int x1 = 0;

int y1 = 0;

int x2 = 0;

int y2 = 0;

MyRectone ( int x1, int x2, int x2, int y2)

{

this.x1 = x1;

this.y1 = y1;

this.x2 = x2;

this.y2 = y2;

}

MyRectone (Point topLeft, Point bottomRight)

{

x1 = topLeft.x;

y1 = topLeft.y;

x2 = bottomRight.x;

y2 = bottomRight.y;

}

MyRectone ( Point topLeft, int w, int h)

{

x1 = topLeft.x;

y1 = top left.y;

x2 = ( x1 + w);

y2 = (y1 + h);

}

void printRect ()

{

System.out.print ("MyRectone: ");

}

public static void main (String args [] )

{

MyRectone rect;

System.out.println ("Calling MyRectone with coordinates 35,35 70,70");

rect = new MyRectone (35,35,70,70);

rect.printRect();

System.out.println ("Calling MyRectone with coordinates (15,15) (30,30)");

rect = new MyRectone (15,15,30,30);

rect.printRect();

System.out.print (" Calling buildRect w/1 point (10,10),");

System.out.println ("width (50) and height (50)");

rect = new MyRectone ( new Point (10,10), 50, 50);

rect.printRect();

Output

Calling MyRectone with coordinates 35,35 70,70:

MyRectone: 

Calling buildRect w/1 points (15,15), (30,30):

MyRectone: 

Calling buildRect w/1 point (10,10), width (50) and height (50):

MyRectone:

CALLING ANOTHER CONSTRUCTOR

Some constructor may be a superset of another constructor defined in your class; that is, they might have the same behavior plus a little bit more. Rather than duplicating identical behavior in multiple constructor Methods in our class, it makes sense to be able to just call that first constructor from inside the body of the second constructor. Java provides a special syntax for doing this. To call a constructor defined on the current class, use this form:

this (arg1, arg2, arg3 …..);

The arguments to this are, of course, the arguments to the constructor.

Answer 2

Overloading a constructor means typing in multiple versions of the constructor, each having a different argument list, like the following examples:

class Car {

Car() { }

Car(String s) { }

}

The preceding Car class has two overloaded constructors, one that takes a string, and one with no arguments. Because there's no code in the no-arg version, it's actually identical to the default constructor the compiler supplies, but remember-since there's already a constructor in this class (the one that takes a string), the compiler won't supply a default constructor. If you want a no-arg constructor to overload the with-args version you already have, you're going to have to type it yourself, just as in the Car example.

Overloading a constructor is typically used to provide alternate ways for clients to instantiate objects of your class.

Answer 3

overloading is the ability to define more than one method with the same name in the same class with different method signatures is part of the method declaration. It is the combination of the method name and the parameter list. class overloadDemo { int c;

public int add(int a,int b) { c=a+b; System.out.println("add="+c);

}

public int add(int a, int b, int d);

{ this.add(5,6);

c=a+b+d; System.out.println("add="+c);

}

public static void main(String arg[]) { int a=5,b=6,d=10;

overloadDemo as=new overloadDemo(); as.add(5,6,10);

}

}

Answer 4

Method overriding is a concept where a method written in one class is overshadowed or masked by a method with the same name and signature in one of the child classes.

Here is a small example for method overriding

first create a class

class alpha{

void m1(){

// please look second class void name both are same

System.out.println("This is class alpha's comment");

}

}

then create your second class

class zero extends alpha{

// extends is a inbuilt java keyword

void m1(){

System.out.println("This is class zero's comment and this is the output");

}

}

you must save this file with your second class name like this

zero.java

then output should be - This is class zero's comment and this is the output

this is the simple example

Answer 5

That means that you have two or more methods with the same name, but with a different parameter list - either the number of parameters varies, or the type of at least one of the parameters.