UNIT II INHERITANCE, PACKAGES AND INTERFACES

Overloading Methods – Objects as Parameters – Returning Objects – Static, Nested and

Inner Classes. Inheritance: Basics – Types of Inheritance – super keyword – Method
Overriding – Dynamic Method Dispatch – Abstract Classes – final with Inheritance.
Packages and Interfaces: Packages – Packages and Member Access – Importing Packages
– Interfaces.

2.1: Overloading Methods

Method Overloading is a feature in Java that allows a class to have more than one
methods having same name, but with different signatures (Each method must have
different number of parameters or parameters having different types and orders).

Advantage:
✓ Method Overloading increases the readability of the program.
✓ Provides the flexibility to use similar method with different parameters.

Three ways to overload a method

In order to overload a method, the argument lists of the methods must differ in either of
these:

1. Number of parameters. (Different number of parameters in argument list)

For example: This is a valid case of overloading
add(int, int)
add(int, int, int)

2. Data type of parameters. (Difference in data type of parameters)

For example:
add(int, int)
add(int, float)

3. Sequence of Data type of parameters.

For example:
add(int, float)
add(float, int)
Rules for Method Overloading:

1. First and important rule to overload a method in java is to change method

signature.
2. Return type of method is never part of method signature, so only changing the
return type of method does not amount to method overloading.

Example: To find the Minimum of given numbers:

public class OverloadingCalculation1

{
public static void main(String[] args)
{
int a = 11;
int b = 6;
int c = 3;
double x = 7.3;
double y = 9.4;

int result1 = minFunction(a, b, c);

double result2 = minFunction(x, y);
double result3 = minFunction(a, x);

System.out.println("Minimum("+a+","+b+","+c+") = " + result1);

System.out.println("Minimum("+x+","+y+") = " + result2);
System.out.println("Minimum("+a+","+x+") = " + result3);
}

public static int minFunction(int n1, int n2, int n3)

{
int min;
int temp = n1<n2? n1 : n2;
min = n3 < temp? n3 : temp;
return min;
}

public static double minFunction(double n1, double n2)

{
double min;
 if (n1 > n2)
min = n2;
else
min = n1;

return min;
}
public static double minFunction(int n1, double n2)
{
double min;
if (n1 > n2)
min = n2;
else
min = n1;

return min;
}
}

This would produce the following result:

Minimum(11,6,3) = 3
Minimum(7.3,9.4) = 7.3
Minimum(11,7.3) = 7.3

Note:-
Method overloading is not possible by changing the return type of the method
because of ambiguity that may arise while calling the method with same parameter
list with different return type.

Example:

class Add
{
static int sum(int a, int b)
{
return a+b;
}
static float sum(int a, int b)
 {
return a+b;
}
public static void main(String arg[])
{
System.out.println(sum(10,20));
System.out.println(sum(15,25));
}
}

Output:
Compile by: javac TestOverloading3.java

Add.java:7: error: method sum(int,int) is already defined in class Add

static float sum(int a, int b)
^
1 error

Method Overloading and Type Promotion

Type Promotion: When a data type of smaller size is promoted to the data type of bigger
size than this is called type promotion, for example: byte data type can be promoted to
short, a short data type can be promoted to int, long, double etc.

Type Promotion in Method Overloading:

One type is promoted to another implicitly if no matching datatype is found.

Type Promotion Table:

The data type on the left side can be promoted to the any of the data type present in
the right side of it.

byte → short → int → long → double

short → int → long → float → double
int → long → float → double
float → double
long → float → double
char → int → long → float → double
Example: Method Overloading with Type Promotion:

class Overloading
{
void sum(int a, float b)
{
System.out.println(a+b);
}
void sum(int a, int b, int c)
{
System.out.println(a+b+c);
}

public static void main(String args[])

{
OverloadingCalculation1 obj=new OverloadingCalculation1();
obj.sum(20,20); //now second int literal will be promoted to float
obj.sum(100,'A'); //Character literal will be promoted to float
obj.sum(20,20,20);
}
}

OUTPUT:

40.0
165.0
60
 2.2: Objects as Parameters
Java is strictly pass-by-value. But the scenario may change when the parameter passed
is of primitive type or reference type.

➢ If we pass a primitive type to a method, then it is called pass-by-value or call-by-

value.
➢ If we pass an object to a method, then it is called pass-by-reference or call-by-
reference.

Object as a parameter is a way to establish communication between two or more

objects of the same class or different class as well.

Pass-by-value vs. Pass-by-reference:

Pass-by-value (Value as parameter) Pass-by-reference (Object as parameter)
Only values are passes to the function Reference to the object is passed. So any
parameters. So any modifications done in modifications done through the object will
the formal parameter will not affect the affect the actual object.
value of actual parameter
Caller and Callee method will have two Caller and Callee methods use the same
independent variables with same value. reference for the object.
Callee method will not have any access to Callee method will have the direct
the actual parameter reference to the actual object
Requires more memory Requires less memory

class CallByVal class CallByRef

{ {
void Increment(int count) int count=0;
{ CallByRef(int c)
count=count+10; {
} count=c;
} }
public class CallByValueDemo { static void Increment(CallByRef obj) {
public static void main(String arg[]) obj.count=obj.count+10;
{ }
CallByVal ob1=new CallByVal();
int count=100; public static void main(String arg[]) {
System.out.println("Value of Count before CallByRef ob1=new CallByRef(10);
method call = "+count); System.out.println("Value of Count (Object 1) before
 ob1.Increment(count); method call = "+ob1.count);
System.out.println("Value of Count after Increment(ob1);
method call = "+count); System.out.println("Value of Count (Object 1) after
} method call = "+ob1.count);
}
} }
OUTPUT: OUTPUT:
Value of Count (Object 1) before method call = 10
Value of Count before method call = 100 Value of Count (Object 1) after method call = 20
Value of Count after method call = 100

Returning Objects:
In Java, a method can return any type of data. Return type may any primitive data type or
class type (i.e. object). As a method takes objects as parameters, it can also return objects
as return value.

Example:
class Add
{
int num1,num2,sum;

static Add calculateSum(Add a1,Add a2)

{
Add a3=new Add();
a3.num1=a1.num1+a1.num2;
a3.num2=a2.num1+a2.num2;
a3.sum=a3.num1+a3.num2;
return a3;
}

public static void main(String arg[])

{
Add ob1=new Add();
ob1.num1=10;
ob1.num2=15;

Add ob2=new Add();

ob2.num1=100;
ob2.num2=150;

Add ob3=calculateSum(ob1,ob2);
System.out.println("Object 1 -> Sum = "+ob1.sum);
 System.out.println("Object 2 -> Sum = "+ob2.sum);
System.out.println("Object 3 -> Sum = "+ob3.sum);
}
}

OUTPUT:

Object 1 -> Sum = 0

Object 2 -> Sum = 0
Object 3 -> Sum = 275

2.3: STATIC, NESTED and INNER CLASSES

Definition:

An inner class is a class that is defined inside another class.

Inner classes let you make one class a member of another class. Just as
classes have member variables and methods, a class can also have member classes.

Benefits:
1. Name control
2. Access control
3. Code becomes more readable and maintainable because it locally group related
classes in one place.

Syntax: For declaring Inner classes

[modifier] class OuterClassName

{
---- Code -----
[modifier] class InnerClassName
{
---- Code ----
}
}
➢ Instantiating an Inner Class:
Two Methods:
1. Instantiating an Inner class from outside the outer class:
To instantiate an instance of an inner class, you must have an instance of the
outer class.
Syntax:
OuterClass.InnerClass objectName=OuterObj.new InnerClass();

2. Instantiating an Inner Class from Within Code in the Outer Class:

From inside the outer class instance code, use the inner class name in the
normal way:
Syntax:
InnerClassName obj=new InnerClassName();

Advantage of java inner classes

There are basically three advantages of inner classes in java. They are as follows:

1) Nested class can access all the members (data members and methods) of
outer class including private.
2) Nested classes are used to develop more readable and maintainable code.
3) Code Optimization: It requires less code to write.

Types of Nested classes

There are two types of nested classes non-static and static nested classes. The non-static
nested classes are also known as inner classes.
o Non-static nested class (inner class)
1. Member inner class
2. Anonymous inner class
3. Local inner class
o Static nested class

Type Description
Member Inner Class A class created within class and outside method.
A class created for implementing interface or
Anonymous Inner Class extending class. Its name is decided by the java
compiler.
Local Inner Class A class created within method.
Static Nested Class A static class created within class.
Nested Interface An interface created within class or interface.
1. Java Member inner class

A non-static class that is created inside a class but outside a method is called member
inner class.

Syntax:
class Outer

//code
class Inner

//code

Java Member inner class example

In this example, we are creating msg() method in member inner class that is accessing
the private data member of outer class.

1. class TestMemberOuter1
2. {
3. private int data=30;
4. class Inner
5. {
6. void msg()
7. {
8. System.out.println("data is "+data);
9. }
10. }
11. public static void main(String args[])
12. {
13. TestMemberOuter1 obj=new TestMemberOuter1();
14. TestMemberOuter1.Inner in=obj.new Inner();
15. in.msg();
16. }
17. }

Output:
2. Java Anonymous inner class
A class that have no name is known as anonymous inner class in java. It should be used
if you have to override method of class or interface. Java Anonymous inner class can be
created by two ways:
1. Class (may be abstract or concrete).
2. Interface

Java anonymous inner class example using class

1. abstract class Person

2. {
3. abstract void eat();
4. }
5. class TestAnonymousInner
6. {
7. public static void main(String args[])
8. {
9. Person p=new Person()
10. {
11. void eat()
12. {
13. System.out.println("nice fruits");
14. }
15. };
16. p.eat();
17. }
18. }

Output:

nice fruits

Java anonymous inner class example using interface

1. interface Eatable
2. {
3. void eat();
 4. }
5. class TestAnnonymousInner1
6. {
7. public static void main(String args[])
8. {
9. Eatable e=new Eatable()
10. {
11. public void eat(){System.out.println("nice fruits");
12. }
13. };
14. e.eat();
15. }
16. }

Output:
nice fruits

3. Java Local inner class

A class i.e. created inside a method is called local inner class in java. If you want to
invoke the methods of local inner class, you must instantiate this class inside the
method.

Java local inner class example

1. public class localInner1

2. {
3. private int data=30;//instance variable
4. void display()
5. {
6. int value=50;
7. class Local
8. {
9. void msg()
10. {
11. System.out.println(data);
12. System.out.println(value);
13. }
14. }
 15. Local l=new Local();
16. l.msg();
17. }
18. public static void main(String args[])
19. {
20. localInner1 obj=new localInner1();
21. obj.display();
22. }
23. }

Output:
30
50

Rules for Java Local Inner class

1. Local inner class cannot be invoked from outside the method.
2. Local inner class cannot access non-final local variable till JDK 1.7. Since JDK 1.8, it
is possible to access the non-final local variable in local inner class.
3. Local variable can't be private, public or protected.

Properties:
1. Completely hidden from the outside world.
2. Cannot access the local variables of the method (in which they are defined), but the
local variables has to be declared final to access.

4. Java static nested class

A static class i.e. created inside a class is called static nested class in java. It cannot
access non-static data members and methods. It can be accessed by outer class name.
o It can access static data members of outer class including private.
o Static nested class cannot access non-static (instance) data member or method.

Java static nested class example with instance method

1. class TestOuter1
2. {
3. static int data=30;
4. static class Inner
5. {
6. void msg()
 7. {
8. System.out.println("data is "+data);
9. }
10. }
11. public static void main(String args[])
12. {
13. TestOuter1.Inner obj=new TestOuter1.Inner();
14. obj.msg();
15. }
16. }

Output:
data is 30

Java static nested class example with static method

If you have the static member inside static nested class, you don't need to create
instance of static nested class.

1. class TestOuter2{
2. static int data=30;
3. static class Inner
4. {
5. static void msg()
6. {
7. System.out.println("data is "+data);
8. }
9. }
10. public static void main(String args[])
11. {
12. TestOuter2.Inner.msg();//no need to create the instance of static nested
class
13. }
14. }

Output:
data is 30
 2.4: Inheritance

Definition:
Inheritance is a process of deriving a new class from existing class, also called as
“extending a class”. When an existing class is extended, the new (inherited) class has
all the properties and methods of the existing class and also possesses its own
characteristics.

✓ The class whose property is being inherited by another class is called “base class”
(or) “parent class” (or) “super class”.
✓ he class that inherits a particular property or a set of properties from the base classis
called “derived class” (or) “child class” (or) “sub class”.

Class A Base class

Properties and
methods

Extended to
Class B
Derived
Properties and methods
of Class A + B’s own
properties and methods

✓ Subclasses of a class can define their own unique behaviors and yet share some of
the same functionality of the parent class.

➢ ADVANTAGES OF INHERITANCE:
• Reusability of Code:
✓ Inheritance is mainly used for code reusability (Code reusability means that
we can add extra features to an existing class without modifying it).
• Effort and Time Saving:
✓ The advantage of reusability saves the programmer time and effort. Since
the main code written can be reused in various situations as needed.
• Increased Reliability:
✓ The program with inheritance becomes more understandable and easily
maintainable as the sub classes are created from the existing reliably
working classes.
➢ “extends” KEYWORD:
✓ Inheriting a class means creating a new class as an extension of another class.
✓ The extends keyword is used to inherit a class from existing class.
✓ The general form of a class declaration that inherits a superclass is shown here:
✓ Syntax:
[access_specifier] class subclass_name extends superclass_name
{
// body of class
}

Characteristics of Class Inheritance:

1. A class cannot be inherited from more than one base class. Java does not support
the inheritance of multiple super classes into a single subclass.
2. Sub class can access only the non-private members of the super class.
3. Private data members of a super class are local only to that class. Therefore, they
can’t be accessed outside the super class, even sub classes can’t access the private
members.
4. Protected features in Java are visible to all subclasses as well as all other classes
in the same package.
✓ Example:
class Vehicle
{
String brand;
String color;
}
class Car extends Vehicle
{
int totalDoor;
}

class Bike extends Vehicle

{
}

In the above example, Vehicle is the super class or base class that holds the
common property of Car and Bike. Car and Bike is the sub class or derived class that
inherits the property of class Vehicle extends is the keyword used to inherit a class.
➢ TYPES OF INHERITACE:
1. Single Inheritance
2. Multilevel Inheritance
3. Multiple Inheritance
Note: The following inheritance types are not directly supported in Java.
4. Hierarchical Inheritance
5. Hybrid Inheritance
 1. SINGLE INHERITANCE

The process of creating only one subclass from only one super class is known as Single
Inheritance.
✓ Only two classes are involved in this inheritance.
✓ The subclass can access all the members of super class.

Example: Animal → Dog

1. class Animal
2. {
3. void eat()
4. {
5. System.out.println("eating...");
6. }
7. }
8. class Dog extends Animal
9. {
10. void bark()
11. {
12. System.out.println("barking...");
13. }
14.}
15.class TestInheritance
16.{
17. public static void main(String args[])
18. {
19. Dog d=new Dog();
20. d.bark();
21. d.eat();
22. }
23.}

Output:
$java TestInheritance
barking...
eating...
 2. MULTILEVEL INHERITANCE:

✓ The process of creating a new sub class from an already inherited sub class is
known as Multilevel Inheritance.
✓ Multiple classes are involved in inheritance, but one class extends only one.
✓ The lowermost subclass can make use of all its super classes' members.
✓ Multilevel inheritance is an indirect way of implementing multiple inheritance.
✓ Example: Animal → Dog → BabyDog

1. class Animal
2. {
3. void eat()
4. {
5. System.out.println("eating...");
6. }
7. }
8. class Dog extends Animal
9. {
10. void bark()
11. {
12. System.out.println("barking...");
13. }
14. }
15. class BabyDog extends Dog
16. {
17. void weep()
18. {
19. System.out.println("weeping...");
20. }
21. }
22. class TestInheritance2
23. {
24. public static void main(String args[]) {
25. BabyDog d=new BabyDog();
26. d.weep();
27. d.bark();
28. d.eat();
29. }
30. }
Output:
$java TestInheritance2
weeping...
barking...
eating..

3. HIERARCHICAL INHERITANCE

✓ The process of creating more than one sub classes from one super class is called
Hierarchical Inheritance.

Animal

Dog Cat

✓ Example:
1. class Animal
2. {
3. void eat()
4. {
5. System.out.println("eating...");
6. }
7. }
8. class Dog extends Animal
9. {
10. void bark()
11. {
12. System.out.println("barking...");
13. }
14. }
15. class Cat extends Animal
16. {
17. void meow()
18. {
19. System.out.println("meowing...");
20. }
 21. }
22. class TestInheritance3
23. {
24. public static void main(String args[])
25. {
26. Cat c=new Cat();
27. c.meow();
28. c.eat();
29. //c.bark();//C.T.Error
30. }
31. }
Output:

meowing...
eating...

Why multiple inheritance is not supported in java?

To reduce the complexity and simplify the language, multiple inheritances is not
supported in java.
Consider a scenario where A, B and C are three classes. The C class inherits A and B classes.
If A and B classes have same method and you call it from child class object, there will be
ambiguity to call method of A or B class.
Since compile time errors are better than runtime errors, java renders compile time error
if you inherit 2 classes. So whether you have same method or different, there will be
compile time error now.
class A { Multiple Inheritance using Interface
void msg()
{ interface Printable {
System.out.println("Hello"); void print();
} }
}
class B { interface Showable {
void msg() void show();
{ }
System.out.println("Welcome"); class A implements Printable, Showable {
} public void print() {
} System.out.println("Hello");
class C extends A,B // this is multiple inheritance which is ERROR }
{ public void show() {
Public Static void main(String args[]) System.out.println("Welcome");
{ }
C obj=new C(); public static void main(String args[]) {
obj.msg();//Now which msg() method would be i A obj = new A();
nvoked? obj.print();
} obj.show();
} }
}
Output Output:
Compile Time Error Hello
welcome
 2.4.1: PROTECTED MEMBER

The private members of a class cannot be directly accessed outside the class. Only
methods of that class can access the private members directly. However, sometimes it
may be necessary for a subclass to access a private member of a superclass. If you make
a private member public, then anyone can access that member. So, if a member of a
superclass needs to be (directly) accessed in a subclass then you must declare that
member protected.

Following table describes the difference

Modifier Class Package subclass World

public Yes Yes Yes Yes
private Yes No No No
protected Yes Yes Yes No

Following program illustrates how the methods of a subclass can directly access a
protected member of the superclass.

Consider two kinds of shapes: rectangles and triangles. These two shapes have certain
common properties height and a width (or base).

This could be represented in the world of classes with a class Shapes from which we
would derive the two other ones : Rectangle and Triangle
Program : (Shape.java)

public class Shape

{
protected double height; // To hold height.
protected double width; //To hold width or base
 public void setValues(double height, double width)
{
this.height = height;
this.width = width;
}
}

Program : (Rectangle.java)

public class Rectangle extends Shape

{
public double getArea()
{
return height * width; //accessing protected members
}
}

Program : (Triangle.java)

public class Triangle extends Shape

{
public double getArea()
{
return height * width / 2; //accessing protected members
}
}

Program : (TestProgram.java)

public class TestProgram

{
public static void main(String[] args)
{
//Create object of Rectangle.
Rectangle rectangle = new Rectangle();

//Create object of Triangle.

Triangle triangle = new Triangle();

//Set values in rectangle object

rectangle.setValues(5,4);
 //Set values in trianlge object
triangle.setValues(5,10);

// Display the area of rectangle.

System.out.println("Area of rectangle : " +
rectangle.getArea());

// Display the area of triangle.

System.out.println("Area of triangle : " +
triangle.getArea());
}
}

Output :
Area of rectangle : 20.0
Area of triangle : 25.0

2.4.2: CONSTRUCTORS IN SUB – CLASSES

In Java, constructor of base class with no argument gets automatically called in derived
class constructor.

When Constructors are Called?

Constructors are called in order of derivation, from superclass to subclass.
Because a superclass has no knowledge of any subclass, any initialization it needs to
perform is separate from and possibly prerequisite to any initialization performed by the
subclass. Therefore, it must be executed first.

Example:

class A
{
A()
{ System.out.println(“ Inside A’s Constructor”); }
}

class B extends A
{
B()
 { System.out.println(“ Inside B’s Constructor”); }
}
class C extends B
{
C()
{ System.out.println(“ Inside C’s Constructor”); }
}
class CallingCons
{
public static void main(String args[])
{
C objC=new C();
}
}
Output:

Inside A’s Constructor

Inside B’s Constructor
Inside C’s Constructor
Program Explanation:
In the above program, we have created three classes A, B and C using multilevel
inheritance concept. Here, constructors of the three classes are called in the order of
derivation. Since super() must be the first statement executed in subclass’s constructor,
this order is the same whether or not super() is used. If super() is not used, then the
default or parameterless constructor of each superclass will be executed. When inheriting
from another class, super() has to be called first in the constructor. If not, the compiler
will insert that call. This is why super constructor is also invoked when a Sub object is
created.

After compiler inserts the super constructor, the sub class constructor looks like the
following:
B()
{
super();
System.out.println("Inside B’s Constructor");
}
C()
{
super();
 System.out.println("Inside C’s Constructor");
}

2.5: “super” keyword

✓ Super is a special keyword that directs the compiler to invoke the superclass
members. It is used to refer to the parent class of the class in which the keyword is
used.
✓ super keyword is used for the following three purposes:
1. To invoke superclass constructor.
2. To invoke superclass members variables.
3. To invoke superclass methods.

1. Invoking a superclass constructor:

✓ super as a standalone statement(ie. super()) represents a call to a constructor of

the superclass.
✓ A subclass can call a constructor method defined by its superclass by use of the
following form of super:
super();
or
super(parameter-list);
✓ Here, parameter-list specifies any parameters needed by the constructor in the
superclass.
✓ super( ) must always be the first statement executed inside a subclassconstructor.
✓ The compiler implicitly calls the base class’s no-parameter constructor or default
constructor.
✓ If the superclass has parameterized constructor and the subclass constructor does
not call superclass constructor explicitly, then the Java compiler reports an error.

2. Invoking a superclass members (variables and methods):

(i) Accessing the instance member variables of the superclass:

Syntax:
super.membervariable;
 (ii) Accessing the methos of the superclass:
Syntax:
super.methodName();

This call is particularly necessary while calling a method of the super

class that is overridden in the subclass.
✓ If a parent class contains a finalize() method, it must be called explicitly by the
derived class’s finalize() method.
super.finalize();

Example:
class A // super class
{
int i;
A(String str) //superclass constructor
{
System.out.println(" Welcome to "+str);
}
void show() //superclass method
{
System.out.println(" Thank You!");
}
}
class B extends A
{
int i; // hides the superclass variable 'i'.
B(int a, int b) // subclass constructor
{
super("Java Programming"); // invoking superclass constructor
super.i=a; //accessing superclass member variable
i=b;
}
// Mehtod overriding
@Override
void show()
{
System.out.println(" i in superclass : "+super.i);
System.out.println(" i in subclass : "+i);
super.show(); // invoking superclass method
 }
}
public class UseSuper {
public static void main(String[] args) {
B objB=new B(1,2); // subclass object construction
objB.show(); // call to subclass method show()
}
}

Output:
Welcome to Java Programming
i in superclass : 1
i in subclass : 2
Thank You!

Program Explanation:
In the above program, we have created the base class named A that contains a instance
variable ‘i’ and a method show(). Class A contains a parameterized constructor that
receives string as a parameter and prints that string. Class B is a subclass of A which
contains a instance variable ‘i’ ( hides the superclass variable ‘i’) and overrides the
superclass method show(). The subclass defines the constructor with two parameters a
and b. The subclass constructor invokes the superclass constructor super(String) by
passing the string “Java Programming” and assigns the value a to the superclass
variable(super.i=a) and b to the subclass variable. The show() method of subclassprints
the values of ‘i’ form both superclass and subclass & invokes the superclassmethod as
super.show().
In the main class, object for subclass B is created and the object is used to invoke
show() method of subclass.

2.6: METHOD OVERRIDING

The process of a subclass redefining a method contained in the superclass (with

the same method signature) is called Method Overriding.

✓ When a method in a subclass has the same name and type signature as a method in
its superclass, then the method in subclass is said to override a method in the
superclass.

Example:
class Bank
{
int getRateOfInterest()// super class method
{
return 0;
}
}
class Axis extends Bank// subclass of bank
{
int getRateOfInterest()// overriding the superclass method
{
return 6;
}
}
class ICICI extends Bank// subclass of Bank
{
int getRateOfInterest()// overriding the superclass method
{
return 15;
}
}
// Mainclass
class BankTest
{
public static void main(String[] a)
{
Axis a=new Axis();
ICICI i=new ICICI();
// following method call invokes the overridden method of subclass AXIS
System.out.println(“AXIS: Rate of Interest = “+a.getRateOfInterest());

// following method call invokes the overridden method of subclass ICICI

System.out.println(“ICICI: Rate of Interest = “+i.getRateOfInterest());
}
}

Output:
 Z:\> java BankTest
AXIS: Rate of Interest = 6
ICICI: Rate of Interest = 15

➢ RULES FOR METHOD OVERRIDING:

✓ The method signature must be same for all overridden methods.

✓ Instance methods can be overridden only if they are inherited by the subclass.
✓ A method declared final cannot be overridden.
✓ A method declared static cannot be overridden but can be re-declared.
✓ If a method cannot be inherited, then it cannot be overridden.
✓ Constructors cannot be overridden.

➢ ADVANTAGE OF JAVA METHOD OVERRIDING

✓ Method Overriding is used to provide specific implementation of a method that is

already provided by its super class.
✓ Method Overriding is used for Runtime Polymorphism

2.7: DYNAMIC METHOD DISPATCH

Dynamic method dispatch is the mechanism by which a call to an overridden

method is resolved at run time, rather than compile time. Dynamic method dispatch
is important because this is how Java implements run-time polymorphism.

Example that illustrate dynamic method dispatch:

class A {
void callme() {
System.out.println(“Inside A’s callme method”);
}
}

class B extends A {
//override callme()
void callme() {
System.out.println(“Inside B’s callme method”);
}}
 class C extends A
{
//override callme()
void callme() {
System.out.println(“Inside C’s callme method”);
}
}

class Dispatch
{
public static void main(String args[])
{
A a=new A(); //object of type A
B b=new B(); //object of type B
C c=new C(); //object of type C
A r;// obtain a reference of type A

r = a; // r refers to an A object // dynamic method dispatch

r.callme();// calls A’s version of callme()

r = b;// r refers to an B object

r.callme();// calls B’s version of callme()

r = c;// r refers to an C object

r.callme();// calls C’s version of callme()
}
}

The output from the program is shown here:

Inside A's callme method

Inside B's callme method
Inside C's callme method
➢ DIFFERENCE BETWEEN METHOD OVERLOADING AND METHOD OVERRIDING IN
JAVA:

Method Overloading Method Overriding

In Method Overloading,
In Method Overriding, sub
Methods of the same class
class have the same method
shares the same name but each
with same name and exactly
Definition method must have different
the same number and type of
number of parameters or
parameters and same return
parameters having different
type as a super class.
types and order.
Method Overloading means Method Overriding means
more than one method shares method of base class is re-
Meaning
the same name in the class but defined in the derived class
having different signature. having same signature.
Method Overloading is to “add” Method Overriding is to
Behavior or “extend” more to method’s “Change” existing behavior of
behavior. method.

Overloading and Overriding is a kind of polymorphism. Polymorphism means “one

name, many forms”.

It is a compile time It is a run time

Polymorphism
polymorphism. polymorphism.
It may or may not need
It always requires inheritance
Inheritance inheritance in Method
in Method Overriding.
Overloading.
In Method Overloading, In Method Overriding,
Signature methods must have different methods must have same
signature. signature.
In Method Overriding,
In Method Overloading,
Relationship of relationship is there between
relationship is there between
Methods methods of super class and
methods of same class.
sub class.
Method Overloading does not Method Overriding requires
No. of Classes require more than one class for at least two classes for
overloading. overriding.
 Class A // Super Class
{
Class Add void display(int num)
{ {
int sum(int a, int b) print num ;
{ }
return a + b; }
Example } //Class B inherits Class A
int sum(int a) Class B //Sub Class
{ {
return a + 10; void display(int num)
} {
} print num ;
}
}

2.8: ABSTRACT CLASSES

➢ Abstraction:

Abstraction is a process of hiding the implementation details and showing only

the essential features to the user.

✓ For example sending sms, you just 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 Classes:

A class that is declared as abstract is known as abstract class. Abstract classes

cannot be instantiated, but they can be subclassed.
✓ Syntax to declare the abstract class:
abstract class <class_name>
{
Member variables;
Concrete methods { }
Abstract methods();
}
✓ Abstract classes are used to provide common method implementation to all the
subclasses or to provide default implementation.

Properties of abstract class:

➢ abstract keyword is used to make a class abstract.

➢ Abstract class can’t be instantiated.
➢ If a class has abstract methods, then the class also needs to be made abstract
using abstract keyword, else it will not compile.
➢ Abstract classes can have both concrete methods and abstract methods.
➢ The subclass of abstract class must implement all the abstract methods unless
the subclass is also an abstract class.
➢ A constructor of an abstract class can be defined and can be invoked by the
subclasses.
➢ We can run abstract class like any other class if it has main() method.

Example:
abstract class GraphicObject {
int x, y;
...
void moveTo(int newX, int newY) {
...
}
abstract void draw();
abstract void resize();
}

➢ Abstract Methods:

A method that is declared as abstract and does not have implementation is

known as abstract method. It acts as placeholder methods that are
implemented in the subclasses.
 ✓ Syntax to declare a abstract method:
abstract class classname
{

abstract return_type <method_name>(parameter_list);//no braces{}

// no implementation required
……..
}
✓ Abstract methods are used to provide a template for the classes that inherit the
abstract methods.

Properties of abstract methods:

➢ The abstract keyword is also used to declare a method as abstract.
➢ An abstract method consists of a method signature, but no method body.
➢ If a class includes abstract methods, the class itself must be declared abstract.
➢ Abstract method would have no definition, and its signature is followed by a
semicolon, not curly braces as follows:
public abstract class Employee {
private String name;
private String address;
private int number;
public abstract double computePay();
//Remainder of class definition
}
➢ Any child class must either override the abstract method or declare itself
abstract.

Write a Java program to create an abstract class named Shape that contains 2
integers and an empty method named PrintArea(). Provide 3 classes named
Rectangle, Triangle and Circle such that each one of the classes extends the
class Shape. Each one of the classes contain only the method PrintArea() that
prints the area of the given shape.

abstract class shape

{
int x, y;
abstract void printArea();
}
class Rectangle extends shape
{
void printArea()
{
System.out.println("Area of Rectangle is " + x * y);
}
}
class Triangle extends shape
{
void printArea()
{
System.out.println("Area of Triangle is " + (x * y) / 2);
}
}
class Circle extends shape
{
void printArea()
{
System.out.println("Area of Circle is " + (22 * x * x) / 7);
}
}
class abs
{
public static void main(String[] args)
{
Rectangle r = new Rectangle();
r.x = 10;
r.y = 20;
r.printArea();

System.out.println(" ------------------------------------------------ ");

Triangle t = new Triangle();

t.x = 30;
t.y = 35;
t.printArea();

System.out.println(" ------------------------------------------------ ");

circle c = new Circle();

c.x = 2;
c.printArea();
System.out.println(" ------------------------------------------------ ");
}
}
Output:
D:\>javac abs.java
D:\>java abs
Area of Rectangle is 200
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
Area of Triangle is 525
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
Area of Circle is 12
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -

2.9: final WITH INHERITANCE

What is final keyword in Java?

Final is a keyword or reserved word in java used for restricting some
functionality. It can be applied to member variables, methods, class and local
variables in Java.
✓ final keyword has three uses:
1. For declaring variable – to create a named constant. A final variable
cannot be changed once it is initialized.
2. For declaring the methods – to prevent method overriding. A final
method cannot be overridden by subclasses.
3. For declaring the class – to prevent a class from inheritance. A final
class cannot be inherited.

1. Final Variable:
Any variable either member variable or local variable (declared inside method or
block) modified by final keyword is called final variable.

✓ The final variables are equivalent to const qualifier in C++ and #define directive
in C.
✓ Syntax:
 ✓ final data_type variable_name = value;

✓ Example:
final int MAXMARKS=100;
final int PI=3.14;

✓ The final variable can be assigned only once.

✓ The value of the final variable will not be changed during the execution of the program.
If an attempt is made to alter the final variable value, the java compiler will throw an error
message.

There is a final variable speedlimit, we are going to change the value of this
variable, but It can't be changed because final variable once assigned a value can never be
changed.
1. class Bike
2. {
3. final int speedlimit=90;//final variable
4. void run( )
5. {
6. speedlimit=400;
7. }
8. public static void main(String args[])
9. {
10. Bike obj=new Bike();
11. obj.run();
12. }
13.}
Output: Compile Time Error
NOTE: Final variables are by default read-only.

2. Final Methods:
✓ Final keyword in java can also be applied to methods.
✓ A java method with final keyword is called final method and it cannot be
overridden in sub-class.
✓ If a method is defined with final keyword, it cannot be overridden in the
subclass and its behaviour should remain constant in sub-classes.
✓ Syntax:
final return_type function_name(parameter_list)
{
// method body
}
 ✓ Example of final method in Java:

1. class Bike
2. {
3. final void run()
4. {
5. System.out.println("running");
6. }
7. }
8. class Honda extends Bike
9. {
10. void run()
11. {
12. System.out.println("running safely with 100kmph");
13. }
14. public static void main(String args[])
15. {
Honda honda= new Honda();
honda.run();
18. }
19.}

Output:

D:\>javac Honda.java
Honda.java:9: error: run() in Honda cannot override run() in Bike
void run()

overridden method is final

1 error

3. Final Classes:
✓ Java class with final modifier is called final class in Java and they cannot
be sub-classed or inherited.
✓ Syntax:
final class class_name
{
// body of the class
}

✓ Several classes in Java are final e.g. String, Integer and other wrapper classes.
 ✓ Example of final class in java:
1. final class Bike
2. {
3. }
4. class Honda1 extends Bike
5. {
6. void run()
7. {
8. System.out.println("running safely with 100kmph");
9. }
10. public static void main(String args[])
11. {
12. Honda1 honda= new Honda1();
13. honda.run();
14. }
15. }
Output:

D:\>javac Honda.java
Honda.java:4: error: cannot inherit from final Bike class Honda extends Bike
^
1 error

Points to Remember:

1) A constructor cannot be declared as final.

