Java

Unit 2&3 mix

 Inheritance in Java
Java, Inheritance is an important pillar of OOP(Object-Oriented
Programming). 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.

Why Do We Need Java Inheritance?

• Code Reusability: The code written in the Superclass is common to

all subclasses. Child classes can directly use the parent class 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 Java 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.

Syntax :
class derived-class extends base-class
{
//methods and fields
}
Inheritance in Java Example

Example: In the below example of inheritance, class Bicycle is a

base class, class MountainBike is a derived class that extends
the Bicycle class and class Test is a driver class to run the
program.
// Java program to illustrate the

// concept of inheritance

// base class

class Bicycle {

// the Bicycle class has two fields

public int gear;

 public int speed;

// the Bicycle class has one constructor

public Bicycle(int gear, int speed)

this.gear = gear;

this.speed = speed;

// the Bicycle class has three methods

public void applyBrake(int decrement)

speed -= decrement;

public void speedUp(int increment)

speed += increment;

// toString() method to print info of Bicycle

public String toString()

return ("No of gears are " + gear + "\n"

+ "speed of bicycle is " + speed);

}
// derived class

class MountainBike extends Bicycle {

// the MountainBike subclass adds one more field

public int seatHeight;

// the MountainBike subclass has one constructor

public MountainBike(int gear, int speed,

int startHeight)

// invoking base-class(Bicycle) constructor

super(gear, speed);

seatHeight = startHeight;

// the MountainBike subclass adds one more method

public void setHeight(int newValue)

seatHeight = newValue;

// overriding toString() method

// of Bicycle to print more info

@Override public String toString()

return (super.toString() + "\nseat height is "

 + seatHeight);

// driver class

public class Test {

public static void main(String args[])

MountainBike mb = new MountainBike(3, 100, 25);

System.out.println(mb.toString());

Output
No of gears are 3
speed of bicycle is 100
seat height is 25

In the above program, when an object of MountainBike class is

created, a copy of all methods and fields of the superclass
acquires memory in this object. That is why by using the object
of the subclass we can also access the members of a superclass.

Please note that during inheritance only the object of the subclass
is created, not the superclass. For more, refer to Java Object
Creation of Inherited Class.

Example 2: In the below example of inheritance, class Employee

is a base class, class Engineer is a derived class that extends the
Employee class and class Test is a driver class to run the
program.
// Java Program to illustrate Inheritance (concise)

import java.io.*;

// Base or Super Class

class Employee {

int salary = 60000;

// Inherited or Sub Class

class Engineer extends Employee {

int benefits = 10000;

// Driver Class

class Gfg {

public static void main(String args[])

Engineer E1 = new Engineer();

System.out.println("Salary : " + E1.salary

+ "\nBenefits : " + E1.benefits);

Output
Salary : 60000
Benefits : 10000

Illustrative image of the program:

In practice, inheritance, and polymorphism are used together in
Java to achieve fast performance and readability of code.

Java Inheritance Types

Below are the different types of inheritance which are supported

by Java.

1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance

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.
Single inheritance

// Java program to illustrate the

// concept of single inheritance

import java.io.*;

import java.lang.*;

import java.util.*;

// Parent class

class one {

public void print_geek()

System.out.println("Geeks");

class two extends one {

public void print_for() { System.out.println("for"); }

}

// Driver class

public class Main {

// Main function

public static void main(String[] args)

two g = new two();

g.print_geek();

g.print_for();

g.print_geek();

Output
Geeks
for
Geeks

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. In Java, a class cannot directly access
the grandparent’s members.
Multilevel Inheritance

// Java program to illustrate the

// concept of Multilevel inheritance

import java.io.*;

import java.lang.*;

import java.util.*;

class one {

public void print_geek()

System.out.println("Geeks");

class two extends one {

public void print_for() { System.out.println("for"); }

}
class three extends two {

public void print_geek()

System.out.println("Geeks");

// Drived class

public class Main {

public static void main(String[] args)

three g = new three();

g.print_geek();

g.print_for();

g.print_geek();

Output
Geeks
for
Geeks

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.
// Java program to illustrate the

// concept of Hierarchical inheritance

class A {

public void print_A() { System.out.println("Class A"); }

class B extends A {

public void print_B() { System.out.println("Class B"); }

class C extends A {

public void print_C() { System.out.println("Class C"); }

class D extends A {

public void print_D() { System.out.println("Class D"); }

}
// Driver Class

public class Test {

public static void main(String[] args)

B obj_B = new B();

obj_B.print_A();

obj_B.print_B();

C obj_C = new C();

obj_C.print_A();

obj_C.print_C();

D obj_D = new D();

obj_D.print_A();

obj_D.print_D();

Output
Class A
Class B
Class A
Class C
Class A
Class D

4. Multiple Inheritance (Through Interfaces)

In Multiple inheritances, one class can have more than one

superclass and inherit features from all parent classes. Please
note that Java does not support multiple inheritances with
classes. In Java, we can achieve multiple inheritances only
 through Interfaces. In the image below, Class C is derived from
interfaces A and B.

Multiple Inheritance

// Java program to illustrate the

// concept of Multiple inheritance

import java.io.*;

import java.lang.*;

import java.util.*;

interface one {

public void print_geek();

interface two {

public void print_for();

}
interface three extends one, two {

public void print_geek();

class child implements three {

@Override public void print_geek()

System.out.println("Geeks");

public void print_for() { System.out.println("for"); }

// Drived class

public class Main {

public static void main(String[] args)

child c = new child();

c.print_geek();

c.print_for();

c.print_geek();

Output
Geeks
for
Geeks

5. 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.

Hybrid Inheritance

Java IS-A type of Relationship

IS-A is a way of saying: This object is a type of that object. Let

us see how the extends keyword is used to achieve inheritance.
public class SolarSystem {

public class Earth extends SolarSystem {

public class Mars extends SolarSystem {

public class Moon extends Earth {

}
Now, based on the above example, in Object-Oriented terms, the
following are true:-

• SolarSystem is the superclass of Earth class.

• SolarSystem is the superclass of Mars class.
• Earth and Mars are subclasses of SolarSystem class.
• Moon is the subclass of both Earth and SolarSystem classes.

class SolarSystem {

class Earth extends SolarSystem {

class Mars extends SolarSystem {

public class Moon extends Earth {

public static void main(String args[])

SolarSystem s = new SolarSystem();

Earth e = new Earth();

Mars m = new Mars();

System.out.println(s instanceof SolarSystem);

System.out.println(e instanceof Earth);

System.out.println(m instanceof SolarSystem);

Output
true
true
true
What Can Be Done in a Subclass?

In sub-classes we can inherit members as is, replace them, hide

them, or supplement them with new members:

• The inherited fields can be used directly, just like any other fields.
• We can declare new fields in the subclass that are not in the
superclass.
• The inherited methods can be used directly as they are.
• We can write a new instance method in the subclass that has the same
signature as the one in the superclass, thus overriding it (as in the
example above, toString() method is overridden).
• We can write a new static method in the subclass that has the same
signature as the one in the superclass, thus hiding it.
• We can declare new methods in the subclass that are not in the
superclass.
• We can write a subclass constructor that invokes the constructor of
the superclass, either implicitly or by using the keyword super.

Advantages Of Inheritance in Java:

1. Code Reusability: Inheritance allows for code reuse and reduces the
amount of code that needs to be written. The subclass can reuse the
properties and methods of the superclass, reducing duplication of
code.
2. Abstraction: Inheritance allows for the creation of abstract classes
that define a common interface for a group of related classes. This
promotes abstraction and encapsulation, making the code easier to
maintain and extend.
3. Class Hierarchy: Inheritance allows for the creation of a class
hierarchy, which can be used to model real-world objects and their
relationships.
4. Polymorphism: Inheritance allows for polymorphism, which is the
ability of an object to take on multiple forms. Subclasses can
override the methods of the superclass, which allows them to change
their behavior in different ways.
Disadvantages of Inheritance in Java:

1. Complexity: Inheritance can make the code more complex and harder
to understand. This is especially true if the inheritance hierarchy is
deep or if multiple inheritances is used.
2. Tight Coupling: Inheritance creates a tight coupling between the
superclass and subclass, making it difficult to make changes to the
superclass without affecting the subclass.

Conclusion

Let us check some important points from the article are mentioned
below:

• Default superclass: Except Object class, which has no superclass,

every class has one and only one direct superclass (single inheritance).
In the absence of any other explicit superclass, every class is
implicitly a subclass of the Object class.
• Superclass can only be one: A superclass can have any number of
subclasses. But a subclass can have only one superclass. This is
because Java does not support multiple inheritances with classes.
Although with interfaces, multiple inheritances are supported by
Java.
• Inheriting Constructors: A subclass inherits all the members (fields,
methods, and nested classes) from its superclass. Constructors are
not members, so they are not inherited by subclasses, but the
constructor of the superclass can be invoked from the subclass.
• Private member inheritance: A subclass does not inherit the private
members of its parent class. However, if the superclass has public or
protected methods(like getters and setters) for accessing its private
fields, these can also be used by the subclass.

Method Overriding in Java

1. Understanding the problem without method overriding
2. Can we override the static method
3. Method overloading vs. method overriding
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 a subclass provides the specific implementation

of the method that has been declared by one of its parent class,
it is known as method overriding.

Usage of Java Method Overriding

• Method overriding is used to provide the specific implementation of

a method which is already provided by its superclass.
• Method overriding is used for runtime polymorphism

Rules for Java Method Overriding

1. The method must have the same name as in the parent class
2. The method must have the same parameter as in the parent class.
3. There must be an IS-A relationship (inheritance).
Understanding the problem without method overriding

Let's understand the problem that we may face in the program if

we don't use method overriding.

1. //Java Program to demonstrate why we need method overrid

ing
2. //Here, we are calling the method of parent class with child
3. //class object.
4. //Creating a parent class
5. class Vehicle{
6. void run(){System.out.println("Vehicle is running");}
7. }
8. //Creating a child class
9. class Bike extends Vehicle{
10. public static void main(String args[]){
11. //creating an instance of child class
12. Bike obj = new Bike();
13. //calling the method with child class instance
14. obj.run();
15. }
16. }

Test it Now

Output:
Vehicle is running

Problem is that I have to provide a specific implementation of run()

method in subclass that is why we use method overriding.
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 are the
same, and there is IS-A relationship between the classes, so
there is method overriding.

1. //Java Program to illustrate the use of Java Method Overrid

ing
2. //Creating a parent class.
3. class Vehicle{
4. //defining a method
5. void run(){System.out.println("Vehicle is running");}
6. }
7. //Creating a child class
8. class Bike2 extends Vehicle{
9. //defining the same method as in the parent class
10. void run(){System.out.println("Bike is running safely");}
11.
12. public static void main(String args[]){
13. Bike2 obj = new Bike2();//creating object
14. obj.run();//calling method
15. }
16. }

Test it Now

Output:
Bike is running safely
A real example of Java Method Overriding

Consider a scenario where Bank is a class that provides

functionality to get the rate of interest. However, the rate of
interest varies according to banks. For example, SBI, ICICI and
AXIS banks could provide 8%, 7%, and 9% rate of interest.

Java method overriding is mostly used in Runtime Polymorphism which we

will learn in next pages.

1. //Java Program to demonstrate the real scenario of Java Me

thod Overriding
2. //where three classes are overriding the method of a parent class.
3. //Creating a parent class.
4. class Bank{
5. int getRateOfInterest(){return 0;}
6. }
7. //Creating child classes.
8. class SBI extends Bank{
9. int getRateOfInterest(){return 8;}
10. }
11.
12. class ICICI extends Bank{
13. int getRateOfInterest(){return 7;}
14. }
15. class AXIS extends Bank{
 16. int getRateOfInterest(){return 9;}
17. }
18. //Test class to create objects and call the methods
19. class Test2{
20. public static void main(String args[]){
21. SBI s=new SBI();
22. ICICI i=new ICICI();
23. AXIS a=new AXIS();
24. System.out.println("SBI Rate of Interest: "+s.getRateOfIntere
st());
25. System.out.println("ICICI Rate of Interest: "+i.getRate
OfInterest());
26. System.out.println("AXIS Rate of Interest: "+a.getRateOfInte
rest());
27. }
28. }

Test it Now
Output:
SBI Rate of Interest: 8
ICICI Rate of Interest: 7
AXIS Rate of Interest: 9

Abstract class in Java

A class which is declared with the abstract keyword is known as an abstract
class in Java. It can have abstract and non-abstract methods (method
with the body).
Before learning the Java abstract class, let's understand the abstraction
in Java first.

Abstraction in Java
Abstraction is a process of hiding the implementation details and showing
only functionality to the user.
Another way, it shows only essential things to the user and hides the
internal details, for example, sending SMS where you type the text and
 send the message. You don't know the internal processing about the
message delivery.
Abstraction lets you focus on what the object does instead of how it does
it.
Ways to achieve Abstraction
There are two ways to achieve abstraction in java
1. Abstract class (0 to 100%)
2. Interface (100%)

Abstract class in Java

A class which is declared as abstract is known as an abstract class. It can
have abstract and non-abstract methods. It needs to be extended and
its method implemented. It cannot be instantiated.
Points to Remember
• An abstract class must be declared with an abstract keyword.
• It can have abstract and non-abstract methods.
• It cannot be instantiated.
• It can have constructors and static methods also.
• It can have final methods which will force the subclass not to change
the body of the method.
Example of abstract class
1. abstract class A{}

Abstract Method in Java

A method which is declared as abstract and does not have implementation
is known as an abstract method.
Example of abstract method
1. abstract void printStatus();//no method body and abstract

Example of Abstract class that has an abstract method

In this example, Bike is an abstract class that contains only one abstract
method run. Its implementation is provided by the Honda class.
1. abstract class Bike{
2. abstract void run();
3. }
4. class Honda4 extends Bike{
5. void run(){System.out.println("running safely");}
6. public static void main(String args[]){
7. Bike obj = new Honda4();
8. obj.run();
9. }
10. }
Test it Now
running safely

Understanding the real scenario of Abstract class

In this example, Shape is the abstract class, and its implementation is
provided by the Rectangle and Circle classes.
Mostly, we don't know about the implementation class (which is hidden to
the end user), and an object of the implementation class is provided by
the factory method.
A factory method is a method that returns the instance of the class. We
will learn about the factory method later.
In this example, if you create the instance of Rectangle class, draw()
method of Rectangle class will be invoked.
File: TestAbstraction1.java
1. abstract class Shape{
2. abstract void draw();
3. }
4. //In real scenario, implementation is provided by others i.e. unknown
by end user
5. class Rectangle extends Shape{
6. void draw(){System.out.println("drawing rectangle");}
7. }
8. class Circle1 extends Shape{
9. void draw(){System.out.println("drawing circle");}
10. }
11. //In real scenario, method is called by programmer or user
12. class TestAbstraction1{
13. public static void main(String args[]){
14. Shape s=new Circle1();//In a real scenario, object is provided th
rough method, e.g., getShape() method
15. s.draw();
16. }
17. }
Test it Now
drawing circle

Another example of Abstract class in java

File: TestBank.java
1. abstract class Bank{
2. abstract int getRateOfInterest();
3. }
4. class SBI extends Bank{
5. int getRateOfInterest(){return 7;}
6. }
 7. class PNB extends Bank{
8. int getRateOfInterest(){return 8;}
9. }
10.
11. class TestBank{
12. public static void main(String args[]){
13. Bank b;
14. b=new SBI();
15. System.out.println("Rate of Interest is: "+b.getRateOfInterest
()+" %");
16. b=new PNB();
17. System.out.println("Rate of Interest is: "+b.getRateOfInterest
()+" %");
18. }}
Test it Now
Rate of Interest is: 7 %
Rate of Interest is: 8 %

Abstract class having constructor, data member and methods

(https://www.javatpoint.com/abstract-class-in-java)

An abstract class can have a data member, abstract method, method body
(non-abstract method), constructor, and even main() method.
File: TestAbstraction2.java
1. //Example of an abstract class that has abstract and non-
abstract methods
2. abstract class Bike{
3. Bike(){System.out.println("bike is created");}
4. abstract void run();
5. void changeGear(){System.out.println("gear changed");}
6. }
7. //Creating a Child class which inherits Abstract class
8. class Honda extends Bike{
9. void run(){System.out.println("running safely..");}
10. }
 11. //Creating a Test class which calls abstract and non-
abstract methods
12. class TestAbstraction2{
13. public static void main(String args[]){
14. Bike obj = new Honda();
15. obj.run();
16. obj.changeGear();
17. }
18. }
Test it Now
bike is created
running safely..
gear changed

Rule: If there is an abstract method in a class, that class must be

abstract.
1. class Bike12{
2. abstract void run();
3. }
Test it Now
compile time error
Rule: If you are extending an abstract class that has an abstract
method, you must either provide the implementation of the method
or make this class abstract.

Another real scenario of abstract class

The abstract class can also be used to provide some implementation of the
interface. In such case, the end user may not be forced to override all
the methods of the interface.
Note: If you are beginner to java, learn interface first and skip this
example.
1. interface A{
2. void a();
 3. void b();
4. void c();
5. void d();
6. }
7.
8. abstract class B implements A{
9. public void c(){System.out.println("I am c");}
10. }
11.
12. class M extends B{
13. public void a(){System.out.println("I am a");}
14. public void b(){System.out.println("I am b");}
15. public void d(){System.out.println("I am d");}
16. }
17.
18. class Test5{
19. public static void main(String args[]){
20. A a=new M();
21. a.a();
22. a.b();
23. a.c();
24. a.d();
25. }}
Test it Now
Output: I am a
I am b
I am c
I am d

Java Package
(https://www.javatpoint.com/package)

1. Java Package
2. Example of package
 3. Accessing package
1. By import packagename.*
2. By import packagename.classname
3. By fully qualified name
4. Subpackage
5. Sending class file to another directory
6. -classpath switch
7. 4 ways to load the class file or jar file
8. How to put two public class in a package
9. Static Import
10. Package class

A java package is a group of similar types of classes, interfaces

and sub-packages.

Package in java can be categorized in two form, built-in package

and user-defined package.

There are many built-in packages such as java, lang, awt, javax,
swing, net, io, util, sql etc.

Here, we will have the detailed learning of creating and using user-
defined packages.

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.

Simple example of java package

The package keyword is used to create a package in java.

1. //save as Simple.java
2. package mypack;
3. public class Simple{
4. public static void main(String args[]){
5. System.out.println("Welcome to package");
6. }
7. }

How to compile java package

If you are not using any IDE, you need to follow the syntax given
below:

1. javac -d directory javafilename

For example
 1. javac -d . Simple.java

The -d switch specifies the destination where to put the

generated class file. You can use any directory name like /home
(in case of Linux), d:/abc (in case of windows) etc. If you want
to keep the package within the same directory, you can use .
(dot).

How to run java package program

You need to use fully qualified name e.g. mypack.Simple etc to run
the class.

To Compile: javac -d . Simple.java

To Run: java mypack.Simple

Output:Welcome to package
The -d is a switch that tells the compiler where to put the class file i.e. it
represents destination. The . represents the current folder.

How to access package from another package?

There are three ways to access the package from outside the
package.

1. import package.*;
2. import package.classname;
3. fully qualified name.

1) Using packagename.*

If you use package.* then all the classes and interfaces of this
package will be accessible but not subpackages.
The import keyword is used to make the classes and interface of
another package accessible to the current package.

Example of package that import the packagename.*

1. //save by A.java
2. package pack;
3. public class A{
4. public void msg(){System.out.println("Hello");}
5. }

1. //save by B.java
2. package mypack;
3. import pack.*;
4.
5. class B{
6. public static void main(String args[]){
7. A obj = new A();
8. obj.msg();
9. }
10. }

Output:Hello

2) Using packagename.classname

If you import package.classname then only declared class of this

package will be accessible.

Example of package by import package.classname

1. //save by A.java
2.
3. package pack;
4. public class A{
5. public void msg(){System.out.println("Hello");}
 6. }

1. //save by B.java
2. package mypack;
3. import pack.A;
4.
5. class B{
6. public static void main(String args[]){
7. A obj = new A();
8. obj.msg();
9. }
10. }

Output:Hello

3) Using fully qualified name

If you use fully qualified name then only declared class of this
package will be accessible. Now there is no need to import. But
you need to use fully qualified name every time when you are
accessing the class or interface.

It is generally used when two packages have same class name e.g.
java.util and java.sql packages contain Date class.

Example of package by import fully qualified name

1. //save by A.java
2. package pack;
3. public class A{
4. public void msg(){System.out.println("Hello");}
5. }

1. //save by B.java
2. package mypack;
3. class B{
 4. public static void main(String args[]){
5. pack.A obj = new pack.A();//using fully qualified name
6. obj.msg();
7. }
8. }

Output:Hello
Note: If you import a package, subpackages will not be imported.

If you import a package, all the classes and interface of that

package will be imported excluding the classes and interfaces of
the subpackages. Hence, you need to import the subpackage as
well.

Note: Sequence of the program must be package then import then class.

Subpackage in java

Package inside the package is called the subpackage. It should be

created to categorize the package further.

Let's take an example, Sun Microsystem has definded a package

named java that contains many classes like System, String,
Reader, Writer, Socket etc. These classes represent a
particular group e.g. Reader and Writer classes are for
 Input/Output operation, Socket and ServerSocket classes are
for networking etc and so on. So, Sun has subcategorized the
java package into subpackages such as lang, net, io etc. and put
the Input/Output related classes in io package, Server and
ServerSocket classes in net packages and so on.

The standard of defining package is domain.company.package e.g.

com.javatpoint.bean or org.sssit.dao.

Example of Subpackage

1. package com.javatpoint.core;
2. class Simple{
3. public static void main(String args[]){
4. System.out.println("Hello subpackage");
5. }
6. }

To Compile: javac -d . Simple.java

To Run: java com.javatpoint.core.Simple

Output:Hello subpackage

How to send the class file to another directory or drive?

There is a scenario, I want to put the class file of A.java source

file in classes folder of c: drive. For example:
 1. //save as Simple.java
2. package mypack;
3. public class Simple{
4. public static void main(String args[]){
5. System.out.println("Welcome to package");
6. }
7. }

To Compile:

e:\sources> javac -d c:\classes Simple.java

To Run:

To run this program from e:\source directory, you need to set classpath
of the directory where the class file resides.

e:\sources> set classpath=c:\classes;.;

e:\sources> java mypack.Simple

Another way to run this program by -classpath switch of java:

The -classpath switch can be used with javac and java tool.

To run this program from e:\source directory, you can use -

classpath switch of java that tells where to look for class file.
For example:

e:\sources> java -classpath c:\classes mypack.Simple

Output:Welcome to package

Ways to load the class files or jar files

There are two ways to load the class files temporary and permanent.

• Temporary
o By setting the classpath in the command prompt

o By -classpath switch

• Permanent
o By setting the classpath in the environment variables

o By creating the jar file, that contains all the class files, and

copying the jar file in the jre/lib/ext folder.

Rule: There can be only one public class in a java source file and it must be
saved by the public class name.

1. //save as C.java otherwise Compilte Time Error

2.
3. class A{}
4. class B{}
5. public class C{}

How to put two public classes in a package?

If you want to put two public classes in a package, have two java source
files containing one public class, but keep the package name same. For
example:

1. //save as A.java
2.
3. package javatpoint;
4. public class A{}

1. //save as B.java
2.
3. package javatpoint;
 4. public class B{}

Exception Handling in Java

1. Exception Handling
2. Advantage of Exception Handling
3. Hierarchy of Exception classes
4. Types of Exception
5. Exception Example
6. Scenarios where an exception may occur

The Exception Handling in Java is one of the powerful mechanism

to handle the runtime errors so that the normal flow of the
application can be maintained.

In this tutorial, we will learn about Java exceptions, it's types, and
the difference between checked and unchecked exceptions.

What is Exception in Java?

Dictionary Meaning: Exception is an abnormal condition.

In Java, an exception is an event that disrupts the normal flow of

the program. It is an object which is thrown at runtime.

What is Exception Handling?

Exception Handling is a mechanism to handle runtime errors such

as ClassNotFoundException, IOException, SQLException,
RemoteException, etc.

Advantage of Exception Handling

The core advantage of exception handling is to maintain the

normal flow of the application. An exception normally disrupts
the normal flow of the application; that is why we need to handle
exceptions. Let's consider a scenario:
 1. statement 1;
2. statement 2;
3. statement 3;
4. statement 4;
5. statement 5;//exception occurs
6. statement 6;
7. statement 7;
8. statement 8;
9. statement 9;
10. statement 10;

Suppose there are 10 statements in a Java program and an

exception occurs at statement 5; the rest of the code will not
be executed, i.e., statements 6 to 10 will not be executed.
However, when we perform exception handling, the rest of the
statements will be executed. That is why we use exception
handling in Java.

Do You Know?

• What is the difference between checked and unchecked

exceptions?
• What happens behind the code int data=50/0;?
• Why use multiple catch block?
• Is there any possibility when the finally block is not executed?
• What is exception propagation?
• What is the difference between the throw and throws keyword?
• What are the 4 rules for using exception handling with method
overriding?

Hierarchy of Java Exception classes

The java.lang.Throwable class is the root class of Java Exception

hierarchy inherited by two subclasses: Exception and Error. The
hierarchy of Java Exception classes is given below:
Types of Java Exceptions

There are mainly two types of exceptions: checked and unchecked.

An error is considered as the unchecked exception. However,
according to Oracle, there are three types of exceptions
namely:

1. Checked Exception
2. Unchecked Exception
3. Error

Difference between Checked and Unchecked Exceptions

1) Checked Exception

The classes that directly inherit the Throwable class except

RuntimeException and Error are known as checked exceptions.
For example, IOException, SQLException, etc. Checked
exceptions are checked at compile-time.

2) Unchecked Exception

The classes that inherit the RuntimeException are known as

unchecked exceptions. For example, ArithmeticException,
NullPointerException, ArrayIndexOutOfBoundsException, etc.
 Unchecked exceptions are not checked at compile-time, but they
are checked at runtime.

3) Error

Error is irrecoverable. Some example of errors are

OutOfMemoryError, VirtualMachineError, AssertionError etc.

Java Exception Keywords

Java provides five keywords that are used to handle the exception.
The following table describes each.

Keyword Description

The "try" keyword is used to specify a block where we should

try place an exception code. It means we can't use try block alone.
The try block must be followed by either catch or finally.

The "catch" block is used to handle the exception. It must be

catch preceded by try block which means we can't use catch block
alone. It can be followed by finally block later.

The "finally" block is used to execute the necessary code of the

finally program. It is executed whether an exception is handled or
not.

throw The "throw" keyword is used to throw an exception.

The "throws" keyword is used to declare exceptions. It specifies

throws that there may occur an exception in the method. It doesn't
throw an exception. It is always used with method signature.

Java Exception Handling Example

Let's see an example of Java Exception Handling in which we are

using a try-catch statement to handle the exception.
JavaExceptionExample.java

1. public class JavaExceptionExample{

2. public static void main(String args[]){
3. try{
4. //code that may raise exception
5. int data=100/0;
6. }catch(ArithmeticException e){System.out.println(e);}
7. //rest code of the program
8. System.out.println("rest of the code...");
9. }
10. }

Test it Now

Output:
Exception in thread main java.lang.ArithmeticException:/ by zero
rest of the code...

In the above example, 100/0 raises an ArithmeticException which

is handled by a try-catch block.

Common Scenarios of Java Exceptions

There are given some scenarios where unchecked exceptions may

occur. They are as follows:

1) A scenario where ArithmeticException occurs

If we divide any number by zero, there occurs an

ArithmeticException.

1. int a=50/0;//ArithmeticException

2) A scenario where NullPointerException occurs

If we have a null value in any variable, performing any operation on
the variable throws a NullPointerException.

1. String s=null;
2. System.out.println(s.length());//NullPointerException

3) A scenario where NumberFormatException occurs

If the formatting of any variable or number is mismatched, it may

result into NumberFormatException. Suppose we have a string
variable that has characters; converting this variable into digit
will cause NumberFormatException.

1. String s="abc";
2. int i=Integer.parseInt(s);//NumberFormatException

4) A scenario where ArrayIndexOutOfBoundsException occurs

When an array exceeds to it's size, the

ArrayIndexOutOfBoundsException occurs. there may be other
reasons to occur ArrayIndexOutOfBoundsException. Consider
the following statements.

1. int a[]=new int[5];

2. a[10]=50; //ArrayIndexOutOfBoundsException

Java Exceptions Index

1. Java Try-Catch Block

2. Java Multiple Catch Block
3. Java Nested Try
4. Java Finally Block
5. Java Throw Keyword
6. Java Exception Propagation
7. Java Throws Keyword
8. Java Throw vs Throws
9. Java Final vs Finally vs Finalize
 10. Java Exception Handling with Method Overriding
11. Java Custom Exceptions

AWT and Swing in Java

AWT and Swing are used to develop window-based applications in Java. Awt
is an abstract window toolkit that provides various component classes
like Label, Button, TextField, etc., to show window components on the
screen. All these classes are part of the Java.awt package.
On the other hand, Swing is the part of JFC (Java Foundation Classes) built
on the top of AWT and written entirely in Java. The javax.swing API
provides all the component classes like JButton, JTextField, JCheckbox,
JMenu, etc.
The components of Swing are platform-independent, i.e., swing doesn't
depend on the operating system to show the components. Also, the
Swing's components are lightweight. The main differences between
AWT and Swing are given in the following table.
Context AWT Swing

The AWT Component The Swing component

API Package classes are provided by classes are provided by
the java.awt package. the javax.swing package.

The Components used in

The Components used in
Swing are not dependent
AWT are mainly
Operating System on the operating system.
dependent on the
It is completely scripted
operating system.
in Java.

The Swing is mostly

lightweight since it
The AWT is heavyweight
doesn't need any
since it uses the
Weightiness Operating system object
resources of the
for processing. The
operating system.
Swing Components are
built on the top of AWT.
 The Appearance of AWT
Components is mainly The Swing Components are
not configurable. It configurable and mainly
Appearance
generally depends on support pluggable look
the operating system's and feel.
look and feels.
Java Swing provides a
The Java AWT provides a greater number of
Number of smaller number of components than AWT,
Components components in such as list, scroll panes,
comparison to Swing. tables, color choosers,
etc.

Java Swing is mainly

Java AWT stands for
referred to as Java
Full-Form Abstract Window
Foundation Classes
Toolkit.
(JFC).

Java Swing has only one

Java AWT has 21 peers.
peer in the form of OS's
There is one peer for
window object, which
each control and one
provides the drawing
peer for the dialogue.
Peers surface used to draw the
Peers are provided by
Swing's widgets (label,
the operating system in
button, entry fields, etc.)
the form of widgets
developed directly by
themselves.
Java Swing Package.

Swing components provide

Java AWT many features
the higher-level inbuilt
that are completely functions for the
Functionality and
developed by the
Implementation developer that
developer. It serves as facilitates the coder to
a thin layer of
write less code.
 development on the top
of the OS.

Java AWT needs a higher Java Swing needs less

Memory amount of memory for memory space as
the execution. compared to Java AWT.

Java AWT is slower than

Java Swing is faster than
Speed swing in terms of
the AWT.
performance.
Java Swing Hierarchy
Java defines the class hierarchy for all the Swing Components, which is
shown in the following image.

Java Swing Example

In the following example, we have created a User form by using the swing
component classes provided by the javax.swing package. Consider the
example.
1. import javax.swing.*;
2. public class SwingApp {
3. SwingApp(){
4. JFrame f = new JFrame();
5.
6. JLabel firstName = new JLabel("First Name");
7. firstName.setBounds(20, 50, 80, 20);
8.
9. JLabel lastName = new JLabel("Last Name");
10. lastName.setBounds(20, 80, 80, 20);
11.
12. JLabel dob = new JLabel("Date of Birth");
13. dob.setBounds(20, 110, 80, 20);
14.
15. JTextField firstNameTF = new JTextField();
16. firstNameTF.setBounds(120, 50, 100, 20);
17.
18. JTextField lastNameTF = new JTextField();
19. lastNameTF.setBounds(120, 80, 100, 20);
20.
21. JTextField dobTF = new JTextField();
22. dobTF.setBounds(120, 110, 100, 20);
23.
24. JButton sbmt = new JButton("Submit");
25. sbmt.setBounds(20, 160, 100, 30);
26.
27. JButton reset = new JButton("Reset");
28. reset.setBounds(120,160,100,30);
29.
30. f.add(firstName);
31. f.add(lastName);
32. f.add(dob);
33. f.add(firstNameTF);
 34. f.add(lastNameTF);
35. f.add(dobTF);
36. f.add(sbmt);
37. f.add(reset);
38.
39. f.setSize(300,300);
40. f.setLayout(null);
41. f.setVisible(true);
42. }
43.
44. public static void main(String[] args) {
45. // TODO Auto-generated method stub
46. SwingApp s = new SwingApp();
47. }
48. }
Output:

Java awt Example

To understand the differences between Awt and Swing, we have created
the same example in awt as well. Consider the following example.
1. import java.awt.*;
2. public class AwtApp extends Frame {
3. AwtApp(){
4. Label firstName = new Label("First Name");
5. firstName.setBounds(20, 50, 80, 20);
6.
7. Label lastName = new Label("Last Name");
8. lastName.setBounds(20, 80, 80, 20);
9.
10. Label dob = new Label("Date of Birth");
11. dob.setBounds(20, 110, 80, 20);
12.
13. TextField firstNameTF = new TextField();
14. firstNameTF.setBounds(120, 50, 100, 20);
15.
16. TextField lastNameTF = new TextField();
17. lastNameTF.setBounds(120, 80, 100, 20);
18.
19. TextField dobTF = new TextField();
20. dobTF.setBounds(120, 110, 100, 20);
21.
22. Button sbmt = new Button("Submit");
23. sbmt.setBounds(20, 160, 100, 30);
24.
25. Button reset = new Button("Reset");
26. reset.setBounds(120,160,100,30);
27.
28. add(firstName);
29. add(lastName);
30. add(dob);
31. add(firstNameTF);
32. add(lastNameTF);
33. add(dobTF);
34. add(sbmt);
35. add(reset);
36.
37. setSize(300,300);
38. setLayout(null);
 39. setVisible(true);
40. }
41. public static void main(String[] args) {
42. // TODO Auto-generated method stub
43. AwtApp awt = new AwtApp();
44.
45. }
Output:

Java MouseListener Interface

The Java MouseListener is notified whenever you change the state of
mouse. It is notified against MouseEvent. The MouseListener interface
is found in java.awt.event package. It has five methods.
Methods of MouseListener interface
The signature of 5 methods found in MouseListener interface are given
below:
1. public abstract void mouseClicked(MouseEvent e);
2. public abstract void mouseEntered(MouseEvent e);
3. public abstract void mouseExited(MouseEvent e);
4. public abstract void mousePressed(MouseEvent e);
5. public abstract void mouseReleased(MouseEvent e);
Java MouseListener Example
1. import java.awt.*;
2. import java.awt.event.*;
3. public class MouseListenerExample extends Frame implements Mous
eListener{
4. Label l;
5. MouseListenerExample(){
6. addMouseListener(this);
7.
8. l=new Label();
9. l.setBounds(20,50,100,20);
10. add(l);
11. setSize(300,300);
12. setLayout(null);
13. setVisible(true);
14. }
15. public void mouseClicked(MouseEvent e) {
16. l.setText("Mouse Clicked");
17. }
18. public void mouseEntered(MouseEvent e) {
19. l.setText("Mouse Entered");
20. }
21. public void mouseExited(MouseEvent e) {
22. l.setText("Mouse Exited");
23. }
24. public void mousePressed(MouseEvent e) {
25. l.setText("Mouse Pressed");
26. }
27. public void mouseReleased(MouseEvent e) {
28. l.setText("Mouse Released");
29. }
30. public static void main(String[] args) {
31. new MouseListenerExample();
32. }
33. }
Output:

Java MouseListener Example 2

1. import java.awt.*;
2. import java.awt.event.*;
3. public class MouseListenerExample2 extends Frame implements Mou
seListener{
4. MouseListenerExample2(){
5. addMouseListener(this);
6.
7. setSize(300,300);
8. setLayout(null);
9. setVisible(true);
10. }
11. public void mouseClicked(MouseEvent e) {
12. Graphics g=getGraphics();
13. g.setColor(Color.BLUE);
14. g.fillOval(e.getX(),e.getY(),30,30);
15. }
16. public void mouseEntered(MouseEvent e) {}
17. public void mouseExited(MouseEvent e) {}
18. public void mousePressed(MouseEvent e) {}
19. public void mouseReleased(MouseEvent e) {}
20.
 21. public static void main(String[] args) {
22. new MouseListenerExample2();
23. }
24. }
Output:

Java ActionListener Interface

The Java ActionListener is notified whenever you click on the button or
menu item. It is notified against ActionEvent. The ActionListener
interface is found in java.awt.event package. It has only one method:
actionPerformed().
actionPerformed() method
The actionPerformed() method is invoked automatically whenever you click
on the registered component.
1. public abstract void actionPerformed(ActionEvent e);
How to write ActionListener
The common approach is to implement the ActionListener. If you implement
the ActionListener class, you need to follow 3 steps:
1) Implement the ActionListener interface in the class:
1. public class ActionListenerExample Implements ActionListener
2) Register the component with the Listener:
1. component.addActionListener(instanceOfListenerclass);
3) Override the actionPerformed() method:
1. public void actionPerformed(ActionEvent e){
 2. //Write the code here
3. }
Java ActionListener Example: On Button click
1. import java.awt.*;
2. import java.awt.event.*;
3. //1st step
4. public class ActionListenerExample implements ActionListener{
5. public static void main(String[] args) {
6. Frame f=new Frame("ActionListener Example");
7. final TextField tf=new TextField();
8. tf.setBounds(50,50, 150,20);
9. Button b=new Button("Click Here");
10. b.setBounds(50,100,60,30);
11. //2nd step
12. b.addActionListener(this);
13. f.add(b);f.add(tf);
14. f.setSize(400,400);
15. f.setLayout(null);
16. f.setVisible(true);
17. }
18. //3rd step
19. public void actionPerformed(ActionEvent e){
20. tf.setText("Welcome to Javatpoint.");
21. }
22. }
Output:

Java ActionListener Example: Using Anonymous class

We can also use the anonymous class to implement the ActionListener. It
is the shorthand way, so you do not need to follow the 3 steps:
1. b.addActionListener(new ActionListener(){
2. public void actionPerformed(ActionEvent e){
3. tf.setText("Welcome to Javatpoint.");
4. }
5. });
Let us see the full code of ActionListener using anonymous class.
1. import java.awt.*;
2. import java.awt.event.*;
3. public class ActionListenerExample {
4. public static void main(String[] args) {
5. Frame f=new Frame("ActionListener Example");
6. final TextField tf=new TextField();
7. tf.setBounds(50,50, 150,20);
8. Button b=new Button("Click Here");
9. b.setBounds(50,100,60,30);
10.
11. b.addActionListener(new ActionListener(){
12. public void actionPerformed(ActionEvent e){
13. tf.setText("Welcome to Javatpoint.");
14. }
15. });
16. f.add(b);f.add(tf);
17. f.setSize(400,400);
18. f.setLayout(null);
19. f.setVisible(true);
20. }
21. }
Output:
Java MouseMotionListener Interface
The Java MouseMotionListener is notified whenever you move or drag
mouse. It is notified against MouseEvent. The MouseMotionListener
interface is found in java.awt.event package. It has two methods.
Methods of MouseMotionListener interface
The signature of 2 methods found in MouseMotionListener interface are
given below:
1. public abstract void mouseDragged(MouseEvent e);
2. public abstract void mouseMoved(MouseEvent e);
Java MouseMotionListener Example
1. import java.awt.*;
2. import java.awt.event.*;
3. public class MouseMotionListenerExample extends Frame implement
s MouseMotionListener{
4. MouseMotionListenerExample(){
5. addMouseMotionListener(this);
6.
7. setSize(300,300);
8. setLayout(null);
9. setVisible(true);
10. }
11. public void mouseDragged(MouseEvent e) {
12. Graphics g=getGraphics();
13. g.setColor(Color.BLUE);
14. g.fillOval(e.getX(),e.getY(),20,20);
15. }
16. public void mouseMoved(MouseEvent e) {}
17.
18. public static void main(String[] args) {
19. new MouseMotionListenerExample();
20. }
21. }
Output:
Java MouseMotionListener Example 2
1. import java.awt.*;
2. import java.awt.event.MouseEvent;
3. import java.awt.event.MouseMotionListener;
4. public class Paint extends Frame implements MouseMotionListener{
5. Label l;
6. Color c=Color.BLUE;
7. Paint(){
8. l=new Label();
9. l.setBounds(20,40,100,20);
10. add(l);
11.
12. addMouseMotionListener(this);
13.
14. setSize(400,400);
15. setLayout(null);
16. setVisible(true);
17. }
18. public void mouseDragged(MouseEvent e) {
19. l.setText("X="+e.getX()+", Y="+e.getY());
 20. Graphics g=getGraphics();
21. g.setColor(Color.RED);
22. g.fillOval(e.getX(),e.getY(),20,20);
23. }
24. public void mouseMoved(MouseEvent e) {
25. l.setText("X="+e.getX()+", Y="+e.getY());
26. }
27. public static void main(String[] args) {
28. new Paint();
29. }
30. }
Output:

BorderLayout (LayoutManagers)
Java LayoutManagers
The LayoutManagers are used to arrange components in a particular
manner. The Java LayoutManagers facilitates us to control the
positioning and size of the components in GUI forms. LayoutManager is
an interface that is implemented by all the classes of layout managers.
There are the following classes that represent the layout managers:
1. java.awt.BorderLayout
 2. java.awt.FlowLayout
3. java.awt.GridLayout
4. java.awt.CardLayout
5. java.awt.GridBagLayout
6. javax.swing.BoxLayout
7. javax.swing.GroupLayout
8. javax.swing.ScrollPaneLayout
9. javax.swing.SpringLayout etc.
Java BorderLayout
The BorderLayout is used to arrange the components in five regions: north,
south, east, west, and center. Each region (area) may contain one
component only. It is the default layout of a frame or window. The
BorderLayout provides five constants for each region:
1. public static final int NORTH
2. public static final int SOUTH
3. public static final int EAST
4. public static final int WEST
5. public static final int CENTER
Constructors of BorderLayout class:
• BorderLayout(): creates a border layout but with no gaps between the
components.
• BorderLayout(int hgap, int vgap): creates a border layout with the
given horizontal and vertical gaps between the components.
Example of BorderLayout class: Using BorderLayout() constructor
FileName: Border.java
1. import java.awt.*;
2. import javax.swing.*;
3.
4. public class Border
5. {
6. JFrame f;
7. Border()
8. {
 9. f = new JFrame();
10.
11. // creating buttons
12. JButton b1 = new JButton("NORTH");; // the button will be l
abeled as NORTH
13. JButton b2 = new JButton("SOUTH");; // the button will be l
abeled as SOUTH
14. JButton b3 = new JButton("EAST");; // the button will be lab
eled as EAST
15. JButton b4 = new JButton("WEST");; // the button will be la
beled as WEST
16. JButton b5 = new JButton("CENTER");; // the button will be
labeled as CENTER
17.
18. f.add(b1, BorderLayout.NORTH); // b1 will be placed in the N
orth Direction
19. f.add(b2, BorderLayout.SOUTH); // b2 will be placed in the
South Direction
20. f.add(b3, BorderLayout.EAST); // b2 will be placed in the Ea
st Direction
21. f.add(b4, BorderLayout.WEST); // b2 will be placed in the
West Direction
22. f.add(b5, BorderLayout.CENTER); // b2 will be placed in the
Center
23.
24. f.setSize(300, 300);
25. f.setVisible(true);
26. }
27. public static void main(String[] args) {
28. new Border();
29. }
30. }
Output:
download this example
Example of BorderLayout class: Using BorderLayout(int hgap, int vgap)
constructor
The following example inserts horizontal and vertical gaps between buttons
using the parameterized constructor BorderLayout(int hgap, int gap)
FileName: BorderLayoutExample.java
1. // import statement
2. import java.awt.*;
3. import javax.swing.*;
4. public class BorderLayoutExample
5. {
6. JFrame jframe;
7. // constructor
8. BorderLayoutExample()
9. {
10. // creating a Frame
11. jframe = new JFrame();
12. // create buttons
13. JButton btn1 = new JButton("NORTH");
14. JButton btn2 = new JButton("SOUTH");
15. JButton btn3 = new JButton("EAST");
16. JButton btn4 = new JButton("WEST");
 17. JButton btn5 = new JButton("CENTER");
18. // creating an object of the BorderLayout class using
19. // the parameterized constructor where the horizontal gap i
s 20
20. // and vertical gap is 15. The gap will be evident when button
s are placed
21. // in the frame
22. jframe.setLayout(new BorderLayout(20, 15));
23. jframe.add(btn1, BorderLayout.NORTH);
24. jframe.add(btn2, BorderLayout.SOUTH);
25. jframe.add(btn3, BorderLayout.EAST);
26. jframe.add(btn4, BorderLayout.WEST);
27. jframe.add(btn5, BorderLayout.CENTER);
28. jframe.setSize(300,300);
29. jframe.setVisible(true);
30. }
31. // main method
32. public static void main(String argvs[])
33. {
34. new BorderLayoutExample();
35. }
36. }
Output:
Java BorderLayout: Without Specifying Region
The add() method of the JFrame class can work even when we do not
specify the region. In such a case, only the latest component added is
shown in the frame, and all the components added previously get
discarded. The latest component covers the whole area. The following
example shows the same.
FileName: BorderLayoutWithoutRegionExample.java
1. // import statements
2. import java.awt.*;
3. import javax.swing.*;
4.
5. public class BorderLayoutWithoutRegionExample
6. {
7. JFrame jframe;
8.
9. // constructor
10. BorderLayoutWithoutRegionExample()
11. {
12. jframe = new JFrame();
13.
 14. JButton btn1 = new JButton("NORTH");
15. JButton btn2 = new JButton("SOUTH");
16. JButton btn3 = new JButton("EAST");
17. JButton btn4 = new JButton("WEST");
18. JButton btn5 = new JButton("CENTER");
19.
20. // horizontal gap is 7, and the vertical gap is 7
21. // Since region is not specified, the gaps are of no use
22. jframe.setLayout(new BorderLayout(7, 7));
23.
24. // each button covers the whole area
25. // however, the btn5 is the latest button
26. // that is added to the frame; therefore, btn5
27. // is shown
28. jframe.add(btn1);
29. jframe.add(btn2);
30. jframe.add(btn3);
31. jframe.add(btn4);
32. jframe.add(btn5);
33.
34. jframe.setSize(300,300);
35. jframe.setVisible(true);
36. }
37.
38. // main method
39. public static void main(String argvs[])
40. {
41. new BorderLayoutWithoutRegionExample();
42. }
43. }
Output: