Unit-1- JAVA

Inheritance, Polymorphism and

Packages
 Inheritance in Java
It is the mechanism in java by which one class is allowed to inherit the
features(fields and methods) of another class. In Java, inheritance means
creating new classes based on existing ones. A class that inherits from
another class can reuse the methods and fields of that class. In addition,
you can add new fields and methods to your current class as well.
Inheritance in Java:
• Code Reusability: The code written in the Superclass is common to all
subclasses. Child classes can directly use the parent class’s code.
• Method Overriding: Method Overriding is achievable only through
Inheritance. It is one of the ways by which java achieves Run Time
Polymorphism.
• Abstraction: The concept of abstract where we do not have to provide
all details is achieved through inheritance. Abstraction only shows the
functionality to the user.
Important terminologies used in Inheritance:
• Class: Class is a set of objects which shares common characteristics/ behavior
and common properties/ attributes. Class is not a real-world entity. It is just a
template or blueprint or prototype from which objects are created.
• Super Class/Parent Class: The class whose features are inherited is known as
a superclass(or a base class or a parent class).
• Sub Class/Child Class: The class that inherits the other class is known as a
subclass(or a derived class, extended class, or child class). The subclass can
add its own fields and methods in addition to the superclass fields and
methods.
• Reusability: Inheritance supports the concept of “reusability”, i.e. when we
want to create a new class and there is already a class that includes some of
the code that we want, we can derive our new class from the existing class. By
doing this, we are reusing the fields and methods of the existing class.
 How to use inheritance in Java?
• The extends keyword is used for inheritance in java. Using the
extends keyword indicates you are derived from an existing
class. In other words, “extends” refers to increased
functionality.
 Types of Inheritance in Java
1. Single Inheritance
In single inheritance, subclasses inherit the features of one
superclass. In the image below, class A serves as a base class for
the derived class B.
 2. Multilevel Inheritance
• In Multilevel Inheritance, a derived class will be inheriting a base class, and as well as
the derived class also acts as the base class for other classes. In the below image, class A
serves as a base class for the derived class B, which in turn serves as a base class for the
derived class C.
 3. Hierarchical Inheritance
• In Hierarchical Inheritance, one class serves as a superclass
(base class) for more than one subclass. In the below image,
class A serves as a base class for the derived classes B, C, and D.
 4. Multiple Inheritance (Through Interfaces)
• In Multiple inheritances, one class can have more than one superclass and
inherit features from all parent classes
• In java, we can achieve multiple inheritances only through Interfaces. In the
image below, Class C is derived from interfaces A and B..
 Hybrid Inheritance(Through Interfaces)
• It is a mix of two or more of the above types of inheritance.
Since java doesn’t support multiple inheritances with classes,
hybrid inheritance is also not possible with classes. In java, we
can achieve hybrid inheritance only through Interfaces.
 Polymorphism in Java

Polymorphism allows us to perform a single action in

different ways. In other words, polymorphism allows you
to define one interface and have multiple
implementations. The word “poly” means many and
“morphs” means forms, So it means many forms.
 In Java POLYMORPHISM is mainly divided into
two types:
• Compile-time Polymorphism
• Runtime Polymorphism
Compile-time Polymorphism

Method Overloading:
 Type-1-Method Overloading:
• When there are multiple functions with the same name but
different parameters then these functions are said to
be overloaded.
• Functions can be overloaded by change in the number of
arguments or/and a change in the type of arguments.
// Java Program for Method overloading
// Class 2
// By using Different Types of Arguments
// Class 1 // Main class
// Helper class class GFG {
class Helper {
// Method with 2 integer parameters // Main driver method
static int Multiply(int a, int b)
public static void main(String[] args)
{
// Returns product of integer numbers {
return a * b;
} // Calling method by passing
// Method 2 // input as in arguments
// With same name but with 2 double parameters
System.out.println(Helper.Multiply(2, 4));
static double Multiply(double a, double b)
System.out.println(Helper.Multiply(5.5, 6.3));
{
// Returns product of double numbers }
return a * b; }
}
}
Run-Time Polymorphism/Dynamic Method
Dispatch
Method Overriding:
 Type 2: Runtime polymorphism or Dynamic
Method Dispatch

• It is also known as Dynamic Method Dispatch. It is a process

in which a function call to the overridden method is
resolved at Runtime. This type of polymorphism is achieved
by Method Overriding. Method overriding, on the other
hand, occurs when a derived class has a definition for one of
the member functions of the base class. That base function
is said to be overridden.
// Java Program for Method Overriding
// Class 3
class subclass2 extends Parent {
// Class 1class Parent {
// Method
// Method of parent class void Print()
void Print() {
{
// Print statement
// Print statement System.out.println("subclass2");
}
}
System.out.println("parent class"); // Class 4 // Main class
} class GFG {
}
// Class 2 // Main driver method
class subclass1 extends Parent { public static void main(String[] args)
{
// Method
// Creating object of class 1
void Print() { Parent a;
System.out.println("subclass1"); }
} // Now we will be calling print methods
// inside main() method

a = new subclass1();
a.Print();

a = new subclass2();
a.Print();
}
 Packages In Java
Package in Java is a mechanism to encapsulate a group of classes, sub packages and interfaces.
Packages are used for:
• Preventing naming conflicts. For example there can be two classes with name Employee in
two packages, college.staff.cse.Employee and college.staff.ee.Employee
• Making searching/locating and usage of classes, interfaces, enumerations and annotations
easier
• Providing controlled access: protected and default have package level access control. A
protected member is accessible by classes in the same package and its subclasses. A default
member (without any access specifier) is accessible by classes in the same package only.
• Packages can be considered as data encapsulation (or data-hiding).
Note: All we need to do is put related classes into packages. After that, we can simply write an
import class from existing packages and use it in our program. A package is a container of a
group of related classes where some of the classes are accessible are exposed and others are
kept for internal purpose.
We can reuse existing classes from the packages as many time as we need it in our program.
• Adding a class to a Package : We can add more classes to a created
package by using package name at the top of the program and
saving it in the package directory. We need a new java file to define
a public class, otherwise we can add the new class to an
existing .java file and recompile it.
• Subpackages: Packages that are inside another package are
the subpackages. These are not imported by default, they have to
imported explicitly. Also, members of a subpackage have no access
privileges, i.e., they are considered as different package for
protected and default access specifiers.
Example :
• import java.util.*; util is a subpackage created inside java package.
 Types of packages:
• Built-in Packages
• These packages consist of a large number of classes which are a part of
Java API.Some of the commonly used built-in packages are:
1) java.lang: Contains language support classes(e.g classed which defines
primitive data types, math operations). This package is automatically
imported.
2) java.io: Contains classed for supporting input / output operations.
3) java.util: Contains utility classes which implement data structures like
Linked List, Dictionary and support ; for Date / Time operations.
4) java.applet: Contains classes for creating Applets.
5) java.awt: Contain classes for implementing the components for
graphical user interfaces (like button , ;menus etc).
6) java.net: Contain classes for supporting networking operations.
 User-defined packages
• These are the packages that are defined by the user. First we create a
directory myPackage (name should be same as the name of the package). Then
create the MyClass inside the directory with the first statement being the package
names.
 Advantage of Java Package
1) Java package is used to categorize the classes and interfaces so that they can be easily
maintained.
2) Java package provides access protection.
3) Java package removes naming collision.