2) Local final variable must be initializing during declaration.
3) All variables declared in an interface are by default final.
4) We cannot change the value of a final variable.
5) A final method cannot be overridden.
6) A final class cannot be inherited.
7) If method parameters are declared final then the value of these parameters
cannot be changed.
8) It is a good practice to name final variable in all CAPS.
9) final, finally and finalize are three different terms. finally is used in exception
handling and
10)finalize is a method that is called by JVM during garbage collection.
 2.10: PACKAGES
Definition:

A Package can be defined as a collection of classes, interfaces, enumerations and

annotations, providing access protection and name space management.

✓ Package can be categorized in two form:

1. Built-in package
2. user-defined package.

Table: List of Built-in Packages

Advantage of Package:

• Package is used to categorize the classes and interfaces so that they can be easily
maintained.
• Package provides access protection.
• Package removes naming collision.
• To bundle classes and interface
• The classes of one package are isolated from the classes of another package
• Provides reusability of code
• We can create our own package or extend already available package
2.10.1 : CREATING USER DEFINED PACKAGES:

Java package created by user to categorize their project's classes and interface
are known as user-defined packages.

✓ When creating a package, you should choose a name for the package.
✓ Put a package statement with that name at the top of every source file that
contains the classes and interfaces.
✓ The package statement should be the first line in the source file.
✓ There can be only one package statement in each source file

✓ Syntax:
package package_name.[sub_package_name];
public class classname
{ ……..
……..
}

✓ Steps involved in creating user-defined package:

1. Create a directory which has the same name as the package.
2. Include package statement along with the package name as the first
statement in the program.
3. Write class declarations.
4. Save the file in this directory as “name of class.java”.
5. Compile this file using java compiler.

✓ Example:
package pack;
public class class1 {
public static void greet()
{ System.out.println(“Hello”); }
}

To create the above package,

1. Create a directory called pack.
2. Open a new file and enter the code given above.
3. Save the file as class1.java in the directory.
4. A package called pack has now been created which contains one class class1.
2.10.2 : ACCESSING A PACKAGE (using “import” keyword):

• The import keyword is used to make the classes and interface of another package
accessible to the current package.

Syntax:

import package1[.package2][.package3].classname or *;

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

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

✓ Using packagename.*
• If you use package.* then all the classes and interfaces of this package will be
accessible but not subpackages.

✓ Using packagename.classname
• If you import package.classname then only declared class of this package will be
accessible.

✓ 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.
Example :

greeting.java (create a folder named “pack” in F:\ and save )

package pack;
public class greeting{
public static void greet()
{ System.out.println(“Hello! Good Morning!”); }
}

FactorialClass.java (create a folder named “Factorial” inside F:\pack and save)

package Factorial;
public class FactorialClass
{
 public int fact(int a)
{
if(a==1)
return 1;
else
return a*fact(a-1);
}
}

ImportClass.java (save the file in F:\ )

import java.lang.*; // using import package.*

import pack.Factorial.FactorialClass; // using import package.subpackage.class;
import java.util.Scanner;
public class ImportClass
{
public static void main(String[] arg)
{
int n;
Scanner in=new Scanner(System.in);
System.out.println("Enter a Number: ");
n=in.nextInt();
pack.greeting p1=new pack.greeting(); // using fully qualified name
p1.greet();
FactorialClass fobj=new FactorialClass();
System.out.println("Factorial of "+n+" = "+fobj.fact(n));
System.out.println("Power("+n+",2) = "+Math.pow(n,2));
}
}

Output:

F:\>java ImportClass
Enter a Number:
5
Hello! Good Morning!
Factorial of 5 = 120
Power(5,2) = 25.0

2.10.3 : PACKAGES AND MEMBER ACCESS:

Access level modifiers determine whether other classes can use a particular field or
invoke a particular method.
There are two levels of access control:
➢ At the top level— public, or package-private (no explicit modifier).
➢ At the member level—public, private, protected, or package-private (no
explicit modifier).

Top Level access control:

✓ A class may be declared with the modifier public, in which case that class is visible
to all classes everywhere.
✓ If a class has no modifier (the default, also known as package-private), it is visible
only within its own package.

Member Level access control:

✓ public – if a member is declared with public, it is visible and accessible to all classes
everywhere.
✓ private - The private modifier specifies that the member can only be accessed in
its own class.
✓ protected - The protected modifier specifies that the member can only be accessed
within its own package and, in addition, by a subclass of its class in another
package.

The following table shows the access to members permitted by each modifier.
Access Levels
Modifier Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

The following figure shows the four classes in this example and how they are related.

Figure: Classes and Packages of the Example Used to Illustrate Access Levels
The following table shows where the members of the Alpha class are visible for each of
the access modifiers that can be applied to them.

Visibility
Modifier Alpha Beta Alphasub Gamma
public Y Y Y Y
protected Y Y Y N
no modifier Y Y N N
private Y N N N

Example:

Z:\MyPack\FirstClass.java

package MyPack;

public class FirstClass

{
public String i="I am public variable";
protected String j="I am protected variable";
private String k="I am private variable";
String r="I dont have any modifier";
}

Z:\MyPack2\SecondClass.java

package MyPack2;
import MyPack.FirstClass;
class SecondClass extends FirstClass {
void method()
{
System.out.println(i); // No Error: Will print "I am public variable".
System.out.println(j); // No Error: Will print “I am protected variable”.
System.out.println(k); // Error: k has private access in FirstClass
System.out.println(r); // Error: r is not public in FirstClass; cannot be accessed
// from outside package
}
 public static void main(String arg[])
{
SecondClass obj=new SecondClass();
obj.method();
}
}

Output:

I am public variable
I am protected variable

Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - k

has private access in MyPack.FirstClass

Visibility of the variables i,j,k and r in MyPack2

Accessibility i j k r
Class Y Y Y Y
Package Y Y N N
Subclass Y Y N N
world Y N N N
Table: Accessibility of variables of MyyPack/FirstClass in MyPack2/SecondClass

2.11: INTERFACES

“interface” is a keyword which is used to achieve full abstraction. Using

interface, we can specify what the class must do but not how it does.
Interfaces are syntactically similar to classes but they lack instance variable and
their methods are declared without body.

Definition:
An interface is a collection of method definitions (without implementations)
and constant values. It is a blueprint of a class. It has static constants and abstract
methods.

➢ Why use Interface?

There are mainly three reasons to use interface. They are given below.
• It is used to achieve fully abstraction.
 • By interface, we can support the functionality of multiple inheritance.
• It can be used to achieve loose coupling.
• Writing flexible and maintainable code.
• Declaring methods that one or more classes are expected to implement.

➢ An interface is similar to a class in the following ways:

• An interface can contain any number of methods.
• An interface is written in a file with a .java extension, with the name of the
interface matching the name of the file.
• The bytecode of an interface appears in a .class file.
• Interfaces appear in packages, and their corresponding bytecode file must be in a
directory structure that matches the package name.

➢ Defining Interfaces:
An interface is defined much like a class. The keyword “interface” is used to
define an interface.

Syntax to define interface:

[access_specifier] interface InterfaceName

{
Datatype VariableName1=value;
Datatype VariableName2=value;
.
.
Datatype VariableNameN=value;
returnType methodName1(parameter_list);
returnType methodName2(parameter_list);
.
.
returnType methodNameN(parameter_list);
}

Where,
Access_specifer : either public or none.
Name: name of an interface can be any valid java identifier.
Variables: They are implicitly public, final and static, meaning that they cannot be
changed by the implementing class. They must be initialized with a constant
value.
Methods: They are implicitly public and abstract, meaning that they must be declared
without body and defined only by the implementing class.

Note: The java compiler adds public

and abstract keywords before the
interface method and public, static
and final keywords before data
members.

✓ In other words, Interface fields

are public, static and final by
default, and methods are
public and abstract.

➢ Understanding relationship between classes and interfaces

As shown in the figure given below, a class extends another class, an interface extends
another interface but a class implements an interface.

➢ Implementing Interfaces (“implements” keyword):

✓ Once an interface has been defined, one or more classes can implement that
interface.
✓ A class uses the implements keyword to implement an interface.
✓ The implements keyword appears in the class declaration following the extends
portion of the declaration.

✓ Syntax:
 [access_specifier] class class_name [extends superclassName] implements
interface_name1, interface_name2…
{
//implementation code and code for the method of the interface
}

Rules:
1. If a class implements an interface, then it must provide implementation for all the
methods defined within that interface.
2. A class can implement more than one interfaces by separating the interface
names with comma(,).
3. A class can extend only one class, but implement many interfaces.
4. An interface can extend another interface, similarly to the way that a class can
extend another class.
5. If a class does not perform all the behaviors of the interface, the class must
declare itself as abstract.
✓ Example:
/* File name : Super.java */
interface Super
{
final int x=10;
void print();
}
/* File name : Sub.java */
class Sub implements Super
{
int y=20;
x=100 //ERROR; cannot change modify the value of final variable

// defining the method of interface

public void print()
{
System.out.println(“X = “+x);
System.out.println(“Y = “+y);
}
}
class sample
{
public static void main(String arg[])
 {
Sub SubObj=new Sub();
SubObj.print();
Super SupObj=new Sub(); // interface variable referring to class object
SupObj.print();
}
}
Output:
$java sample
X = 10
Y = 20
X = 10
Y = 20

➢ The rules for interfaces:

Member variables:
• Can be only public and are by default.
• By default are static and always static
• By default are final and always final

Methods:
• Can be only public and are by default.
• Cannot be static
• Cannot be Final

➢ When overriding methods defined in interfaces there are several rules to be

followed:
• The signature of the interface method and the same return type or subtype should
be maintained when overriding the methods.
• An implementation class itself can be abstract and if so interface methods need
not be implemented.

➢ Properties of Interfaces:
1. Interfaces are not classes. So the user can never use the new operator to
instantiate an interface.
Example: interface super {}
X=new Super() // ERROR
 2. The interface variables can be declared, even though the interface objects
can’t be constructed.
Super x; // OK
3. An interface variable must refer to an object of a class that implements the
interface.
4. The instanceOf() method can be used to check if an object implements an
interface.
5. A class can extend only one class, but implement many interfaces.
6. An interface can extend another interface, similarly to the way that a class
can extend another class.
7. All the methods in the interface are public and abstract.
8. All the variable in the interface are public, static and final.

➢ Extending Interfaces:
✓ An interface can extend another interface, similarly to the way that a class can
extend another class.
✓ The extends keyword is used to extend an interface, and the child interface
inherits the methods of the parent interface.
✓ Syntax:
[accessspecifier] interface InterfaceName extends interface1, interface2,…..
{
Code for interface
}

Rule: When a class implements an interface that inherits another interface it must
provide implementation for all the methods defined within the interface inheritance
chain.

Example:

interface A
{
void method1();
}
/* One interface can extend another interface. B now has two abstract methods */
interface B extends A
{
void method2();
}
// This class must implement all the methods of A and B

class MyClass implements B

{
public void method1() // overriding the method of interface A
{
System.out.println(“—Method from interface: A—“);
}
public void method2() // overriding the method of interface B
{
System.out.println(“—Method from interface: B—“);
}
public void method3() // instance method of class MyClass
{
System.out.println(“—Method of the class : MyClass—“);
}
public static void main(String[] arg)
{
MyClass obj=new MyClass();
Obj.method1();
Obj.method2();
Obj.method3();
}
}

Output:
F:\> java MyClass
--Method from Interface: A—
--Method from Interface: B—
--Method of the class: MyClass--
➢ Difference between Class and Interface:

Class Interface
The class is denoted by a keyword class The interface is denoted by a keyword
interface
The class contains data members and The interfaces may contain data members
methods. but the methods are defined in and methods but the methods are not
the class implementation. thus class defined. the interface serves as an outline
contains an executable code for the class
By creating an instance of a class the class you cannot create an instance of an
members can be accessed interface
The class can use various access specifiers The interface makes use of only public
like public, private or protected access specifier
The members of a class can be constant or The members of interfaces are always
final declared as final

➢ Difference between Abstract class and interface

Abstract Class Interface

Multiple inheritance is not possible; the Multiple inheritance is possible; The class
class can inherit only one abstract class can implement more than one interfaces
Members of abstract class can have any Members of interface are public by
access modifier such as public, private default
and protected
The methods in abstract class may be The methods in interfaces are abstract by
abstract method or concrete method default
The method in abstract class may or may The methods in interface have no
not have implementation implementation at all. Only declaration
of the method is given
Java abstract class is extended using the Java interface can be implemented by
keyword extends using the keyword implements
The member variables of abstract class The member variables of interface are
can be non-final final by default
Abstract classes can have constructors Interfaces do not have any constructor
Only abstract methods need to be All the method of an interface must be
overridden. overridden.
Non-abstract methods can be static. Methods cannot be static.
Example: Example:
public abstract class Shape public interface Drawable
{ {
public abstract void draw(); void draw();
} }
Example for Interface :

1. interface Bank
2. {
3. float rateOfInterest();
4. }
5. class SBI implements Bank
6. {
7. public float rateOfInterest()
8. {
9. return 9.15f;
10. }
11. }
12. class PNB implements Bank
13. {
14. public float rateOfInterest()
15. {
16. return 9.7f;
17. }
18. }
19. class TestInterface2
20. {
21. public static void main(String[] args)
22. {
23. Bank b=new SBI();
24. System.out.println("ROI: "+b.rateOfInterest());
25. }
26. }
Output:
ROI: 9.15
DOWNLOADED FROM STUCOR APP Department of CSE
CS3391 - Object Oriented Programming

Unit – 3: EXCEPTION HANDLING AND MULTITHREADING

Chapter
Topic Page No.
No.

Exception Handling Basics 1

3.1 3.1.1: Exception Hierarchy 1

3.1.2: Exception Hanlding 3

3.2 Multiple catch blocks 7

3.3 Nested try Block 9

3.4 Throwing and Catching Exceptions 10

Types of Exceptions 13
3.5.1 : Built-in Exceptions
3.5 A. Checked Exceptions 14
B. Unchecked Exceptions
3.5.2: User-Defined Exceptions (Custom Exceptions) 18
3.6 Multithreaded Programming 21
3.7 Thread Model 23
3.8 Creating Threads 27
3.9 Thread Priority 31
3.10 Thread Synchronization 33
3.11 Inter-Thread Communication 38
3.12 Suspending, Resuming and Stopping Threads 41
3.13 Wrappers 44
3.14 Autoboxing 47
DOWNLOADED FROM STUCOR APP Department of CSE
UNIT- 3 EXCEPTION HANDLING AND MULTITHREADING

Exception Handling basics - Multiple catch Clauses- Nested try Statements - Java’s built-in
exceptions, User defined exception, Multithreaded Programming: Java Thread Model,
Creating a thread and multiple threads- Priorities- Synchronization- Inter-Thread
communication-Suspending-Resuming and Stopping Threads- Multithreading. Wrappers-
Auto boxing.

