Constructor overloading in Java allows a class to have multiple constructors that differ in their parameter lists, while inheritance allows a subclass to inherit properties and behaviors from a parent class using the extends keyword, and method overriding provides a specific implementation of a method defined in the parent class in the subclass.
Constructor overloading in Java allows a class to have multiple constructors that differ in their parameter lists, while inheritance allows a subclass to inherit properties and behaviors from a parent class using the extends keyword, and method overriding provides a specific implementation of a method defined in the parent class in the subclass.
Constructor overloading in Java allows a class to have multiple constructors that differ in their parameter lists, while inheritance allows a subclass to inherit properties and behaviors from a parent class using the extends keyword, and method overriding provides a specific implementation of a method defined in the parent class in the subclass.
Constructor overloading in Java allows a class to have multiple constructors that differ in their parameter lists, while inheritance allows a subclass to inherit properties and behaviors from a parent class using the extends keyword, and method overriding provides a specific implementation of a method defined in the parent class in the subclass.
Download as DOCX, PDF, TXT or read online from Scribd
Download as docx, pdf, or txt
You are on page 1/ 9
Constructor Overloading in Java
Constructor overloading is a technique in Java in which a class can have any
number of constructors that differ in parameter lists.
Example of Constructor Overloading
class Student{ int id; String name; int age; Student(int i,String n){ id = i; name = n; } Student(int i,String n,int a){ id = i; name = n; age=a; } void display(){System.out.println(id+" "+name+" "+age);}
public static void main(String args[]){
Student s1 = new Student(1,"ISOEH"); Student s2 = new Student(2,"ISOAH",20); s1.display(); s2.display(); } }
Output:
1 ISOEH 0 2 ISOAH 20 Java Copy Constructor
There is no copy constructor in java. But, we can copy the values of
one object to another like copy constructor in C++.
There are many ways to copy the values of one object into another in java. They are:
By constructor
By assigning the values of one object into another
In this example, we are going to copy the values of one object into another using java constructor.
class Student{ int id; String name;
Student(int i,String n){
id = i; name = n; }
Student(Student s){ id = s.id; name =s.name; }
void display(){System.out.println(id+" "+name);}
public static void main(String args[]){
Student s1 = new Student(1,"ISOEH"); Student s2 = new Student(s1); s1.display(); s2.display(); } } Output:
1 ISOEH 1 ISOEH
Copying values without constructor
We can copy the values of one object into another by assigning the objects values to another object. In this case, there is no need to create the constructor.
class Student{ int id; String name; Student(int i,String n){ id = i; name = n; } Student(){} void display(){System.out.println(id+" "+name);}
public static void main(String args[]){
Student s1 = new Student(1,"ISOEH"); Student s2 = new Student(); s2.id=s1.id; s2.name=s1.name; s1.display(); s2.display(); } }
Output:
1 ISOEH 1 ISOEH Inheritance in Java Inheritance in java is a mechanism in which one object acquires all the properties and behaviors of parent object.
The idea behind inheritance in java is that you can create new classes that are built upon existing classes. Inheritance represents the IS-A relationship, also known as parent-child relationship.
Why use inheritance in java
For Method Overriding (so runtime polymorphism can be
achieved).
For Code Reusability.
Syntax of Java Inheritance
class Subclass-name extends Superclass-name
{ //methods and fields }
The extends keyword indicates that you are making a new class that derives from an existing class.
In the terminology of Java, a class that is inherited is called a super
class. The new class is called a subclass. Understanding the simple example of inheritance
As displayed in the above figure, Programmer is the subclass and Employee is
the superclass. Relationship between two classes is Programmer IS-A Employee.It means that Programmer is a type of Employee.
class Employee{ float salary=40000; } class Programmer extends Employee{ int bonus=10000; public static void main(String args[]){ Programmer p=new Programmer(); System.out.println("Programmer salary is:"+p.salary); System.out.println("Bonus of Programmer is:"+p.bonus); } } Programmer salary is:40000.0 Bonus of programmer is:10000
In the above example, Programmer object can access the field of own class as well as of Employee class i.e. code reusability.
Types of inheritance in java
On the basis of class, there can be three types of inheritance in java: single, multilevel and hierarchical.
In java programming, multiple and hybrid inheritance is supported
through interface only. We will learn about interfaces later.
Note: Multiple inheritance is not supported in java through class.
When a class extends multiple classes i.e. known as multiple inheritance. For Example:
Method Overriding in Java
If subclass (child class) has the same method as declared in the parent class, it is known as method overriding in java.
In other words, If subclass provides the specific implementation of the
method that has been provided by one of its parent class, it is known as method overriding.
Usage of Java Method Overriding
o Method overriding is used to provide specific implementation of a method that is already provided by its super class.
o Method overriding is used for runtime polymorphism
Rules for Java Method Overriding:
1. method must have the same name as in the parent class
2. method must have the same parameter as in the parent class.
3. method must have the same return type as in parent class.
4. must be IS-A relationship (inheritance).
Example of method overriding
In this example, we have defined the run method in the subclass as defined in the parent class but it has some specific implementation. The name and parameter of the method is same and there is IS-A relationship between the classes, so there is method overriding.
class Trainer{ void run(){System.out.println("Trainer is guiding");} } class Student extends Trainer { void run(){System.out.println("Student is learning");}
public static void main(String args[]){
Trainer obj = new Trainer (); Student obj2 = new Student (); obj.run(); obj2.run(); } Output: Trainer is guiding Student is learning