3.1: EXCEPTION HANDLING BASICS

Definition:
An Exception is an event that occurs during program execution which disrupts the normal
flow of a program. It is an object which is thrown at runtime.
Occurrence of any kind of exception in java applications may result in an abrupt
termination of the JVM or simply the JVM crashes.
In Java, an exception is an object that contains:
o Information about the error including its type
o The state of the program when the error occurred
o Optionally, other custom information

3.1.1: Exception Hierarchy

All exceptions and errors extend from a common java.lang.Throwable parent class.
The Throwable class is further divided into two classes:
1. Exceptions and
2. Errors.
DOWNLOADED FROM STUCOR APP Department of CSE

Exceptions: Exceptions represents errors in the Java application program, written by the
user. Because the error is in the program, exceptions are expected to be handled, either
• Try to recover it if possible
• Minimally, enact a safe and informative shutdown.

Sometimes it also happens that the exception could not be caught and the program may
get terminated. Eg. ArithmeticException

An exception can occur for many different reasons. Following are some scenarios where an
exception occurs.
• A user has entered an invalid data.
• A file that needs to be opened cannot be found.
• A network connection has been lost in the middle of communications or the JVM has
run out of memory.
Some of these exceptions are caused by user error, others by programmer error, and
others by physical resources that have failed in some manner.

Errors: Errors represent internal errors of the Java run-time system which could not be
handled easily. Eg. OutOfMemoryError.

DIFFERENCE BETWEEN EXCEPTION AND ERROR:

S.No. Exception Error

1. Exceptions can be recovered Errors cannot be recovered
Exceptions are of type Errors are of type java.lang.Error
2.
java.lang.Exception
Exceptions can be classified into two There is no such classification for
types: errors. Errors are always unchecked.
3.
a) Checked Exceptions
b) Unchecked Exceptions
In case of Checked Exceptions,compiler In case of Errors, compiler won’t have
will have knowledge of checked knowledge of errors. Because they
exceptions and force to keep try…catch happen at run time.
4.
block. Unchecked
Exceptions are not known to compiler
because they occur at run time.
Exceptions are mainly caused by the Errors are mostly caused by the
5. application itself. environment in which application is
running.
DOWNLOADED FROM STUCOR APP Department of CSE
Examples: Examples:
Checked Exceptions: Java.lang.StackOverFlowError,
SQLException, IOException java.lang.OutOfMemoryError
6.
Unchecked Exceptions:
ArrayIndexOutOfBoundsException,
NullPointerException

3.1.2: Exception Handling

What is exception handling?

Exception Handling is a mechanism to handle runtime errors, such as
ClassNotFoundException, IOException, SQLException, RemoteException etc. by taking the
necessary actions, so that normal flow of the application can be maintained.

Advantage of using Exceptions:

• Maintains the normal flow of execution of the application.
• Exceptions separate error handling code from regular code.
o Benefit: Cleaner algorithms, less clutter
• Meaningful Error reporting.
• Exceptions standardize error handling.

JAVA EXCEPTION HANDLING KEYWORDS

Exception handling in java is managed using the following five keywords:

S.No. Keyword Description
1 try A block of code that is to be monitored for exception.
The catch block handles the specific type of exception along
2 catch with the try block. For each corresponding try block there
exists the catch block.
It specifies the code that must be executed even though
3 finally
exception may or may not occur.
This keyword is used to explicitly throw specific exception from
4 throw
the program code.
It specifies the exceptions that can be thrown by a particular
5 throws
method.

➢ try Block:
✓ The java code that might throw an exception is enclosed in try block. It must be used
within the method and must be followed by either catch or finally block.
DOWNLOADED FROM STUCOR APP Department of CSE
✓ If an exception is generated within the try block, the remaining statements in the try
block are not executed.

➢ catch Block:
✓ Exceptions thrown during execution of the try block can be caught and handled in a
catch block.
✓ On exit from a catch block, normal execution continues and the finally block is
executed.

➢ finally Block:
A finally block is always executed, regardless of the cause of exit from the try block, or
whether any catch block was executed.
✓ Generally finally block is used for freeing resources, cleaning up, closing
connections etc.
✓ Even though there is any exception in the try block, the statements assured by
finally block are sure to execute.
✓ Rule:
• For each try block there can be zero or more catch blocks, but only one
finally block.
• The finally block will not be executed if program exits(either by calling
System.exit() or by causing a fatal error that causes the process to abort).

The try-catch-finally structure(Syntax):

try {
// Code block
}
catch (ExceptionType1 e1) {
// Handle ExceptionType1 exceptions
}
catch (ExceptionType2 e2) {
// Handle ExceptionType2 exceptions
}
// ...
finally {
// Code always executed after the
// try and any catch block
}
DOWNLOADED FROM STUCOR APP Department of CSE
Rules for try, catch and finally Blocks:
1) Statements that might generate an exception are placed in a try block.
2) Not all statements in the try block will execute; the execution is interrupted if an
exception occurs
3) For each try block there can be zero or more catch blocks, but only one finally
block.
4) The try block is followed by
i. one or more catch blocks
ii. or, if a try block has no catch block, then it must have the finally block
5) A try block must be followed by either at least one catch block or one finally block.
6) A catch block specifies the type of exception it can catch. It contains the code
known as exception handler
7) The catch blocks and finally block must always appear in conjunction with a try
block.
8) The order of exception handlers in the catch block must be from the most specific
exception

Program without Exception handling: (Default exception handler):

class Simple
{
public static void main(String args[])
{
int data=50/0;

System.out.println("rest of the code...");

}
}

Output:

Exception in thread main java.lang.ArithmeticException:/ by zero

As displayed in the above example, rest of the code is not executed i.e. rest of the
code... statement is not printed.

Program Explanation:

The JVM firstly checks whether the exception is handled or not. If exception is not
handled, JVM provides a default exception handler that performs the following tasks:
• Prints out exception description.
• Prints the stack trace (Hierarchy of methods where the exception occurred).
• Causes the program to terminate.
DOWNLOADED FROM STUCOR APP Department of CSE

Example:
public class Demo
{
public static void main(String args[])
{
try {
int data=25/0;
System.out.println(data);
}
catch(ArithmeticException e)
{
System.out.println(e);
}
finally {
System.out.println("finally block is always executed");
}
System.out.println("rest of the code...");
}
}

Output:
java.lang.ArithmeticException: / by zero
finally block is always executed
rest of the code...
DOWNLOADED FROM STUCOR APP Department of CSE

3.2: Multiple catch blocks

Multiple catch is used to handle many different kind of exceptions that may be generated
while running the program. i.e more than one catch clause in a single try block can be used.

Rules:
• At a time only one Exception can occur and at a time only one catch block is executed.
• All catch blocks must be ordered from most specific to most general i.e. catch for
ArithmeticException must come before catch for Exception.

Syntax:

try {
// Code block
}
catch (ExceptionType1 e1) {
// Handle ExceptionType1 exceptions
}
catch (ExceptionType2 e2) {
// Handle ExceptionType2 exceptions
}
DOWNLOADED FROM STUCOR APP Department of CSE

Example:

public class MultipleCatchBlock2 {

public static void main(String[] args) {

try
{
int a[]= {1,5,10,15,16};
System.out.println("a[1] = "+a[1]);
System.out.println("a[2]/a[3] = "+a[2]/a[3]);
System.out.println("a[5] = "+a[5]);
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic Exception occurs");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("ArrayIndexOutOfBounds Exception occurs");
}
catch(Exception e)
{
System.out.println("Parent Exception occurs");
}
DOWNLOADED FROM STUCOR APP Department of CSE
System.out.println("rest of the code");
}
}

Output:

a[1] = 5
a[2]/a[3] = 0
ArrayIndexOutOfBounds Exception occurs
rest of the code

3.3: Nested Try Block

Definition: try block within a try block is known as nested try block.

Why use nested try block?

✓ Sometimes a situation may arise where a part of a block may cause one error and
the entire block itself may cause another error. In such cases, exception handlers
have to be nested.
✓ If an inner try statement does not have a matching catch statement for a particular
exception, the control is transferred to the next try statement’s catch handlers that
for a matching catch statement.
✓ If none of the catch statement match, then the Java run-time system will handle the
exception. Syntax:
....
try
Example: {
statement 1;
statement 2;
try
class NestedExcep {
statement 1;
{
statement 2;
public static void main(String[] args) }
{ catch(Exception e)
try {
}
{ }
int arr[]={1,5,4,10}; catch(Exception e)
try {
{ }
....
int x=arr[3]/arr[1];
DOWNLOADED FROM STUCOR APP Department of CSE
System.out.println("Quotient = "+x);
}
catch(ArithmeticException ae)
{
System.out.println("divide by zero");
}
arr[4]=3;
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("array index out of bound exception");
}
System.out.println("...End of Program...");
}
}
Output:
Quotient = 2
array index out of bound exception
...End of Program...

3.4: THROWING AND CATCHING EXCEPTIONS

Before catching an exception, it is must to throw an exception first. This means that
there should be a code somewhere in the program that could catch exception thrown in
the try block.
An exception can be thrown explicitly
1. Using the throw statement
2. Using the throws statement

1: Using the throw statement

✓ A program can explicitly throw an exception using the throw statement besides the
implicit exception thrown.
✓ We can throw either checked, uncheked exceptions or custom(user defined)
exceptions
✓ When throw statement is called:
1) It causes the termination of the normal flow of control of the program code and
stops the execution of the subsequent statements.
2) It transfers the control to the nearest catch block handling the type of exception
object thrown
3) If no such catch block exists, then the program terminates.
DOWNLOADED FROM STUCOR APP Department of CSE

The general format of the throw statement is as follows:

throw <exception reference>;

The Exception reference must be of type Throwable class or one of its subclasses. A detail
message can be passed to the constructor when the exception object is created.
Example:

1) public class ThrowDemo

2) {
3) static void validate(int age)
4) {
5) if(age<18)
6) throw new ArithmeticException("not valid");
7) else
8) System.out.println("welcome to vote");
9) }
10) public static void main(String args[])
11) {
12) validate(13);
13) System.out.println("rest of the code...");
14) }
15) }

Output:

Exception in thread "main" java.lang.ArithmeticException: not valid

at ThrowDemo.validate(ThrowDemo.java:6)
at ThrowDemo.main(ThrowDemo.java:12)

In this example, we have created the validate method that takes integer value as a
parameter. If the age is less than 18, we are throwing the ArithmeticException otherwise
print a message welcome to vote.

2: Using throws keyword:

✓ The throws statement is used by a method to specify the types of exceptions the
method throws.
✓ If a method is capable of raising an exception that it does not handle, the method
must specify that the exception have to be handled by the calling method.
✓ This is done using the throws clause. The throws clause lists the types of exceptions
that a method might throw.
DOWNLOADED FROM STUCOR APP Department of CSE
Syntax:

Return-type method_name(arg_list) throws exception_list

{
// method body
}

Example:

1. import java.util.Scanner;
2. public class ThrowsDemo
3. {
4. static void divide(int num, int din) throws ArithmeticException
5. {
6. int result=num/din;
7. System.out.println("Result : "+result);
8. }
9. public static void main(String args[])
10. {
11. int n,d;
12. Scanner in=new Scanner(System.in);
13. System.out.println("Enter the Numerator : ");
14. n=in.nextInt();
15. System.out.println("Enter the Denominator : ");
16. d=in.nextInt();
17. try
18. {
19. divide(n,d);
20. }
21. catch(Exception e)
22. {
23. System.out.println(" Can't Handle : divide by zero ERROR");
24. }
25. System.out.println(" ** Continue with rest of the code ** ");
26. }
27. }

Output:

Enter the Numerator :

4
DOWNLOADED FROM STUCOR APP Department of CSE
Enter the Denominator :
0
Can't Handle : divide by zero ERROR
** Continue with rest of the code **
Enter the Numerator :
6
Enter the Denominator :
2
Result : 3
** Continue with rest of the code **

Difference between throw and throws:

throw keyword throws keyword

1) throw is used to explicitly throw
throws is used to declare an exception.
an exception.
2) checked exception cannot be checked exception can be propagated with
propagated without throws. throws.
3) throw is followed by an instance. throws is followed by class.
4) throw is used within the method. throws is used with the method signature.
You can declare multiple exception
5)You cannot throw multiple
e.g. public void method()throws
exception
IOException,SQLException.

3.5: Types of Exceptions

13
DOWNLOADED FROM STUCOR APP Department of CSE

3.5.1: Built-in Exceptions

Built-in exceptions are the exceptions which are available in Java libraries. These
exceptions are suitable to explain certain error situations. Below is the list of important
built-in exceptions in Java.

S. No. Exception Description

Thrown when a problem in arithmetic
1. ArithmeticException
operation is noticed by the JVM.
Thrown when you access an array with
2. ArrayIndexOutOfBoundsException
an illegal index.
Thrown when you try to access a class
3. ClassNotFoundException
which is not defined
Thrown when you try to access a non-
4. FileNotFoundException
existing file.
Thrown when the input-output
5. IOException
operation has failed or interrupted.
Thrown when a thread is interrupted
6. InterruptedException
when it is processing, waiting or sleeping
7. IllegalAccessException Thrown when access to a class is denied
Thrown when you try to access any field
8. NoSuchFieldException
or variable in a class that does not exist
Thrown when you try to access a non-
9. NoSuchMethodException
existing method.
Thrown when you refer the members of
10. NullPointerException
a null object
Thrown when a method is unable to
11. NumberFormatException
convert a string into a numeric format
Thrown when you access a String array
12. StringIndexOutOfBoundsException
with an illegal index.

A. Checked Exceptions:

✓ Checked exceptions are called compile-time exceptions because these exceptions are
checked at compile-time by the compiler.
✓ Checked Exceptions forces programmers to deal with the exception that may be thrown.
✓ The compiler ensures whether the programmer handles the exception using try.. catch ()
block or not. The programmer should have to handle the exception; otherwise, compilation
will fail and error will be thrown.
DOWNLOADED FROM STUCOR APP Department of CSE
Example:
1. ClassNotFoundException 5. NoSuchFileException
2. CloneNotSupportedException 6. NoSuchMethodException
3. IllegalAccessException, 7. IOException
4. MalformedURLException.

Example Program: (Checked Exception)

FileNotFoundException is a checked exception in Java. Anytime, we want to read a file

from filesystem, Java forces us to handle error situation where file may not be present in
place.
Without try-catch
import java.io.*;

public class CheckedExceptionExample {

public static void main(String[] args)
{
FileReader file = new FileReader("src/somefile.txt");
}
}

Output:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:

Unhandled exception type FileNotFoundException

To make program able to compile, you must handle this error situation in try-catch block.
Below given code will compile absolutely fine.
With try-catch
import java.io.*;
public class CheckedExceptionExample {
public static void main(String[] args) {
try {
@SuppressWarnings("resource")
FileReader file = new FileReader("src/somefile.java");
System.out.println(file.toString());
}
catch(FileNotFoundException e){
System.out.println("Sorry...Requested resource not availabe...");
} }
}

Output:
Sorry...Requested resource not availabe...
DOWNLOADED FROM STUCOR APP Department of CSE

B. Unchecked Exceptions(RunTimeException):

✓ The unchecked exceptions are just opposite to the checked exceptions.

✓ Unchecked exceptions are not checked at compile-time rather they are checked
at runtime.
✓ The compiler doesn’t force the programmers to either catch the exception or
declare it in a throws clause.
✓ In fact, the programmers may not even know that the exception could be
thrown.

Example:

1. ArrayIndexOutOfBoundsException
2. ArithmeticException
3. NullPointerException.

Example: Unchecked Exception

Consider the following Java program. It compiles fine, but it

throws ArithmeticException when run. The compiler allows it to compile,
because ArithmeticException is an unchecked exception.

class Main {
public static void main(String args[]) {
int x = 0;
int y = 10;
int z = y/x;
}
}

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

at Main.main(Main.java:5)
 17

Example 1: NullPointer Exception

//Java program to demonstrate NullPointerException
class NullPointer_Demo
{
public static void main(String args[])
{
try {
String a = null; //null value
System.out.println(a.charAt(0));
} catch(NullPointerException e) {
System.out.println("NullPointerException..");
}
}
}

Output:
NullPointerException..

Example 2: NumberFormat Exception

// Java program to demonstrate NumberFormatException
class NumberFormat_Demo
{
public static void main(String args[])
{
try {
// "akki" is not a number
int num = Integer.parseInt ("akki") ;
System.out.println(num);
} catch(NumberFormatException e) {
System.out.println("Number format exception");
}
}
}

Output:

Number format exception

 18

3.5.2: USER-DEFINED EXCEPTIONS (CUSTOM EXCEPTIONS)

E
Exception types created by the user to describe the exceptions related to their applications
are known as User-defined Exceptions or Custom Exceptions.

To create User-defined Exceptions:

1. Pick a self-describing *Exception class name.
2. Decide if the exception should be checked or unchecked.
✓ Checked : extends Exception
✓ Unchecked: extends RuntimeException
3. Define constructor(s) that call into super class constructor(s), taking message
that can be displayed when the exception is raised.
4. Write the code that might generate the defined exception inside the try-catch
block.
5. If the exception of user-defined type is generated, handle it using throw clause
as follows:
throw ExceptionClassObject;
Example:

The following program illustrates how user-defined exceptions can be created and
thrown.

public class EvenNoException extends Exception

{
EvenNoException(String str)
{
super(str); // used to refer the superclass constructor
}

public static void main(String[] args)

{
int arr[]={2,3,4,5};
int rem;
int i;
for(i=0;i<arr.length;i++)
{
rem=arr[i]%2;
try
{
 19

if(rem==0)
{
System.out.println(arr[i]+" is an Even Number");
}
else
{
EvenNoException exp=new EvenNoException(arr[i]+" is
not an Even Number");
throw exp;
}
}
catch(EvenNoException exp)
{
System.out.println("Exception thrown is "+exp);
}
} // for loop
} // main()
} // class

Output:

0 is an Even Number
Exception thrown is EvenNoException: 3 is not an Even Number
4 is an Even Number
Exception thrown is EvenNoException: 5 is not an Even Number

Program Explanation:

In the above program, the EvenNumberException class is created which inherits the
Exception super class. Then the constructor is defined with the call to the super class
constructor. Next, an array arr is created with four integer values. In the main(), the array
elements are checked one by one for even number. If the number is odd, then the object of
EvenNumberException class is created and thrown using throw clause. The
EvenNumberException is handled in the catch block.
 20

Comparison Chart - final Vs. finally Vs. finalize

Basis for
final finally finalize
comparison

Basic Final is a "Keyword" Finally is a "block" in Finalize is a "method"

and "access modifier" Java. in Java.
in Java.

Applicable Final is a keyword Finally is a block that finalize() is a method

applicable to classes, is always associated applicable to objects.
variables and methods. with try and catch
block.

Working (1) Final variable A "finally" block, Finalize method

becomes constant, and clean up the performs cleans up
it can't be reassigned. resources used in activities related to the
(2) A final method "try" block. object before its
can't be overridden by destruction.
the child class.
(3) Final Class can not
be extended.

Execution Final method is "Finally" block finalize() method

executed upon its call. executes just after the executes just before the
execution of"try- destruction of the
catch" block. object.

Example class FinalExample{ class FinallyExample{ class FinalizeExample{

public static void public static void public void
main(String[] args){ main(String[] args){ finalize(){System.out.pr
final int x=100; try{ intln("finalize called");}
x=200;//Compile Time int x=300; public static void
Error }catch(Exception main(String[] args){
}} e){System.out.println FinalizeExample
(e);} f1=new
finally{ FinalizeExample();
System.out.println("fi FinalizeExample
nally block is f2=new
executed"); FinalizeExample();
} f1=null;
}} f2=null;
System.gc();
}}
 21

3.6: MULTITHREADED PROGRAMMING

3.6.1 : Introduction to Thread

Definition: Thread
A thread is a lightweight sub-process that defines a separate path of execution. It is the
smallest unit of processing that can run concurrently with the other parts (other threads)
of the same process.

✓ Threads are independent.

✓ If there occurs exception in one thread, it doesn't affect other threads.
✓ It uses a shared memory area.

✓ As shown in the above figure, a thread is executed inside the process.

✓ There is context-switching between the threads.
✓ There can be multiple processes inside the OS, and one process can have multiple
threads.
DIFFERENCE BETWEEN THREAD AND PROCESS:

S.NO PROCESS THREAD

1) Process is a heavy weight program Thread is a light weight process
2) Each process has a complete set of its Threads share the same data
own variables
3) Processes must use IPC (Inter- Threads can directly communicate
Process Communication) to with each other with the help of
communicate with sibling processes shared variables
4) Cost of communication between Cost of communication between
 22

processes is high. threads is low.

5) Process switching uses interface in Thread switching does not require
operating system. calling an operating system.
6) Processes are independent of one Threads are dependent of one another
another
7) Each process has its own memory All threads of a particular process
and resources shares the common memory and
resources
8) Creating & destroying processes Takes less overhead to create and
takes more overhead destroy individual threads

3.6.2 : MULTITHREADING

A program can be divided into a number of small processes. Each small process can be
addressed as a single thread.

Definition: Multithreading
Multithreading is a technique of executing more than one thread, performing different
tasks, simultaneously.
Multithreading enables programs to have more than one execution paths which
executes concurrently. Each such execution path is a thread. For example, one thread
is writing content on a file at the same time another thread is performing spelling check.

Advantages of Threads / Multithreading:

1. Threads are light weight compared to processes.
2. Threads share the same address space and therefore can share both data and code.
3. Context switching between threads is usually less expensive that between
processes.
4. Cost of thread communication is low than inter-process communication.
5. Threads allow different tasks to be performed concurrently.
6. Reduces the computation time.
7. Through multithreading, efficient utilization of system resources can be achieved.

MULTITASKING

Definition: Multitasking
Multitasking is a process of executing multiple tasks simultaneously. We use
multitasking to maximize the utilization of CPU.

Unit 3
 23
Multitasking can be achieved in two ways:
1) Process-based Multitasking (Multiprocessing):-
❖ It is a feature of executing two or more programs concurrently.
❖ For example, process-based multitasking enables you to run the Java compiler at
the same time that you are using a text editor or visiting a web site.

2) Thread-based Multitasking (Multithreading):-

❖ It is a feature that a single program can perform two or more tasks
simultaneously.
❖ For instance, a text editor can format text at the same time that it is printing, as
long as these two actions are being performed by two separate threads.
Differences between multi-threading and multitasking

Characteristics Multithreading Multitasking

Meaning A process is divided into several The execution of more than one
different sub-processes called as task simultaneously is called as
threads, which has its own path multitasking.
of execution. This concept is
called as multithreading.
Number of CPU Can be one or more than one One
Number of Various components of the same One by one job is being
process being process are being executed at a executed at a time.
executed time.
Number of users Usually one. More than one.
Memory Space Threads are lighter weight. They Processes are heavyweight
share the same address space tasks that require their own
separate address spaces.
Communication Interthread communication is Interprocess communication is
between units Inexpensive expensive and limited.
Context Switching Context switching from one Context switching from one
thread to the next is lower in process to another is also costly.
cost.

3.7: Thread Model / Thread Life Cycle (Different states of a Thread)

Different states, a thread (or applet/servlet) travels from its object creation to
object removal (garbage collection) is known as life cycle of thread. A thread goes
through various stages in its life cycle. At any time, a thread always exists in any one of
the following state:
 24

1. New State
2. Runnable State
3. Running State
4. Waiting/Timed Waiting/Blocked state
5. Terminated State/ dead state

1. New State:
A new thread begins its life cycle in the new state. It remains in this state until the
program starts
the thread by calling start() method, which places the thread in the runnable state.
✓ A new thread is also referred to as a born thread.
✓ When the thread is in this state, only start() and stop() methods can be called.
Calling any other methods causes an IllegalThreadStateException.
✓ Sample Code: Thread myThread=new Thread();

2. Runnable State:
After a newly born thread is started, the thread becomes runnable or running by
calling the run() method.
✓ A thread in this state is considered to be executing its task.
✓ Sample code: myThread.start();
✓ The start() method creates the system resources necessary to run the thread,
schedules the thread to run and calls the thread’s run() method.

3. Running state:
✓ Thread scheduler selects thread to go from runnable to running state. In running
state Thread starts executing by entering run() method.
 25

✓ Thread scheduler selects thread from the runnable pool on basis of priority, if
priority of two threads is same, threads are scheduled in unpredictable manner.
Thread scheduler behaviour is completely unpredictable.
✓ When threads are in running state, yield() method can make thread to go in
Runnable state.

4. Waiting/Timed Waiting/Blocked State :

❖ Waiting State:
Sometimes one thread has to undergo in waiting state because another thread starts
executing. A runnable thread can be moved to a waiting state by calling the wait() method.
✓ A thread transitions back to the runnable state only when another thread signals
the waiting thread to continue executing.
✓ A call to notify() and notifyAll() may bring the thread from waiting state to
runnable state.

❖ Timed Waiting:
A runnable thread can enter the timed waiting state for a specified interval of time
by calling the sleep() method.
✓ After the interval gets over, the thread in waiting state enters into the runnable
state.
✓ Sample Code:
try {
Thread.sleep(3*60*1000);// thread sleeps for 3 minutes
}
catch(InterruptedException ex) { }

❖ Blocked State:
When a particular thread issues an I/O request, then operating system moves the
thread to
blocked state until the I/O operations gets completed.
✓ This can be achieved by calling suspend() method.
✓ After the I/O completion, the thread is sent back to the runnable state.

5. Terminated State:
A runnable thread enters the terminated state when,
(i) It completes its task (when the run() method has finished)
public void run() { }
(ii) Terminates ( when the stop() is invoked) – myThread.stop();
 26

A terminated thread cannot run again.

New : A thread begins its life cycle in the new state. It remains in this state until the
start() method is called on it.
Runnable : After invocation of start() method on new thread, the thread becomes
runnable.
Running : A thread is in running state if the thread scheduler has selected it.
Waiting : A thread is in waiting state if it waits for another thread to perform a task.
In this stage the thread is still alive.
Terminated : A thread enter the terminated state when it complete its task.

THE “main” THREAD

The “main” thread is a thread that begins running immediately when a java
program starts up. The “main” thread is important for two reasons:
1. It is the thread form which other child threads will be spawned.
2. It must be the last thread to finish execution because it performs various shutdown
actions.

✓ Although the main thread is created automatically when our program is started, it
can be controlled through a Thread object.
✓ To do so, we must obtain a reference to it by calling the method currentThread().

Example:
class CurrentThreadDemo {
public static void main(String args[])
{
Thread t=Thread.currentThread();
System.out.println(“Current Thread: “+t);

// change the name of the main thread

t.setName(“My Thread”);
System.out.println(“After name change : “+t);

try {
for(int n=5;n>0;n--) {
System.out.println(n);
Thread.sleep(1000);// delay for 1 second
}
 27

} catch(InterruptedException e) {
System.out.println(“Main Thread Interrrupted”);
}
}
}

Output:
Current Thread: Thread[main,5,main]
After name change: Thread[My Thread,5,main]
5
4
3
2
1
 28

3.8: Creating Threads

We can create threads by instantiating an object of type Thread. Java defines two ways
to create threads:

1. By implementing Runnable interface (java.lang.Runnable)

2. By extending the Thread class (java.lang.Thread)

1. Creating threads by implementing Runnable interface:

• The Runnable interface should be implemented by any class whose instances are
intended to be executed as a thread.

• Implementing thread program using Runnable is preferable than implementing it

by extending Thread class because of the following two reasons:
1. If a class extends a Thread class, then it cannot extend any other class.
2. If a class Thread is extended, then all its functionalities get inherited. This is
an expensive operation.
• The Runnable interface has only one method that must be overridden by the class
which implements this interface:
public void run()// run() contains the logic of the thread
{
// implementation code
}
• Steps for thread creation:
1. Create a class that implements Runnable interface. An object of this class is
Runnable object.
public class MyThread implements Runnable
{
---
}
 29
2. Override the run() method to define the code executed by the thread.
3. Create an object of type Thread by passing a Runnable object as argument.
Thread t=new Thread(Runnable threadobj, String threadName);
4. Invoke the start() method on the instance of the Thread class.
t.start();

• Example:
class MyThread implements Runnable
{

public void run()

{
for(int i=0;i<3;i++)
{
System.out.println(Thread.currentThread().getName()+" # Printing "+i);
try
{
Thread.sleep(1000);
}catch(InterruptedException e)
{
System.out.println(e);
 30

}
}
}
}
public class RunnableDemo {
public static void main(String[] args)
{
MyThread obj=new MyThread();
MyThread obj1=new MyThread();
Thread t=new Thread(obj,"Thread-1");
t.start();
Thread t1=new Thread(obj1,"Thread-2");
t1.start();
}
}

Output:
Thread-0 # Printing 0
Thread-1 # Printing 0
Thread-1 # Printing 1
Thread-0 # Printing 1
Thread-1 # Printing 2
Thread-0 # Printing 2

2. Creating threads by extending Thread class:

Thread class provide constructors and methods to create and perform operations on a
thread.
Commonly used Constructors of Thread class:
• Thread()
• Thread(String name)
• Thread(Runnable r)
• Thread(Runnable r, String name)
All the above constructors creates a new thread.

Commonly used methods of Thread class:

1. public void run(): is used to perform action for a thread.
2. public void start(): starts the execution of the thread.JVM calls the run() method
on the thread.
 31

3. public void sleep(long miliseconds): Causes the currently executing thread to

sleep (temporarily cease execution) for the specified number of milliseconds.
4. public void join(): waits for a thread to die.
5. public void join(long miliseconds): waits for a thread to die for the specified
miliseconds.
6. public int getPriority(): returns the priority of the thread.
7. public int setPriority(int priority): changes the priority of the thread.
8. public String getName(): returns the name of the thread.
9. public void setName(String name): changes the name of the thread.
10. public Thread currentThread(): returns the reference of currently executing
thread.
11. public boolean isAlive(): tests if the thread is alive.
12. public void yield(): causes the currently executing thread object to temporarily
pause and allow other threads to execute.
13. public void suspend(): is used to suspend the thread(depricated).
14. public void resume(): is used to resume the suspended thread(depricated).
15. public void stop(): is used to stop the thread(depricated).
16. public boolean isDaemon(): tests if the thread is a daemon thread.
17. public void setDaemon(boolean b): marks the thread as daemon or user
thread.
18. public void interrupt(): interrupts the thread.
19. public boolean isInterrupted(): tests if the thread has been interrupted.
20. public static boolean interrupted(): tests if the current thread has been
interrupted.

• Steps for thread creation:

1. Create a class that extends java.lang.Thread class.
public class MyThread extends Thread
{
---
}
2. Override the run() method in the sub class to define the code executed by the
thread.
3. Create an object of this sub class.
MyThread t=new MyThread(String threadName);
4. Invoke the start() method on the instance of the subclass to make the thread
for running.
start();
• Example:
 32

class SampleThread extends Thread

{
public void run()
{
for(int i=0;i<3;i++)
{
System.out.println(Thread.currentThread().getName()+" # Printing "+i);
try
{
Thread.sleep(1000);
}catch(InterruptedException e)
{
System.out.println(e);
}
}
}
}

public class ThreadDemo {

public static void main(String[] args) {
SampleThread obj=new SampleThread();
obj.start();
SampleThread obj1=new SampleThread();
obj1.start();
}
}
Output:

Thread-0 # Printing 0
Thread-1 # Printing 0
Thread-1 # Printing 1
Thread-0 # Printing 1
Thread-0 # Printing 2
Thread-1 # Printing 2

3.9: THREAD PRIORITY

✓ Thread priority determines how a thread should be treated with respect to

others.
 33

✓ Every thread in java has some priority, it may be default priority generated by
JVM or customized priority provided by programmer.
✓ Priorities are represented by a number between 1 and 10.
1 – Minimum Priority5 – Normal Priority 10 – Maximum Priority
✓ Thread scheduler will use priorities while allocating processor. The thread which
is having highest priority will get the chance first.
✓ Thread scheduler is a part of Java Virtual Machine (JVM). It decides which thread
should execute first among two or more threads that are waiting for execution.
✓ It is decided based on the priorities that are assigned to threads. The thread having
highest priority gets a chance first to execute.
✓ If two or more threads have same priorities, we can’t predict the execution of
waiting threads. It is completely decided by thread scheduler. It depends on the
type of algorithm used by thread scheduler.

✓ Higher priority threads get more CPU time than lower priority threads.
✓ A higher priority thread can also preempt a lower priority thread. For instance,
when a lower priority thread is running and a higher priority thread resumes (for
sleeping or waiting on I/O), it will preempt the lower priority thread.
✓ If two or more threads have same priorities, we can’t predict the execution of
waiting threads. It is completely decided by thread scheduler. It depends on the
type of algorithm used by thread scheduler.
✓ 3 constants defined in Thread class:
1.public static int MIN_PRIORITY
2.public static int NORM_PRIORITY
3.public static int MAX_PRIORITY
✓ Default priority of a thread is 5 (NORM_PRIORITY). The value of MIN_PRIORITY is
1 and the value of MAX_PRIORITY is 10.
✓ To set a thread’s priority, use the setPriority() method.
✓ To obtain the current priority of a thread, use getPriority() method.

✓ Example:
class TestMultiPriority1 extends Thread{
public void run(){
System.out.println("running thread name is:"+Thread.currentThread().getNam
e());
System.out.println("running thread priority is:"+
Thread.currentThread().getPriority());

}
 34

public static void main(String args[]){

TestMultiPriority1 m1=new TestMultiPriority1();
TestMultiPriority1 m2=new TestMultiPriority1();
m1.setPriority(Thread.MIN_PRIORITY);
m2.setPriority(Thread.MAX_PRIORITY);
m1.start();
m2.start();
}
}

Output:
running thread name is:Thread-0
running thread priority is:10
running thread name is:Thread-1
running thread priority is:1

3.10: Thread Synchronization

Definition: Thread Synchronization

Thread synchronization is the concurrent execution of two or more threads that share
critical resources.
When two or more threads need to use a shared resource, they need some way to ensure
that the resource will be used by only one thread at a time. The process of ensuring single
thread access to a shared resource at a time is called synchronization.

Threads should be synchronized to avoid critical resource use conflicts. Otherwise,

conflicts may arise when parallel-running threads attempt to modify a common variable
at the same time.
✓ Why use Synchronization
The synchronization is mainly used to
1. To prevent thread interference.
2. To prevent consistency problem.

✓ Thread Synchronization
There are two types of thread synchronization mutual exclusive and inter-thread
communication.
1. Mutual Exclusive
1. Synchronized method.
2. Synchronized block.
 35

3. static synchronization.
2. Cooperation (Inter-thread communication in java)

✓ Mutual Exclusive
Mutual Exclusive helps keep threads from interfering with one another while sharing
data. This can be done by two ways in java:
1. by synchronized method
2. by synchronized block

✓ Concept of Lock in Java

Synchronization is built around an internal entity known as the lock or monitor. Every
object has a lock associated with it. By convention, a thread that needs consistent access
to an object's fields has to acquire the object's lock before accessing them, and then
release the lock when it's done with them.

1. Java synchronized method

✓ If you declare any method as synchronized, it is known as synchronized method.

Synchronized method is used to lock an object for any shared resource.
✓ When a thread invokes a synchronized method, it automatically acquires the lock for
that object and releases it when the thread completes its task.

Syntax to use synchronized method:

Access_modifier synchronized return_type method_name(parameters)
{ …….. }

Example of java synchronized method:

class Table{
synchronized void printTable(int n)//synchronized method
{
for(int i=1;i<=5;i++) {
System.out.println(n*i);
try{ Thread.sleep(400); }
catch(Exception e) { System.out.println(e); }
}
}
}
 36

class MyThread1 extends Thread {

Table t;
MyThread1(Table t){
this.t=t;
}
public void run(){
t.printTable(5);
}
}

class MyThread2 extends Thread{

Table t;
MyThread2(Table t){
this.t=t;
}
public void run(){
t.printTable(100);
}
}
public class TestSynchronization2{
public static void main(String args[]){
Table obj = new Table(); //only one object
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}}
Output:
5
10
15
20
25
100
200
300
400
500
 37

2. Synchronized block in java

✓ Synchronized block can be used to perform synchronization on any specific
resource of the method.
✓ Suppose you have 50 lines of code in your method, but you want to synchronize
only 5 lines, you can use synchronized block.
✓ If you put all the codes of the method in the synchronized block, it will work same
as the synchronized method.

Points to remember for Synchronized block

• Synchronized block is used to lock an object for any shared resource.
• Scope of synchronized block is smaller than the method.

Syntax to use synchronized block

1. synchronized (object reference expression) {
2. //code block
3. }

Example of synchronized block

class Table{
void printTable(int n)
{
synchronized(this) //synchronized block
{
for(int i=1;i<=5;i++){
System.out.println(n*i);
try{ Thread.sleep(400); }catch(Exception e){System.out.println(e);}
}
}
}//end of the method
}

class MyThread1 extends Thread{

Table t;
MyThread1(Table t){
this.t=t;
}
public void run(){
t.printTable(5);
 38

}
}

class MyThread2 extends Thread{

Table t;
MyThread2(Table t){
this.t=t;
}
public void run(){
t.printTable(100);
}
}

public class TestSynchronizedBlock1

{
public static void main(String args[])
{
Table obj = new Table();//only one object
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);

t1.start();
t2.start();
}
}

Output:
5
10
15
20
25
100
200
300
400
500
 39

Difference between synchronized method and synchronized block:

Synchronized method Synchronized block
1. Lock is acquired on critical block of
1. Lock is acquired on whole method.
code only.
2. Less preferred.
2. Preferred.
3. Performance will be less as compared
3. Performance will be better as
to synchronized block.
compared to synchronized method.

3.11: Inter-Thread Communication

Inter-Thread Communication or Co-operation is all about allowing synchronized

threads to communicate with each other.

Definition: Inter-Thread Communication

Inter-thread communication is a mechanism in which a thread is paused running in its
critical section and another thread is allowed to enter (or lock) in the same critical section
to be executed.

It is implemented by following methods of Object class and all these methods can be
called only from within a synchronized context.

S.No. Method & Description

1 public final void wait() throws InterruptedException
Causes the current thread to wait until another thread invokes the notify().
2 public final void wait(long timeout) throws InterruptedException
Causes current thread to wait until either another thread invokes the notify()
method or the notifyAll() method for this object, or a specified amount of time
has elapsed.
Parameters:
timeout − the maximum time to wait in milliseconds.
3 public final void notify()
Wakes up a single thread that is waiting on this object's monitor.
4 Public final void notifyAll()
Wakes up all the threads that called wait( ) on the same object.
 40

Difference between wait() and sleep()

Parameter wait() sleep()
wait should be called from
synchronized context i.e. from
block or method, If you do notcall It need not be called from
Synchonized it using synchronizedcontext, it synchronized block or
will throw methods
IllegalMonitorStateExcept ion

Sleep method operates on

wait method operates on Object
Calls on current thread and is in
and defined in Object class
java.lang.Thread
wait release lock of object on
Sleep method does not release
Release of lock which it is called and also other
lock at all
locks if it holds any
Wake up until call notify() or notifyAll() Until time expires or calls
condition from Object class interrupt()
Static wait is non-static method sleep is static method

Example: The following program illustrates simple bank transaction operations with
inter-thread communication:

class Customer{
int Balance=10000;

synchronized void withdraw(int amount)

{
System.out.println("going to withdraw..."+amount);

if(Balance<amount)
{
System.out.println("Less balance; Balance = Rs. "+Balance+"\nWaiting for
deposit...\n");
try
{
wait();
}
catch(Exception e){}
}
 41

Balance-=amount;
System.out.println("withdraw completed...");
}
synchronized void deposit(int amount)
{
System.out.println("going to deposit... Rs. "+amount);
Balance+=amount;
System.out.println("deposit completed... Balance = "+Balance);
notify();
}
}

class ThreadCommn
{
public static void main(String args[]) {
Customer c=new Customer();
new Thread()
{
public void run(){c.withdraw(20000);}
}.start();
new Thread(){
public void run(){c.deposit(15000);}
}.start();
}
}

Output:

going to withdraw...20000
Less balance; Balance = Rs. 10000
Waiting for deposit...

going to deposit... Rs. 15000

deposit completed... Balance = 25000
withdraw completed...

3.12: Suspending, Resuming and Stopping threads

The functions of Suspend, Resume and Stop a thread is performed using Boolean-type
 42
flags in a multithreading program. These flags are used to store the current status of the
thread.
1. If the suspend flag is set to true, then run() will suspend the execution of the
currently running thread.
2. If the resume flag is set to true, then run() will resume the execution of the
suspended thread.
3. If the stop flag is set to true, then a thread will get terminated.

Example

class NewThread implements Runnable

{
String name; //name of thread
Thread thr;
boolean suspendFlag;
boolean stopFlag;

NewThread(String threadname)
{
name = threadname;
thr = new Thread(this, name);
System.out.println("New thread : " + thr);
suspendFlag = false;
stopFlag = false;
thr.start(); // start the thread
}

/* this is the entry point for thread */

public void run()
{
try
{
for(int i=1; i<10; i++)
{
System.out.println(name + " : " + i);
Thread.sleep(1000);
 43

synchronized(this)
{
while(suspendFlag)
{
wait();
}
if(stopFlag)
break;
}
}
}
catch(InterruptedException e)
{
System.out.println(name + " interrupted");
}

System.out.println(name + " exiting...");

}

synchronized void mysuspend()

{
suspendFlag = true;
}

synchronized void myresume()

{
suspendFlag = false;
notify();
}

synchronized void mystop()

{
suspendFlag=false;
stopFlag=true;
notify();
System.out.println("Thread "+name+" Stopped!!!");
}

}
 44

class SuspendResumeThread
{
public static void main(String args[])
{

NewThread obj1 = new NewThread("One");

NewThread obj2 = new NewThread("two");

try
{
Thread.sleep(1000);
obj1.mysuspend();
System.out.println("Suspending thread One...");
Thread.sleep(1000);
obj1.myresume();
System.out.println("Resuming thread One...");

obj2.mysuspend();
System.out.println("Suspending thread Two...");
Thread.sleep(1000);
obj2.myresume();
System.out.println("Resuming thread Two...");
obj2.mystop();

}
catch(InterruptedException e)
{
System.out.println("Main thread Interrupted..!!");
}

System.out.println("Main thread exiting...");

}
}

Output:

New thread : Thread[One,5,main]

New thread : Thread[two,5,main]
 45

One : 1
two : 1
One : 2
Suspending thread One...
two : 2
two : 3
Resuming thread One...
One : 3
Suspending thread Two...
One : 4
Resuming thread Two...
two : 4
Thread two Stopped!!!
Main thread exiting...
two exiting...
One : 5
One : 6
One : 7
One : 8
One : 9
One exiting...

3.13: Wrappers

Wrappers
Wrapper classes provide a way to use primitive data types (int, boolean, etc..) as objects.

The table below shows the primitive type and the equivalent wrapper class:
Primitive Data Type Wrapper Class
Byte Byte
Short Short
Int Integer
Long Long
Float Float
Double Double
Boolean Boolean
Char Character
 46

3.13.1. Use of Wrapper classes

✓ Change the value in Method: Java supports only call by value. So, if we pass a
primitive value, it will not change the original value. But, if we convert the primitive
value in an object, it will change the original value.
✓ Serialization: We need to convert the objects into streams to perform the
serialization. If we have a primitive value, we can convert it in objects through the
wrapper classes.
✓ Synchronization: Java synchronization works with objects in Multithreading.
✓ java.util package: The java.util package provides the utility classes to deal with
objects.
✓ Collection Framework: Java collection framework works with objects only. All
classes of the collection framework (ArrayList, LinkedList, Vector, HashSet,
LinkedHashSet, TreeSet, PriorityQueue, ArrayDeque, etc.) deal with objects only.

3.14: Autoboxing

3.14. Autoboxing
The automatic conversion of primitive data type into its corresponding wrapper class is
known as autoboxing, for example, byte to Byte, char to Character, int to Integer, long to
Long, float to Float, boolean to Boolean, double to Double, and short to Short.

Example:
public class WrapperExample1{
public static void main(String args[]){
//Converting int into Integer
int a=20;
Integer i=Integer.valueOf(a);//converting int into Integer explicitly
Integer j=a;//autoboxing, now compiler will write Integer.valueOf(a) internally
System.out.println(a+" "+i+" "+j);
}
}
Output
20 20 20

3.14.1. Unboxing
The automatic conversion of wrapper type into its corresponding primitive type is
known as unboxing. It is the reverse process of autoboxing.

Example:
 47

//Unboxing example of Integer to int

public class WrapperExample2
{
public static void main(String args[])
{
//Converting Integer to int
Integer a=new Integer(3);
int i=a.intValue(); //converting Integer to int explicitly
int j=a; //unboxing, now compiler will write a.intValue() internally
System.out.println(a+" "+i+" "+j);
}
}
Output
3 3 3

A1: STACK TRACE ELEMENTS

A Stack Trace is a list of method calls from the point when the application was
started to the current location of execution within the program. A Stack Trace is
produced automatically by the Java Virtual Machine when an exception is thrown
to indicate the location and progression of the program up to the point of the
exception. They are displayed whenever a Java program terminates with an
uncaught exception.
✓ We can access the text description of a stack trace by calling the
printStackTrace() method of the Throwable class.
✓ The java.lang.StackTraceElement is a class where each element represents a
single stack frame.
✓ We can call the getStackTrace() method to get an array of StackTraceElement
objects that we want analyse in our program.

Class Declaration
Following is the declaration for java.lang.StackTraceElement class
public final class StackTraceElement extends Object implements
Serializable

Class constructors
 Constructor & Description
StackTraceElement(String declaringClass, String methodName, String fileName,
int lineNumber)
This creates a stack trace element representing the specified execution point.

Parameters:
• declaringClass – the fully qualified name of the class containing the execution point
represented by the stack trace element.
• methodName – the name of the method containing the execution point represented
by
the stack trace element.
• fileName – the name of the file containing the execution point represented by the
stack
trace element, or null if this information is unavailable
• lineNumber – the line number of the source line containing the execution point
represented by this stack trace element, or a negative number if
thisinformation is unavailable. A value of -2 indicates that the
method containing the execution point is a native method.
Throws: NullPointerException – if declaringClass or methodName is null.

Methods in StackTraceElement class:

Method Name Description
String getFileName() Gets the name of the source file containing the
execution point represented by the
StackTraceElement.
int getLineNumber() Gets the line number of the source file containing
the execution point represented by the
StackTraceElement.
String getClassName() Gets the fully qualified name of the class
containing the execution point represented by the
StackTraceElement.
String getMethodName() Gets the name of the method containing the
execution point represented by the
StackTraceElement.
boolean isNativeMethod() Returns true if the execution point of the
StackTraceElement is inside a native method.
String toString() Returns a formatted string containing the class
name, method name, file name and the line
number, if available.
 Unit – 5: JAVAFX EVENT HANDLING, CONTROLS AND
COMPONENTS
Chapter
Topic Page No.
No.
Introduction to JavaFX 1
5.1 5.1.1: JavaFX Application Structure 2
5.1.2: Lifecycle of a JavaFX Application 4
JavaFX Events 5
5.2 5.2.1: Basics of JavaFX Events 5
5.2.2: Event Handling 6
Handling Key Events and Mouse Events 10
5.3 5.3.1: Handling Key Events 10
5.3.2: Handling Mouse Events 13
5.4 JavaFX UI Controls 16
Layouts – FlowPane – HBox and VBox – BorderPane –
5.5 24
StackPane – GridPane.
5.6 Menus – Basics – Menu – Menu bars – MenuItem. 32
UNIT V JAVAFX EVENT HANDLING, CONTROLS AND COMPONENTS

JAVAFX Events and Controls: Event Basics – Handling Key and Mouse Events.
Controls: Checkbox, ToggleButton – RadioButtons – ListView – ComboBox –
ChoiceBox – Text Controls – ScrollPane. Layouts – FlowPane – HBox and VBox –
BorderPane – StackPane – GridPane. Menus – Basics – Menu – Menu bars –
MenuItem.

5.1: Introduction to JavaFX

What is JavaFX?
JavaFX is a set of graphics and media packages that enable developers to design,
create, test, debug, and deploy desktop applications and Rich Internet Applications
(RIA) that operate consistently across diverse platforms. The applications built in
JavaFX can run on multiple platforms including Web, Mobile, and Desktops.

Features of JavaFX:

Feature Description
It consists of many classes and interfaces that are written in
Java Library
Java.
FXML is the XML based Declarative markup language. The
FXML coding can be done in FXML to provide the more enhanced GUI
to the user.
Scene Builder generates FXML mark-up which can be ported to
Scene Builder
an IDE.
Web View uses WebKitHTML technology to embed web pages
Web view
into the Java Applications.
Built-in controls are not dependent on operating system. The UI
Built in UI controls
components are used to develop a full featured application.
JavaFX code can be embedded with the CSS to improve the style
CSS like styling
and view of the application.
The JavaFX applications can be embedded with swing code
Swing
using the Swing Node class. We can update the existing swing
interoperability
application with the powerful features of JavaFX.
Canvas API provides the methods for drawing directly in an area
Canvas API
of a JavaFX scene.
Rich Set of APIs JavaFX provides a rich set of API's to develop GUI applications.
Integrated Graphics It is provided to deal with 2D and 3D graphics.
Library
JavaFX graphics are based on Graphics rendered
Graphics Pipeline pipeline(prism). It offers smooth graphics which are hardware
accelerated.
High Performance The media pipeline supports the playback of web multimedia on
Media Engine a low latency. It is based on a Gstreamer Multimedia framework.
Self-contained Self-Contained application packages have all of the application
application resources and a private copy of Java and JavaFX Runtime.
deployment model

5.1.1 : JavaFX Application Structure:

A JavaFX application will have three major components namely

1) Stage
2) Scene and
3) Nodes
as shown in the following diagram.

Figure: JavaFX App.lication Structure Figure: Scene Graph and Nodes

1) Stage
✓ Stage(a window) in a JavaFX application is similar to the Frame in a Swing
Application. It acts like a container for all the JavaFX objects.
✓ Primary Stage is created internally by the platform. Other stages can further be
created by the application.
 ✓ A stage has two parameters determining its position namely Width and Height. It
is divided as Content Area and Decorations (Title Bar and Borders).
✓ There are five types of stages available −
o Decorated
o Undecorated
o Transparent
o Unified
o Utility
✓ We have to call the show() method to display the contents of a stage.

2) Scene
✓ A scene represents the physical contents of a JavaFX application. It contains all
the contents of a scene graph.
✓ The class Scene of the package javafx.scene represents the scene object. At an
instance, the scene object is added to only one stage.

3) Scene Graph and Nodes

✓ A scene graph is a tree-like data structure (hierarchical) representing the contents
of a scene. In contrast, a node is a visual/graphical object of a scene graph.
✓ A node may include −
• Geometrical (Graphical) objects (2D and 3D) such as − Circle, Rectangle,
Polygon, etc.
• UI Controls such as − Button, Checkbox, Choice Box, Text Area, etc.
• Containers (Layout Panes) such as Border Pane, Grid Pane, Flow Pane, etc.
• Media elements such as Audio, Video and Image Objects.
✓ A node is of three types −
o Root Node − The first Scene Graph is known as the Root node.
o Branch Node/Parent Node − the node with child nodes are known as
branch/parent nodes. The parent nodes will be of the following types −
➢ Group − A group node is a collective node that contains a list of children
nodes. Whenever the group node is rendered, all its child nodes are
rendered in order. Any transformation, effect state applied on the group
will be applied to all the child nodes.
➢ Region − It is the base class of all the JavaFX Node based UI Controls, such
as Chart, Pane and Control.
➢ WebView − This node manages the web engine and displays itscontents.
o Leaf Node − The node without child nodes is known as the leaf node.

5.1.2 : Lifecycle of a JavaFX Application:

The JavaFX Application class has three life cycle methods, which are –
1) launch() - to launch JavaFX application.
2) init() − An empty method which can be overridden, but you
cannot create a stage or scene in this method.
3) start() − The entry point method where the JavaFX graphics
code is to be written.
4) stop() − An empty method which can be overridden, here we
can write the logic to stop the application.

General Rules for writing JavaFX Application:

✓ A JavaFX Application must extend javafx.application.Application.
✓ The main() method should call Application.launch()
✓ The start() method is the main entry point for all JavaFX applications
• Start() is called when a Stage is connected to the Operating System’s
window
✓ The content of the scene is represented as a hierarchical scene graph of nodes:
• Stage is the top-level JavaFX Container
• Scene is the container for all content
 5.2 JavaFX Events

5.2.1 : Basic of JavaFX Events:

A GUI based applications are mostly driven by Events. Events are the actions that the user
performs and the responses the application generates.

Example: Button clicks by user, key press on the application etc.

An event is a notification about a change. It encapsulates the state changes in the

event source. Registered event filters and event handlers within the application
receive the event and provide a response.

❖ JavaFX provides support to handle events through the base class “Event” which is
available in the package javafx.event.

Examples of Events:
o Action Event — widely used to indicate things like when a button is pressed.
Class:- ActionEvent
Actions:- button pressed.
o Mouse Event — occurs when mouse is clicked
Class:- MouseEvent
Actions:- mouse clicked, mouse pressed, mouse released, mouse moved, mouse
entered target, mouse exited target.
o Drag Event — occurs when the mouse is dragged.
Class:- DragEvent
Actions:- drag entered, drag dropped, drag entered target, drag exited target,
drag over.
o Key Event — indicates that a keystroke has occurred.
Class:- KeyEvent
Actions:- Key pressed, key released and key typed.
o Window Event:
Class:- WindowEvent
Actions:- window hiding, window shown, window hidden, window showing.
o Scroll Event — indicates scrolling by mouse wheel, track pad, touch screen, etc...
o TouchEvent — indicates a touch screen action
5.2.2 : Event Handling:

Event handling is the mechanism that controls the event and decides what should
happen, if an event occurs. It has the code which is known as Event Handler that is
executed when an event occurs.

Event Handling in JavaFX is done by Event Filters and Event Handlers. They contain the
event handling logic to process a generated event.
Every event in JavaFX has three properties:

1. Event source
2. Event target
3. Event type
S.N Property Description
It denotes source of the event i.e. the origin which is responsible
1 Event Source
for generating the event.
It denotes the node on which the event is created. It remains
unaffected for the generated event. Event Target is the instance
2 Event Target
of any of the class that implements the java interface
“EventTarget”.
It is the type of the event that is being generated. It is basically
the instance of EventType class.
3 Event Type
Example: KeyEvent class contains KEY_PRESSED,
KEY_RELEASED, and KEY_TYPED types.

Phases of Event Handling in JavaFX:

Whenever an event is generated, JavaFX undergoes the following phases:

1. Target Selection – Depends on the particular event type.
2. Route Construction – Specified by the event target.
3. Event Capturing – Event travels from the stage to the event target.
4. Event Bubbling – Event travel back from the target to the stage.

1. Target Selection:
The first step to process an event is the selection of the event target. Event target
is the node on which the event is created. Event target is selected based in the Event
Type.

• For key events, the target is the node that has key focus.
• The node where the mouse cursor is located is the target for mouse events.

2. Route Construction:
Usually, an event travels through the event dispatchers in order in the event
dispatch chain. An Event Dispatch Chain is created to determine the default route
of the event whenever an event is generated. It contains the path from the stage
to the node on which the event is generated.

3. Event Capturing:
In this phase, an event is dispatched by the root node and passed down in the
Event Dispatch Chain to the target node.
Event Handlers will not be invoked in this phase.
If any node in the chain has registered the event filter for the type of event that
occurred, then the filter on that node is called. When the filter completes, the
 event is moved down to the next node in the Dispatch Chain. If no event filters
consumes the event, then the event target receives and processes the generated
event.

4. Event Bubbling:
In this phase, a event returns from the target node to the root node along the event
dispatch chain.
Events handlers will be invoked in this phase.
If any node in the chain has a handler for the generated event, that handler is
executes. When the handler completes, the event is bubbled up in the chain. If the
handler is not registered for a node, the event is returned to the bubbled up to next
node in the route. If no handler in the path consumed the event, the rootnode
consumes the event and completes the processing.

Three methods for Event Handling:

1. Convenience Methods:
✓ setOnKeyPressed(eventHandler);
✓ setOnMouseClicked(eventHandler);
2. Event Handler/Filter Registration Methods:
✓ addEventHandler(eventType, eventHandler);
✓ addEventFilter(eventType, eventFilter);
3. Event Dispatcher Property (lambda expression).

Event Filters:
❖ Event Filters provides the way to handle the events generated by the Keyboard
Actions, Mouse Actions, Scroll Actions and many more event sources.
❖ They process the events during Event Capturing Phase.
❖ A node must register the required event filters to handle the generated event on that
node. handle() method contains the logic to execute when the event is triggered.

❖ Adding Event-Filter to a node:

To register the event filter for a node, addEventFilter() method is used.

Syntax:
node.addEventFilter (<Event_Type>, new EventHandler<Event-Type>()
{
public void handle(Event-Type)
{
//Actual logic

});

Where,
 First argument is the type of event that is generated.
Second argument is the filter to handle the event.

❖ Removing Event-Filter:
We can remove an event filter on a node using removeEventFilter() method.

Syntax:
node.removeEventFilter(<Input-Event>, filter);

Event Handlers:
❖ Event Filters provides the way to handle the events generated by the Keyboard
Actions, Mouse Actions, Scroll Actions and many more event sources.
❖ They are used to handle the events during Event Bubbling Phase.
❖ A node must register the event handlers to handle the generated event on that node.
handle() method contains the logic to execute when the event is triggered.

❖ Adding Event-Handler to a node:

To register the event handler for a node, addEventHandler() method is used.

Syntax:
node.addEventHandler (<Event_Type>, new EventHandler<Event-Type>()
{
public void handle(<Event-Type> e)
{
//Handling Code
});

Where,
First argument is the type of event that is generated.
Second argument is the filter to handle the event.

❖ Removing Event-Filter:
We can remove an event handler on a node using removeEventHandler() method.

Syntax:
node.removeEventHandler(<EventType>, handler);
 A node can register for more than one Event Filters and Handlers.
The interface javafx.event.EventHanler must be implemented by all the event filters and
event handlers.

5.3: Handling Key Events and Mouse Events

5.3.1 : HANDLING KEY EVENTS

Key Event − It is an input event that indicates the key stroke occurred on a node.
✓ It is represented by the class named KeyEvent.
✓ This event includes actions like key pressed, key released and key typed.

Types of Key Event in Java

1. KEY_PRESSED – When a key on the keyboard is pressed, this event will be
triggered.
2. KEY_RELEASED – When the pressed key on the keyboard is released, this event
will be executed.
3. KEY_TYPED – This event will be triggered when a Unicode character is entered

Methods in the KeyEvent class to get the key details

▪ KeyCode getCode() – This method returns the key information or the KeyCode
enum constant linked with the pressed or released key.
▪ String getText() – This method returns a String description of the KeyCode linked
with the KEY_PRESSED and KEY_RELEASED events.
▪ String getCharacter() – This method returns a string representing a character or a
sequence of characters connected with the KEY_TYPED event.

Example:

/* Program to handle KeyTyped and KeyPressed Events.

Whenever a key is pressed in TextFiled1, it will be displayed in TextFiled2.
Whenever BackSpace key is pressed in TextFiled1, last character in TextFiled2 will
be erased.
If you attempt to type a character in TextField2, alert box will be displaying */

import javafx.application.Application;
import static javafx.application.Application.launch;
import javafx.event.*;
import javafx.scene.*;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.Stage;
import javafx.scene.input.*;
import javafx.scene.control.Alert.*;

public class NewFXMain extends Application {

@Override
public void start(Stage primaryStage)
{

TextField tf1=new TextField();

TextField tf2=new TextField();
Label l1=new Label("Text Pressed : ");

EventHandler<KeyEvent> handler1=new EventHandler<KeyEvent>() {

String str="",str1="";
int d;
public void handle(KeyEvent event)
{
if(event.getCode()== KeyCode.BACK_SPACE)
{
str=str.substring(0,str.length()-1);
tf2.setText(str);
}
else
{
str+=event.getText();
tf2.setText(str);
}
}
};

EventHandler<KeyEvent> handler2=new EventHandler<KeyEvent>(){

public void handle(KeyEvent event)
{
Alert a=new Alert(AlertType.WARNING);
a.setContentText("Sorry! Dont Type Anything Here!!");
a.show();
}
};

tf1.setOnKeyPressed(handler1);
tf2.setOnKeyTyped(handler2);
 GridPane root = new GridPane();
root.addRow(1,tf1);
root.addRow(2,l1);
root.addRow(3,tf2);
Scene scene = new Scene(root, 300, 250);
primaryStage.setTitle("KeyEvent-Demo");
primaryStage.setScene(scene);
primaryStage.show();
}

public static void main(String[] args) {

launch(args);
}
}

Figure 1: When a key is pressed in TextField 1 Figure 2: When backspace key is pressed in TextField 1
5.3.2 : HANDLING MOUSE EVENTS

JavaFX Mouse Events are used to handle mouse events. The MouseEvents works when
you Clicked, Dragged, or Pressed and etc. An object of the MouseEvent class representsa
mouse events.

Types of Mouse Events in JavaFX

▪ ANY – This mouse event type is known as the supertype of all mouse event types. If
you want your node to receive all types of events. This event type would be used for
your handlers.
▪ MOUSE_PRESSED – When you press a mouse button, this event is triggered. The
MouseButton enum defines three constants that represent a mouse button: NONE,
PRIMARY, and SECONDARY. The MouseEvent class’s getButton() method returns the
mouse button that is responsible for the event.
▪ MOUSE_RELEASED – The event is triggered if you pressed and released a mouse
button in the same node.
▪ MOUSE_CLICKED – This event will occur when you pressed and released a node.
▪ MOUSE_MOVED – Simply move your mouse without pressing any mouse buttons to
generate this type of mouse event.
▪ MOUSE_ENTERED – This event occurs when the mouse or cursor enters the target
node.
▪ MOUSE_EXITED – This event occurs when the mouse or cursor leaves or moved
outside the target node.
▪ MOUSE_DRAGGED – This event occurs when you move the mouse with a pressed
mouse button to a target node.

Example:

import javafx.application.Application;
import javafx.event.Event.*;
import javafx.scene.*;
import javafx.event.EventHandler;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.*;
import javafx.stage.Stage;
import javafx.scene.control.*;
import java.util.*;

public class MouseEvents extends Application {

@Override
public void start(Stage primaryStage) {
Button btn = new Button();
Label status=new Label();

btn.setText("Mouse Event");
status.setText("Hello");
btn.setOnMousePressed(new EventHandler<MouseEvent>() {
public void handle(MouseEvent me) {
status.setText("Mouse pressed");
}
});

btn.setOnMouseEntered(e-> {
status.setText("Mouse Entered");
});

btn.setOnMouseExited(e-> {
status.setText("Mouse Exited");
});

btn.setOnMouseReleased(e-> {
status.setText("Mouse Released");
});
BorderPane bp = new BorderPane();
bp.setCenter(btn);
bp.setBottom(status);

Scene scene = new Scene(bp, 300, 250);

scene.setOnMouseDragged(e-> {
status.setText("Mouse Dragged");
});

primaryStage.setTitle("MouseEvent-Demo");
primaryStage.setScene(scene);
primaryStage.show();
}
 public static void main(String[] args) {
launch(args);
}
}

OUTPUT
 5.4: JavaFX UI Controls

Every user interface considers the following three main aspects −

1. UI elements − These are the core visual elements which the user eventually sees
and interacts with.
2. Layouts − They define how UI elements should be organized on the screen.
3. Behavior − These are events which occur when the user interacts with UI
elements.

❖ JavaFX provides several classes in the package javafx.scene.control.

Figure: JavaFX UI Controls
 18

S. No. UI Control Description Constructors

Component that is used to define a new Label()
1. Label simple text on the screen. It is an not new Label(String S, Node n)
editable text control. new Label(String s)
Used to get the input from the user in
2. TextField the form of text. Allows to enter a New TextField()
limited quantity of text.
Used to get the kind of information
from the user which contains various new CheckBox()
3. CheckBox
choices. User marked the checkbox new CheckBox(String s)
either on (true) or off(false).
Used to provide various options to the
user. The user can only choose one new RadioButton()
4. RadioButton
option among all. A radio button is new RadioButton(String s)
either selected or deselected.
Component that controls the function new Button()
5. Button
of the application. new Button(String s)
new ComboBox
Shows a list of items out of which user
6. ComboBox new
can select at most one item
ComboBox(ObservableList i)
Shows a set of items and allows the user
to select a single choice and it will show
new ChoiceBox
the currently selected item on the top.
7. ChoiceBox new
ChoiceBox by default has no selected
ChoiceBox(ObservableList i)
item unless otherwise
selected.
Enables users to choose one or more
8. ListView options from a predefined list of new ListView();
choices.
It provides a scrollable view of UI
Elements. It is a container that has two
scrollbars around the component it
contains if the component is larger than
9. ScrollPane new ScrollPane();
the visible area of the ScrollPane. The
scrollbars enable the user to scroll
around the component shown inside
the ScrollPane
Special control having the ability to be new ToggleButton
selected. Basically, ToggleButton is newToggleButton(String txt)
rendered similarly to a Button butthese new ToggleButton(String txt,
two are the different types of Controls. Node graphic)
10. ToggleButton A Button is a “command” button that
invokes a function when clicked. But a
ToggleButton is a control with a
Boolean indicating whether it is
selected.
 19

Example : JavaFX program for Simple Registration form using UI Controls:

import javafx.application.Application;
import javafx.collections.*;

import javafx.geometry.Insets;
import javafx.geometry.Pos;

import javafx.scene.image.*;

import javafx.scene.Scene;
import javafx.scene.control.*;

import javafx.scene.layout.*;
import javafx.scene.text.Text;

import javafx.stage.Stage;

public class JavaFXControlDemo extends Application {

@Override
public void start(Stage stage)
{
 20

//Label for name

Text nameLabel = new Text("Name");

//Text field for name

TextField nameText = new TextField();

//Label for date of birth

Text dobLabel = new Text("Date of birth");

//date picker to choose date

DatePicker datePicker = new DatePicker();

//Label for gender

Text genderLabel = new Text("gender");

//Toggle group of radio buttons

ToggleGroup groupGender = new ToggleGroup();
RadioButton maleRadio = new RadioButton("male");
maleRadio.setToggleGroup(groupGender);
RadioButton femaleRadio = new RadioButton("female");
femaleRadio.setToggleGroup(groupGender);

//Label for reservation

Text reservationLabel = new Text("Reservation");

//Toggle button for reservation

ToggleButton yes = new ToggleButton("Yes");
ToggleButton no = new ToggleButton("No");
ToggleGroup groupReservation = new ToggleGroup();
yes.setToggleGroup(groupReservation);
no.setToggleGroup(groupReservation);

//Label for technologies known

Text technologiesLabel = new Text("Technologies Known");

//check box for education

CheckBox javaCheckBox = new CheckBox("Java");
javaCheckBox.setIndeterminate(false);

//check box for education

CheckBox dotnetCheckBox = new CheckBox("DotNet");
javaCheckBox.setIndeterminate(false);

//Label for education

 21

Text educationLabel = new Text("Educational qualification");

//list View for educational qualification

ObservableList<String> names = FXCollections.observableArrayList(
"B.E","M.E","BBA","MCA", "MBA", "Vocational", "M.TECH", "Mphil",
"Phd");
ListView<String> educationListView = new ListView<String>(names);
educationListView.setMaxSize(100, 100);

educationListView.getSelectionModel().setSelectionMode(SelectionMode.MU
LTIPLE);

Label interest=new Label("Area of Interest");

ComboBox AoI=new ComboBox();
AoI.getItems().addAll("Android App. Dev.", "IoS App. Dev.", "FUll Stack
Dev.", "Azure FrmWork", "AWS", "Web Dev.", "Ui/Ux Design");
AoI.setVisibleRowCount(3);

//Label for location

Text locationLabel = new Text("location");

//Choice box for location

ChoiceBox locationchoiceBox = new ChoiceBox();
locationchoiceBox.getItems().addAll
("Hyderabad", "Chennai", "Delhi", "Mumbai", "Vishakhapatnam");

//Label for register

Button buttonRegister = new Button("Register");

//Creating a Grid Pane

GridPane gridPane = new GridPane();
//Setting size for the pane gridPane.setMinSize(500, 500);

//Setting the padding

gridPane.setPadding(new Insets(10, 10, 10, 10));

//Setting the vertical and horizontal gaps between the columns

gridPane.setVgap(5);
gridPane.setHgap(5);

//Setting the Grid alignment

gridPane.setAlignment(Pos.CENTER);
 22

//Arranging all the nodes in the grid

gridPane.add(nameLabel, 0, 0);
gridPane.add(nameText, 1, 0);

gridPane.add(dobLabel, 0, 1);
gridPane.add(datePicker, 1, 1);

gridPane.add(genderLabel, 0, 2);
gridPane.add(maleRadio, 1, 2);
gridPane.add(femaleRadio, 2, 2);
gridPane.add(reservationLabel, 0, 3);
gridPane.add(yes, 1, 3);
gridPane.add(no, 2, 3);

gridPane.add(technologiesLabel, 0, 4);
gridPane.add(javaCheckBox, 1, 4);
gridPane.add(dotnetCheckBox, 2, 4);

gridPane.add(educationLabel, 0, 5);
gridPane.add(educationListView, 1, 5);

gridPane.add(interest,0,6);
gridPane.add(AoI,1,6);

gridPane.add(locationLabel, 0, 7);
gridPane.add(locationchoiceBox, 1, 7);

gridPane.add(buttonRegister, 2, 8);

Scene scene = new Scene(gridPane);

//Setting title to the Stage

stage.setTitle("Registration Form");

//Adding scene to the stage

stage.setScene(scene);

//Displaying the contents of the stage

stage.show();
}
 23

public static void main(String args[])

{
launch(args);
}
}

OUTPUT:
 24

5.5: Layouts – FlowPane – HBox and VBox – BorderPane – StackPane – GridPane.

In JavaFX, Layout defines the way in which the components are to be seen on the stage. It
basically organizes the scene-graph nodes.
Layout Panes: Layout panes are containers which are used for flexible and dynamic
arrangements of UI controls within a scene graph of a JavaFX application.

Package used: javaFX.scene.layout package

JavaFX provides various built-in Layouts that are

1. Pane 5. FlowPane
2. VBox 6. GridPane
3. HBox 7. StackPane.
4. BorderPane

JavaFX provides many types of panes for organizing nodes in a container:

Class Description Representation

Base class for layout panes.

It containes the getChildren()
Pane
method for returning a list of
nodes in the pane.
 25

Places the nodes in a single

VBox
column

Places the nodes in a single

HBox
row

Places the nodes in the top,

BorderPane right, bottom, left and center
regions

Places the nodes row-by-row

FlowPane horizontally or column-by-
column vertically

Places the nodes in the cells

GridPane in a two-dimensional
grid(like matrix)

Places the nodes on top of

StackPane each other in the center of
the pane
 26

DOWNLOADED FROM STUCOR APP

Methods and Properties of different layouts:

Layout Constructors Methods/Properties

1. VBox() : creates layout with 0 spacing Property Description Setter Methods
2. Vbox(Double spacing) : creates layout with Alignment
This property is for the alignment of
setAlignement(Double)
a spacing value of double type the nodes.
3. Vbox(Double spacing, Node? children) : This property is of the boolean type.
The Widtht of resizeable nodes can be
VBox creates a layout with the specified spacing FillWidth
made equal to the Width of the VBox
setFillWidth(boolean)
among the specified child nodes by setting this property to true.
4. Vbox(Node? children) : creates a layout This property is to set some spacing
with the specified nodes having 0 spacing Spacing setSpacing(Double)
among the nodes of VBox.
among them
Property Description Setter Methods
This represents the alignment of the
Alignment setAlignment(Double)
nodes.
1. new HBox() : create HBox layout with 0 This is a boolean property. If you set
spacing this property to true the height of the
HBox fillHeight setFillHeight(Double)
2. new Hbox(Double spacing) : create HBox nodes will become equal to the
layout with a spacing value height of the HBox.
This represents the space between
spacing the nodes in the HBox. It is of double setSpacing(Double)
type.
Type Property Setter Methods Description
Add the node to the bottom of the
1. BorderPane() :- create the empty layout Node Bottom setBottom()
screen
2. BorderPane(Node Center):- create the Add the node to the centre of the
Node Centre setCentre()
layout with the center node screen
BorderPane Add the node to the left of the
3. BorderPane(Node Center, Node top, Node Node Left setLeft()
screen
right, Node bottom, Node left) :- create the Add the node to the right of the
Node Right setRight()
layout with all the nodes screen
Add the node to the top of the
Node Top setTop()
screen
 27

DOWNLOADED FROM STUCOR APP

Property Description Setter Methods
The overall alignment of
alignment setAlignment(Pos value)
the flowpane's content.
The horizontal alignment
1. FlowPane() columnHalignme setColumnHalignment(HPo
of nodes within the
nt s Value)
2. FlowPane(Double Hgap, Double Vgap) columns.
Horizontal gap between
3. FlowPane(Double Hgap, Double Vgap, Node? hgap setHgap(Double value)
the columns.
children) Orientation of the setOrientation(Orientation
orientation
FlowPane 4. FlowPane(Node... Children) flowpane value)
5. FlowPane(Orientation orientation) The preferred height or
width where content
6. FlowPane(Orientation orientation, double prefWrapLength should wrap in the
setPrefWrapLength(double
Hgap, Double Vgap) value)
horizontal or vertical
flowpane.
The vertical alignment of setRowValignment(VPos
rowValignment
the nodes within the rows. value)
The vertical gap among the
vgap setVgap(Double value)
rows
Property Description Setter Methods
Represents the alignment of
alignment setAlignment(Pos value)
the grid within the GridPane.
This property is intended for
debugging. Lines can be
Public GridPane(): creates a gridpane with 0 displayed to show the setGridLinesVisible(Boo
GridPane hgap/vgap. gridLinesVisible
gidpane's rows and columns lean value)
by setting this property to
true.
Horizontal gaps among the
hgap setHgap(Double value)
columns
vgap Vertical gaps among the rows setVgap(Double value)
Property Description Setter Methods
1. StackPane()
2. StackPane(Node? Children) It represents the default
StackPane alignment of children setAlignment(Node
alignment
within the StackPane's child, Pos value)
width and height
 28

DOWNLOADED FROM STUCOR APP

Example: Program for Layouts, Menus and MenuBars, Event Handling

import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.*;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.stage.Stage;

public class JavaFXApplication1 extends Application {

@Override//from ww w . ja v a2s . co m
public void start(Stage primaryStage) {
// Create the top section of the UI
Text tNumber1 = new Text("Number 1:");
Text tNumber2 = new Text("Number 2:");
Text tResult = new Text("Result:");
TextField tfNumber1 = new TextField();
TextField tfNumber2 = new TextField();
TextField tfResult = new TextField();
tfResult.setEditable(false);

Menu me=new Menu("Edit");

// create menuitems
MenuItem m1 = new MenuItem("Set Default Value");
MenuItem m2 = new MenuItem("Clear All values");

// add menu items to menu

me.getItems().add(m1);
me.getItems().add(m2);

Menu mc=new Menu("Bg_Color");

MenuItem c1 = new MenuItem("Red");
MenuItem c2 = new MenuItem("Green");

mc.getItems().addAll(c1,c2);
MenuBar mb = new MenuBar();

// add menu to menubar

mb.getMenus().add(me);
 29

DOWNLOADED FROM STUCOR APP

mb.getMenus().add(mc);

VBox vb=new VBox(mb);

m1.setOnAction(e -> {
tfNumber1.setText("10");
tfNumber2.setText("20");
});

m2.setOnAction(e ->{
tfNumber1.setText("");
tfNumber2.setText("");
tfResult.setText("");
});

// Create the bottom section of the UI

Button btAdd = new Button("Add");
Button btSubtract = new Button("Subtract");
Button btMultiply = new Button("Multiply");
Button btDivide = new Button("Divide");

// Add top and bottom UI to HBox containers

GridPane calcTop = new GridPane();

calcTop.setAlignment(Pos.CENTER);
calcTop.setPadding(new Insets(5));
calcTop.add(tNumber1, 0, 0);
calcTop.add(tfNumber1, 1, 0);
calcTop.add(tNumber2, 0, 1);
calcTop.add(tfNumber2, 1, 1);
calcTop.add(tResult, 0, 2);
calcTop.add(tfResult, 1, 2);

FlowPane calcBottom = new FlowPane();

calcBottom.setAlignment(Pos.CENTER);
calcBottom.setPadding(new Insets(5));
 30

DOWNLOADED FROM STUCOR APP

calcBottom.getChildren().addAll(btAdd, btSubtract, btMultiply, btDivide);

// Add HBox containers to a BorderPane

BorderPane pane = new BorderPane();
pane.setTop(vb);
pane.setCenter(calcTop);
pane.setBottom(calcBottom);

c1.setOnAction(e -> {
pane.setBackground(new Background(new BackgroundFill(Color.RED,null,null)));
});
c2.setOnAction(e -> {
pane.setBackground(new Background(new
BackgroundFill(Color.GREEN,null,null)));
});

// Register event handlers for buttons

btAdd.setOnAction(e -> {
double a = getDoubleFromTextField(tfNumber1);
double b = getDoubleFromTextField(tfNumber2);
tfResult.setText(String.valueOf(a + b));
});

btSubtract.setOnAction(e -> {
double a = getDoubleFromTextField(tfNumber1);
double b = getDoubleFromTextField(tfNumber2);
tfResult.setText(String.valueOf(a - b));
});

btMultiply.setOnAction(e -> {
double a = getDoubleFromTextField(tfNumber1);
double b = getDoubleFromTextField(tfNumber2);
tfResult.setText(String.valueOf(a * b));
});

btDivide.setOnAction(e -> {
double a = getDoubleFromTextField(tfNumber1);
double b = getDoubleFromTextField(tfNumber2);
tfResult.setText(b == 0 ? "NaN" : String.valueOf(a / b));
 31

DOWNLOADED FROM STUCOR APP

});

Scene scene = new Scene(pane);

primaryStage.setTitle("Simple Calculator");
primaryStage.setScene(scene);
primaryStage.setResizable(false);
primaryStage.show();
}

private static double getDoubleFromTextField(TextField t) {

return Double.parseDouble(t.getText());
}

public static void main(String[] args) {

launch(args);
}
}
 32

DOWNLOADED FROM STUCOR APP

5.6: Menus – Basics – Menu – Menu bars – MenuItem.

5.6.1. JavaFX Menus, MenuItem and MenuBar:

Menu is a popup menu that contains several menu items that are displayed when
the user clicks a menu. The user can select a menu item after which the menu goes into
a hidden state.

MenuBar is usually placed at the top of the screen which contains several menus. JavaFX
MenuBar is typically an implementation of a menu bar.

Constructor of the MenuBar class are:

1. MenuBar(): creates a new empty menubar.
2. MenuBar(Menu... m): creates a new menubar with the given set of menu.

Constructor of the Menu class are:

1. Menu(): creates an empty menu
2. Menu(String s): creates a menu with a string as its label
3. Menu(String s, Node n):Constructs a Menu and sets the display text with the
specified text and sets the graphic Node to the given node.
4. Menu(String s, Node n, MenuItem... i):Constructs a Menu and sets the display text
with the specified text, the graphic Node to the given node, and inserts the given
items into the items list.

Commonly used methods:

Method Explanation
getItems() returns the items of the menu
hide() hide the menu
show() show the menu
getMenus() The menus to show within this MenuBar.
isUseSystemMenuBar() Gets the value of the property useSystemMenuBar
setUseSystemMenuBar(boolean
Sets the value of the property useSystemMenuBar.
v)
setOnHidden(EventHandler v) Sets the value of the property onHidden.
 33

DOWNLOADED FROM STUCOR APP

setOnHiding(EventHandler v) Sets the value of the property onHiding.

setOnShowing(EventHandler v) Sets the value of the property onShowing.
setOnShown(EventHandler v Sets the value of the property onShown.

JavaFX Menu

✓ In the JavaFX application, in order to create a menu, menu items, and menu bar,
Menu, MenuItem, and MenuBar class is used. The menu allows us to choose options
among available choices in the application.
✓ All methods needed for this purpose are present in the javafx.scene.control.Menu
class.

Example: Java program to create a menu bar and add menu to it and also add
menuitems to the menu

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.control.Menu;
import javafx.scene.control.MenuBar;
import javafx.scene.control.MenuItem;
import javafx.scene.layout.VBox;
public class MenuUI extends Application {
@Override
public void start(Stage primaryStage) throws Exception
{
Menu newmenu = new Menu("File");
Menu newmenu2 = new Menu("Edit");

MenuItem m1 = new MenuItem("Open");

MenuItem m2 = new MenuItem("Save");
MenuItem m3 = new MenuItem("Exit");
MenuItem m4 = new MenuItem("Cut");
MenuItem m5 = new MenuItem("Copy");
 34

DOWNLOADED FROM STUCOR APP

MenuItem m6 = new
MenuItem("Paste");
newmenu.getItems().add(
m1);
newmenu.getItems().add(
m2);
newmenu.getItems().add(
m3);
newmenu2.getItems().add(
m4);
newmenu2.getItems().add(
m5);
newmenu2.getItems().add(
m6); MenuBar newmb =
new MenuBar();
newmb.getMenus().add(ne
wmenu);
newmb.getMenus().add(ne
wmenu2); VBox box = new
VBox(newmb);
Scene scene = new
Scene(box,400,200);
primaryStage.setScene(scene);
primaryStage.setTitle("JavaFX
Menu Example");
primaryStage.show();
}
public static void main(String[] args)
{
Application.launch(args);
}
}

Output:
 35

DOWNLOADED FROM STUCOR APP