Object Oriented Programming

Mahlet Teklay
Mohammed Abrar

FDRE Technical and Vocational Training Institute

 Object Oriented Programming

Mahlet Teklay

Mohammed Abrar

Information Technology

January 2024

FDRE Technical and Vocational Training Institute

Yeka Subcity, Woreda 9, Addis Ababa, Ethiopia
Phone: 011-646-4455, Fax: 011-646-5675/5678
E-mail: info@etu.edu.et, Website: http://www.etu.edu.et
Table of Contents
Course Profile ......................................................................................................................................... 1
Detailed Course Outline .......................................................................................................................... 2
Chapter One : Introduction to Object-Oriented Programming .............................................................. 5
Week One: Session ................................................................................................................................. 7
1.1 Types of Programming Paradigm ........................................................................................... 7
1.2 Programming paradigms ....................................................................................................... 10
1.3 Overview of OOP principles and features ............................................................................ 16
Week One: Practical .............................................................................................................................. 19
Week One : Assesment ......................................................................................................................... 22
Week Two: Session ............................................................................................................................... 23
1.4 Basics of Java Programming ................................................................................................. 23
1.5 Editing, Compiling and Interpreting ...................................................................................... 26
Week Two: Practical.............................................................................................................................. 38
Week Two : Assessment ....................................................................................................................... 44
Reference .............................................................................................................................................. 45
Chapter Two: Basics in Java Programming ........................................................................................... 46
Week Three: Session ............................................................................................................................. 48
2.1. Variable types and identifiers ............................................................................................... 48
Week Three: Practical ........................................................................................................................... 66
Assessments .......................................................................................................................................... 69
Week Four : Session .............................................................................................................................. 73
2.2. Operators and operator precedence ....................................................................................... 73
Week Four : Practical ............................................................................................................................ 91
Week Four: Assessments ...................................................................................................................... 94
Week Five : Session ............................................................................................................................... 95
2.3. Program Control Statements ................................................................................................. 95
Week Five: Practical ............................................................................................................................ 130
Week Five: Assessments ..................................................................................................................... 135
Reference ............................................................................................................................................ 138
Chapter Three : Objects and Classes................................................................................................... 140
Week Six: Session ................................................................................................................................ 142
3.1. Classes and objects ............................................................................................................. 142

i
Week Six : Practical ............................................................................................................................. 155
Week Six: Assessments ....................................................................................................................... 157
Week Seven: Session........................................................................................................................... 158
3.2. Instance Fields Constructors and Methods ......................................................................... 158
Week Seven: Practical ......................................................................................................................... 170
Week Seven: Assessments .................................................................................................................. 175
Reference ............................................................................................................................................ 176
Chapter Four: Object Oriented Programming Concepts ................................................................... 178
Week Nine: Session............................................................................................................................. 180
4.1. Inheritance........................................................................................................................... 180
4.2. Encapsulation ...................................................................................................................... 188
Week Nine: Practical ........................................................................................................................... 192
Week Nine : Assesment ...................................................................................................................... 193
Week Ten: Session .............................................................................................................................. 195
4.3. Polymorphism ..................................................................................................................... 195
Week Ten: Practical ............................................................................................................................ 212
Week Ten : Assesment ........................................................................................................................ 217
Reference ............................................................................................................................................ 219
Chapter Five: Exception Handling in Java .......................................................................................... 220
Week Eleven: Session ......................................................................................................................... 222
5.1. Exception Handling in Java ................................................................................................ 222
5.2. Java try and catch block ...................................................................................................... 226
5.3. Java finally block ................................................................................................................ 234
5.4. Why use java finally ........................................................................................................... 235
5.5. Difference between throw and throws in Java .................................................................... 236
5.6. Java Custom Exception ....................................................................................................... 239
Week Eleven: Practical ........................................................................................................................ 241
Week Eleven : Assesment ................................................................................................................... 244
Week Twelve: Session ......................................................................................................................... 245
5.7. Exception Hierarchy ........................................................................................................... 245
5.8. Types of Exception in Java ................................................................................................. 245
5.8.1. Checked exception .......................................................................................................... 247
5.8.2. Unchecked exception ...................................................................................................... 254
Week Twelve: Practical ....................................................................................................................... 261

ii
Week Twelve: Assesment ................................................................................................................... 263
Chapter Six: AWT, Swing and Java Applets ......................................................................................... 268
Week Thirteen: Session ...................................................................................................................... 270
6.1 Introduction ......................................................................................................................... 270
6.2 AWT ................................................................................................................................... 271
Week Thirteen : Practical .................................................................................................................... 304
Week Thirteen : Assesment ................................................................................................................ 308
Week 14: Session ............................................................................................................................... 310
6.3 Swing .................................................................................................................................. 310
Week Fourteen : Practical ................................................................................................................... 315
Week Fourteen : Assesment ............................................................................................................... 318
Week Fifteen: Session ........................................................................................................................ 322
6.4 Applet.................................................................................................................................. 322
Week Fifteen : Practical ...................................................................................................................... 337
Week Fifteen: Assessment ................................................................................................................. 340
Reference ............................................................................................................................................ 343

iii
iv
 Course Profile
Department Information Technology

Course title Object Oriented Programming

This course provides an introduction to the concepts and methodology of Object-

Oriented Programming with Java as an illustration language. Students’ previous
exposure to and skills in structured programming is assumed (although a review of
Course the necessary basic 161 programming notions is included). It includes Object
description Oriented Programming paradigm and its use; classes, Objects, Abstraction and
Encapsulation; Inheritance, Polymorphism, Creating Graphical User interfaces
(GUIs), Data Structures, Exceptions, File input/output (I/O), Threads and Java
Database Connectivity.

• Understand major concepts of object-oriented programming

• Knowledge and skills in OO design and program development
• Experience in Java programming and program development within an
integrated development environment
• Use arrays and other data collections
Course
• Implement error-handling techniques using exception handling
Objective
• Create event-driven GUI using Java technology GUI components: panels,
buttons, labels, text fields, and text areas
• Implement I/O functionality to read from and write to data and text files.
• Create multithreaded programs
• Create JDBC applications
• Justify the philosophy of object-oriented design and the concepts of
• encapsulation, abstraction, inheritance, and polymorphism
• Describe how the class mechanism supports encapsulation and information
hiding
Learning
• Compare and contrast the notions of overloading and overriding methods in
outcomes
an object-oriented language.
• Explain the relationship between the static structure of the class and the
dynamic structure of the instances of the class.
• Describe how iterators access the elements of a container.
Pre-requisite Programming Using C++ (ITec 2033)
Target group Technical teacher education for TVET B-level trainer.

1
Detailed Course Outline

Topics to be covered Topics to be covered Required materials

Week Outcomes
(3 lecture hours) (3 lab hours) /equipment/devices

Chapter One: Introduction to Object-Oriented Programming

1.1 Types of programming • J PC, JDK, netbeans

paradigm
1
1.2. Overview of OO principles
and features

1.3. Overview of Java • Installation of Java IDE 5.1.1 PC, JDK, netbeans

Programming and types of Java 5.1.2

Programs

2 1.4 (Definition of Java

Application, Java Applets;

Editing, Compiling and

Interpreting)

Chapter Two: Basics in Java Programming

2.1. Variable types and • Variable declaration 5.1.2 PC, JDK, netbeans
identifiers
• Datatype defination
3
2.2. Number types, strings,
constants

2.3 Operators and operator • Operators in practice 5.1.1 PC, JDK, netbeans

4 precedence
• Type conversion and 5.1.2
2.4. Type Conversion/ Casting casting in java
5.1.3
5.1.2
2.5. Decision and Repetition • If statement PC, JDK, netbeans
5.1.3
5 Statements • Switch statement

• For loop

2
 • While, Do while loop

Chapter Three: Objects and Classes

6 3.1. Object variables • Defining a class 5.1.3 PC, JDK, netbeans

3.2. Class concept • Creating objects 5.1.2

3.3. Instantiating and using • 5.1.3

objects

7 3.4 Instance fields, Construction • Instantiating and using 5.1.3 PC, JDK, netbeans
and methods objects
5.1.2
• Passing and returning
5.1.3
objects

8 Mid Term examination

Chapter Four: OOP Concepts

9 4.1.Inheritance, method • OOP Principles: 5.1.2 PC, JDK, netbeans

overloading and overriding Encapsulation
5.2.1
Inheritance and
4.2 . Encapsulation
5.2.2
overloading

10 4.3. Polymorphism • OOP Principles: and Data 5.1.2 PC, JDK, netbeans
abstraction, and
4.4.Abstract classes and 5.2.1
Polymorphism
Interfaces
5.2.2

Chapter Five: Exception Handling in Java

11 5.1 Exception Handling in Java • Methods to print 5.1.2 PC, JDK, netbeans

5.2 Exception Hierarchy the Exception information 5.2.1

5.2.2

12 5.3 Types of Exceptions • Java Exception Handling 5.2.2 PC, JDK, netbeans
Example
5.4 Errors

3
 • Java error handling

Chapter Six: AWT, Swing and Java Applets

13 6.1 Abstract Window Toolkit • Creating Graphical User PC, JDK, netbeans
Interface (GUI) in Java.
(AWT) 5.2.1
like button, label,
Basic ideas 5.2.2
checkbox
General Layout of AWT

14 6.2 Swing • Java Swing PC, JDK, netbeans

Examples
Hierarchy of Java Swing classes 5.2.1
• JButton class
5.2.2
• JRadioButton class

• JTextArea class

• JComboBox class

• JTable class

15 6.3 Java Applets • Converting an 5.2.1 PC, JDK, netbeans

application to an applet
- Applets and HTML, 5.2.2
• Applet Initialization
- Security Issues,
Methods

• Restrictions

• Packaging The Applet

16 Final Examination period:

4
 Chapter One : Introduction to Object-Oriented Programming

Chapter One : Introduction to Object-Oriented

Programming

Lesson Plan
1. Learning objectives

• Be able to define Object Oriented Programming.

• Be able to know principles and features of Object Oriented Programming.

• Be able to install Java IDE software.

• Be able to know the complete development cycle of Java IDE.

• Be able to differenciate java application and java applets.

2. Motivation

• Outputs through Question and Answer; repetitive discussion of java programming

basics; individual internet search.

• Solving a problem using Object Oriented programming.

• Controlling the flow control of instruction execution.

3. Expectations or Outcomes

 Define the terminologies, differentiate different programming paradigms, explain

Object Oriented programming principles; the assessment standard attached at the end
of the job task sheet.
 Can write Object Oriented instructions using Java to solve any problem using
programming.
4. Equipment

• Desktop or Laptop computer.

• Java IDE (NetBeans) software

5. Practice contents/Activities/Safety

 Brief introduction of Java complete development life cycle (Java IDE).

 Active practice; on java input and output, writing (Editing), compiling, interprating.

5
 Chapter One : Introduction to Object-Oriented Programming

6. Assessments

• How can you install Java IDE (Netbeans) software?

• How to create class and objects?
7. Clean-up

 After finishing practice, computers should be properly shut down.

8. Independent practice/Follow-up activities

• Learning through assignment (practical exercises)

9. Review/Reflection

• Review the outcome of the practice, improvement measure and previous reflected
opinions.

6
 Chapter One : Introduction to Object-Oriented Programming

Week One: Session

1.1 Types of Programming Paradigm

The term programming paradigm refers to a style of programming. It does not refer to a specific
language, but rather it refers to the way you program. There are lots of programming languages
that are well-known but all of them need to follow some strategy when they are implemented.
And that strategy is a paradigm.

There are basically two types of computer programming languages given below:

I. Low level language

II. High level language

1.1.1. Low Level Languages

The programming languages that are very close to machine code (0s and 1s) are called low-
level programming languages. Machine Language and Assembly Language are the two
examples of low level language.

A. Machine Language

The instructions in binary form, which can be directly understood by the computer (CPU)
without translating them, is called a machine language or machine code. Machine language is
also known as the first generation of programming language. Machine language is the
fundamental language of the computer and the program instructions in this language are in the
binary form (that is 0's and 1's). This language is different for different computers. It is not easy
to learn the machine language.

Advantage of Machine Language

The only advantage of machine language is that the program of machine language runs very
fast because no translation program is required for the CPU.

Disadvantage of Machine Language

Here are some of the main disadvantages of machine languages:

➔ Machine Dependent - the internal design of every computer is different from every
other type of computer, machine language also differs from one computer to another.

7
 Chapter One : Introduction to Object-Oriented Programming

Hence, after becoming proficient in the machine language of one type of computer, if
a company decides to change to another type, then its programmer will have to learn a
new machine language and would have to rewrite all existing program.

➔ Difficult to Modify - it is difficult to correct or modify this language. Checking

machine instructions to locate errors is very difficult and time consuming.

➔ Difficult to Program - a computer executes machine language program directly and

efficiently, it is difficult to program in machine language. A machine language
programming must be knowledgeable about the hardware structure of the computer.

B. Assembly Language

Assembly language is also known as the second generation of programming language. With
assembly language, a programmer writes instructions using symbolic instruction code instead
of binary codes. Symbolic codes are meaningful abbreviations such as SUB is used for
substation operation, MUL for multiply operation and so on. Therefore this language is also
called the low-level symbolic language. The set of program instructions written in assembly
language are also called mnemonic code. Assembly language provides facilities for controlling
the hardware.

Advantages:

Here are some of the main advantages of using assembly language:

➔ Easy to understand and use - due to the use of mnemonic instead of numeric op-
codes and symbolic names for data location instead of numeric addresses, it is much
easier to understand and use in contrast with machine language.

➔ Easier to locate and correct errors - the programmers need not to keep track of
storage location of the data and instruction, fewer errors are made while writing
programs in assembly language and those that are made, are easier to find and correct.

➔ Easy to modify - assembly language is easier to understand, it is easier to locate,

correct and modify instruction of an assembly language program.

Disadvantages:

Some of the main disadvantages of using assembly language are:

8
 Chapter One : Introduction to Object-Oriented Programming

➔ Machine dependent - each instruction of an assembly language program is

translated into exactly one machine language instruction, an assembly language
program is dependent on machine language.

➔ Knowledge of hardware required - assembly languages are machine dependent,

an assembly language programmer must have a good knowledge of characteristics and
logical structure of his/her computer to write a good assembly language computer code.

➔ Machine level coding - assembly language instruction is substituted for one

machine language instruction.

Hence like machine language programs, writing assembly language program is also time
consuming and difficult.

1.1.2. High Level Languages

The programming languages that are close to human languages (example like English
languages) are called the high-level languages. The examples of high-level languages are:
Fortran, COBOL, Basic, Pascal, C, C++, Java, C#, Python, etc.

Advantages: There are several advantages of high level programming languages. The most
important advantages are:

➔ Easy to learn - the high level languages are very easy to learn than low level
languages.

➔ Easy to understand - the program written in high level language by one

programmer can easily be understood by another because the program instructions are
similar to the English language.

➔ Easy to write program - in high level language, a new program can easily be written
in a very short time.

➔ Easy to detect and remove errors - the errors in a program can be easily detected
and removed.

➔ Built-in library functions - Each high level language provides a large number of
built-in functions or procedures that can be used to perform specific tasks during
designing of new programs.

9
 Chapter One : Introduction to Object-Oriented Programming

➔ Machine Independence - program written in high level language is machine

independent.

Disadvantages: The main limitations of high level languages are:

➔ Low efficiency - a program written in high level languages has lower efficiency than
one written in a machine/assembly language to do the same job.

➔ Less flexibility - high level languages are less flexible than assembly languages
because they do not normally have instructions or mechanisms to control a computer's
CPU, memory and register.

1.2 Programming paradigms

Refers to a style of programming. It does not refer to a specific language, but rather it refers to
the way you program. There are lots of programming languages that are well-known but all of
them need to follow some strategy when they are implemented. And that strategy is a paradigm.

1.2.1. Types of Programming Paradigms

Figure 1:Programming Paradigms

1. Imperative programming paradigm

The word “imperative” comes from the Latin “impero” meaning “I command”. The paradigm
consists of several statements, and after the execution of all of them, the result is stored. It’s
about writing a list of instructions to tell the computer what to do step by step.

10
 Chapter One : Introduction to Object-Oriented Programming

In an imperative programming paradigm, the order of the steps is crucial, because a given step
will have different consequences depending on the current values of variables when the step is
executed.

It is one of the oldest programming paradigm. It features close relation to machine architecture.
It is based on Von Neumann architecture. It works by changing the program state through
assignment statements. It performs step by step task by changing state. The main focus is on
how to achieve the goal. The paradigm consist of several statements and after execution of all
the result is stored.

Table 0-1: Imperative programming

Advantage Disadvantage

Very simple to implement Complex problem cannot be solved

It contains loops, variables etc. Less efficient and less productive

Parallel programming is not possible

Examples of Imperative programming paradigm:

1. // average of five number in

2. int marks[5] = { 12, 32, 45, 13, 19 } int sum = 0;
3. float average = 0.0;
4. for (int i = 0; i < 5; i++) {
5. sum = sum + marks[i];
6. }
7. average = sum / 5;

Imperative programming is divided into three broad categories: Procedural, OOP and parallel
processing. These paradigms are as follows:

A. Procedural programming paradigm

This paradigm emphasizes on procedure in terms of under lying machine model. There is no
difference in between procedural and imperative approach. It has the ability to reuse the code
and it was boon at that time when it was in use because of its reusability.
11
 Chapter One : Introduction to Object-Oriented Programming

Examples of Procedural programming paradigm:

• C : developed by Dennis Ritchie and Ken Thompson

• C++ : developed by Bjarne Stroustrup

• Java : developed by James Gosling at Sun Microsystems

• ColdFusion : developed by J J Allaire

• Pascal : developed by Niklaus Wirth

C++

1. #include <iostream>
2. using namespace std;
3. int main()
4. {
5. int i, fact = 1, num;
6. cout << "Enter any Number: ";
7. cin >> number;
8. for (i = 1; i <= num; i++) {
9. fact = fact * i;
10. }
11. cout << "Factorial of " << num << " is: " << fact << endl;
12. return 0;
13. }

B. Object oriented programming

The program is written as a collection of classes and object which are meant for communication.
The smallest and basic entity is object and all kind of computation is performed on the objects
only. More emphasis is on data rather procedure. It can handle almost all kind of real life
problems which are today in scenario.

Advantages:

• Data security

• Inheritance

• Code reusability

• Flexible and abstraction is also present

12
 Chapter One : Introduction to Object-Oriented Programming

Examples of Object Oriented programming paradigm:

1. import java.io.*;
2. class GFG {
3. public static void main(String[] args)
4. {
5. System.out.println("GfG!");
6. Signup s1 = new Signup();
7. s1.create(22, "riya", "riya2@gmail.com", 'F', 89002);
8. }
9. }
10. class Signup {
11. int userid;
12. String name;
13. String emailid;
14. char sex;
15. long mob;
16. public void create(int userid, String name,
17. String emailid, char sex, long mob)
18. {
19. System.out.println("Welcome to GeeksforGeeks\nLets
create your account\n");
20. this.userid = 132;
21. this.name = "Radha";
22. this.emailid = "radha.89@gmail.com";
23. this.sex = 'F';
24. this.mob = 900558981;
25. System.out.println("your account has been created");
26. }
27. }

C. Parallel processing approach

Parallel processing is the processing of program instructions by dividing them among multiple
processors. A parallel processing system posses many numbers of processor with the objective
of running a program in less time by dividing them. This approach seems to be like divide and
conquer. Examples are NESL (one of the oldest one) and C/C++ also supports because of some
library function.

13
 Chapter One : Introduction to Object-Oriented Programming

2. Declarative programming paradigm

It is divided as Logic, Functional, Database. In computer science the declarative

programming is a style of building programs that expresses logic of computation without
talking about its control flow. It often considers programs as theories of some logic.It may
simplify writing parallel programs. The focus is on what needs to be done rather how it should
be done basically emphasize on what code code is actually doing. It just declares the result we
want rather how it has be produced. This is the only difference between imperative (how to do)
and declarative (what to do) programming paradigms. Getting into deeper we would see logic,
functional and database.

A. Logic programming paradigms

It can be termed as abstract model of computation. It would solve logical problems like puzzles,
series etc. In logic programming we have a knowledge base which we know before and along
with the question and knowledge base which is given to machine, it produces result.

In normal programming languages, such concept of knowledge base is not available but while
using the concept of artificial intelligence, machine learning we have some models like
Perception model which is using the same mechanism. In logical programming the main
emphasize is on knowledge base and the problem. The execution of the program is very much
like proof of mathematical statement, e.g., Prolog sum of two number in prolog:

1. predicates
2. sumoftwonumber(integer, integer)
3. clauses
4. sum(0, 0).
5. sum(n, r):-
6. n1=n-1,
7. sum(n1, r1),
8. r=r1+n

B. Functional programming paradigms

The functional programming paradigms has its roots in mathematics and it is language
independent. The key principal of this paradigms is the execution of series of mathematical
functions. The central model for the abstraction is the function which are meant for some
specific computation and not the data structure. Data are loosely coupled to functions.The
function hide their implementation. Function can be replaced with their values without

14
 Chapter One : Introduction to Object-Oriented Programming

changing the meaning of the program. Some of the languages like perl, javascript mostly uses
this paradigm.

C. Database/Data driven programming approach

This programming methodology is based on data and its movement. Program statements are
defined by data rather than hard-coding a series of steps. A database program is the heart of a
business information system and provides file creation, data entry, update, query and reporting
functions. There are several programming languages that are developed mostly for database
application. For example SQL. It is applied to streams of structured data, for filtering,
transforming, aggregating (such as computing statistics), or calling other programs. So it has
its own wide application.

Difference between Procedural Programming and Object Oriented Programming:

Table 0-2: Procedural Programming VS Object Oriented Programming

Procedural Oriented Programming Object Oriented Programming

In procedural programming, program In object oriented programming,

is divided into small parts program is divided into small parts
called functions. called objects.

Procedural programming follows top Object oriented programming

down approach. follows bottom up approach.

There is no access specifier in Object oriented programming have

procedural programming. access specifiers like private, public,
protected etc.

Adding new data and function is not Adding new data and function is
easy. easy.

Procedural programming does not Object oriented programming

have any proper way for hiding data so provides data hiding so it is more
it is less secure. secure.

15
 Chapter One : Introduction to Object-Oriented Programming

Procedural Oriented Programming Object Oriented Programming

In procedural programming, Overloading is possible in object

overloading is not possible. oriented programming.

In procedural programming, function In object oriented programming,

is more important than data. data is more important than function.

Procedural programming is based Object oriented programming is

on unreal world. based on real world.

Examples: C, FORTRAN, Pascal, Examples: C++, Java, Python, C#

Basic etc. etc.

1.3 Overview of OOP principles and features

Object means a real-world entity such as a pen, chair, table, computer, watch, etc.
Object-Oriented Programming is a methodology or paradigm to design a program objects.
It simplifies software development and maintenance by providing some concepts:

Figure 2: Object-Oriented Programming Comcepts

Object-oriented programming (OOP) is a programming paradigm based on the concept of

objects, which are data structures that contain data, in the form of fields (or attributes) and code,
in the form of procedures (or methods). An object is an entity that has states and behaviors. A

16
 Chapter One : Introduction to Object-Oriented Programming

distinguishing feature of objects is that an object’s procedures provide access to and modify its
fields.

The main ideas behind Java’s Object-Oriented Programming, OOP concepts include object,
class, abstraction, encapsulation, inheritance and polymorphism.

i. Object
Any entity that has state and behavior is known as an object.

E.g, a chair, pen, table, keyboard, bike, etc. It can be physical or logical.

An Object can be defined as an instance of a class. An object contains an address and takes up
some space in memory.

ii. Class
Collection of objects is called class. It is a logical entity. A class can also be defined as a
blueprint from which you can create an individual object. Class doesn't consume any space.

E.g.

class Book {

}
iii. Inheritance
When one object acquires all the properties and behaviors of a parent object, it is known as
inheritance. It provides code reusability. It is used to achieve runtime polymorphism.
Inheritance is a mechanism in which one object acquires all the states and behaviors of a parent
object. Inheritance uses a parent-child relationship (IS-A relationship).

iv. Polymorphism

If one task is performed in different ways, it is known as polymorphism. For example: to

convince the customer differently, to draw something, for example, shape, triangle, rectangle,
etc. In Java, we use

 method overloading and

 method overriding to achieve polymorphism.

Polymorphism is the ability of an object to take on many forms. Polymorphism in OOP occurs
when a superclass references a subclass object

17
 Chapter One : Introduction to Object-Oriented Programming

v. Abstraction

Hiding internal details and showing functionality is known as abstraction. For example phone
call, we don't know the internal processing. In Java, we use abstract class and interface to
achieve abstraction. Abstraction is a process of hiding the implementation details and showing
only functionality to the user.
vi. Encapsulation
Binding (or wrapping) code and data together into a single unit are known as encapsulation.
For example, a capsule, it is wrapped with different medicines.

A java class is the example of encapsulation. Java bean is the fully encapsulated class because
all the data members are private here. Encapsulation is a process of wrapping code and data
together into a single unit. It's just like a capsule that contains a mix of several medicines, and
is a technique that helps keep instance variables protected.

vii. Association
Association represents the relationship between the objects. Here, one object can be associated
with one object or many objects. There can be four types of association between the objects:

▪ One to One

▪ One to Many

▪ Many to One, and

▪ Many to Many

Association can be unidirectional or bidirectional.

Aggregation
Aggregation is a way to achieve Association. Aggregation represents the relationship where
one object contains other objects as a part of its state. It represents the weak relationship
between objects. It is also termed as a has-a relationship in Java. Like, inheritance represents
the is-a relationship. It is another way to reuse objects.
Composition

The composition is also a way to achieve Association. The composition represents the
relationship where one object contains other objects as a part of its state. There is a strong
relationship between the containing object and the dependent object. It is the state where
containing objects do not have an independent existence. If you delete the parent object, all the
child objects will be deleted automatically.
18
 Chapter One : Introduction to Object-Oriented Programming

Week One: Practical

Functional Programming

Functional programming is a programming paradigm where you have a style of building the
structure and elements of computer programs. Here you treat computation as an evaluation of
mathematical functions and you avoid changing-state and mutable data. Functional
programming consists only of PURE functions. So, what do you understand by Pure functions?

Pure functions are those which take an argument list as an input and whose output is a return
value. Now you may feel that all functions are pure as any function takes in values and returns
a value.

For example, if a function relies on the global variable or class member’s data, then it is not
pure. And in such cases, the return value of that function is not entirely dependent on the list
of arguments received as input and can also have side effects. So, what do you understand by
the term side effect? A side effect is a change in the state of an application that is observable
outside the called function other than its return value. For example: Modifying any external
variable or object property such as a global variable, or a variable in the parent function scope
chain.

Features of Functional Paradigm

Pure functions – As seen above, if the input is an array, the output will be a new array and the
input array will not be modified. So in case of pure functions, the output depends only on the
input. Here’s a function in the language Scala that takes values and returns their sum.

scala> def add(a:Int,b:Int) = a + b

add: (a: Int, b: Int)Int

The add function caused no side-effects. It did not alter the input values provided, it used
another pure function, the + operator, and returned the sum of the values as the result of the
call. The add function is a pure function.

Recursion-A recursive function is a function that calls itself during its execution. This enables
the function to repeat itself several times, the result being outputted at the end of each iteration.
Below is an example of a recursive function.

Function Count (integer N)

19
 Chapter One : Introduction to Object-Oriented Programming

if (N <= 0) return "Must be a Positive Integer";

if (N > 9) return "Counting Completed";
else return Count (N+1);
end function

The function Count() above uses recursion to count from any number between 1 and 9, to the
number 10. For example, Count(1) would return 2,3,4,5,6,7,8,9,10. Count(7) would return
8,9,10.

You will note that recursive functions are common in computer science because they allow you
to write efficient programs using a minimal amount of code. The downside is that they can
cause infinite loops and other unexpected results if not written properly. For example, in the
example above, the function is terminated if the number is 0 or less or greater than 9. If proper
cases are not included in the function to stop the execution, the recursion will repeat forever,
causing the program to crash, or worse yet, hang the entire computer system.

Referential transparency-An expression is said to be referentially transparent if it can be

replaced with its corresponding value without changing the program's behavior. As a result,
evaluating a referentially transparent function gives the same value for fixed arguments.
In functional programming, only referentially transparent functions are considered. They are a
lot easier to read and understand.

int add(int a, int b)

{
return a + b
}
int mult(int a, int b)
{
return a * b;
}
int x = add(2, mult(3, 4));

In this example, the mult method is referentially transparent because any call to it may be
replaced with the corresponding return value. This may be observed by replacing mult(3, 4)
with 12:

int x = add(2, 12)

In the same way, add(2, 12) may be replaced with the corresponding return value, 14:
20
 Chapter One : Introduction to Object-Oriented Programming

int x = 14;

• Functions are First-Class and can be Higher-Order-A programming language is said to

have First-class functions when functions in that language are treated like any other variable.
For example, in such a language, a function can be passed as an argument to
other functions, can be returned by another function and can be assigned as a value to a
variable. Higher-order functions are functions that take at least one first-class function as a
parameter.

• Variables are Immutable-In functional programming you cannot modify a variable after
it has been initialized. You can create new variables and this helps to maintain state
throughout the runtime of a program. Strings are immutable objects.

var name = “Susie”

var uppd = name.toUpperCase()

*name will have the value – Susie*uppd will have the value - SUSIE

Lisp is the second-oldest high-level programming language after Fortran but still in use. Lisp
is a functional programming language; that is, functions are first-class objects in Lisp. However,
it is not a pure-functional language such as Haskell, because operations in Lisp can have side-
effects. Lisp continues to be popular in the field of artificial intelligence down to the present
day.

Programming Languages that support functional programming: Haskell, JavaScript, Scala,

Erlang, Lisp, ML, Clojure, OCaml, Common Lisp, Racket.

• using recursive function

(defun –reverse (list)

(let ((return –value ‘()))
(dolist (e list) (push e return-value))
return-value))

21
 Chapter One : Introduction to Object-Oriented Programming

Week One : Assesment

I. Subjective Questions

1. What is the difference between object and class?

2. What is the difference between inheritance and polymorphism?

3. What is the advantage of using the OOP paradigm?

4. List and differenciate the different programming paragigms?

5. List and explain the different concepts of OOP?

22
 Chapter One : Introduction to Object-Oriented Programming

Week Two: Session

1.4 Basics of Java Programming

Java programming language was originally developed by Sun Microsystems which was
initiated by James Gosling and released in 1995 as a core component of Sun Microsystems'
Java platform. Java is guaranteed to be Write Once, Run Anywhere.

Java is:

 Object Oriented - In Java, everything is an Object. Java can be easily extended since
it is based on the Object model.

 Platform Independent - Unlike many other programming languages including C and

C++, when Java is compiled, it is not compiled into platform specific machine, rather
into platform independent byte code. This byte code is distributed over the web and
interpreted by the Virtual Machine (JVM) on whichever platform it is being run on.

 Simple - Java is designed to be easy to learn. If you understand the basic concept of
OOP Java, it would be easy to master.

 Secure - With Java's secure feature it enables the development of virus-free, tamper-
free systems. Authentication techniques are based on public-key encryption.

 Architecture-neutral - Java compiler generates an architecture-neutral object file

format, which makes the compiled code executable on many processors, with the
presence of Java runtime system.

 Distributed - Java is designed for the distributed environment of the internet.

 Robust - Java makes an effort to eliminate error prone situations by emphasizing

mainly on compile time error checking and runtime checking.

 Multithreaded - With Java's multithreaded feature it is possible to write programs that

can perform many tasks simultaneously. This design feature allows the developers to
construct interactive applications that can run smoothly.

 Portable - Being architecture-neutral and having no implementation dependent aspects

of the specification makes Java portable.

23
 Chapter One : Introduction to Object-Oriented Programming

 Interpreted - Java byte code is translated on the fly to native machine instructions and
is not stored anywhere. The development process is more rapid and analytical since the
linking is an incremental and light-weight process.

 High Performance - With the use of Just-In-Time compilers, Java enables high
performance.

 Dynamic - Java is considered to be more dynamic than C or C++ since it is designed

to adapt to an evolving environment. Java programs can carry an extensive amount of
run-time information that can be used to verify and resolve accesses to objects on run-
time.

The Java Programming Language Platforms

There are four platforms of the Java programming language:

• Java Platform, Standard Edition (Java SE)

• Java Platform, Enterprise Edition (Java EE)

• Java Platform, Micro Edition (Java ME)

• Java FX
All Java platforms consist of a Java Virtual Machine (VM) and an application programming
interface (API). The Java Virtual Machine is a program, for a particular hardware and software
platform, that runs Java technology applications. An API is a collection of software
components that you can use to create other software components or applications. Each Java
platform provides a virtual machine and an API, and this allows applications written for that
platform to run on any compatible system with all the advantages of the Java programming
language: platform-independence, power, stability, ease-of-development, and security.

1. Java SE
When most people think of the Java programming language, they think of the Java SE API.
Java SE's API provides the core functionality of the Java programming language. It defines
everything from the basic types and objects of the Java programming language to high-level
classes that are used for networking, security, database access, graphical user interface (GUI)
development, and XML parsing. In addition to the core API, the Java SE platform consists of
a virtual machine, development tools, deployment technologies, and other class libraries and
toolkits commonly used in Java technology applications.

24
 Chapter One : Introduction to Object-Oriented Programming

2. Java EE
The Java EE platform is built on top of the Java SE platform. The Java EE platform provides
an API and runtime environment for developing and running large-scale, multi-tiered, scalable,
reliable, and secure network applications.

3. Java ME

The Java ME platform provides an API and a small-footprint virtual machine for running Java
programming language applications on small devices, like mobile phones. The API is a subset
of the Java SE API, along with special class libraries useful for small device application
development. Java ME applications are often clients of Java EE platform services.

4. Java FX
Java FX technology is a platform for creating rich internet applications written in JavaFX
ScriptTM. JavaFX Script is a statically-typed declarative language that is compiled to Java
technology bytecode, which can then be run on a Java VM. Applications written for the JavaFX
platform can include and link to Java programming language classes, and may be clients of
Java EE platform services.

1.4.1. Types of Java Program

A java program can be either a java application or a java applet.

Java Application is a Java program that runs on an underlying operating system with the
support of a virtual machine. It is also known as an application program. The graphical user
interface is not necessary to execute the java applications, it can be run with or without it.

An applet is a Java program that can be embedded into a web page. It runs inside the web
browser and works at the client side. An applet is embedded in an HTML page using the
APPLET or OBJECT tag and hosted on a web server. Applets are used to make the web site
more dynamic and entertaining

Figure 3: Java

25
 Chapter One : Introduction to Object-Oriented Programming

Figure 4: Java Application Vs Java Applet

Java is a general-purpose, object-oriented programming language. We can develop two types
of Java programs namely:

▪ Stand-alone application

▪ Web applets

Executing stand-alone Java program involves two steps:

▪ Compiling source code into byte code javac compiler.

▪ Executing the bytecode program using java interpreter.

Applets are small programs developed for Internet applications. An applet located on a distant
computer (server) can be downloaded via Internet and executed on a local computer (client)
using a Java-capable browser.

1.5 Editing, Compiling and Interpreting

Java programs come in two different varieties, applications and applets, and the process differs

slightly for each of them.

26
 Chapter One : Introduction to Object-Oriented Programming

A. Editing a Program
Any text editor may be used to edit a program by merely typing the program and making
corrections as needed. Popular Unix and Linux editors include vi and emacs. Macintosh editors
include SimpleText and BBEdit, and the WinEdit and NotePad editors are available for
windows.

As we have seen, a Java program consists of one or more class definitions. We will follow the
convention of placing each class definition in its own file. (Normally in Java a source file
should contain only one public class definition.) The files containing these classes' definitions
must be named ClassName.java where ClassName is the name of the public Java class
contained in the file.

NB: A file that defines a public class named ClassName must be saved in text file named
ClassName.java otherwise an error will result.

B. Compiling a Program
Recall that before you can run a Java source program you have to compile it into the Java
bytecode, the intermediate code understood by the Java Virtual Machine (JVM). Source code
for applets and applications must be compiled. To run a Java program, whether an applet or an
application, the JVM is then used to interpret and execute the bytecode.

J2SE (Java SE) comes in two parts, a runtime program, called the Java Runtime Environment
(JRE) and a development package, called the Software Development Kit (SDK). If you are just
going to run Java programs, you need only install the JRE on your computer. In order to run
Java applets, our browser, such as Internet Explorer and Netscape Navigator, must contain a
plug-in version of the JRE. On the other hand, if you are going to be developing Java programs,
you will need to install the SDK as well.

The Java SDK compiler is named javac. In some environments such as within Linux or at the
Windows command prompt HelloWorld.java would be compiled by typing the following
command at the system prompt: Javac HelloWorld.java

C. Running/Interpreting a Java Program:

The approach to run application and applet is different.

1. Running a Java Application

In order to run (or execute) a program on any computer, the program's executable code must
be loaded into the computer's main memory. For Java environments, this means that the
27
 Chapter One : Introduction to Object-Oriented Programming

program's .class file must be loaded into the computer's memory, where it is then interpreted
by the Java Virtual Machine. To run a Java program on Linux systems or at the Windows
command prompt, type: Java HelloWorld

2. Running a Java Applet

To run a Java applet, you need to use either a Web browser or the SDK's appletviewer, a
stripped-down Web browser for running applets. The Web browser (or appletviewer) uses an
HTML (HyperText Markup Language) document to locate the applet's bytecode files on the
Web (or directly on your computer's hard drive). The HTML file must contain an <applet> tag....

<html>
...
<applet code="HelloWorldApplet.class" width=200
height=200>
</applet>
....
</html>

Compiled and Interpreted

Java combines both these approaches thus makes it a two-stage system. Java compiler
translates the source code into bytecode instructions Java interpreter generates the machine
code that can be directly executed by the machine that is running the java program.

Java Virtual Machine (JVM)

Java compiler produces an intermediate code known as bytecode for a machine that does not
exist. This machine is known as Java Virtual Machine (JVM) & it exists only inside computer
memory. It is a simulated computer within the computer and does all major functions of the
real computer.

The JVM is responsible in interpreting bytecode to machine understandable code (Machine

code).

Just In Time compiler (JIT), part of the JVM, is responsible for compiling code as it is needed,
during execution.

28
 Chapter One : Introduction to Object-Oriented Programming

Your first java program

1. public class Sample

2. {
3. public static void main (String args [])
4. {
5. System.out.print(“Hello World!”);
6. }
7. }

▪ Let us discuss the program line by line:

Class Declaration: the first line class Sample declares a class, which is an object constructor.
Class is keyword and declares a new class definition and Sample is a java identifier that
specifies the name of the class to be defined.

Opening Brace “{“: Every class definition in java begins with an opening brace and ends with
a closing brace “}”.

The main line: the third line public static void main(String args[]) defines a method named as
main. Is the starting point for the interpreter to begin the execution of the program.

A java program can have any number of classes but only one of them must include the main
method to initiate the execution. Java applets will not use the main method at all.

The third line uses a number of keywords: public, static and void

▪ Public: is an access specifier that declares the main method as “unprotected” and
therefore making it accessible to all other classes.

▪ static: declares that this method as one that belongs to the entire class and not a part of
any objects of the class.

▪ Main must always be declared as static since the interpreter uses this method before
any objects are created.

▪ void : states that the main method does not return any value.

▪ All parameters to a method are declared inside a pair of parenthesis. Here, String args[ ]
declares a parameter named args, which contains array of objects of the class type
String.

▪ The Output Line: The only executable statement in the program is

29
 Chapter One : Introduction to Object-Oriented Programming

System.out.println(“Hello world.”);

▪ This is similar to cout<< constructor of C++.

▪ The printlnmethod is a member of the out object, which is a static data member of
System class.

Java Program Structure

Documentation Section Suggested

Optional
Package Statement

Optional
Import Statements

Optional
Interface Statements

Class Definitions Optional

Main Method class

{ Essential
Main Method Definition
}

Figure 5: Java Program Structure

Documentation Section

comprises a set of comment lines giving the name of the program, the author and other details,
which the programmer would like to refer at a later stage. Java supports three types of
comments:

i. Single line comment //

ii. Multiple line comment /*………………

………………*/

iii. Documentation comment /**….*/

This form of comment is used for generating documentation automatically.

Package Statement

Is the first statement in Java file and is optional.It declares a package name and informs the
compiler that the classes defined here belong to this package.

30
 Chapter One : Introduction to Object-Oriented Programming

Example: package student;

import statements

Next to package statements (but before any class definitions) a number of import statements
may exist. This is similar to #include statements in C or C++. Using import statements we can
have access to classes that are part of other named packages.

Example: import java.lang.Math;

interface Statements

An interface is like a class but includes a group of method declarations. It is also an optional
section. It is used only when we wish to implement the multiple inheritance features in the
program

Class Definitions

A Java program may contain multiple class definitions. Classes are the primary and essential
elements of a Java program.These classes are used to map objects of real-world problems. The
number of classes depends on the complexity of the problem.

Main Method Class

Since every Java stand-alone program requires a main method as its starting point, this class is
the essential part of a Java program. A simple Java program may contain only this part. The
main method creates objects of various classes and establishes communications between them.
On reaching the end of main, the program terminates and control passes back to the operating
system. A class in java is defined by a set of declaration statements and methods containing
executable statements.Most statements contain expressions, which describe the actions carried
out on data.Smallest individual units in a program are known as tokens.

Input/Out put Statements

Java I/O (Input and Output) is used to process the input and produce the output. Java uses the
concept of a stream to make I/O operation fast. The java.io package contains all the classes
required for input and output operations.

In Java, 3 streams are created for us automatically. All these streams are attached with the
console.

1) System.out: standard output stream

31
 Chapter One : Introduction to Object-Oriented Programming

2) System.in: standard input stream

3) System.err: standard error stream

Let's see the code to print output and an error message to the console.

System.out.println("simple message");
System.err.println("error message");

Let's see the code to get input from console.

int i=System.in.read();//returns ASCII code of 1st

character
System.out.println((char)i);//will print the
character

OutputStream

Java application uses an output stream to write data to a destination; it may be a file, an array,
peripheral device or socket.

InputStream

Java application uses an input stream to read data from a source; it may be a file, an array,
peripheral device or socket. Let's understand the working of Java OutputStream and
InputStream by the figure given below.

Figure 6: working of Java input and OutputStream

OutputStream class

OutputStream class is an abstract class. It is the superclass of all classes representing an output
stream of bytes. An output stream accepts output bytes and sends them to some sink.

32
 Chapter One : Introduction to Object-Oriented Programming

Useful methods of OutputStream

Table 0-3: OutputStream Methods

Method Description

1) public void write(int)throws is used to write a byte to the current output

IOException stream.

2) public void write(byte[])throws is used to write an array of byte to the current

IOException output stream.

3) public void flush()throws flushes the current output stream.

IOException

4) public void close()throws is used to close the current output stream.

IOException

OutputStream Hierarchy

Figure 7: OutputStream Hierarchy

InputStream class

InputStream class is an abstract class. It is the superclass of all classes representing an input
stream of bytes.

33
 Chapter One : Introduction to Object-Oriented Programming

Useful methods of InputStream

Table 0-4: InputStream Methods

Method Description

1) public abstract int reads the next byte of data from the input stream. It
read()throws IOException returns -1 at the end of the file.

2) public int returns an estimate of the number of bytes that can

available()throws be read from the current input stream.
IOException

3) public void is used to close the current input stream.

close()throws IOException

InputStream Hierarchy

Figure 8: InputStream Hierarchy

Java FileOutputStream Class

Java FileOutputStream is an output stream used for writing data to a file. If you have to write
primitive values into a file, use FileOutputStream class. You can write byte-oriented as well as
character-oriented data through FileOutputStream class. But, for character-oriented data, it is
preferred to use FileWriter than FileOutputStream.

34
 Chapter One : Introduction to Object-Oriented Programming

FileOutputStream class declaration

The declaration for Java.io.FileOutputStream class:

public class FileOutputStream extends OutputStream

FileOutputStream class methods

Table 0-5: FileOutputStream class methods

Method Description

protected void finalize() It is used to clean up the connection with the file output
stream.

void write(byte[] ary) It is used to write ary.length bytes from the byte array to
the file output stream.

void write(byte[] ary, It is used to write len bytes from the byte array starting at
int off, int len) offset off to the file output stream.

void write(int b) It is used to write the specified byte to the file output
stream.

FileChannel It is used to return the file channel object associated with

getChannel() the file output stream.

FileDescriptor getFD() It is used to return the file descriptor associated with the
stream.

void close() It is used to closes the file output stream.

Java FileInputStream Class

Java FileInputStream class obtains input bytes from a file. It is used for reading byte-oriented
data (streams of raw bytes) such as image data, audio, video etc. You can also read character-
stream data. But, for reading streams of characters, it is recommended to use FileReader class.

Java FileInputStream class declaration

35
 Chapter One : Introduction to Object-Oriented Programming

The declaration for java.io.FileInputStream class:

public class FileInputStream extends InputStream

Table 0-6: Java FileInputStream class methods

Method Description

int available() It is used to return the estimated number of bytes that

can be read from the input stream.

int read() It is used to read the byte of data from the input stream.

int read(byte[] b) It is used to read up to b.length bytes of data from the

input stream.

int read(byte[] b, int off, int It is used to read up to len bytes of data from the input
len) stream.

long skip(long x) It is used to skip over and discards x bytes of data from
the input stream.

FileChannel getChannel() It is used to return the unique FileChannel object

associated with the file input stream.

FileDescriptor getFD() It is used to return the FileDescriptor object.

36
 Chapter One : Introduction to Object-Oriented Programming

How JVM Works

Figure 9: JVM
Disadvantages of Java

▪ Running bytecode through the interpreter is not as fast as running machine code, which is
specific to that platform.

▪ Because it is platform independent, it is difficult to use platform specific features (e.g.,

Windows taskbar, quick launch) in Java.

▪ Java interpreter must be installed on the computer in order to run Java programs.

37
 Chapter One : Introduction to Object-Oriented Programming

Week Two: Practical

How To Install and Get Started with Java Programming(on Windows, Mac
OS and Ubuntu)

NetBeans (@ http://netbeans.org) is an open-source Integrated Development Environment

(IDE). NetBeans began in 1996 as a Java IDE student project at Charles University in Prague.
Sun Microsystems acquired NetBeans in 1999. In 2010, Oracle acquired Sun (and thus
NetBeans).

Compared with its rival Eclipse (http://www.elicpse.org) (both are open-source, so I don't
know what are they competing for?), NetBeans provides seamless support for Java
AWT/Swing, Java ME mobility pack, Java EE, and bundled with an excellent profiler for
performance tuning.

How to Install NetBeans 8.2

A. How to Install NetBeans on Windows

Step 1: Install JDK

To use NetBeans for Java programming, you need to first install Java Development Kit
(JDK). See "JDK - How to Install".

Step 2: Download

Download "NetBeans IDE" installer from http://netbeans.org/downloads/index.html.

There are many "bundles" available. For beginners, choose the 1st entry "Java SE" (e.g.,
"netbeans-8.2-javase-windows.exe" 95MB).

Step 3: Run the Installer

Run the downloaded installer.

B. How to Install NetBeans on Mac OS X

To use NetBeans for Java programming, you need to first install JDK. Read "How to install
JDK on Mac".

To install NetBeans:

1. Download NetBeans from http://netbeans.org/downloads/. Set "Platform" to "Mac

38
 Chapter One : Introduction to Object-Oriented Programming

OS X". There are many "bundles" available. For beginners, choose "Java SE" (e.g.,
"netbeans-8.2-javase-macosx.dmg" 116MB).

2. Double-click the download Disk Image (DMG) file.

3. Double-click the "NetBeans 8.x.mpkg", and follow the instructions to install

NetBeans. NetBeans will be installed under "/Applications/NetBeans".

4. Eject the Disk Image (".dmg").

You can launch NetBeans from the "Applications".

Notes: To uninstall NetBeans, drag the "/Applications/NetBeans" folder to trash.

C. How to Install NetBeans on Ubuntu Linux

To use NetBeans for Java programming, you need to first install JDK. Read "How to install
JDK on Ubuntu".

To install NetBeans:

1. Download NetBeans from http://netbeans.org/downloads/. Choose platform "Linux

(x86/x64)" ⇒ "Java SE". You shall receive a sh file (e.g., "netbeans-7.x-ml-javase-
linux.sh") in "~/Downloads".

2. Set the downloaded sh file to executable and run the sh file. Open a Terminal:

$ cd ~/Downloads
$ chmod a+x netbeans-7.x-ml-javase-linux.sh // Set
to executable for all (a+x)
$ ./netbeans-7.x-ml-javase-linux.sh // Run

Follow the instructions to install NetBeans.

To start NetBeans, run the script "netbeans" in the NetBeans' bin directory:

$ cd netbeans-bin-directory

$ ./netbeans

Eg: Writing a Hello-world Java Program in NetBeans

Step 1: Launch NetBeans

Launch NetBeans. If the "Start Page" appears, close it by clicking the "cross" button next to
the "Start Page" title.
39
 Chapter One : Introduction to Object-Oriented Programming

Step 2: Create a New Project

For each Java application, you need to create a "project" to keep all the source files, classes
and relevant resources.

1. From "File" menu ⇒ Choose "New Project...".

2. The "Choose Project" diglog pops up ⇒ Under "Categories", choose "Java" ⇒

Under "Projects", choose "Java Application" ⇒ "Next".

3. The "Name and Location" dialog pops up ⇒ Under "Project Name", enter
"FirstProject" ⇒ In "Project Location", select a suitable directory to save your
works ⇒ Uncheck "Use Dedicated Folder for Storing Libraries" ⇒ Uncheck
"Create Main class" ⇒ Finish.

Step 3: Write a Hello-world Java Program

1. Right-click on "FirstProject" ⇒ New ⇒ Java Class (OR choose the "File" menu
⇒ "New File..." ⇒ Categories: "Java", File Types: "Java Class" ⇒ "Next").

2. The "Name and Location" dialog pops up ⇒ In "Class Name", enter "Hello" ⇒
Delete the content in "Package" if it is not empty ⇒ "Finish".

3. The source file "Hello.java" appears in the editor panel. Enter the following codes:

public class Hello {

public static void main(String[] args) {
System.out.println("Hello, world");
}
}

Step 4: Compile & Execute

There is no need to "compile" the source code in NetBeans explicitly, as NetBeans performs
the so-called incremental compilation (i.e., the source statement is compiled as and when it is
entered).

To run the program, right-click anywhere in the source (or from the "Run" menu) ⇒ Run File.
Observe the output on the output console.

Notes:

40
 Chapter One : Introduction to Object-Oriented Programming

• You should create a NEW Java project for EACH of your Java application.

• Nonetheless, NetBeans allows you to keep more than one programs in a project,
which is handy for writing toy programs (such as your tutorial exercises). To run a
particular program, open and right-click on the source file ⇒ Run File.

Correcting Syntax Error

NetBeans performs incremented compilation, as and when a source line is entered. It marked
a source line with syntax error with a RED CROSS. Point your cursor at the RED CROSS to
view the error message. You CANNOT RUN the program if there is any syntax error (marked
by a RED CROSS before the filename). Correct all the syntax errors; and RUN the program.

[TODO] Diagram

HINTS: In some cases, NetBeans shows a ORANGE LIGHT-BULB (for HINTS) next to the
ERROR RED-CROSS (Line 5 in the above diagram). You can click on the LIGHT-BULB to
get a list of HINTS to resolve this particular error, which may or may not work!

SYNTAX WARNING: marked by a orange triangular exclaimation sign. Unlike errors,

warnings may or may not cause problems. Try to fix these warnings as well. But you can RUN
your program with warnings.

Read the NetBeans Documentation

At a minimum, you SHOULD READ the "IDE Basics, Getting Started, Java Application",
which is accessible via NetBeans's "HELP" menu ⇒ Help Contents. This will save you many
agonizing hours trying to figure out how to do somethings later.

The "Help" ⇒ "Online Doc and Support" (@ http://netbeans.org/kb/index.html) contains many

articles and tutorial on using NetBeans.

The NetBeans "Start Page" also provides many useful links to get you started.

Debugging Program in NetBeans

Step 1: Write a Java Program

The following program computes and prints the factorial of n (=1*2*3*...*n). The program,
however, has a logical error and produce a wrong answer for n=20 ("The Factorial of 20 is -
2102132736" - a negative number?!).

Let us use the graphic debugger to debug the program.

41
 Chapter One : Introduction to Object-Oriented Programming

1. /** Compute the factorial of n */

2. public class Factorial {
3. // Print factorial of n
4. public static void main(String[] args) {
5. int n = 20;
6. int factorial = 1;
7. // n! = 1*2*3...*n
8. for (int i = 1; i <= n; i++) {
9. factorial *= i;
10. }
11. System.out.println("The Factorial of " + n
+ " is " + factorial);
12. }
13. }

Step 2 : Set an initial Breakpoint

A breakpoint suspends program execution for you to examine the internal states of the program.
Before starting the debugger, you need to set at least one breakpoint to suspend the execution
inside the program. Set a breakpoint at main() method by clicking on the left-margin of the line
containing main(). A red circle or an inverted Triangle appears in the left-margin indicating a
breakpoint is set at that line.

Input/Out put Statements

Input statement is used to read input from key board in the run time or from files. Output is
used to display output in the screen. In Java everything is treated as a class and object.Java
class is a template or blue print that the object will follow. Class consists of properties and
actions, properties is variables and actions are method. Every class consists of variables and
methods.

In order to access class variables and methods we have to create an instance of this class is
called object. Object is a reference of a class.

IOSTREAMS

▪ System is a class where input and output is built in, in is an object for input

▪ Output is an object for output

42
 Chapter One : Introduction to Object-Oriented Programming

▪ System.in - --- read the data from keyboard

▪ System.out ----- Display the data on screen
▪ System.err- Display the error messages
▪ All these iostreams are available in java.lang, they are available in lang package
▪ Import.lang.*;
Output statement
System.out.print – everything will be printed in a single line
System.out.print(“ welcome”);
System.out.print(“Java”);

The output will be welcome Java

System.out.println- Everything will be printed in a multiple line
Input Functions
In order to read the data from the keyboard
Scanner – Class - Keyboard
Buffered Reader – class with the help of Input StreamReader and File Reader from
existing file or from the keyboard
Scanner is available in util package, buffered reader is from IO package
Import java.util.Scanner to use the keyboard
Or import java.util.*
Bufferred Reader
Import java.io.*;
Keyboard Input
To assign value for variables interactively through the keyboard, we first create a Scanner
object, that is attached to the System.in data stream object
E.g. Scanner input = new Scanner(System.in);
Then use the various methods of the Scanner class to read input.
For example, the nextLine() method reads a line of string input
E.g. System.out.print("What is your name? ");
String name = in.nextLine();
nextInt(), nextDouble() etc are methods to read.We must import java.util.*; package so as to
use the Scanner class.

43
 Chapter One : Introduction to Object-Oriented Programming

Week Two : Assessment

Part I: Practical Questions

1. Write a Java program to print the sum of any two numbers

2. Write a Java program to print the sum, multiply, subtract, divide and remainder of any two
numbers.

3. Write a Java program that takes three numbers as input to calculate and print the average
of the numbers

4. Write a Java program to swap two variables

5. Write a Java program to convert a decimal number to binary numbers

6. Write a Java program to convert a binary number to decimal number

7. Write a Java program to check whether Java is installed on your computer or not

8. Write a Java program and compute the sum of the digits of an integer

9. Write a Java program to compare two numbers

10. Write a Java program to count the letters, spaces, numbers and other characters of an input
string

11. Write a Java program to print the ascii value of a given character

12. Write a Java program that accepts an integer (n) and computes the value of n+nn+nnn

13. Write a Java program to display the system time

Part II: Subjective Questions

1. What is Java Virtual Machine (JVM)?

2. List and Explain the properties of Java?

3. Compare C++ and Java?

4. What is the difference between java application and java applet?

5. List and explain the different java programming platforms?

44
 Chapter One : Introduction to Object-Oriented Programming

Reference
1. Java: A Beginner's Guide, Eighth Edition by Herbert Schildt
2. Java: How to Program, 9th Edition (Deitel)
3. https://www.javatpoint.com/

45
 Chapter Two: Basics in Java Programming

Chapter Two: Basics in Java Programming

Lesson Plan
1. Learning objectives

• Know Java’s primitive types

• Use literals

• Initialize variables

• Know the scope rules of variables within a method

• Use the arithmetic operators , the relational and logical operators

• Understand the assignment operators

• Use shorthand assignments

• Understand type conversion in assignments

• Cast incompatible types

• Understand type conversion in expressions

• Input characters from the keyboard

• Know the complete form of the if statement

• Use the switch statement

• Know the complete form of the for loop

• Use the while loop

• Use the dowhile loop

• Use break to exit a loop

• Use break as a form of goto

• Apply continue
2. Motivation

• Outputs through Question and Answer; repetitive discussion of java programming

basics; individual internet search.

• Solving a problem using Object Oriented programming.

46
 Chapter Two: Basics in Java Programming

• Controlling the flow control of instruction execution.

3. Expectations or Outcomes

 Define the terminologies, differentiate different programming paradigms, explain

Object Oriented programming principles; the assessment standard attached at the end
of the job task sheet.
 Can write Object Oriented instructions using Java to solve any problem using
programming.
4. Equipment

• Desktop or Laptop computer.

• Java IDE (NetBeans) software

5. Practice contents/Activities/Safety

 Brief introduction of Java complete development life cycle (Java IDE).

 Active practice; on java input and output, writing (Editing), compiling, interprating.

6. Assessments

• How can you install Java IDE (Netbeans) software?

• How to create class and objects?
7. Clean-up

 After finishing practice, computers should be properly shut down.

8. Independent practice/Follow-up activities

• Learning through assignment (practical exercises)

9. Review/Reflection

• Review the outcome of the practice, improvement measure and previous reflected
opinions.

47
 Chapter Two: Basics in Java Programming

Week Three: Session

2.1. Variable types and identifiers

2.1.1. Identifiers
In Java an identifier is, essentially, a name given to a method, a variable, or any other user-
defined item. Identifiers can be from one to several characters long. Variable names may start
with any letter of the alphabet, an underscore, or a dollar sign. Next may be either a letter, a
digit, a dollar sign, or an underscore. The underscore can be used to enhance the readability of
a variable name, as in line_count. Uppercase and lowercase are different; that is, to Java,
myvar and MyVar are separate names.

In general , Java identifiers follow the following rules:

 They can have alphabets, digits, and the underscore and dollar sign characters.

 They must not begin with a digit

 Uppercase and lowercase letters are distinct.

 They can be of any length.

Here are some examples of acceptable identifiers:

Test, X, y2, MaxLaad ,$up, Jo, p, nriyvar, sample23

Remember, you can’t start an identifier with a digit. Thus, 12x is invalid, for example.

In general, you cannot use the Java keywords as identifier names. Also, you should not use the
name of any standard method, such as println, as an identifier. Beyond these two restrictions,
good programming practice dictates that you use identifier names that reflect the meaning or
usage of the items being named.

2.1.2. Keywords
Sixty-one keywords are currently defined in the Java language. These keywords, combined
with the syntax of the operators and separators, form the definition of the Java language. In
general, keywords cannot be used as names for a variable, class, or method. The exceptions to
this rule are the context-sensitive keywords added by JDK 9 to support modules. Also,
beginning with JDK 9, an underscore by itself is considered a keyword in order to prevent its
use as the name of something in your program.

48
 Chapter Two: Basics in Java Programming

Table 0-7: The Java Keywords

abstract assert boolean break Byte case

catch char class const continue default

do double else enum exports extends

final finally float For goto if

implements import instanceof Inf interface long

module native new open opens package

private protected provides public requires return

short static strictfp super switch synchronized

this throw throws To transient transitive

try uses void volatile while with

The keywords const and goto are reserved but not used. In the early days of Java, several other
keywords were reserved for possible future use. However, the current specification for Java
defines only the keywords shown in Table 1-1.

In addition to the keywords, Java reserves four other names. Three have been part of Java since
the start: true, false, and null. These are values defined by Java. You may not use these words
for the names of variables, classes, and so on. Beginning with JDK 10, the word var has
been added as a context-sensitive, reserved type name.

2.1.3. Variable
Perhaps no other construct is as important to a programming language as the assignment of a
value to a variable. A variable is a named memory location that can be assigned a value. Further,
the value of a variable can be changed during the execution of a program. That is, the content
of a variable is changeable, not fixed. The following program creates two variables called
myVar1 and myVar2:

49
 Chapter Two: Basics in Java Programming

/*
This demonstrates a variable.
Call this file Example2.java.
*/
class Example2 {
public static void main(String args[]) {
int myVar1; // this declares a variable.
int myVar2; // this declares another variable
myVar1 = 1024; // this assigns 1024 to myVar1.
System.out.println("myVar1 contains " + myVar1);
myVar2 = myVar1 / 2;
System.out.print("myVar2 contains myVar1 / 2: ");
System.out.println(myVar2);
}

When you run this program, you will see the following output:

myVar1 contains 1024

myVar2 contains myVar1 / 2: 512

This program introduces several new concepts. First, the statement int myVar1 declares a
variable called myVar1 of type integer. In Java, all variables must be declared before they are
used. Further, the type of values that the variable can hold must also be specified. This is called
the type of the variable. In this case, myVar1 can hold integer values. These are whole number
values. In Java, to declare a variable to be of type integer, precede its name with the keyword
int. Thus, the preceding statement declares a variable called myVar1 of type int.

The next line declares a second variable called myVar2:

int myVar2; // this declares another variable

Notice that this line uses the same format as the first line except that the name of the variable
is different.

In general, to declare a variable you will use a statement like this: type var-name;

Here, type specifies the type of variable being declared, and var-name is the name of the
variable. In addition to int, Java supports several other data types.

50
 Chapter Two: Basics in Java Programming

The following line of code assigns myVar1 the value 1024: myVar1 = 1024; // this assigns
1024 to varl

In Java, the assignment operator is the single equal sign. It copies the value on its right side
into the variable on its left.

The next line of code outputs the value of myVar1 preceded by the string "myVar1 contains":

System.out.println(“myVarl contains ” + myVar1);

In this statement, the plus sign causes the value of myVar1 to be displayed after the string that
precedes it. This approach can be generalized. Using the + operator, you can chain together as
many items as you want within a single println( ) statement.

The next line of code assigns myVar2 the value of myVar1 divided by 2: myVar2 = myVar1 /
2;

This line divides the value in myVar1 by 2 and then stores that result in myVar2. Thus, after
the line executes, myVar2 will contain the value 512. The value of myVar1 will be unchanged.

Here are the next two lines in the program:

System.out.print ("myVar2 contains myVarl / 2: ");

System.out.println(myVar2);

Two new things are occurring here. First, the built-in method print( ) is used to display the
string "myVar2 contains myVarl / 2:". This string is not followed by a new line. This means
that when the next output is generated, it will start on the same line. The print( ) method is just
like println( ), except that it does not output a new line after each call. Second, in the call to
println( ), notice that myVar2 is used by itself. Both print( ) and println( ) can be used to output
values of any of Java’s built-in types.

One more point about declaring variables before we move on: It is possible to declare two or
more variables using the same declaration statement. Just separate their names by commas. For
example, myVarl and myVar2 could have been declared like this:

2.1.4. Data types

At the foundation of any programming language are its data types and operators, and Java is
no exception. These elements define the limits of a language and determine the kind of tasks

51
 Chapter Two: Basics in Java Programming

to which it can be applied. Fortunately, Java supports a rich assortment of both data types and
operators, making it suitable for any type of programming.

Why data types are important ?

Data types are especially important in Java because it is a strongly typed language. This means
that all operations are type-checked by the compiler for type compatibility. Illegal operations
will not be compiled. Thus, strong type checking helps prevent errors and enhances reliability.
To enable strong type checking, all variables, expressions, and values have a type. There is no
concept of a “type-less” variable, for example. Furthermore, the type of a value determines
what operations are allowed on it. An operation allowed on one type might not be allowed on
another.

2.1.5. JAVA’S PRIMITIVE TYPES

Java contains two general categories of built-in data types: object-oriented and non-object-
oriented. Java’s object-oriented types are defined by classes, and a discussion of classes is
deferred until later. However, at the core of Java are eight primitive (also called elemental or
simple) types of data, which are shown in Table 2-1. The term primitive is used here to indicate
that these types are not objects in an object-oriented sense, but rather, normal binary values.
These primitive types are not objects because of efficiency concerns. All of Java’s other data
types are constructed from these primitive types.

Table 0-8: Java’s Built-in Primitive Data Types

Type Meaning

boolean Represents true/false values

byte 8-bit integer

char Character

double Double-precision floating point

float Single-precision floating point

int Integer

52
 Chapter Two: Basics in Java Programming

Type Meaning

long Long integer

short Short integer

Java strictly specifies a range and behavior for each primitive type, which all implementations
of the Java Virtual Machine must support. Because of Java’s portability requirement, Java is
uncompromising on this account. For example, an int is the same in all execution environments.
This allows programs to be fully portable. There is no need to rewrite code to fit a specific
platform. Although strictly specifying the range of the primitive types may cause a small loss
of performance in some environments, it is necessary in order to achieve portability.

Integers
Java defines four integer types: byte, short, int, and long, which are shown here:

Table 0-9: integer Data types

Type Width in Bits Range

byte 8 -128 to 127

short 16 -32,768 to 32,767

int 32 -2,147,483,648 to 2,147,483,647

long 64 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

As the table shows, all of the integer types are signed positive and negative values. Java does
not support unsigned (positive-only) integers. Many other computer languages support both
signed and unsigned integers. However, Java’s designers felt that unsigned integers were
unnecessary. Technically, the Java run-time system can use any size it wants to store a primitive
type. However, in all cases, types must act as specified.

The most commonly used integer type is int. Variables of type int are often employed to control
loops, to index arrays, and to perform general-purpose integer math.

53
 Chapter Two: Basics in Java Programming

When you need an integer that has a range greater than int, use long. For example, here is a
program that computes the number of cubic inches contained in a cube that is one mile by one
mile, by one mile:

//Compute the number of cubic inches in 1 cubic mile.

class Inches
{
public static void main(string args [])
{
long ci;
long im;
im = 5280 * 12;
ci = im * im * im;
System.out.println("There are " + ci + " cubic inches
in cubic mile.");
}
}

Here is the output from the program:

There are 254358061056000 cubic inches in cubic mile.

Clearly, the result could not have been held in an int variable.

The smallest integer type is byte. Variables of type byte are especially useful when working
with raw binary data that may not be directly compatible with Java’s other built-in types. The
short type creates a short integer. Variables of type short are appropriate when you don’t need
the larger range offered by int.

Floating-Point Types
The floating-point types can represent numbers that have fractional components. There are two kinds
of floating-point types, float and double, which represent single- and double-precision numbers,
respectively. Type float is 32 bits wide and type double is 64 bits wide.

Of the two, double is the most commonly used, and many of the math functions in Java’s class library
use double values. For example, the sqrt( ) method (which is defined by the standard Math class)
returns a double value that is the square root of its double argument. Here, sqrt( ) is used to compute
the length of the hypotenuse, given the lengths of the two opposing sides:

54
 Chapter Two: Basics in Java Programming

/*
Use the Pythagorean theorem to find the length of the
hypotenuse given the lengths of the two opposing sides.
*/
class Hypot {
public static void main{String args[]) {
double x, y, z;
x = 3;
y = 4 ;
z= Math.sqrt(x*x + y*y); //Notice how sqrt() is
called. It is preceded by the name of the class of
which it is a member.
System.out.println("Hypotenuse is " + z) ;
}
}

The output from the program is shown here:

Hypotenuse is 5.0

One other point about the preceding example: As mentioned, sqrt( ) is a member of the
standard Math class. Notice how sqrt( ) is called; it is preceded by the name Math. This is
similar to the way System.out precedes println( ). Although not all standard methods are
called by specifying their class name first, several are.

Characters

In Java, characters are not 8-bit quantities like they are in many other computer languages.
Instead, Java uses Unicode. Unicode defines a character set that can represent all of the
characters found in all human languages. In Java, char is an unsigned 16-bit type having a range
of o to 65,535. The standard 8-bit ASCII character set is a subset of Unicode and ranges from
0 to 127. Thus, the ASCII characters are still valid Java characters.

A character variable can be assigned a value by enclosing the character in single quotes. For
example, this assigns the variable ch the letter X:

char ch;
ch = ‘ X’;

55
 Chapter Two: Basics in Java Programming

You can output a char value using a println( ) statement. For example, this line outputs the
value in ch:

System.out.println(" This is ch: " + ch) ;

Since char is an unsigned 16-bit type, it is possible to perform various arithmetic manipulations
on a char variable. For example, consider the following program:

// Character variables can be handled like integers,

class CharArithDemo {
public static void main(String args [])
{
char ch;
ch = 'X';
System.out.println("ch contains " + ch) ;
ch+ + ; / / A char can be incremented.
System.out.println("ch is now " + ch) ;
ch = 90; // A char can be assigned an integer value.
System.out.println("ch is now " + ch);
}

The output generated by this program is shown here:

ch contains X

ch is now Y

ch is now s

In the program, ch is first given the value X. Next, ch is incremented. This results in ch
containing Y, the next character in the ASCII (and Unicode) sequence. Next, ch is assigned the
value 90, which is the ASCII (and Unicode) value that corresponds to the letter Z. Since the
ASCII character set occupies the first 127 values in the Unicode character set, all the “old tricks”
that you may have used with characters in other languages will work in Java, too.

56
 Chapter Two: Basics in Java Programming

Q: Why does Java use Unicode?

A: Java was designed for worldwide use. Thus, it needs to use a character set that can represent
all the world’s languages. Unicode is the standard character set designed expressly for this
purpose. Of course, the use of Unicode is inefficient for languages such as English, German,
Spanish, or French, whose characters can be contained within 8 bits. But such is the price that
must be paid for global portability.

The boolean type

The boolean type represents true/false values. Java defines the values true and false using the
reserved words true and false. Thus, a variable or expression of type boolean will be one of
these two values. Here is a program that demonstrates the boolean type:

// Demonstrate boolean values.

class BoolDemo {
public static void main. (String args [J )
{
boolean b;
b = false;
System. out. println("b is " + b) ;
b = true;
System.out.println("b is " + b);
// a boolean value can control the if statement if(b)
System.out.println("This is executed.");
b=false;
if (b)
System. out.println("This is not executed"} ;
// outcome of a relational operator is a boolean value
System.out. println(" 10 > 9 is " + (10 > 9));
}

The output generated by this program is shown here:

b is false
b is true
This is executed.
10 > 9 is true

57
 Chapter Two: Basics in Java Programming

There are three interesting things to notice about this program. First, as you can see, when a
boolean value is output by println( ), "true" or "false" is displayed. Second,the value of a
boolean variable is sufficient, by itself, to control the if statement. There is no need to write an
if statement like this:

if(b = = true) .. .

Third, the outcome of a relational operator, such as <, is a boolean value. This is why the
expression 10 > 9 displays the value "true." Further, the extra set of parentheses around 10 > 9
is necessary because the + operator has a higher precedence than the >.

Literals

In Java, literals refer to fixed values that are represented in their human-readable form. For
example, the number 100 is a literal. Literals are also commonly called constants. For the most
part, literals, and their usage, are so intuitive that they have been used in one form or another
by all the preceding sample programs. Now the time has come to explain them formally.

Java literals can be of any of the primitive data types. The way each literal is represented
depends upon its type. As explained earlier, character constants are enclosed in single quotes.
For example, 'a' and' %' are both character constants.

Integer literals are specified as numbers without fractional components. For example, 10 and
-100 are integer literals. Floating-point literals require the use of the decimal point followed by
the number’s fractional component. For example, 11.123 is a floating-point literal. Java also
allows you to use scientific notation for floating-point numbers.

By default, integer literals are of type int. If you want to specify a long literal, append an l or
an L. For example, 12 is an int, but 12L is a long.

By default, floating-point literals are of type double. To specify a float literal, append an F or
f to the constant. For example, 10.19F is of type float.

Although integer literals create an int value by default, they can still be assigned to variables
of type char, byte, or short as long as the value being assigned can be represented by the target
type. An integer literal can always be assigned to a long variable.

You can embed one or more underscores into an integer or floating-point literal. Doing so can
make it easier to read values consisting of many digits. When the literal is compiled, the
underscores are simply discarded.

58
 Chapter Two: Basics in Java Programming

Here is an example:

123_45_1234

This specifies the value 123,451,234. The use of underscores is particularly useful when
encoding things like part numbers, customer IDs, and status codes that are commonly thought
of as consisting of subgroups of digits.

Character Escape Sequences

Enclosing character constants in single quotes works for most printlng characters, but a few
characters, such as the carriage return, pose a special problem when a text editor is used. In
addition, certain other characters, such as the single and double quotes, have special meaning
in Java, so you cannot use them directly. For these reasons, Java provides special escape
sequences, sometimes referred to as backslash character constants, shown in Table 2-2. These
sequences are used in place of the characters that they represent.

Table 0-10: Character Escape Sequences

Escape Sequence Description

\' Single quote

\" Double quote

\\ Backslash

\r Carriage return

\n New line

\f Form feed

\t Horizontal tab

\b Backspace

\ddd Octal constant (where ddd is an octal constant)

\uxxxx Hexadecimal constant (where xxxx is a hexadecimal constant)

For example, this assigns ch the tab character:

59
 Chapter Two: Basics in Java Programming

ch ='\t';

The next example assigns a single quote to ch:

ch = '\' ';

String Literals

Java supports one other type of literal: the string. A string is a set of characters enclosed by
double quotes. For example,

"this is a test"

is a string. You have seen examples of strings in many of the println( ) statements in the
preceding sample programs.

In addition to normal characters, a string literal can also contain one or more of the escape
sequences just described. For example, consider the following program. It uses the \n and \t
escape sequences.

// Demonstrate escape sequences in strings,

class StrDemo {
public static void main(
String args[]) {
System.out.println("First line\nSecond line"); // Use
\n to generate a new line.
System.out.println("A\tB\tC"); t
System.out.println("D\tE\tF") ;'

Use tabs to align output

The output is shown here:

First line

Second line

A B C

D E F

60
 Chapter Two: Basics in Java Programming

Ask the Expert

Q: Is a string consisting of a single character the same as a character literal? For example, is
"k" the same as 'k'?

A: No. You must not confuse strings with characters. A character literal represents a single
letter of type char. A string containing only one letter is still a string. Although strings consist
of characters, they are not the same type.

Notice how the \n escape sequence is used to generate a new line. You don’t need to use
multiple println( ) statements to get multiline output. Just embed \n within a longer string at
the points where you want the new lines to occur.

A closer look at variables

Variables were introduced in Chapter 1. Here, we will take a closer look at them. As you
learned earlier, variables are declared using this form of statement,

type var-name;

where type is the data type of the variable, and var-name is its name. You can declare a variable
of any valid type, including the simple types just described, and every variable will have a type.
Thus, the capabilities of a variable are determined by its type. For example, a variable of type
boolean cannot be used to store floating-point values. Furthermore, the type of a variable
cannot change during its lifetime. An int variable cannot turn into a char variable, for example.

All variables in Java must be declared prior to their use. This is necessary because the compiler
must know what type of data a variable contains before it can properly compile any statement
that uses the variable. It also enables Java to perform strict type checking.

Initializing a Variable

In general, you must give a variable a value prior to using it. One way to give a variable a value
is through an assignment statement, as you have already seen. Another way is by giving it an
initial value when it is declared. To do this, follow the variable’s name with an equal sign and
the value being assigned. The general form of initialization is shown here:

type var = value;

Here, value is the value that is given to var when var is created. The value must be compatible
with the specified type. Here are some examples:

61
 Chapter Two: Basics in Java Programming

int count = 10; // give count an initial value of 10

char ch = 'X'; // initialise ch with the letter X
float f = 1.2F; // f is initialized with 1.2

When declaring two or more variables of the same type using a comma-separated list, you can
give one or more of those variables an initial value. For example:

int a, b = 8, c = 19, d; // b and c have

initializations

In this case, only b and c are initialized.

Dynamic Initialization

Although the preceding examples have used only constants as initializers, Java allows variables
to be initialized dynamically, using any expression valid at the time the variable is declared.
For example, here is a short program that computes the volume of a cylinder given the radius
of its base and its height:

// Demonstrate dynamic initialization, class Dynlnit {

public static void main(String args[]) { double radius
= 4, height = 5;
volume is dynamically initialized at run time.
// dynamically initialize volume
double volume = 3.1416 * radius * radius * height
System.out.println("Volume is " + volume);
}
}

Here, three local variables—radius, height, and volume—are declared. The first two, radius
and height, are initialized by constants. However, volume is initialized dynamically to the
volume of the cylinder. The key point here is that the initialization expression can use any
element valid at the time of the initialization, including calls to methods, other variables, or
literals.

2.1.6. The scope and lifetime of variables

So far, all of the variables that we have been using were declared at the start of the main( )
method. However, Java allows variables to be declared within any block. A block is begun
with an opening curly brace and ended by a closing curly brace. A block defines a scope. Thus,
62
 Chapter Two: Basics in Java Programming

each time you start a new block, you are creating a new scope. A scope determines what objects
are visible to other parts of your program. It also determines the lifetime of those objects.

In general, every declaration in Java has a scope. As a result, Java defines a powerful, finely
grained concept of scope. Two of the most common scopes in Java are those defined by a class
and those defined by a method. A discussion of class scope (and variables declared within it)
is deferred until later in this book, when classes are described. For now, we will examine only
the scopes defined by or within a method.

The scope defined by a method begins with its opening curly brace. However, if that method
has parameters, they too are included within the method’s scope. A method’s scope ends with
its closing curly brace. This block of code is called the method body.

As a general rule, variables declared inside a scope are not visible (that is, accessible) to code
that is defined outside that scope. Thus, when you declare a variable within a scope, you are
localizing that variable and protecting it from unauthorized access and/or modification. Indeed,
the scope rules provide the foundation for encapsulation. A variable declared within a block is
called a local variable.

Scopes can be nested. For example, each time you create a block of code, you are creating a
new, nested scope. When this occurs, the outer scope encloses the inner scope. This means that
objects declared in the outer scope will be visible to code within the inner scope. However, the
reverse is not true. Objects declared within the inner scope will not be visible outside it.

To understand the effect of nested scopes, consider the following program:

// Demonstrate block scope,

class ScopeDemo {
public static void main(String args [])
{
int x; // known to all code within main
x = 10;
if(x = = 10) { // start new scope
int y = 20; // known only to this block
// x and y both known here.
System.out.println("x and y: " + x + " " + y);
x = y * 2;
}

63
 Chapter Two: Basics in Java Programming

// y = 100; // Error! y not known here ------Here, y is

outside of its scope.
// x is still known here.
System.out.println("x is " + x);
}

As the comments indicate, the variable x is declared at the start of main( )’s scope and is
accessible to all subsequent code within main( ). Within the if block, y is declared. Since a
block defines a scope, y is visible only to other code within its block. This is why outside of its
block, the line y = 100; is commented out. If you remove the leading comment symbol, a
compile-time error will occur, because y is not visible outside of its block. Within the if block,
x can be used because code within a block (that is, a nested scope) has access to variables
declared by an enclosing scope.

Within a block, variables can be declared at any point, but are valid only after they are declared.
Thus, if you define a variable at the start of a method, it is available to all of the code within
that method. Conversely, if you declare a variable at the end of a block, it is effectively useless,
because no code will have access to it.

Here is another important point to remember: variables are created when their scope is entered,
and destroyed when their scope is left. This means that a variable will not hold its value once
it has gone out of scope. Therefore, variables declared within a method will not hold their
values between calls to that method. Also, a variable declared within a block will lose its value
when the block is left. Thus, the lifetime of a variable is confined to its scope.

If a variable declaration includes an initializer, that variable will be reinitialized each time the
block in which it is declared is entered. For example, consider this program:

// Demonstrate lifetime of a variable,.

class VarlnitDemo {
public static void main(String args[]) {
int x;
for(x = 0; x < 3; x++) {
int y = -1; // y is initialized each time block is
entered
System.out.println("y is: " + y); // this always prints
-1

64
 Chapter Two: Basics in Java Programming

y = 100;
System.out.println("y is now: " + y);
}
}

The output generated by this program is shown here:

Y is: - 1

y is now: 100

y is: -1

y is now: 100

y is: -1

y is now: 100

As you can see, y is reinitialized to -l each time the inner for loop is entered. Even though it is
subsequently assigned the value 100, this value is lost.

There is one quirk to Java’s scope rules that may surprise you: although blocks can be nested,
no variable declared within an inner scope can have the same name as a variable declared by
an enclosing scope. For example, the following program, which tries to declare two separate
variables with the same name, will not compile.

65
 Chapter Two: Basics in Java Programming

Week Three: Practical

Excersie 1:Assign values to variables in Java

First, use the class DeclareDatatype that is provided below,

public class DeclareDatatype {

public static void main(String[] args)

// Enter your code here

Secondly, declare and assign variables of the following different data types.

• Declare a variable named value_int of the data type int that is assigned the value 20
• Secondly, declare a variable named value_string of the data type string that is assigned the
value “Java”
• Third, create a variable named value_double of the data type double that is assigned the value
23.63
• Finally, print all variables in the console.
To create a new variable in Java,

• First specify the data type followed by the variable name

• Then assign the value equal to the “=” operator
• Don’t forget the semicolon at the end
public class DeclareDatatype

public static void main(String[] args)

// Assigns the value 20 to the variable value_int of type int

int value_int = 20;

// Assigns the value "Java" to value_string

String value_string = "Java";

// Assigns the value 23.63 to the value type double value_double

66
 Chapter Two: Basics in Java Programming

double value_double = 23.63;

// Print the variables

System.out.println(value_int);

System.out.println(value_string);

System.out.println(value_double);

Resulting in,

20

Java

23.63

Exercise 2: Assign values to variables and convert data type

Similarly, use the class DeclareDatatype that is provided below,

public class DeclareDatatype {

public static void main(String[] args)

// Enter your code here

First,

• Declare a variable named value of the data type int that is assigned the value 50
• Secondly, declare a variable named another_value of the data type double that is assigned the
value 30.2
Secondly,

• Convert the variable value from data type int to data type double. Save the new variable to a
new variable value_double
Finally,

• Add the variable value and another_value and assign the value to a new variable which is
assigned the name sum_value of type double.
• Print the result

67
 Chapter Two: Basics in Java Programming

• We easily create variables by first specifying the data type, followed by the variable name and
the value we want to assign to the variable.
• We can convert an int to a double by creating a new variable of the data type double.
• Summing up is easy with the plus operator +
public class DeclareDatatype {

public static void main(String[] args)

//First, declaring the variables

int value = 50;

double another_value = 30.2;

// Convert the variable value to a double

double value_double = value;

// Finally, Sum the variables

double sum_value = value_double + another_value;

// Print the result

System.out.println(sum_value);

68
 Chapter Two: Basics in Java Programming

Assessments

Theory

Part I: Objective Type Question

1. Which of the following are valid Identifiers?
a) $amount
b) 6tally
c) my*Name
d) salary
e) score
f) first Name
g) total#
h) cast
2. Where to declare local variables ?
A. It declares inside the class and outside of method.
B. It declares inside the class with static prefix and outside of method.
C. It declares inside the method.
3. Where to declare instance variables ?
A. It declares inside the class and outside of method.
B. It declares inside the class with static prefix and outside of method.
C. It declares inside the method.
4. Where to declare class variables ?
A. It declares inside the class and outside of method.
B. It declares inside the class with static prefix and outside of method.
C. It declares inside the method.
5. Which of following can not be used as variable name in Java programming
language ?
A. literal
B. Keywords
C. Identifier
D. Identifier and Keywords
69
 Chapter Two: Basics in Java Programming

6. A name of variable is known as

A. Data Type
B. Constant
C. Identifier
7. 6. Which is the invalid variable name ?
A. tenthTeam
B. TenthTeam
C. 10thTeam
D. None of Above
8. A variable name should not begin with
A. A number
B. Special characters but underscore and dollar sign
C. All of above
9. Which is the valid variable name ?
A. 5thTeam
B. &5thteam
C. _5thTeam
D. None of Above
10. A variable declared inside the method is known as
public class TestMain {
public static void main(String[] args) {
String msg = "Hello World"; // msg variable name
System.out.println(msg);
}
}

A. Instance Variable
B. Class Variable
C. Local Variable
11. A variable declared outside of a method is known as
public class TestMain {
String msg = "Hello World"; // msg variable name
public static void main(String[] args) {

70
 Chapter Two: Basics in Java Programming

TestMain test = new TestMain();

System.out.println(test.msg);
}
}
A. Instance Variable
B. Class Variable
C. Local Variable
12. A variable declared outside of a method with prefix static keyword is known as
public class TestMain {
static String msg = "Hello World"; // msg variable name
public static void main(String[] args) {
System.out.println(msg);
}
}
A. Instance Variable
B. Class Variable
C. Local Variable

71
 Chapter Two: Basics in Java Programming

Part II: Subjective Type Question

1. Why does Java strictly specify the range and behavior of its primitive types?

2. What is Java’s character type, and how does it differ from the character type used by some other
programming languages?

3. A boolean value can have any value you like because any non-zero value is true. True or False?

4. Given this output,

One

Two

Three

using a single string, show the println( ) statement that produced it.

5. What is wrong with this fragment?

for(i =0; i < 10; i++) { int sum;

sum = sum + i;

System. out. println (“ Sum is: u “+ sum);

6. Explain the difference between the prefix and postfix forms of the increment operator.

7. Show how a short-circuit AND can be used to prevent a divide-by-zero error.

8. In an expression, what type are byte and short promoted to?

9. In general, when is a cast needed?

10. Write a program that finds all of the prime numbers between 2 and 100.

72
 Chapter Two: Basics in Java Programming

Week Four : Session

2.2. Operators and operator precedence

2.2.1. Operators
Java provides a rich operator environment. An operator is a symbol that tells the compiler to
perform a specific mathematical or logical manipulation.

Java has four general classes of operators:

• arithmetic,
• bitwise,
• relational, and
• Logical.

Java also defines some additional operators that handle certain special situations.

A. Arithmetic operators
Java defines the following arithmetic operators:

Table 0-11: Arithmetic operators

Operator Meaning

+ Addition (also unary plus)

- Subtraction (also unary

minus)

* Multiplication

/ Division

% Modulus

++ Increment

-- Decrement

73
 Chapter Two: Basics in Java Programming

The operators +,-,*, and / all work the same way in Java as they do in any other computer
language (or algebra, for that matter). These can be applied to any built-in numeric data type.
They can also be used on objects of type char.

Although the actions of arithmetic operators are well known to all readers, a few special
situations warrant some explanation. First, remember that when / is applied to an integer, any
remainder will be truncated; for example, 10/3 will equal 3 in integer division. You can obtain
the remainder of this division by using the modulus operator %. It yields the remainder of an
integer division. For example, 10 % 3 is 1. In Java, the % can be applied to both integer and
floating-point types. Thus, 10.0 % 3.0 is also 1.

The following program demonstrates the modulus operator.

// Demonstrate the % operator.

class ModDemo {
public static void main(String args [])
{
int iresult, irem;
double dresult, drem;
iresult =10/3;
irem = 10 % 3;
dresult = 10.0 / 3.0;
drem = 10.0 % 3.0;
System.out.println("Result and remainder of 10 / 3: "
+iresult + " " + irem);
System.out.println("Result and remainder of 10.0 / 3.0:
" +dresult + " " + drem) ;

The output from the program is shown here:

Result and remainder of 10 / 3: 3 1

Result and remainder of 10.0 / 3.0: 3.3333333333333335 1.0

As you can see, the % yields a remainder of 1 for both integer and floating-point operations.

74
 Chapter Two: Basics in Java Programming

B. Increment and Decrement

Introduced in Chapter 1, the ++ and -- are Java’s increment and decrement operators. As you
will see, they have some special properties that make them quite interesting. Let’s begin by
reviewing precisely what the increment and decrement operators do.

The increment operator adds 1 to its operand, and the decrement operator subtracts 1.

Therefore,

x = x + 1; is the same as x + +;

x = x - 1; is the same as x-- ;

Both the increment and decrement operators can either precede (prefix) or follow (postfix) the
operand. For example,

x = x + 1; can be written as + +x; // prefix form or as

x++; // postfix form

In the foregoing example, there is no difference whether the increment is applied as a prefix or
a postfix. However, when an increment or decrement is used as part of a larger expression,
there is an important difference. When an increment or decrement operator precedes its operand,
Java will perform the corresponding operation prior to obtaining the operand’s value for use
by the rest of the expression. If the operator follows its operand, Java will obtain the operand’s
value before incrementing or decrementing it. Consider the following:

x = 10;

y = ++x;

In this case, y will be set to 11. However, if the code is written as

x = 10;

y = x++;

then y will be set to 10. In both cases, x is still set to 11; the difference is when it happens.
There are significant advantages in being able to control when the increment or decrement
operation takes place.

C. Relational and logical operators

In the terms relational operator and logical operator, relational refers to the relationships that
values can have with one another, and logical refers to the ways in which true and false values

75
 Chapter Two: Basics in Java Programming

can be connected together. Since the relational operators produce true or false results, they
often work with the logical operators. For this reason they will be discussed together here.

The outcome of the relational and logical operators is a boolean value.

Table 0-12: The relational operators Table 0-13: The logical operators

Operator Meaning Operator Meaning

== Equal to & AND

!= Not equal to 1 OR

> Greater than ꓥ XOR (exclusive

OR)
< Less than
II Short-circuit OR
>= Greater than or equal to
&& Short-circuit ND
<= Less than or equal to
! NOT

In Java, all objects can be compared for equality or inequality using = = and !=. However, the
comparison operators, <, >, <=, or >=, can be applied only to those types that support an
ordering relationship. Therefore, all of the relational operators can be applied to all numeric
types and to type char. However, values of type boolean can only be compared for equality or
inequality, since the true and false values are not ordered. For example, true > false has no
meaning in Java.

For the logical operators, the operands must be of type boolean, and the result of a logical
operation is of type boolean. The logical operators, &, |,ꓥ, and !, support the basic logical
operations AND, OR, XOR, and NOT, according to the following truth table:

Table 0-14: Truth table

p q p&q pvq p ꓥq !P

False False False False False True

True False False True True False

76
 Chapter Two: Basics in Java Programming

False True False True True True

True True True True False False

As the table shows, the outcome of an exclusive OR operation is true when exactly one and
only one operand is true.

Here is a program that demonstrates several of the relational and logical operators:

// Demonstrate the relational and logical operators.

class RelLogOps {
public static void main(String args []) {
int i, j;
boolean b1, b2 ;
i = 10;
j = 11;
if (i < j) System.out.println(" i < j");
if(i <= j) System.out.println("i <= j");
if(i != j) System.out.println(" i != j");
if(i == j) System.out.println("this won't execute");
if(i >= j) System.out.println(" this won’t execute");
if(i > j) System.out.println("this won't execute");
b1= true;
b2 = false;
if (b1 & b2 )System.out.println("this won’t execute") ;
if(!(b1 & b2)) System.out.println("!(b1 & b2) is
true");
if(b1 | b2) System.out.println("b1 | b2 is true");
if(b1 ꓥ b2) System.out.println("b1 ꓥ b2 is true");

}
}

77
 Chapter Two: Basics in Java Programming

The output from the program is shown here:

I<j

i <= j

i!=j

!(b1 & b2) is true

b1 | b2 is true

b1 ꓥ b2 is true

D. Short-circuit logical operators

Java supplies special short-circuit versions of its AND and OR logical operators that can be
used to produce more efficient code. To understand why, consider the following. In an AND
operation, if the first operand is false, the outcome is false no matter what value the second
operand has. In an OR operation, if the first operand is true, the outcome of the operation is
true no matter what the value of the second operand. Thus, in these two cases there is no need
to evaluate the second operand. By not evaluating the second operand, time is saved and more
efficient code is produced.

The short-circuit AND operator is &&, and the short-circuit OR operator is ||. Their normal
counterparts are & and |. The only difference between the normal and short- circuit versions is
that the normal operands will always evaluate each operand, but short-circuit versions will
evaluate the second operand only when necessary.

Here is a program that demonstrates the short-circuit AND operator. The program determines
whether the value in d is a factor of n. It does this by performing a modulus operation. If the
remainder of n / d is zero, then d is a factor. However, since the modulus operation involves a
division, the short-circuit form of the AND is used to prevent a divide-by-zero error.

// Demonstrate the short-circuit operators.

class SCops {
public static void main(String args[]) {
int n, d, q;
n = 10;
d = 2;

78
 Chapter Two: Basics in Java Programming

if(d != 0 && (n % d) == 0)
System.out.println(d + " is a factor of "+ n) ;
d = 0; // now, set d to zero
// Since d is zero, the second operand is not
evaluated.
if (d != 0 && (n % d) == 0);//The short-circuit
operator prevents a division by zero.
System.out.println(d + " is a factor of " + n) ;
/* Now, try same thing without short-circuit operator.
This will cause a divide-by-zero error.
* /
if (d!=0 && (n%d)==0) // Now both expressions are
evaluated, allowing a division by zero to occur.
System.out.println(d+" is a factor of " + n) ;
}
}

To prevent a divide-by-zero, the if statement first checks to see if d is equal to zero. If it is, the
short-circuit AND stops at that point and does not perform the modulus division. Thus, in the
first test, d is 2 and the modulus operation is performed. The second test fails because d is set
to zero, and the modulus operation is skipped, avoiding a divide- by-zero error. Finally, the
normal AND operator is tried. This causes both operands to be evaluated, which leads to a run-
time error when the division by zero occurs.

One last point: The formal specification for Java refers to the short-circuit operators as the
conditional-or and the conditional-and operators, but the term “short-circuit” is commonly used.

E. THE ASSIGNMENT OPERATOR

You have been using the assignment operator since Chapter l. Now it is time to take a formal
look at it. The assignment operator is the single equal sign, =. This operator works in Java much
as it does in any other computer language. It has this general form:

var = expression;

Here, the type of var must be compatible with the type of expression.

The assignment operator does have one interesting attribute that you may not be familiar with:
it allows you to create a chain of assignments. For example, consider this fragment:

79
 Chapter Two: Basics in Java Programming

int x, y, z;
x = y = z = 100; // set x, y, and z to 100

This fragment sets the variables x, y, and z to 100 using a single statement. This works because
the = is an operator that yields the value of the right-hand expression. Thus, the value of z =
100 is 100, which is then assigned to y, which in turn is assigned to x. Using a “chain of
assignment” is an easy way to set a group of variables to a common value.

Shorthand assignments

Java provides special shorthand assignment operators that simplify the coding of certain
assignment statements. Let’s begin with an example. The assignment statement shown here

x = x + 10;

can be written, using Java shorthand, as

x + = 10;

Ask the Expert

Q: Since the short-circuit operators are, in some cases, more efficient than their normal
counterparts, why does Java still offer the normal AND and OR operators?

A: In some cases you will want both operands of an AND or OR operation to be evaluated
because of the side effects produced. Consider the following:

// Side effects can be important,

class SideEffects {
public static void main(String args[]) {
int i;
i = 0;
/* Here, i is still incremented even though the if
statement fails. */
if(false & (++i < 100))
System.out.println("this won't be displayed");
System.out.println("if statement executed: " + i); //
displays 1
/* In this case, i is not incremented because
the short-circuit operator skips the increment. */
if(false && (++i < 100))
80
 Chapter Two: Basics in Java Programming

System.out.println("this won't be displayed");

System.out.println("if statement executed: " + i); //
still 1 !!
}
}

As the comments indicate, in the first if statement, i is incremented whether the if succeeds or
not. However, when the short-circuit operator is used, the variable i is not incremented when
the first operand is false. The lesson here is that if your code expects the right-hand operand of
an AND or OR operation to be evaluated, you must use Java’s non-short-circuit forms of these
operations.

The operator pair += tells the compiler to assign to x the value of x plus 10. Here is another
example. The statement

x = x - 100;

is the same as

x -= 100;

Both statements assign to x the value of x minus 100.

This shorthand will work for all the binary operators in Java (that is, those that require two
operands). The general form of the shorthand is

var op = expression;

Thus, the arithmetic and logical shorthand assignment operators are the following:

Table 0-15: arithmetic and logical shorthand assignment operators

+= -= *= /=

%= &= |= ꓥ=

Because these operators combine an operation with an assignment, they are formally referred
to as compound assignment operators.

The compound assignment operators provide two benefits. First, they are more compact than
their “longhand” equivalents. Second, in some cases, they are more efficient. For these reasons,
you will often see the compound assignment operators used in professionally written Java
programs.

81
 Chapter Two: Basics in Java Programming

2.2.2. Type conversion in assignments

In programming, it is common to assign one type of variable to another. For example, you
might want to assign an int value to a float variable, as shown here:

int i;
float f;
i = 10;
f = i; // assign an int to a float

When compatible types are mixed in an assignment, the value of the right side is automatically
converted to the type of the left side. Thus, in the preceding fragment, the value in i is converted
into a float and then assigned to f. However, because of Java’s strict type checking, not all
types are compatible, and thus, not all type conversions are implicitly allowed. For example,
boolean and int are not compatible.

When one type of data is assigned to another type of variable, an automatic type conversion
will take place if

• The two types are compatible.

• The destination type is larger than the source type.

When these two conditions are met, a widening conversion takes place. For example, the int
type is always large enough to hold all valid byte values, and both int and byte are integer types,
so an automatic conversion from byte to int can be applied.

For widening conversions, the numeric types, including integer and floating-point types, are
compatible with each other. For example, the following program is perfectly valid since long
to double is a widening conversion that is automatically performed.

// Demonstrate automatic conversion from long to

double.
class LtoD {
public static void main(String args[]) {
long L;
double D;
L = 1001232S5L;
D = L; // Automatic conversion from long to double
System.out.println("L and D: " + L + " " + D);

82
 Chapter Two: Basics in Java Programming

)
}

Although there is an automatic conversion from long to double, there is no automatic

conversion from double to long, since this is not a widening conversion. Thus, the following
version of the preceding program is invalid.

// *** This program will not compile. ***

class LtoD {
public static void main(String args []) {
long L;
double D;
D = 100123235.0;
L = D; // Illegal!!! No automatic conversion from
double to long
System.out.println( " L and D: " + L + " " + D) ;
}

There are no automatic conversions from the numeric types to char or boolean. Also, char and
boolean are not compatible with each other. However, an integer literal can be assigned to char.

Casting incompatible types

Although the automatic type conversions are helpful, they will not fulfill all programming
needs because they apply only to widening conversions between compatible types. For all other
cases you must employ a cast. A cast is an instruction to the compiler to convert one type into
another. Thus, it requests an explicit type conversion. A cast has this general form:

(target-type) expression

Here, target-type specifies the desired type to convert the specified expression to. For example,
if you want to convert the type of the expression x/y to int, you can write

double x, y;
// . . *
(int) (x / y)

Here, even though x and y are of type double, the cast converts the outcome of the expression
to int. The parentheses surrounding x/y are necessary. Otherwise, the cast to int would apply

83
 Chapter Two: Basics in Java Programming

only to the x and not to the outcome of the division. The cast is necessary here because there
is no automatic conversion from double to int.

When a cast involves a narrowing conversion, information might be lost. For example, when
casting a long into a short, information will be lost if the long’s value is greater than the range
of a short because its high-order bits are removed. When a floating-point value is cast to an
integer type, the fractional component will also be lost due to truncation. For example, if the
value 1.23 is assigned to an integer, the resulting value will simply be 1. The 0.23 is lost.

The following program demonstrates some type conversions that require casts:

// Demonstrate casting, class CastDemo {

public static void main(String args[]) {
double x, y;
byte b;
int i;
char ch;
x = 10.0;
y = 3 . 0 ;
i = (int) (x / y); // Truncation will occur in this
conversion. cast double to int
System.out.println("Integer outcome of x / y: " + i);
i = 100;
b = (byte)i;-// No loss of info here. A byte can hold
the value 100.
System.out.println("Value of b: " + b);
i = 2 57;
b = (byte) i;-// Information loss this time. A byte
cannot holdthe value 257.
System.out.println("Value of b: " + b);
b = 88; //It ASCII code for X
ch = (char) b; // Cast between incompatible types
System.out.println("ch: " + ch);
}

The output from the program is shown here:

84
 Chapter Two: Basics in Java Programming

Integer outcome of x / y: 3

value of b: 100

Value of b: 1

ch: X

In the program, the cast of (x / y) to int results in the truncation of the fractional component,
and information is lost. Next, no loss of information occurs when b is assigned the value 100
because a byte can hold the value 100. However, when the attempt is made to assign b the
value 257, information loss occurs because 257 exceeds a byte’s maximum value. Finally, no
information is lost, but a cast is needed when assigning a byte value to a char.

2.2.3. Operator precedence

Table 16 shows the order of precedence for all Java operators, from highest to lowest. This
table includes several operators that will be discussed later in this book. Although technically
separators, the [], (), and . can also act like operators. In that capacity, they would have the
highest precedence.

Table 0-16: The Precedence of the Java Operators

85
 Chapter Two: Basics in Java Programming

Try this : Display a Truth Table for the Logical Operators

LogicalOpTable.java

In this project, you will create a program that displays the truth table for Java’s logical operators.
You must make the columns in the table line up. This project makes use of several features
covered in this chapter, including one of Java’s escape sequences and the logical operators. It
also illustrates the differences in the precedence between the arithmetic + operator and the
logical operators.

1. Create a new file called LogicalOpTable.java.

2. To ensure that the columns line up, you will use the \t escape sequence to embed tabs
into each output string. For example, this println( ) statement displays the header for
the table:
System. out. println("P\tQ\tAND\tOR\tXOR\tNOT") ;

3. Each subsequent line in the table will use tabs to position the outcome of each operation
under its proper heading.
4. Here is the entire LogicalOpTable.java program listing. Enter it at this time.

// Try This 2-2: a truth table for the logical operators,

class LogicalOpTable {
public static void main(String args[]} {
boolean p, q;
System.out.println("P\tQ\tAND\tOR\tXOR\tNOT");
p = true; q = true;
System.out.print(p + "\t" + q +"\t");
System.out.print ((p&q)+" \t" +(p|q) +"\t");
System.out.println((pꓥq) + "\t" + (!p));
p = true; q = false;
System.out.print(p + "\t" + q +"\t");
System.out.print ((p&q) +" \t"+ (p|q)+"\t");
System.out.println((pꓥq) + "\t" +(!p));
p = false; q =true;
System.out.print (p + " \t" + q +"\t");
System.out.print ((p&q) +" \t"+ (p|q)+"\t");
System.out.println((pꓥq) + "\t" + (!p));
p = false; q = false;

86
 Chapter Two: Basics in Java Programming

System.out.print (p + "\t" + q + "\t");

System.out.print ((p&q)+ " \t" +(p|q) +"\t" );
System.out.println((pꓥq) + "\t" + (!p));
}

Notice the parentheses surrounding the logical operations inside the println( ) statements. They
are necessary because of the precedence of Java’s operators. The + operator is higher than the
logical operators.

5. Compile and run the program. The following table is displayed.

P Q AND OR XOR NOT

true true true true false false

true false false true true false
false true false true true true

false false false false false true

6. On your own, try modifying the program so that it uses and displays 1’s and 0’s, rather
than true and false. This may involve a bit more effort than you might at first think!

EXPRESSIONS

Operators, variables, and literals are constituents of expressions. You probably already know
the general form of an expression from your other programming experience, or from algebra.
However, a few aspects of expressions will be discussed now.

Type Conversion in Expressions

Within an expression, it is possible to mix two or more different types of data as long as they
are compatible with each other. For example, you can mix short and long within an expression
because they are both numeric types. When different types of data are mixed within an
expression, they are all converted to the same type. This is accomplished through the use of
Java’s type promotion rules.

First, all char, byte, and short values are promoted to int. Then, if one operand is a long, the
whole expression is promoted to long. If one operand is a float operand, the entire expression
is promoted to float. If any of the operands is double, the result is double. It is important to
understand that type promotions apply only to the values operated upon when an expression is
evaluated. For example, if the value of a byte variable is promoted to int inside an expression,

87
 Chapter Two: Basics in Java Programming

outside the expression, the variable is still a byte. Type promotion only affects the evaluation
of an expression.

Type promotion can, however, lead to somewhat unexpected results. For example, when an
arithmetic operation involves two byte values, the following sequence occurs: First, the byte
operands are promoted to int. Then the operation takes place, yielding an int result. Thus, the
outcome of an operation involving two byte values will be an int. This is not what you might
intuitively expect. Consider the following program:

// A promotion surprise!
class PromDemo {
public static void main(String args []) {
byte b; int i ;
b = 10;
i =b * b; // No cast needed because result is already
elevated to int
b = (byte)(b* b); // Cast is needed here to assign an
int to a byte!
System.out.println("i and b: " + i +" " + b);
}

Somewhat counter intuitively, no cast is needed when assigning b*b to i, because b is promoted
to int when the expression is evaluated. However, when you try to assign b * b to b, you do
need a cast—back to byte! Keep this in mind if you get unexpected type- incompatibility error
messages on expressions that would otherwise seem perfectly OK.

This same sort of situation also occurs when performing operations on chars. For example, in
the following fragment, the cast back to char is needed because of the promotion of chi and
ch2 to int within the expression:

char ch1= 'a', ch2 = 'b ' ;

ch1 = (char) (ch1 + ch2);

Without the cast, the result of adding ch1 to ch2 would be int, which can’t be assigned to a
char.

Casts are not only useful when converting between types in an assignment. For example,
consider the following program. It uses a cast to double to obtain a fractional component from
an otherwise integer division.
88
 Chapter Two: Basics in Java Programming

// Using a cast, class UseCast {

public static void main(String args[j) {
int i;
for(i = 0; i < 5; i++) {
System.out.println(i + " / 3 : " + i / 3) ;
System.out.println(i + " / 3 with fractions: " +
(double) i / 3);
System.out.println();
}
}
}

The output from the program is shown here:

0/3: 0
0 / 3 with fractions: 0 .0
1/ 3: 0
1 / 3 with fractions: 0.3333333333333333
2/3: 0
2 / 3 with fractions: 0 .6666666666666666
3/3:1
3 / 3 with fractions: 1.0
4/3 :1
4 / 3 with fractions: 1.3333333333333333

Spacing and Parentheses

An expression in Java may have tabs and spaces in it to make it more readable. For example,
the following two expressions are the same, but the second is easier to read:

x=10/y*(127/x);

x = 10 / y * (127/x);

89
 Chapter Two: Basics in Java Programming

Parentheses increase the precedence of the operations contained within them, just like in
algebra. Use of redundant or additional parentheses will not cause errors or slow down the
execution of the expression. You are encouraged to use parentheses to make clear the exact
order of evaluation, both for yourself and for others who may have to figure out your program
later. For example, which of the following two expressions is easier to read?

x = y/3-34*temp+12 7;

x = (y/3) - (34*temp) + 127;

90
 Chapter Two: Basics in Java Programming

Week Four : Practical

In this exercise we are going to declare five variables , accept their values from user and finally display
them for user

BASIC INPUT USING Scanner with System.in

import java.util.Scanner;

public class ScannerDemo {

public static void main(String[] arguments){
Scanner input = new Scanner(System.in);
Step1 : declare the five variable
String username;
double age;
String gender;
String marital_status;
int telephone_number;
Step2 : Receive the inputs from the user for five
variable that have been declared

// Allows a person to enter his/her name

Scanner one = new Scanner(System.in);
System.out.println("Enter Name:" );
username = one.next();

// Allows a person to enter his/her age

Scanner two = new Scanner(System.in);
System.out.println("Enter Age:" );
age = two.nextDouble();

// Allows a person to enter his/her gender

Scanner three = new Scanner(System.in);
System.out.println("Enter Gender:" );
gender = three.next();

91
 Chapter Two: Basics in Java Programming

// Allows a person to enter his/her marital

status
Scanner four = new Scanner(System.in);
System.out.println("Enter Marital status:" );
marital_status = four.next();
System.out.println("Marital status accepted " +
marital_status);
Step3 : Display the values of the variables on that
have been received from user
// Allows a person to enter his/her telephone
number
Scanner five = new Scanner(System.in);
System.out.println("Enter Telephone number:" );
telephone_number = five.nextInt();
System.out.println("Name accepted " +
username);
System.out.println("Age accepted " + age);
System.out.println("Gender accepted " +
gender);
System.out.println("Marital status accepted " +
marital_status);
System.out.println("Telephone number accepted "
+ telephone_number);
}
}

BASIC INPUT USING Scanner with System.in with simple arithmetic

In this exersice we are going to add three numbers which have different data types then display the
result
import java.util.Scanner;

public class ScannerDemo {

92
 Chapter Two: Basics in Java Programming

public static void main(String[] arguments){

Scanner input = new Scanner(System.in);
Step1 : declare the three variable and Receive the
inputs for them
double result;
int number1=input.nextInt();
System.out.println(“Enter Integer number”);

float number2=input.nextFloat();
System.out.println(“Enter Float number”);

double number3=input.nextDouble();
System.out.println(“Enter Double number”);
Step2 : Add the three variable and Display the result

Result=number1+number2+number3;
System.out.println(“Result is is:”+result);

}
}

93
 Chapter Two: Basics in Java Programming

Week Four: Assessments

Part I: Objective Type Question

1. Which of the following are valid Identifiers?

a) $amount

b) 6tally

c) my*Name

d) salary

e) score

f) first Name

g) total#

h) cast

Part II: Subjective Type Question

1. What is the value of number?
int number = 5 * 3 – 3 / 6 – 9 * 3;

2. What is the value of result?

int x = 8;

int y = 2;

boolean result = (15 == x * y);

3. What is the value of result?

boolean x = 7;

boolean result = (x < 8) && (x > 4);

4. What is the value of numCars?

int numBlueCars = 5;

int numGreenCars = 10;

int numCars = numGreenCars++ + numBlueCars + ++numGreeenCars;

94
 Chapter Two: Basics in Java Programming

Week Five : Session

2.3. Program Control Statements

In this chapter, you will learn about the statements that control a program’s flow of execution.
There are three categories of program control statements:

• selection statements, which include the if and the switch;

• iteration statements, which include the for, while, and do-while loops; and
• jump statements, which include break, continue, and return.

Input characters from the keyboard

Before examining Java’s control statements, we will make a short digression that will allow
you to begin writing interactive programs. Up to this point, the sample programs in this book
have displayed information to the user, but they have not received information from the user.
Thus, you have been using console output, but not console (keyboard) input. The main reason
for this is that Java’s input capabilities rely on or make use of features not discussed until later
in this book. Also, most real-world Java applications will be graphical and window based, not
console based. For these reasons, not much use of console input is found in this book. However,
there is one type of console input that is relatively easy to use: reading a character from the
keyboard. Since several of the examples in this chapter will make use of this feature, it is
discussed here.

To read a character from the keyboard, we will use System.in.read( ). System.in is the
complement to System.out. It is the input object attached to the keyboard. The read( ) method
waits until the user presses a key and then returns the result. The character is returned as an
integer, so it must be cast into a char to assign it to a char variable. By default, console input is
line buffered. Here, the term buffer refers to a small portion of memory that is used to hold the
characters before they are read by your program. In this case, the buffer holds a complete line
of text. As a result, you must press ENTER before any character that you type will be sent to
your program. Here is a program that reads a character from the keyboard:

// Read a character from the keyboard.

class KbIn {
public static void main(String args [])
throws java.io.IOException {

95
 Chapter Two: Basics in Java Programming

char ch;
System.out.print("Press a key followed by ENTER: ");
ch = (char) System.in. read () ; // Read a character
from the keyboard.
System.out.println("Your key is: " + ch);
}

Here is a sample run:

Press a key followed by ENTER: t Your key is: t

In the program, notice that main( ) begins like this:

public static void main(String args [] )

throws java.io.IOException {

Because System.in.read( ) is being used, the program must specify the throws
java.io.IOException clause. This line is necessary to handle input errors. It is part of Java’s
exception handling mechanism, which is discussed in another Chapter. For now, don’t worry
about its precise meaning.

The fact that System.in is line buffered is a source of annoyance at times. When you press
ENTER, a carriage return, line feed sequence is entered into the input stream. Furthermore,
these characters are left pending in the input buffer until you read them. Thus, for some
applications, you may need to remove them (by reading them) before the next input operation.
You will see an example of this later in this chapter.

2.3.1. The if statement

The complete form of the if statement is

If(condition) statement;
else statement;

where the targets of the if and else are single statements. The else clause is optional. The targets
of both the if and else can be blocks of statements. The general form of the if, using blocks of
statements, is

if(condition)
{
statement sequence

96
 Chapter Two: Basics in Java Programming

}
Else
{
statement sequence
}

If the conditional expression is true, the target of the if will be executed; otherwise, if it exists,
the target of the else will be executed. At no time will both of them be executed. The conditional
expression controlling the if must produce a boolean result.

To demonstrate the if (and several other control statements), we will create and develop a
simple computerized guessing game that would be suitable for young children. In the first
version of the game, the program asks the player for a letter between A and Z. If the player
presses the correct letter on the keyboard, the program responds by printlng the message **
Right **. The program is shown here:

// Guess the letter game.

class Guess {
public static void main(String args[])
throws java.io.IOException {
char ch, answer = 'K';
System.out.println("I'm thinking of a letter between A
and Z.");
System.out.print("Can you guess it: ");
ch = (char) System.in.read(); // read a char from the
keyboard
if(ch == answer) System.out.println("** Right **");
}
}

This program prompts the player and then reads a character from the keyboard. Using an if
statement, it then checks that character against the answer, which is K in this case. If K was
entered, the message is displayed. When you try this program, remember that the K must be
entered in uppercase.

Taking the guessing game further, the next version uses the else to print a message when the
wrong letter is picked.

97
 Chapter Two: Basics in Java Programming

// Guess the letter game, 2nd version.

class Guess2 {
public static void main(String args[])
throws java.io.IOException {
char ch, answer = 'K';
System.out.println("I'm thinking of a letter between A
and Z." ;
System.out.print("Can you guess it: ");
ch = (char) System.in.read(); // get a char
if(ch == answer) System.out.println("** Right **");
else System.out.println("... Sorry, you're
wrong.");
}

Nested ifs

A nested if is an if statement that is the target of another if or else. Nested ifs are very common in
programming. The main thing to remember about nested ifs in Java is that an else statement always
refers to the nearest if statement that is within the same block as the else and not already associated with
an else. Here is an example:

if(i == 10) {
if (j < 20) a = b;
if(k > 100) c = d;
else a = c; // this else refers to if(k > 100)
}
else a = d; // this else refers to if(i == 10)

As the comments indicate, the final else is not associated with if(j < 20), because it is not in the same
block (even though it is the nearest if without an else). Rather, the final else is associated with if(i==
10). The inner else refers to if(k > 100), because it is the closest if within the same block.

You can use a nested if to add a further improvement to the guessing game. This addition provides the
player with feedback about a wrong guess.

// Guess the letter game, 3rd version.

class Guess3 {
public static void main(String args[])
throws java.io.IOException {

98
 Chapter Two: Basics in Java Programming

char ch, answer =' K';

System.out.println("I'm thinking of a letter between A
and Z. ");
System.out.print("Can you guess it: ");
ch = (char) System.in.read(); // get a char
if(ch == answer) System.out.println("** Right **");
else {
System.out.print("...Sorry, you're ");
if(ch < answer) System.out.println("too low");// This
is a nested if.
else System. out. println(11 too high");
}
}
}

A sample run is shown here:

I'm thinking of a letter between A and Z*

Can you guess it: Z .*-Sorry, you're too high

The if-else-if ladder

A common programming construct that is based upon the nested if is the if-else-if ladder. It
looks like this:

if{condition)
statement;
else if(condition)
statement;
else if(condition)
statement;
.
.
.
else
statement;

99
 Chapter Two: Basics in Java Programming

The conditional expressions are evaluated from the top downward. As soon as a true condition
is found, the statement associated with it is executed, and the rest of the ladder is bypassed. If
none of the conditions are true, the final else statement will be executed. The final else often
acts as a default condition; that is, if all other conditional tests fail, the last else statement is
performed. If there is no final else and all other conditions are false, no action will take place.

The following program demonstrates the if-else-if ladder:

// Demonstrate an if-else-if ladder,

class Ladder {
public static void main(String args[]) {
int x;
for(x=0; x<6; x++) {
if(x==1)
System.out.println( "x is one");
else if(x==2)
System.out.println(" x is two");
else if(x==3)
System.out.println( "x is three");
else if(x==4)
System.out.println( "x is four");
else
System.out.println( "x is not between 1 and 4");
}
default statement.
}

The program produces the following output:

X is not between 1 and 4

X is one

X is two

X is three

X is four

X is not between 1 and 4

100
 Chapter Two: Basics in Java Programming

As you can see, the default else is executed only if none of the preceding if statements succeeds.

2.3.2. The switch statement

The second of Java’s selection statements is the switch. The switch provides for a multiway
branch. Thus, it enables a program to select among several alternatives. Although a series of
nested if statements can perform multiway tests, for many situations the switch is a more
efficient approach. It works like this: the value of an expression is successively tested against
a list of constants. When a match is found, the statement sequence associated with that match
is executed. The general form of the switch statement is

switch (expression) {
case constant1: statement sequence
break;
case constant2:
statement sequence
break;
case constants3:
statement sequence
break;
default:
statement sequence
}

For versions of Java prior to JDK 7, the expression controlling the switch must resolve to type
byte, short, int, char, or an enumeration. (Enumerations are described in Chapter 12.)
However, beginning with JDK 7, expression can also be of type String. This means that modern
versions of Java can use a string to control a switch. (This technique is demonstrated in Chapter
5, when String is described.) Frequently, the expression controlling a switch is simply a
variable rather than a larger expression.

Each value specified in the case statements must be a unique constant expression (such as a
literal value). Duplicate case values are not allowed. The type of each value must be compatible
with the type of expression.

101
 Chapter Two: Basics in Java Programming

The default statement sequence is executed if no case constant matches the expression. The
default is optional; if it is not present, no action takes place if all matches fail. When a match
is found, the statements associated with that case are executed until the break is encountered
or, in the case of default or the last case, until the end of the switch is reached.

The following program demonstrates the switch:

// Demonstrate the switch, class SwitchDemo {

public static void main{String args[J) {
int i;
£or(i=0; i<10; i++)
switch(i} {
case 0:
System.out.println (" i is zero " );
break;
case 1:
System.out.println(" i is one");
break;
case 2:
System.out.println (" i is two");
break;
case 3:
System. out. println(" i is three " );
break;
case 4:
System.out* println(" i is four ");
break;
default:
System. out. println(" i is five or more");
}
}
}

The output produced by this program is shown here:

102
 Chapter Two: Basics in Java Programming

i is zero

i is one

i is two

i is three

i is four

i is five or more

i is five or more

i is five or more

i is five or more

i is five or more

As you can see, each time through the loop, the statements associated with the case constant
that matches i are executed. All others are bypassed. When i is five or greater, no case
statements match, so the default statement is executed.

Technically, the break statement is optional, although most applications of the switch will use
it. When encountered within the statement sequence of a case, the break statement causes
program flow to exit from the entire switch statement and resume at the next statement outside
the switch. However, if a break statement does not end the statement sequence associated with
a case, then all the statements at and following the matching case will be executed until a break
(or the end of the switch) is encountered.

For example, study the following program carefully. Before looking at the output, can you
figure out what it will display on the screen?

// Demonstrate the switch without break statements.

class NoBreak {
public static void main(String args[]) {
int i;
for(i=0; i<=5; i++) {
switch(i) {
System.out.println("i is less than one");
case 1:
System.out.println("i is less than two");
103
 Chapter Two: Basics in Java Programming

case 2:
System.out.println("i is less than three
case 3:
System.out.println("i is less than four")
case 4:
System.out.println("i is less than five"}
}
System.out.println();

The case statements fall through here.

This program displays the following output:

i is less than one

i is less than two

i is less than three

i is less than four

i is less than five

i is less than two

i is less than three

1 is less than four

i is less than five

i is less than three

1 is less than four

i is less than five

i is less than four

1 is less than five

1 is less than five

As this program illustrates, execution will continue into the next case if no break statement is
present.

You can have empty cases, as shown in this example:

104
 Chapter Two: Basics in Java Programming

switch(i) {
case 1: case 2 :
case 3: System.out.println("i is 1, 2 or 3M); break;
case 4: System.out.println(" i is 4 11) ; break;
}

In this fragment, if i has the value 1, 2, or 3, the first println( ) statement executes. If it is 4, the
second println( ) statement executes. The “stacking” of cases, as shown in this example, is
common when several cases share common code.

NESTED SWITCH STATEMENTS

It is possible to have a switch as part of the statement sequence of an outer switch. This is called
a nested switch. Even if the case constants of the inner and outer switch contain common values,
no conflicts will arise. For example, the following code fragment is perfectly acceptable:

switch(ch1) {
case 'A':
System.out.println("This A is part of outer switch.");
break;
switch(ch2) { case 'A':
System.out.println("This A is part of inner switch");
break;
case 'B' : // ...
} // end of inner switch
break case 'B': // ...

Start Building a Java Help System

Help.java

This project builds a simple help system that displays the syntax for the Java control statements.
The program displays a menu containing the control statements and then waits for you to
choose one. After one is chosen, the syntax of the statement is displayed. In this first version
of the program, help is available for only the if and switch statements. The other control
statements are added in subsequent projects.

1. Create a file called Help .java.

2. The program begins by displaying the following menu:

105
 Chapter Two: Basics in Java Programming

Help on:

a. if
b. switch

Choose one:

To accomplish this, you will use the statement sequence shown here:

System.out.println("Help on: ") ;

System.out.println(" 1. if");
System.out.println(" 2. switch");
System.out.print("Choose one: " );
3. Next, the program obtains the user’s selection by calling System.in.read( ), as
shown here:
choice = (char) System.in.read{);
4. Once the selection has been obtained, the program uses the switch statement shown
here to display the syntax for the selected statement.
switch(choice) {
case '1':
System.out.println(" The if : \n ") ;
System.out.println(if (condition) statement; ");
System.out.println("else statement; ") ;
break;
case '2':
System.out.println("The switch:\n");
System.out.println("switch (expression) { ") ;
System.out.println("case constant: " ) ;
System.out.println("statement sequence");
System.out.println("break;") ;
System.out.println("// ... ");
System.out.println("} ") ;
break;
default:
System.out.print("Selection not found.");

Notice how the default clause catches invalid choices. For example, if the user enters

106
 Chapter Two: Basics in Java Programming

5. no case constants will match, causing the default sequence to execute.

6. Here is the entire Help.java program listing:

//Try This 3-1 A simple help system

class Help {
public static void main(String args [) )
throws java.io.IOException {
char choice;
System.out.println( "Help on: " ) ;
System.out.println("1.if");
System.out.println("2.switch");
System.out.print("Choose one: " ) ;
choice = (char) System.in.read();
System.out.println("\n");
switch(choice) { case '1':
System.out.println("The if : \ n") ;
System.out.println("if (condition) statement; ") ;
System.out.println("else statement;")
break;
case '2':
System.out.println("The switch:\n");
System.out.println("switch (expression) { ") ;
System.out.println("case constant:");
System.out.println("statement sequence");
System.out.println("break; ") ;
System.out.println("// ..");
System.out.println("} ") ;
break;
default:
System.out.print("Selection not found.");
}
}
}

107
 Chapter Two: Basics in Java Programming

6. Here is a sample run.

Help on:

1. if
2. switch

Choose one: 1

The if:

if(condition) statement;

else statement;

2.3.3. The for loop

You have been using a simple form of the for loop since Chapter l. You might be surprised at just how
powerful and flexible the for loop is. Let’s begin by reviewing the basics, starting with the most
traditional forms of the for.

The general form of the for loop for repeating a single statement is

for (initialization; condition; iteration) statement;

For repeating a block, the general form is

for (initialization; condition; iteration)

{
statement sequence
}

Ask the Expert

Q: Under what conditions should I use an if-else-if ladder rather than a switch when coding a
multiway branch?

A: In general, use an if-else-if ladder when the conditions controlling the selection process do
not rely upon a single value. For example, consider the following if-else-if sequence:

for(initialization; condition; iteration)

statement sequence

108
 Chapter Two: Basics in Java Programming

This sequence cannot be recoded into a switch because all three conditions involve different
variables and differing types. What variable would control the switch? Also, you will need to
use an if-else-if ladder when testing floating-point values or other objects that are not of types
valid for use in a switch expression.

The initialization is usually an assignment statement that sets the initial value of the loop
control variable, which acts as the counter that controls the loop.

The condition is a Boolean expression that determines whether or not the loop will repeat.

The iteration expression defines the amount by which the loop control variable will change
each time the loop is repeated.

Notice that these three major sections of the loop must be separated by semicolons. The for
loop will continue to execute as long as the condition tests true. Once the condition becomes
false, the loop will exit, and program execution will resume on the statement following the for.

The following program uses a for loop to print the square roots of the numbers between l and
99. It also displays the rounding error present for each square root.

// Show square roots of 1 to 99 and the rounding error*

class SqrRoot {
public static void main(String args []) {
double num, sroot, rerr;
for(num = 1,0; num < 10 0.0; num++) {
sroot = Math.sqrt(num);
System.out. println("Square root of " + num + " is "
+ sroot) ;
// compute rounding error rerr = num - (sroot * sroot);
System.out.println("Rounding error is " + rerr);
System.out.println();
}
}
}

Notice that the rounding error is computed by squaring the square root of each number. This
result is then subtracted from the original number, thus yielding the rounding error.

109
 Chapter Two: Basics in Java Programming

The for loop can proceed in a positive or negative fashion, and it can change the loop control
variable by any amount. For example, the following program prints the numbers 100 to -95, in
decrements of 5:

//A negatively running for loop,

class DecrFor {
public static void main(String args[]) {
int x;
for(x = 100; x > -100; x -= 5) //loop control
variable is decremented by 5 each time.
System.out.println(x);
}
}

An important point about for loops is that the conditional expression is always tested at the top
of the loop. This means that the code inside the loop may not be executed at all if the condition
is false to begin with. Here is an example:

for(counts=10; count < 5; count++)

x += count; // this statement will not execute

This loop will never execute because its control variable, count, is greater than 5 when the loop
is first entered. This makes the conditional expression, count < 5, false from the outset; thus,
not even one iteration of the loop will occur.

Some variations on the for loop

The for is one of the most versatile statements in the Java language because it allows a wide range of
variations. For example, multiple loop control variables can be used.

Consider the following program:

// Use commas in a for statement,

class Comma {
public static void main(String args[]) {
int i, j;
for(i=0, j = 10; i < j; i + +, j--) // Notice the
two loop control variables.
System.out.println(" i and j: " + i + " " + j) ;
}
110
 Chapter Two: Basics in Java Programming

The output from the program is shown here:

i and j : 0 10

i and j : 1 9

i and j : 2 8

i and j : 3 7

i and j : 4 6

Here, commas separate the two initialization statements and the two iteration expressions.
When the loop begins, both i and j are initialized. Each time the loop repeats, i is incremented
and j is decremented. Multiple loop control variables are often convenient and can simplify
certain algorithms. You can have any number of initialization and iteration statements, but in
practice, more than two or three make the for loop unwieldy.

The condition controlling the loop can be any valid Boolean expression. It does not need to
involve the loop control variable. In the next example, the loop continues to execute until the
user types the letter S at the keyboard:

// Loop until an S is typed

class ForTest {
public static void main{String args [])
throws java.io.lOException {
int i;
System. out .println("Press S to stop.");
for(i = 0; (char) System.in.read() != 'S'; i++)
System.out.println("Pass #"+ i) ;
)
}

Missing pieces

Some interesting for loop variations are created by leaving pieces of the loop definition empty.
In Java, it is possible for any or all of the initialization, condition, or iteration portions of the
for loop to be blank. For example, consider the following program:

// Parts of the for can be empty,

111
 Chapter Two: Basics in Java Programming

class Empty {
public static void main(String args[j) {
int i;
for(i = 0; i < 10; ) { //The
iteration expression is missing.
System.out.println("Pass #" + i);
i++; // increment loop control var
}
}
}

Here, the iteration expression of the for is empty. Instead, the loop control variable i is
incremented inside the body of the loop. This means that each time the loop repeats, i is tested
to see whether it equals 10, but no further action takes place. Of course, since i is still
incremented within the body of the loop, the loop runs normally, displaying the following
output:

Pass #0

Pass #1

Pass #2

Pass #3

Pass #4

Pass #5

Pass #6

Pass #7

Pass #8

Pass #9

In the next example, the initialization portion is also moved out of the for:

// Move more out of the for loop,

class Empty2 {
public static void main(String args[]) {
int i;

112
 Chapter Two: Basics in Java Programming

i = 0; // The initialization expression is moved out of

the loop.
for(; i < 10; ) {
System.out.println("Pass #" + i);
i++; // increment loop control var
}
}

In this version, i is initialized before the loop begins, rather than as part of the for. Normally,
you will want to initialize the loop control variable inside the for. Placing the initialization
outside of the loop is generally done only when the initial value is derived through a complex
process that does not lend itself to containment inside the for statement.

The Infinite Loop

You can create an infinite loop (a loop that never terminates) using the for by leaving the conditional
expression empty. For example, the following fragment shows the way many Java programmers create
an infinite loop:

for( ; ; ) // intentionally infinite loop

{
//.. -
}

This loop will run forever. Although there are some programming tasks, such as operating system
command processors, that require an infinite loop, most “infinite loops” are really just loops with special
termination requirements. Near the end of this chapter, you will see how to halt a loop of this type.
(Hint: It’s done using the break statement.)

Loops with no body

In Java, the body associated with a for loop (or any other loop) can be empty. This is because a null
statement is syntactically valid. Body-less loops are often useful. For example, the following program
uses one to sum the numbers l through 5:

// The body of a loop can be empty,

class Empty3 {
public static void main(String args[]) {
int i ;
int sum = 0;

113
 Chapter Two: Basics in Java Programming

// sum the numbers through 5

for ( i = 1; i <= 5; sum += i++) // No body in
this loop!
System.out.println("Sum is " + sum);
}
}

The output from the program is shown here:

Sum is 15

Notice that the summation process is handled entirely within the for statement, and no body is
needed. Pay special attention to the iteration expression:

sum += i++

Don’t be intimidated by statements like this. They are common in professionally written Java
programs and are easy to understand if you break them down into their parts. In other words,
this statement says, “Add to sum the value of sum plus i, then increment i.” Thus, it is the same
as this sequence of statements:

sum = sum + i;
i+ + ;

Declaring loop control variables inside the for loop

Often the variable that controls a for loop is needed only for the purposes of the loop and is not
used elsewhere. When this is the case, it is possible to declare the variable inside the
initialization portion of the for. For example, the following program computes both the
summation and the factorial of the numbers l through 5. It declares its loop control variable i
inside the for.

// Declare loop control variable inside the for.

class ForVar {
public static void main(String args[]) {
int sum = 0; int fact = 1;
// compute the factorial of the numbers through 5
for (int i = 1; i <= 5; i + + ) { The
variable i is declared

114
 Chapter Two: Basics in Java Programming

sum += i; // i is known throughout the loop inside the

for statement.
fact *= i;
}
// but, i is not known here
System.out.println("Sum is " + sum);
System.out.println("Factorial is " + fact);
}

When you declare a variable inside a for loop, there is one important point to remember: the
scope of that variable ends when the for statement does. (That is, the scope of the variable is
limited to the for loop.) Outside the for loop, the variable will cease to exist. Thus, in the
preceding example, i is not accessible outside the for loop. If you need to use the loop control
variable elsewhere in your program, you will not be able to declare it inside the for loop.

Before moving on, you might want to experiment with your own variations on the for loop. As
you will find, it is a fascinating loop.

The enhanced for loop

There is another form of the for loop, called the enhanced for. The enhanced for provides a
streamlined way to cycle through the contents of a collection of objects, such as an array. The
enhanced for loop is discussed after arrays have been introduced.

2.3.4. The while loop

Another of Java’s loops is the while. The general form of the while loop is

while(condition) statement;

where statement may be a single statement or a block of statements, and condition defines the
condition that controls the loop. The condition may be any valid Boolean expression. The loop
repeats while the condition is true. When the condition becomes false, program control passes
to the line immediately following the loop.

Here is a simple example in which a while is used to print the alphabet:

// Demonstrate the while loop.

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

115
 Chapter Two: Basics in Java Programming

char ch;
// print the alphabet using a while loop
ch = 'a ';
while(ch <='z') {
System.out.print (ch)
ch++;
}
}
}

Here, ch is initialized to the letter a. Each time through the loop, ch is output and then
incremented. This process continues until ch is greater than z.

As with the for loop, the while checks the conditional expression at the top of the loop, which
means that the loop code may not execute at all. This eliminates the need for performing a
separate test before the loop. The following program illustrates this characteristic of the while
loop. It computes the integer powers of 2, from 0 to 9.

// Compute integer powers of 2 .

class Power {
public static void main(String argsU) { int e; int
result;
for(int i=p; i < 10; i++) {
result = 1;
e = i ;
while(e > 0) {
result *= 2;
e--;
}
System.out.println(“2 to the '' + i + '' power is “+
result) ;
}
}
}

The output from the program is shown here:

116
 Chapter Two: Basics in Java Programming

2 to the 0 power is 1

2 to the 1 power is 2

2 to the 2 power is 4

2 to the 3 power is 8

2 to the 4 power is 16

2 to the 5 power is 32

2 to the 6 power is 64

2 to the 7 power is 12 8

2 to the 8 power is 256

2 to the 9 power is 512

Notice that the while loop executes only when e is greater than o. Thus, when e is zero, as it is
in the first iteration of the for loop, the while loop is skipped.

Ask the Expert

Q: Given the flexibility inherent in all of Java’s loops, what criteria should I use when selecting
a loop? That is, how do I choose the right loop for a specific job?

A: Use a for loop when performing a known number of iterations based on the value of a loop
control variable. Use the do-while when you need a loop that will always perform at least one
iteration. The while is best used when the loop will repeat until some condition becomes false.

2.3.5. The do-while loop

The last of Java’s loops is the do-while. Unlike the for and the while loops, in which the
condition is tested at the top of the loop, the do-while loop checks its condition at the bottom
of the loop. This means that a do-while loop will always execute at least once. The general
form of the do-while loop is

do{
statements;
} while(condition);

Although the braces are not necessary when only one statement is present, they are often used
to improve readability of the do-while construct, thus preventing confusion with the while. The
do-while loop executes as long as the conditional expression is true.
117
 Chapter Two: Basics in Java Programming

The following program loops until the user enters the letter q:

// Demonstrate the do-while loop.

class DWDemo {
public static void main{String args[])
throws java.io.IOException {
char ch;
do {
System.out.print("Press a key followed by ENTER: '';
ch = (char) System.in.read(); // get a char
} while(ch != 'q');
}
}

Using a do-while loop, we can further improve the guessing game program from earlier in this
chapter. This time, the program loops until you guess the letter.

// Guess the letter game, 4th version.

class Guess4 {
public static void main(String args [])
throws java.io.IOException {
char ch, ignore, answer = 'K';
do {
System.out.println("I'm thinking of a letter between A
and Z. ");
System.out.print("Can you guess it: ");
// read a character
ch = (char) System.in.read();
// discard any other characters in the input buffer do
{
ignore = (char) System.in.read();
} while(ignore != '\n');
if(ch == answer) System.out.println("** Right **");
else {
System.out.print("...Sorry, you're ");
if(ch < answer)

118
 Chapter Two: Basics in Java Programming

System.out.println("too low");
else
System.out.println("too high");
System.out.println("Try again!\n");
}
} while(answer != ch);
}

Here is a sample run:

I'm thinking of a letter between A and Z.

Can you guess it: A

,,,Sorry, you're too low

Try again I

I'm thinking of a letter between A and Z.

Can you guess it: Z

...Sorry, you're too high

Try again!

I'm thinking of a letter between A and Z,

Can you guess it: K

** Right **

Notice one other thing of interest in this program. There are two do-while loops in the program.
The first loops until the user guesses the letter. Its operation and meaning should be clear. The
second do-while loop, shown again here, warrants some explanation:

// discard any other characters in the input buffer

do {
ignore = (char) System - in,read() ;
} while(ignore != 1\n1);

As explained earlier, console input is line buffered—you have to press ENTER before
characters are sent. Pressing ENTER causes a carriage return and a line feed (newline)
sequence to be generated. These characters are left pending in the input buffer. Also, if you

119
 Chapter Two: Basics in Java Programming

typed more than one key before pressing ENTER, they too would still be in the input buffer.
This loop discards those characters by continuing to read input until the end of the line is
reached. If they were not discarded, then those characters would also be sent to the program as
guesses, which is not what is wanted. (To see the effect of this, you might try removing the
inner do-while loop.) In Chapter 10, after you have learned more about Java, some other,
higher-level ways of handling console input are described. However, the use of read( ) here
gives you insight into how the foundation of Java's I/O system operates. It also shows another
example of Java's loops in action.

Improve the Java Help System

Help2.java j

This project expands on the Java help system that was created. This version adds the syntax for
the for, while, and do-while loops. It also checks the user’s menu selection, looping until a
valid response is entered.

1. Copy Help .java to a new file called Help2.java.

2. Change the first part of main( ) so that it uses a loop to display the choices, as shown here:

public static void main(String args[])

throws java.io.lOException {
char choice, ignore;
do {
System.out.println("Help on:");
System.out.println("1- if") ;
System.out.println("2. switch");
System.out.println("3. for"} ;
System.out.println("4. while");
System.out.println("5. do-while\n");
System.out.print ( "Choose one; ");
choice = (char) System.in.read();
do {
ignore = (char) System.in.read();
} while(ignore != '\n');
} while( choice < '1' | choice > '5');

120
 Chapter Two: Basics in Java Programming

Notice that a nested do-while loop is used to discard any unwanted characters remaining in the
input buffer. After making this change, the program will loop, displaying the menu until the
user enters a response that is between 1 and 5.

3. Expand the switch statement to include the for, while, and do-while loops, as shown
here:

switch(choice) {
case '1':
System.out.println("The if : \n") ;
System.out.println("if (condition) statement;") ;
System.out.println("else statement;");
break;
case '2':
System.out.println("The switch: \n") ;
System.out.println("switch (expression) {") ;
System.out.println(" case constant:");
System.out.println(" statement sequence");
System.out.println(" break; ") ;
System.out.println(" // ….");
System.out.println("}") ;
break;
case '3':
System.out.println("The for:\n");
System.out.print("for (init; condition; iteration") ;
System.out.println(" statement; ") ;
break;
case '4':
System.out.println("The while; \n") ;
System.out.println("while (condition) statement; '')
break;
case '5':
System.out.println("The do-while:\n");
System.out.println("do {");
System.out.println("statement;") ;

121
 Chapter Two: Basics in Java Programming

System.out.println("} while (condition);");

break;
}

Notice that no default statement is present in this version of the switch. Since the menu loop
ensures that a valid response will be entered, it is no longer necessary to include a default
statement to handle an invalid choice.

4. Here is the entire Help2.java program listing:

/*
Try This 3-2
An improved Help system that uses a do-while to process
a menu selection.
*/
class Help2 {
public static void main(String args[])
throws java.io.IOException {
char choice, ignore;
do {
System.out.println("Help on:");
System.out.println("1- if") ;
System.out.println("2. switch");
System.out.println("3. for") ;
System.out.println("4. while");
System.out.println("5. do-while\n");
System.out.print ( "Choose one; ");
choice = (char) System.in.read();
do {
ignore = (char) System.in.read();
} while(ignore != '\n');
} while( choice < '1' | choice > '5');
System.out.print ( "\n");
switch(choice) {
case '1':
System.out.println("The if : \n") ;

122
 Chapter Two: Basics in Java Programming

System.out.println("if (condition) statement;") ;

System.out.println("else statement;");
break;
case '2':
System.out.println("The switch: \n") ;
System.out.println("switch (expression) {") ;
System.out.printlnn ("case constant:");
System.out.println(" statement sequence");
System.out.println(" break; ") ;
System.out.println(" // ….");
System.out.println("}") ;
break;
case '3':
System.out.println("The for:\n");
System.out.print("for (init; condition; iteration") ;
System.out.println(" statement; ") ;
break;
case '4':
System.out.println ("The while; \n") ;
System.out.println("while (condition) statement; ") ;
break;
case '5':
System.out.println("The do-while:\n");
System.out.println("do {");
System.out.println("statement;") ;
System.out.println("} while (condition);");
break;
}
}
}

2.3.6. Use break to exit a loop

It is possible to force an immediate exit from a loop, bypassing any remaining code in the body
of the loop and the loop’s conditional test, by using the break statement. When a break

123
 Chapter Two: Basics in Java Programming

statement is encountered inside a loop, the loop is terminated and program control resumes at
the next statement following the loop. Here is a simple example:

// Using break to exit a loop, class BreakDemo {

public static void main(String argsf]) {
int num;
num = 100;
// loop while i-squared is less than num
for(int i=0; i < num; i++) {
if(i*i >= num) break; // terminate loop if i*i >= 100
System.out.print (i + " ") ;
}
System.out.println("Loop complete. " ) ;
}
}

This program generates the following output:

0 1 2 3 4 5 6 7 8 9 Loop complete.

As you can see, although the for loop is designed to run from 0 to num (which in this case is
100), the break statement causes it to terminate early, when i squared is greater than or equal
to num.

The break statement can be used with any of Java’s loops, including intentionally infinite loops.
For example, the following program simply reads input until the user types the letter q:

// Read input until a q is received.

class Break2 {
public static void main(String args [])
throws java.io.IOException {
char ch;
for ( ; ; ) { //This "infinite" loop is terminated
by the break
ch = (char) System.in.read () ; // get a char.
if(ch == 'q ') break; 1
}
System.out.println("You pressed q!");

124
 Chapter Two: Basics in Java Programming

When used inside a set of nested loops, the break statement will break out of only the
innermost loop. For example:

// Using break with nested loops.

class Break3 {
public static void main(String args[]) {
for(int i=0; i<3; i++) {
System.out.println("Outer loop count:" + i);
System.out.print(" Inner loop count: ");
int t = 0;
while(t < 100) {
if(t == 10} break; // terminate loop if t is 10
System.out.print(t + " ") }
t++;
System.out.println();
}
System.out.println("Loops complete . ") ;
}
}

This program generates the following output:

Outer loop count: 0

Inner loop count: 0 1 2 3 4 5 6 7 8 9

Outer loop count: 1

Inner loop count: 0 1 2 3 4 5 6 7 8 9

Outer loop count: 2

Inner loop count: 0 1 2 3 4 5 6 7 8 9

Loops complete.

As you can see, the break statement in the inner loop causes the termination of only that loop.
The outer loop is unaffected.

125
 Chapter Two: Basics in Java Programming

Here are two other points to remember about break. First, more than one break statement may
appear in a loop. However, be careful. Too many break statements have the tendency to
destructure your code. Second, the break that terminates a switch statement affects only that
switch statement and not any enclosing loops.

Ask the Expert

Q: You say that the goto is unstructured and that the break with a label offers a better
alternative. But really, doesn’t breaking to a label, which might be many lines of code and
levels of nesting removed from the break, also destructure code?

A: The short answer is yes! However, in those cases in which a jarring change in program flow
is required, breaking to a label still retains some structure. A goto has none!

2.3.7. Use continue

It is possible to force an early iteration of a loop, bypassing the loop’s normal control structure.
This is accomplished using continue. The continue statement forces the next iteration of the
loop to take place, skipping any code between itself and the conditional expression that controls
the loop. Thus, continue is essentially the complement of break. For example, the following
program uses continue to help print the even numbers between o and 100:

// Use continue.
class ContDemo {
public static void main(String argsf]) {
int i; // print even numbers between 0 and 100
for(i = 0; i< = 100; i + + } {
if((i%2)!=0) continue; // iterate
System.out.println(i);
}
}
}

Only even numbers are printed, because an odd one will cause the loop to iterate early,
bypassing the call to println( ).

In while and do-while loops, a continue statement will cause control to go directly to the
conditional expression and then continue the looping process. In the case of the for, the iteration

126
 Chapter Two: Basics in Java Programming

expression of the loop is evaluated, then the conditional expression is executed, and then the
loop continues.

As with the break statement, continue may specify a label to describe which enclosing loop to
continue. Here is an example program that uses continue with a label:

// Use continue with a label. C

lass ContToLabel {
public static void main(String args[]) {
outerloop:
for(int i=l; i < 10; i++) {
System.out.print ("\n Outer loop pass "+ i +", Inner
loop: ");
for(int j = 1; j < 10; j++) {
if(j == 5) continue outerloop; // continue outer loop
System.out.print(j);
}
}
}

The output from the program is shown here:

Outer loop pass 1, Inner loop: 1234

Outer loop pass 2, Inner loop: 1234

Outer loop pass 3, Inner loop: 1234

Outer loop pass 4, Inner loop: 1234

Outer loop pass 5, Inner loop: 1234

Outer loop pass 6, Inner loop: 1234

Outer loop pass 7, Inner loop: 1234

Outer loop pass 9, Inner loop: 1234

As the output shows, when the continue executes, control passes to the outer loop,skipping the
remainder of the inner loop.

127
 Chapter Two: Basics in Java Programming

Good uses of continue are rare. One reason is that Java provides a rich set of loop statements
that fit most applications. However, for those special circumstances in which early iteration is
needed, the continue statement provides a structured way to accomplish it.

NESTED LOOPS

As you have seen in some of the preceding examples, one loop can be nested inside of another.
Nested loops are used to solve a wide variety of programming problems and are an essential
part of programming. So, before leaving the topic of Java’s loop statements, let’s look at one
more nested loop example. The following program uses a nested for loop to find the factors of
the numbers from 2 to 100:

/*
Use nested loops to find factors of numbers between 2
and 100,
*/
class FindFac {
public static void main{String args []) {
for(int i=2; i <= 100; i++) {
System.out.print (" Factors of " + i + ,f: ") ;
for(int j = 2; j < i; j++)
if((i%j) == 0) System.out.print(j + " ") ;
System.out.println();
}
}
}

Here is a portion of the output produced by the program:

Factors of 2

Factors of 3

Factors of 4 2

Factors of 5

Factors of 6 23

Factors of 7

Factors of 8 24

128
 Chapter Two: Basics in Java Programming

Factors of 9 3

Factors of 10 : 2 5

Factors of 1—E 1—E

Factors of 12 : 2 3 4

Factors of 13 :

Factors of 14 : 2 7

Factors of 15 : 3 5

Factors of 16 : 2 4 8

Factors of 17 :

Factors of 18 : 2 3 6

Factors of 19:

Factors of 20 : 2 4 5

In the program, the outer loop runs i from 2 through 100. The inner loop successively tests all
numbers from 2 up to i, printlng those that evenly divide i. Extra challenge: The preceding
program can be made more efficient. Can you see how? (Hint: The number of iterations in the
inner loop can be reduced.)

129
 Chapter Two: Basics in Java Programming

Week Five: Practical

Finish the Java Help System

Helps.java I

This project puts the finishing touches on the Java help system that was created in the previous
projects. This version adds the syntax for break and continue. It also allows the user to request
the syntax for more than one statement. It does this by adding an outer loop that runs until the
user enters q as a menu selection.

Try This 3-3

1. Copy Help2.java to a new file called Help3.java.

2. Surround all of the program code with an infinite for loop. Break out of this loop, using
break, when a letter q is entered. Since this loop surrounds all of the program code, breaking
out of this loop causes the program to terminate.

3. Change the menu loop as shown here:

do {
System.out.println("Help on:");
System.out.println("1. if") ;
System.out.println("2. switch");
System.out.println("3. for") ;
System.out.println("4. while");
System.out.println("5. do-while\n");
System.out.println( "Choose one; ");
choice = (char) System.in.read();
do {
ignore = (char) System.in.read();
} while(ignore != '\n');
} while( choice < '1' | choice > '5');
do {
System.out.println("Help on:");
System.out.println("1- if") ;
System.out.println("2. switch");

130
 Chapter Two: Basics in Java Programming

System.out.println("3. for") ;
System.out.println("4. while");
System.out.println("5. do-while\n") ;
System.out.println("6. break");
System.out.println("7. continue \n");
System.out.print ( "Choose one (q to quit ");
choice = (char) System.in.read();
do {
ignore = (char) System.in.read();
} while(ignore != '\n');
} while( choice < '1' | choice > '7' & choice !);

Notice that this loop now includes the break and continue statements. It also accepts the letter
q as a valid choice.

4. Expand the switch statement to include the break and continue statements, as shown
here:

case '6 ' : System.out.println("The break;\n");

System.out.println("break; or break label;"); break;

case ‘7’: System. out .println("The continue ; \n") ;

System. out .println("continue; or continue label;"); break;

5. Here is the entire Help3.java program listing:

/*
Try This 3-3
The finished Java statement Help system that processes
multiple requests.
*/
class Help3 {
public static void main(String argstl) throws
java.io.IOException { char choice, ignore;
for{;;) {
do {
System.out.println("Help on:");

131
 Chapter Two: Basics in Java Programming

System.out.println("1- if") ;
System.out.println("2. switch");
System.out.println("3. for") ;
System.out.println("4. while");
System.out.println("5. do-while\n") ;
System.out.println("6. break");
System.out.println("7. continue \n");
System.out.print("Choose one (q to quit) : ,r) ;
choice = (char) System.in.read();
do {
ignore = (char) System.in.read();
} while(ignore != '\n');
} while( choice < '1'|| choice >'7' & &choice!='q');
if(choice == 'q') break;
System.out.println("\n"} ;
switch(choice) {
case '1':
System.out.println("The if: \n") ;
System.out.println("if(condition) statement;");
System.out.println("else statement;"); break;
case '2':
System.out.println("The switch:\n");
System.out.println("switch(expression) {");
System.out.println(" case constant:");
System.out.println(" statement sequence");
System.out.println(" break;");
System.out.println(" // ...");
System.out.println("}"); break;
case '3':
System.out.println("The for:\n");
System.out.println("for(init; condition; iteration)");
System.out.println(" statement;"); break;
case '4':
System.out.println("The while:\n");

132
 Chapter Two: Basics in Java Programming

System.out.println("while(condition) statement;");
break;
case '5':
System.out. println( "The do-while: \n")
System.out.println("do {");
System.out.println(" statement;");
System.out.println("} while (condition);"); break;
case '6':
System.out.println("The break:\n");
System.out.println("break; or break label;"); break;
case '7':
System.out.println("The continue:\n");
System.out.println("continue; or continue label;");
break;
}
System.out.println();
}
}

6. Here is a sample run:

Help on:

1, if

2. switch

3. for

4. while

5. do-while

6. break

7. continue

Choose one (q to quit): 1 The if:

if (condition) statement; else statement;

Help on:

1. if 2. switch 3 . for

133
 Chapter Two: Basics in Java Programming

4. while

5. do-while

6, break

7, continue

Choose one Cq to quit): 6 The break:

break; or break label;

Help on:

1. if

2. switch

3 . for

4. while

5. do-while 6 - break

7, continue

Choose one (q to quit): q

134
 Chapter Two: Basics in Java Programming

Week Five: Assessments

1. Find out Errors in the following program and discuss ways for correction.

a) //Errors.java

1. public Class Errors{

2. public void main(String [] args){
3. int i, j = 32768;
4. short s = j;
5. double m = 5.3f, n = 2.1f;
6. float x = 5.3, y = 2.1;
7. byte z = 128;
8. System.out.println("x % y = "+x % y);
9. boolean b = 1 ;
10. if (b) System.out.println(“b is true”);
11. else System.out.println(“b is false”);
12. }
13. }

2. Write a Java application program that asks the user to enter two numbers obtains the
numbers from the user and prints the sum, product, difference and quotient of the
numbers?

3. Write a Java application program that asks the user to enter two integers, obtains the
numbers from the user and displays the larger number followed by the words “is larger
than “ the smaller number in the screen. If the numbers are equal, print the message
“These numbers are equal.”

4. Write four different Java statements that each add 1 to integer variable x.

5. Rewrite each of the following without using compound relations:

a) if(grade<=59 && grade>=50)

second+=1;

a) if(num>100 || num<0)

System.out.prinln(“Out of Range”);

135
 Chapter Two: Basics in Java Programming

else

sum+=num;

a) If((M>60 && N>60)||T>200)

y=1;

else

y=0;

6. Write a Java application program that reads the coefficients of a quadratic equation
(ax2+bx+c=0), generates and display the roots.

Note:

An appropriate message should be generated when the user types an invalid input to the
equation.

1. What do the following program print?

public class Mystery3{

public static void main(String
args[]){
int row = 10, column;
while(row >= 1){
column = 1;
while(column <= 10){
System.out.print(row % 2
== 1 ? “<” : “>”);
++column;
}
--row;
System.out.println();
}
}
}

2. Write a Java application program that asks the user to enter an integer number from the
keyboard and computes the sum of the digits of the number.

136
 Chapter Two: Basics in Java Programming

[ Hint: if the user types 4567as input , then the output will be 22 ]

1. Given a number, write a program using while loop to reverse the digits of the
number. [ Hint: Use Modulus Operator to extract the last digit and the integer
division by 10 to get the n-1 digit number from the n digit]

2. write codes that print the following outputs.

a)

$ $ $ $ $

$ $ $ $

$ $ $

$ $

b)

1 2

1 2 3

1 2 3 4

1 2 3 4 5

137
 Chapter Two: Basics in Java Programming

Reference
1. Java: A Beginner's Guide, Eighth Edition by Herbert Schildt
2. Java: How to Program, 9th Edition (Deitel)
3. https://www.javatpoint.com/

138
 Chapter Two: Basics in Java Programming

139
 Chapter Three : Objects and Classes

Chapter Three : Objects and Classes

Lesson Plan
1. Learning objectives

• Be able to define Object Oriented Programming.

• Be able to know principles and features of Object Oriented Programming.

• Be able to install Java IDE software.

• Be able to know the complete development cycle of Java IDE.

• Be able to differenciate java application and java applets.

2. Motivation

• Outputs through Question and Answer; repetitive discussion of java programming

basics; individual internet search.

• Solving a problem using Object Oriented programming.

• Controlling the flow control of instruction execution.

3. Expectations or Outcomes

 Define the terminologies, differentiate different programming paradigms, explain

Object Oriented programming principles; the assessment standard attached at the end
of the job task sheet.
 Can write Object Oriented instructions using Java to solve any problem using
programming.
4. Equipment

• Desktop or Laptop computer.

• Java IDE (NetBeans) software

5. Practice contents/Activities/Safety

 Brief introduction of Java complete development life cycle (Java IDE).

 Active practice; on java input and output, writing (Editing), compiling, interprating.

140
 Chapter Three : Objects and Classes

6. Assessments

• How can you install Java IDE (Netbeans) software?

• How to create class and objects?
7. Clean-up

 After finishing practice, computers should be properly shut down.

8. Independent practice/Follow-up activities

• Learning through assignment (practical exercises)

9. Review/Reflection

• Review the outcome of the practice, improvement measure and previous reflected
opinions.

141
 Chapter Three : Objects and Classes

Week Six: Session

3.1. Classes and objects

Object-oriented programming (OOP) involves programming using objects. An object
represents an entity in the real world that can be distinctly identified. For example, a student, a
desk, a circle, a button, and even a loan can all be viewed as objects. An object has a unique
identity, state, and behaviors. The state of an object consists of a set of data fields (also known
as properties) with their current values. The behavior of an object is defined by a set of methods.

◼ Classes are constructs that define objects of the same type. (Building plan of similar
objects). A class is a collection of fields (data) and methods (procedure or function) that
operate on that data.

Creating a Class

Classes contain two things:

Fields (attributes, data members, class variables):

• Data items that differentiate one object of the class from another. e.g.
employee name, student number

• Characteristics of an object that have values

Methods (behaviors):

• Named, self-contained blocks of code that typically operate on the fields

• Describe what an object can do

• Can be thought of as the verbs in a problem domain

Classes are defined in Java using the following format:

[Access Modifier] class <ClassName> {

type instance-variable1;

type instance-variable2;

// ...

142
 Chapter Three : Objects and Classes

type instance-variableN;

type methodname1(parameter-list) {

// body of method

type methodname2(parameter-list) {

// body of method

// ...

type methodnameN(parameter-list) {

// body of method

For example:

public class Student {

String name;
String IDNo;
int GPA;
void study(){}
}

Access modifiers define what classes can access this class. Valid access modifiers for class are:

• Public

• Abstract

• Final

If no access modifier is declared, it defaults to public

The naming convention for the name of a class (ClassName) states that classes should begin
with a capital letter.

• The data, or variables, defined within a class are called instance variables.

143
 Chapter Three : Objects and Classes

• The code is contained within methods.

• Collectively, the methods and variables defined within a class are called members of
the class.

• In most classes, the instance variables are acted upon and accessed by the methods
defined for that class.

• Thus, it is the methods that determine how a class’ data can be used.

Here is an example of a class called House:

public class House

{
}

Declaring a Variable of a Class Type

Variables and Data Type

Variables are defined in Java using the following format:

<access modifier> <type> <variable name>;

e.g. public String name;

private int count;

Valid access modifiers for fields(variables) are:

• Public: available to all methods and classes.

• Private: available only to methods in the class.

• Protected: available only to methods in the class, it’s children and other classes in the
same package.
A typical program uses various values and these values keep changing while the program is
running. For example, you create a program that is used to perform calculations; the values
entered by one user will obviously be different from the values entered by another user. This
also means that, when creating the program, you cannot know all possible values that will be
entered in your program. You should still be able to manage the values that the users will
eventually enter in your program

If you create a program used to perform calculations as introduced above, when a user enters a
new value that would be involved in the calculation, to manage that value, you can (temporarily)

144
 Chapter Three : Objects and Classes

store it in the computer memory. Since the values entered in a reserved memory area change
regularly, they are called variables. Because neither you nor the compiler can predict all
possible values that would be used, there are safeguards you can use. First, you must ask the
compiler to reserve an area of memory for a value you intend to use. Asking the compiler to
reserve an area of memory is referred to as Declaring a Variable. Remember that when you
declare a variable, the compiler reserves an area of the compiler memory for you. Eventually,
you can put the desired but appropriate values in that memory space.

After declaring a variable, when you need the value stored in its memory area, you can ask the
compiler to retrieve it and hand it to you. To effectively handle this transaction, the compiler
would need two pieces of information from you: a name of your choice for the memory area
that will be reserved, and the type of value that will be stored in that area of memory. Based
on this, the formula to declare a variable is:

TypeOfValue VariableName

All variables must have a data type. You can use primitive types such as int, float, boolean, etc.
Or you can use reference types, such as strings, arrays, or objects.

Like any normal variable, to use a class in your program, you can first declare a variable for it.
To declare a variable of a class, you can use its name followed by a name for the variable. For
example, to declare a variable of the above House class, you could type the following:

class House {

public class Main {

public static void main(String[] args) {

House property;

The variables we have declared so far are called value variables. This is because such variables
of primitive types hold their value. You can use another type of variable. This time, when you
declare the variable, its name does not hold the value of the variable; it holds a reference to the

145
 Chapter Three : Objects and Classes

address where the actual variable is stored in memory. This reference type is the kind used to
declare a variable for a class.

Variable Initialization

After declaring a variable, you can store a value in the memory reserved for it. When you have
just declared a variable, it may not hold a significant value. To know the value it has, you
should put an initial value into that memory space. Putting an initial value is referred to as
initializing the variable.

To initialize a variable, on the right side of its name, type the assignment operator, followed by
the value you want to put in the reserved memory. You cannot and should not put any type of
value in a variable.

To use a variable as reference, you must initialize it using an operator called new. Here is an
example:

class House {
}
public class Main {
public static void main(String[] args) {
House property = new House();
}
}

You can also first declare the variable. Then, on another line, you can allocate memory for it
using the new operator. Here is an example:

class House {
}
public class Main {
public static void main(String[] args) {
House property;
property = new House();
}
}

After declaring a variable and once it has a value, to display that value, you can provide the
name of the variable to the parentheses of the System.out.print() method.

146
 Chapter Three : Objects and Classes

Data Input/Output (IO)

Data Input

In Java to do anything, you have to go through a class. To retrieve a value, you have to go
through different classes. When you type a value in a program, to retrieve it, you can use in
object of the System package:

System.in

After getting that value, you must first store it somewhere. One of the classes you can use is
called Scanner. Before using the Scanner class, you must import the java.util.Scanner
package into your program. This would be done by writing the following in the top section of
the file:

import java.util.Scanner;

To use the Scanner class to retrieve a value, use the following formula:

Scanner VariableName = new Scanner(System.in);

The only thing we need to mention at this time is that, after the Scanner class, you must give
a variable name. An example would be:

Scanner scnr = new Scanner(System.in);

After declaring a Scanner class, its variable is ready to receive the value. The value depends
on a type. When getting a value, the Scanner class must be able to convert it to its appropriate
type. To support this, the Scanner class is equipped with a mechanism (actually called a
method) for each type of value. To retrieve a value, you will write the name of the Scanner
variable, followed by a period, followed by the mechanism as we will indicate, then assign it
to the variable whose value you want to retrieve. The formula will be:

VariableName = ScannerVariable.Mechanism();

Notice the parentheses and the semi-colon.

To retrieve the value a variable of type int, apply nextInt() to the Scanner variable. Here
is an example:

import java.util.Scanner;
public class Exercise {
public static void main(String[] args) {

147
 Chapter Three : Objects and Classes

Scanner scnr = new Scanner(System.in);

int days;
System.out.print("Enter number of days:
");
days = scnr.nextInt();
System.out.print("Days Passed: ");
System.out.println(days);
}
}

Here is an example of running the program:

Enter number of days: 42

Days Passed: 42

Bytes

A byte is series of 8 bits. It is used to represent small numbers. To declare a variable that would
hold a natural number between -128 and 127, you can use the byte data type.

To retrieve the value of a byte variable, apply nextByte() to the Scanner variable. Here is an
example:

import java.util.Scanner;
public class Exercise {
public static void main(String[] args) {
Scanner scnr = new Scanner(System.in);
byte temperature;
System.out.print("Enter the temperature:
");
temperature = scnr.nextByte();
System.out.print("Temperature: ");
System.out.println(temperature);
}
}

Here is an example of running the program:

Enter the temperature: 32

148
 Chapter Three : Objects and Classes

Temperature: 32

To initialize a byte variable, make sure you assign it a number in the appropriate range.
Here is an example:

public class Exercise {

public static void main(String[] args) {
byte temperature = -28;
System.out.print("Temperature: ");
System.out.println(temperature);
}
}

This would produce:

Temperature: -28

The value assigned to a byte variable must in the correct range; otherwise you would receive
an error. For example, if you assign a value lower than -128 or higher than 127 to a byte variable,
the program would not work.

Data Output

To display a value, you can write it in the parentheses of System.out.print(). If the value is a
character, include it between single-quotes. Here is an example:

public class Exercise {

public static void main(String[] args) {
System.out.print('Q');
}
}

This would produce:

If the value is a word or a sentence, include it between double-quotes. Here is an example:

public class Exercise {

public static void main(String[] args) {
System.out.print("James Harding");
}

149
 Chapter Three : Objects and Classes

This would produce:

James Harding

If the value is a (constant) number, simply type that number in the parentheses of
System.out.print() or System.out.println(). Here is an example:

public class Exercise {

public static void main(String[] args) {
System.out.print(248);
}
}

This would produce:

248

If the value is stored in a variable, you can write the name of that variable in the parentheses of
System.out.print().

Class' Member Variables

Consider a class named House:

public class House {

}

The section between the curly brackets, { and }, of a class is referred to as its body. In the body
of a class, you can create a list of the parts that make up the class. Each of these parts must be
a complete variable with a name and a data type. For example, here are the characteristics that
make up a house, declared as the parts of the above class and each declared as a variable:

public class House {

String propertyNumber;
char propertyType;
byte Stories;
int bedrooms;
double Value;
}

150
 Chapter Three : Objects and Classes

The variables declared in the body of a class are referred to as its member variables. In Java,
these member variables are called fields. The fields can be any data type. When creating a class,
it is your job to decide what your object is made of.

Initializing an Object

After declaring an instance of a class, you can access each of its members and assign it the
desired value. Here is an example:

public class House {

long propertyNumber;
String propertyType;
byte Stories;
public int Bedrooms;
double MarketValue;
}
public class Main {
public static void main(String[] args) {
House property = new House();
property.propertyNumber = 283795;
property.propertyType = "Single Family";
property.Bedrooms = 4;
property.MarketValue = 652880;
}
}

Once a member variable has been initialized, you can use the period operator to access it and
retrieve its value:

public class Main {

public static void main(String[] args) {
House property = new House();
property.propertyNumber = 283795;
property.propertyType = "Single Family";
property.Bedrooms = 4;
property.MarketValue = 652880;
System.out.println("=//= Altair Realty =//=");

151
 Chapter Three : Objects and Classes

System.out.println("Properties Inventory"); ;
System.out.println("Property #: " +
property.propertyNumber);
System.out.println("Property Type: " +
property.propertyType);
System.out.println("Bedrooms: " +
property.Bedrooms);
System.out.println("Market Value: " +
property.MarketValue);
}
}

This would produce:

=//= Altair Realty =//=

Properties Inventory

Property #: 283795

Property Type: Single Family

Bedrooms: 4

Market Value: 652880.0

The Methods of a Class

Methods are defined in Java using the following format:

<access modifier> <return type> <MethodName> (<parm list>) {}

Valid access modifiers for methods are:

• Public: available to all other methods and classes

• Private: available only to other methods in the class.

• Protected: available only to other methods in the class, it’s children, and other classes
in the same package.
Naming conventions for methods state that method name should begin with a lower case letter.
When you create a class, the fields are meant to describe it. For an example of a class named
House, such aspects as the number of bedrooms or its market value, are used to describe it.

152
 Chapter Three : Objects and Classes

Besides the characteristics used to describe it, an object can also perform actions or assignments.
An action performed by a class is called a method. A method is simply a section of code that
takes care of a particular detail for the functionality of the class. To create a method, you specify
its name, which follows the rules we defined for variables. The name of a method is followed
by parentheses.

A method's job is to carry a specific assignment within a program. As such, it could provide a
value once the assignment has been carried. In some cases, a method must produce a result. If
it doesn't, then it is considered void. The type of value that a method can provide (or return) is
written on the left side of the method name. If the method doesn't produce a result, type void
to its left. The assignment that a method carries is included between an opening curly bracket
"{" and a closing curly bracket "}". Here is an example:

public class House {

long propertyNumber;
String propertyType;
byte Stories;
public int Bedrooms;
double MarketValue;
void Display( ) {
}
}

The Main Method of an Application

The main method provides the control of program flow. The Java interpreter executes the
application by invoking the main method. The default implementation of the main() method is
of type void. Another way to implement the main() method is to make it return an integer. The
rule is the same as for any method of type int. The main() method can return any type of integer
as long as it is a valid integer.

The main method looks like this:

• public static void main(String[] args) {

//Statements;
}

153
 Chapter Three : Objects and Classes

• Public is an access specifier that declares the method unprotected and therefore making
it accessible to all other classes.

• Static is a keyword, which declares this method as one that belongs to the entire class
and not a part of any objects of the class.

• Void does not return anything.

• arr[]takes the values of command line arguments. Suppose we are giving a b c d

arr[0]=a, arr[1]=b, arr[2]=c, arr[3]=d.

For main, modifiers must be public static, return type must be void, and the parameter
represents an array of type String, String []. This parameter represents the command line
arguments when the program is executed. The most regularly used method of a Java program
is called main.

After creating a method, in its body delimited by its curly brackets, you can define the desired
behavior. For example, you can write the member variables in the parentheses of
System.out.print() or System.out.pr

intln(). Here are examples:

public class House {

long propertyNumber;
String propertyType;
byte Stories;
public int Bedrooms;
double MarketValue;
void Display() {
System.out.println("=//= Altair Realty =//=");
System.out.println("Properties Inventory");
System.out.println("Property Type: " +
propertyType);
System.out.println("Bedrooms: " +
Bedrooms);
}
}

In the same way, you can create as many methods as you want in a class.

154
 Chapter Three : Objects and Classes

Week Six : Practical

Activity 1: An OOP to find the area and perimeter of a rectangle by using

the dot operator for initialization
class Rectangle{
//instance variables
double height,width;
//method of rectangle class
public void Area()
{
System.out.println("Area of the rectangle is:
"+height*width);
}
public void Perimeter()
{
System.out.println("Perimeter of the rectangle is:
"+2*height+2*width);
}
}//end of Rectangle class
public class Chapter4Examples {
public static void main(String[] args) {
//object instantiating
Rectangle ob=new Rectangle();
//instance varibale initialization
ob.height=15.5;
ob.width=16.5;
//method calling of Rectangle class
ob.Area();
ob.Perimeter();

}//end of main
}//end of class that contains main

155
 Chapter Three : Objects and Classes

Activity 2: An OOP to find the area and perimeter of a rectangle by using

the help of methods for initializing.
class Rectangle{
//instance variables
double height,width;
//method of rectangle class
public void Area()
{
System.out.println("Area of the rectangle is:
"+height*width);
}
public void Perimeter()
{
System.out.println("Perimeter of the rectangle
is:"+2*height+2*width);
}
// Help method for initialization of instance variable
public void Initialize(double h,double w)
{
height=h;
width=w;
}
}//end of class Rectangle
public class USINGMETHOD {
public static void main(String[] args) {
Rectangle ob=new Rectangle();
//instance variable initialization using a help
method
ob.Initialize(15.5,16.5);
//method calling of Rectangle class
ob.Area();
ob.Perimeter();
}
}//end of class of USINGMETHOD

156
 Chapter Three : Objects and Classes

Week Six: Assessments

I. Subjective

1. What is the difference between a class and an object?

2. How is a class defined?

3. What does each object have its own copy of?

4. Using two separate statements, show how to declare an object called counter of a
class

called MyCounter.

5. Show how a method called myMeth( ) is declared if it has a return type of double
and has two int parameters called a and b.

157
 Chapter Three : Objects and Classes

Week Seven: Session

3.2. Instance Fields Constructors and Methods

3.2.1. The Static Members of a Class
Static Fields

Imagine you create a class. To access it in the main() method, you can declare its variable. A
variable you have declared of a class is also called an instance of the class. In the same way,
you can declare various instances of the same class as necessary:

class Book {
String Title;
String Author;
short YearPublished;
int NumberOfPages;
char CoverType;
}
public class Main {
public static void main(String[] args) {
Book written = new Book();
Book bought = new Book();
}
}

Each one of these instances gives you access to the members of the class but each instance
holds the particular values of the members of its instance. Consider the results of the following
program:

class Book {
String Title;
String Author;
short YearPublished;
int NumberOfPages;
char CoverType;
}

158
 Chapter Three : Objects and Classes

public class Main {

public static void main(String[] args) {
Book First = new Book();
First.Title = "Psychology and Human Evolution";
First.Author = "Jeannot Lamm";
First.YearPublished = 1996;
First.NumberOfPages = 872;
First.CoverType = 'H';
System.out.println("Book Characteristics");
System.out.println("Title: " + First.Title);
System.out.println("Author: " + First.Author);
System.out.println("Year: " +
First.YearPublished);
System.out.println("Pages: " +
First.NumberOfPages);
System.out.println("Cover: " +
First.CoverType);
Book Second = new Book();
Second.Title = "Java First Step";
Second.Author = "Alexandra Nyango";
Second.YearPublished = 2004;
Second.NumberOfPages = 604;
Second.CoverType = 'P';
System.out.println("Book Characteristics");
System.out.println("Title: " + Second.Title);
System.out.println("Author: " + Second.Author);
System.out.println("Year: " +
Second.YearPublished);
System.out.println("Pages: " +
Second.NumberOfPages);
System.out.println("Cover: " +
Second.CoverType);
}
}

159
 Chapter Three : Objects and Classes

This would produce:

Book Characteristics

Title: Psychology and Human Evolution

Author: Jeannot Lamm

Year: 1996

Pages: 872

Cover: H

Book Characteristics

Title: Java First Step

Author: Alexandra Nyango

Year: 2004

Pages: 604

Cover: P

All of the member variables and methods of classes we have used so far are referred to as
instance members because, in order to access them, you must have an instance of a class
declared in another class in which you want to access them.

In your application, you can declare a class member and refer to it regardless of which instance
of an object you are using. Such a member variable is called static. To declare a member
variable of a class as static, type the static keyword on its left. Whenever you have a static
member, in order to refer to it, you must "qualify" it in the class in which you want to call it.
Qualifying a member means you must specify its class. Here is an example:

class Book {
static String Title;
static String Author;
int yearPublished;
int Pages;
char CoverType;
}
public class Main {

160
 Chapter Three : Objects and Classes

public static void main(String[] args) {

Book First = new Book();
Book.Title = "Psychology and Human Evolution";
Book.Author = "Jeannot Lamm";
First.YearPublished = 1996;
First.Pages = 872;
First.CoverType = 'H';
System.out.println("Book Characteristics");
System.out.println("Title: " + Book.Title);
System.out.println("Author: " + Book.Author);
System.out.println("Year: " +
First.YearPublished);
System.out.println("Pages: " + First.Pages);
System.out.println("Cover: " +
First.CoverType);
Book Second = new Book();
Book.Title = "Java First Step";
Book.Author = "Alexandra Nyango";
Second.YearPublished = 2004;
Second.Pages = 604;
Second.CoverType = 'P';
System.out.println("Book Characteristics");
System.out.println("Title: " + Book.Title);
System.out.println("Author: " + Book.Author);
System.out.println("Year: " +
Second.YearPublished);
System.out.println("Pages: " + Second.Pages);
System.out.println("Cover: " +
Second.CoverType);
}
}

Notice that when a member variable has been declared as static, you don't need an instance of
the class to access that member variable outside of the class. Based on this, if you declare all
members of a class as static, you don't need to declare a variable of their class in order to access
161
 Chapter Three : Objects and Classes

them. In the following example, the Title and Author fields of the Book class are accessed from
the Exercise class without using an instance of the Book class:

class Book {
public static String Title;
public static String Author;
}
public class Main {
public static void main(String[] args) {
Book.Title = "Psychology and Human Evolution";
Book.Author = "Jeannot Lamm";
System.out.println("Book Characteristics");
System.out.println("Title: " + Book.Title);
System.out.println("Author: " + Book.Author);
Book.Title = "Java First Step";
Book.Author = "Alexandra Miles";
System.out.println("Book Characteristics");
System.out.println("Title: " + Book.Title);
System.out.println("Author: " + Book.Author);
}
}

Static Methods

Like a member variable, a method of a class can be defined as static. Consequently, this
particular method can access any member of the class regardless of the instance if there are
many instances of the class declared.

To define a method as static, type the static keyword to its left. Here is an example:

class Book {
static String Title;
static String Author;
static int Pages;
static double Price;
static void CreateBook() {
Title = "Psychology and Human Evolution";

162
 Chapter Three : Objects and Classes

Author = "Jeannot Lamm";

Pages = 472;
Price = 24.95;
}
static void ShowBook() {
System.out.println("Book Characteristics");
System.out.println("Title: " +
Book.Title);
System.out.println("Author: " +
Book.Author);
System.out.println("Pages: " + Pages);
System.out.printf("Price: " + Price);
}
}
public class Main {
public static void main(String[] args) {
Book.CreateBook();
Book.ShowBook();
}
}

This would produce:

Book Characteristics

Title: Psychology and Human Evolution

Author: Jeannot Lamm

Pages: 472

Price: 24.95

3.2.2. Methods in Java

In general, a method is a way to perform some task. Similarly, the method in Java is a collection
of instructions that performs a specific task. It provides the reusability of code. We can also
easily modify code using methods. In this section, we will learn what is a method in Java, types
of methods, method declaration, and how to call a method in Java.

163
 Chapter Three : Objects and Classes

A method is a block of code which only runs when it is called. You can pass data, known as
parameters, into a method. Methods are used to perform certain actions, and they are also
known as functions.

A method is a block of code or collection of statements or a set of code grouped together to

perform a certain task or operation. It is used to achieve the reusability of code. We write a
method once and use it many times. We do not require to write code again and again. It also
provides the easy modification and readability of code, just by adding or removing a chunk of
code. The method is executed only when we call or invoke it.

Method Declaration

The method declaration provides information about method attributes, such as visibility, return-
type, name, and arguments. It has six components that are known as method header, as we have
shown in the following figure.

Figure 10: Method Declaration

Method Signature: Every method has a method signature. It is a part of the method declaration.
It includes the method name and parameter list.

Access Specifier: Access specifier or modifier is the access type of the method. It specifies the
visibility of the method. Java provides four types of access specifier:

Public: The method is accessible by all classes when we use public specifier in our application.

Private: When we use a private access specifier, the method is accessible only in the classes
in which it is defined.

164
 Chapter Three : Objects and Classes

Protected: When we use protected access specifier, the method is accessible within the same
package or subclasses in a different package.

Default: When we do not use any access specifier in the method declaration, Java uses default
access specifier by default. It is visible only from the same package only.

Return Type: Return type is a data type that the method returns. It may have a primitive data
type, object, collection, void, etc. If the method does not return anything, we use void keyword.

Method Name: It is a unique name that is used to define the name of a method. It must be
corresponding to the functionality of the method. Suppose, if we are creating a method for
subtraction of two numbers, the method name must be subtraction(). A method is invoked by
its name.

Parameter List: It is the list of parameters separated by a comma and enclosed in the pair of
parentheses. It contains the data type and variable name. If the method has no parameter, left
the parentheses blank.

Method Body: It is a part of the method declaration. It contains all the actions to be performed.
It is enclosed within the pair of curly braces.

Naming a Method

While defining a method, remember that the method name must be a verb and start with a
lowercase letter. If the method name has more than two words, the first name must be a verb
followed by adjective or noun. In the multi-word method name, the first letter of each word
must be in uppercase except the first word.

Accessing a Method

After creating a method, you can access it outside of its class. You do this following the same
rules used to access a member variable, using the period operator. Unlike a member variable,
the name of a class must be followed by parentheses. Here is an example:

public class Main {

public static void main(String[] args) {
House property = new House();
property.propertyNumber = 283795;
property.propertyType = "Single Family";
property.Bedrooms = 4;
property.MarketValue = 652880;
165
 Chapter Three : Objects and Classes

property.Display();
}
}

3.2.3. Constructors in Java

In Java, a constructor is a block of codes similar to the method. It is called when an instance of
the class is created. At the time of calling constructor, memory for the object is allocated in the
memory. It is a special type of method which is used to initialize the object.

Every time an object is created using the new() keyword, at least one constructor is called. It
calls a default constructor if there is no constructor available in the class. In such case, Java
compiler provides a default constructor by default.

There are two types of constructors in Java:

• no-arg constructor, and

• parameterized constructor.

Note: It is called constructor because it constructs the values at the time of object creation. It
is not necessary to write a constructor for a class. It is because java compiler creates a default
constructor if your class doesn't have any.

Rules for creating Java constructor

There are two rules defined for the constructor.

• Constructor name must be the same as its class name

• A Constructor must have no explicit return type

• A Java constructor cannot be abstract, static, final, and synchronized

Note: We can use access modifiers while declaring a constructor. It controls the object creation.
In other words, we can have private, protected, public or default constructor in Java.

Types of Java constructors

There are two types of constructors in Java:

• Default constructor (no-arg constructor)

• Parameterized constructor

166
 Chapter Three : Objects and Classes

Figure 11: Types of constructors in Java

A constructor is called "Default Constructor" when it doesn't have any parameter.

Syntax of default constructor:

<class_name>(){}

Example of default constructor

In this example, we are creating the no-arg constructor in the Bike class. It will be invoked at
the time of object creation.

//Java Program to create and call a default constructor

class Bike1{
//creating a default constructor
Bike1(){System.out.println("Bike is created");}
//main method
public static void main(String args[]){
//calling a default constructor
Bike1 b=new Bike1();
}
}

167
 Chapter Three : Objects and Classes

Figure 12: Example of default constructor

Java Parameterized Constructor

A constructor which has a specific number of parameters is called a parameterized

constructor.

Why use the parameterized constructor?

The parameterized constructor is used to provide different values to distinct objects. However,
you can provide the same values also.

Example of parameterized constructor

In this example, we have created the constructor of Student class that have two parameters. We
can have any number of parameters in the constructor.

//Java Program to demonstrate the use of the

parameterized constructor.
class Student4{
int id;
String name;
//creating a parameterized constructor
Student4(int i,String n){
id = i;
name = n;
}
//method to display the values
void display(){System.out.println(id+" "+name);}

168
 Chapter Three : Objects and Classes

public static void main(String args[]){

//creating objects and passing values
Student4 s1 = new Student4(111,"Karan");
Student4 s2 = new Student4(222,"Aryan");
//calling method to display the values of object
s1.display();
s2.display();
}
}

169
 Chapter Three : Objects and Classes

Week Seven: Practical

Activity on Constructors
It can be tedious to initialize all of the variables in a class each time an instance is created. Even
when you add convenience functions like setDim( )…

It is possible to initialize objects they are created by:

• Using the dot operator

• The help of methods

• But it would be simpler and more concise to initialize an object when it is first created.

Java supports a special type of method, called a constructor, that enables an object to initialize
itself when it is created. Constructors are special methods that are used to construct an instance
of a class.

A constructor initializes an object immediately upon creation. But object creation only doesn’t
call constructor rather it will be called when the object is instantiated.

Call the constructor(s) preceding it with the new keyword.

Rules with Constructors

Class name and constructor name should be the same. That is, it has the same name as the class
in which it resides and is syntactically similar to a method. Constructors have no return type
(not even void), this is because they return the instance of the class itself.

• Constructors should be public.

• Constructors can not be inherited.

• They can be overloaded. Many constructors with the same name can be defined.

Types of Constructors

• Default constructor: is the type of constructor with out any argument.

• Parameterized Constructor: is a constructor with one or more argument.

When an instance of an object is created then the instance will call the constructor.

170
 Chapter Three : Objects and Classes

It will be the default constructor which will be called, if there are no any parameterized
constructor. But if there is any parameterized constructor, then it will be the parameterized
constructor with the specified parameter(s) which will be called.

Default Constructor

When you do not write a constructor in a class, it implicitly has a constructor with no arguments
and an empty body. But we can also have a default constructor with no parameter(s) as follows:

class A
{
// Variable declaration and initialization
// Method definition
System.out.println(“Welcome”);}
class A{
public A(){
System.out.println(“Welcome”);
}}

Parameterized Constructors

class employee
{
private String Ename, empno;
private float salary;

employee(String eno, String name, float sal)

{
empno = eno;
Ename= name;
salary = sal;
}

public void print()

{
System.out.prinln(empno+”\t”+Ename+”\t”+sal);

171
 Chapter Three : Objects and Classes

}
}
public class demoEmp
{
public static void main(String args[])
{
employee emp = new employee(“Au196/03”,
“Jhon Micheal”, 2563.54);
}
}

Example:

class Box {
double width;
double height;
double depth;
// This is the constructor for Box.
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// compute and return volume
double volume() {
return width * height * depth;
}
} class BoxDemo7 {
public static void main(String args[]) {
// declare, allocate, and initialize Box objects
Box mybox1 = new Box(10, 20, 15);
Box mybox2 = new Box(3, 6, 9);
double vol;
// get volume of first box

172
 Chapter Three : Objects and Classes

vol = mybox1.volume();
System.out.println("Volume is " + vol);
// get volume of second box
vol = mybox2.volume();
System.out.println("Volume is " + vol);
}
}

Using Objects as Parameters

It is both correct and common to pass objects to methods.

Example :

class Test {
int a, b;
Test(int i, int j) {
a = i;
b = j;
}
// return true if o is equal to the invoking object
boolean equals(Test o) {
if(o.a == a && o.b == b) return true;
else return false;
}
}
class PassOb {
public static void main(String args[]) {
Test ob1 = new Test(100, 22);
Test ob2 = new Test(100, 22);
Test ob3 = new Test(-1, -1);
System.out.println("ob1 == ob2: " + ob1.equals(ob2));
System.out.println("ob1 == ob3: " + ob1.equals(ob3));
}
}

173
 Chapter Three : Objects and Classes

Activity: An OOP to find the area and perimeter of a rectangle by using constructor

class Rectangle{
//instance variables of Rectangle class
double height,width;
//Parametrized constructor
public Rectangle(double h,double w)
{
height=h;
width=w;
}
//methods of Rectangle class
public void Area()
{ System.out.println("Area of the rectangle is:
"+height*width);}
public void Perimeter()
{
System.out.println("Perimeter of the rectangle is:
"+2*height+2*width);
}
}//end of Rectangle class
public class UsingConstructor {
public static void main(String[] args) {
//object instantiating
Rectangle ob=new Rectangle(15.5,16.5);
ob.Area();
ob.Perimeter();
}//end of main
}//end of class UsingConstructor

174
 Chapter Three : Objects and Classes

Week Seven: Assessments

I. Subjective

1. How must a method return if it returns a value?

2. What name does a constructor have?
3. What is garbage collection, and how does it work? What is finalize( )?
4. Can a constructor have one or more parameters?
5. If a method returns no value, what must its return type be?

175
 Chapter Three : Objects and Classes

Reference
1. Java: A Beginner's Guide, Eighth Edition by Herbert Schildt
2. Java: How to Program, 9th Edition (Deitel)
3. https://www.javatpoint.com/

176
 Chapter Three : Objects and Classes

177
 Chapter Four: Object Oriented Programming Concepts

Chapter Four: Object Oriented Programming

Concepts

Lesson Plan
1. Learning objectives

• Be able to Basic Concepts of Object Oriented Programming.

• Be able to know principles Encapsulation

• Be able to use of the concept of inheritance

• Be able to use of the concept of Polymorphism

2. Motivation

• Outputs through Question and Answer; repetitive discussion of java programming

basics; individual internet search.

• Solving a problem using Object Oriented programming.

• Controlling the flow control of instruction execution.

3. Expectations or Outcomes

 Define the terminologies, differentiate different programming paradigms, explain

Object Oriented programming principles; the assessment standard attached at the end
of the job task sheet.
 Can write Object Oriented instructions using Java to solve any problem using
programming.
4. Equipment

• Desktop or Laptop computer.

• Java IDE (NetBeans) software

5. Practice contents/Activities/Safety

 Brief introduction of Java complete development life cycle (Java IDE).

 Active practice; on java input and output, writing (Editing), compiling, interprating.

6. Assessments

178
 Chapter Four: Object Oriented Programming Concepts

• How can you install Java IDE (Netbeans) software?

• How to create class and objects?
7. Clean-up

 After finishing practice, computers should be properly shut down.

8. Independent practice/Follow-up activities

• Learning through assignment (practical exercises)

9. Review/Reflection

• Review the outcome of the practice, improvement measure and previous reflected
opinions.

179
 Chapter Four: Object Oriented Programming Concepts

Week Nine: Session

4.1. Inheritance
Inheritance is the process by which one object can acquire the properties of another object. This
is important because it supports the concept of hierarchical classification. If you think about it,
most knowledge is made manageable by hierarchical (i.e., top-down) classifications. For
example, a Red Delicious apple is part of the classification apple, which in turn is part of the
fruit class, which is under the larger class/food. That is, the food class possesses certain
qualities (edible, nutritious, etc.) which also, logically, apply to its subclass, fruit. In addition
to these qualities, the fruit class has specific characteristics (juicy, sweet, etc.) that distinguish
it from other food. The apple class defines those qualities specific to an apple (grows on trees,
not tropical, etc.). A Red Delicious apple would, in turn, inherit all the qualities of all preceding
classes, and would define only those qualities that make it unique.

Without the use of hierarchies, each object would have to explicitly define all of its
characteristics. Using inheritance, an object need only define those qualities that make it unique
within its class. It can inherit its general attributes from its parent. Thus, it is the inheritance
mechanism that makes it possible for one object to be a specific instance of a more general
case. There are various types of inheritance as demonstrated below.

180
 Chapter Four: Object Oriented Programming Concepts

Figure 13: Types of inheritance

• Single Inherintence: Derivation a subclass from only one super class is called Single
Inherintence.

• Hierarchical Inherintence: Derivation of several classes from a single super class is

called Hierarchical Inherintence:

• Multilevel Inheritance: Derivation of a classes from another derived classes called

Multilevel Inheritance.

• Multiple Inheritance: Derivation of one class from two or more super classes is called
Multiple Inheritance. But java does not support Multiple Inheritance directly. It can be
implemented by using interface concept.

• Hybrid Inheritance: Derivation of a class involving more than one from on

Inheritance is called Hydrid Inheritance
Defining a Subclass:

A subclass is defined as

Systax: class subclass-name extends superclass-name

{
Variable declaration;
Method declaration;
}

181
 Chapter Four: Object Oriented Programming Concepts

A very important fact to remember is that Java does not support multiple inheritance. This
means that a class cannot extend more than one class. Therefore following is illegal –

Member access and inheritance

Often an instance variable of a class will be declared private to prevent its unauthorized use or
tampering. Inheriting a class does not overrule the private access restriction. Thus, even though
a subclass includes all of the members of its superclass, it cannot access those members of the
superclass that have been declared private.

Constructors and inheritance

In a hierarchy, it is possible for both superclasses and subclasses to have their own constructors.
This raises an important question: What constructor is responsible for building an object of the
subclass—the one in the superclass, the one in the subclass, or both? The answer is this: The
constructor for the superclass constructs the superclass portion of the object, and the
constructor for the subclass constructs the subclass part. This makes sense because the
superclass has no knowledge of or access to any element in a subclass. Thus, their construction
must be separate. The preceding examples have relied upon the default constructors created
automatically by Java, so this was not an issue. However, in practice, most classes will have
explicit constructors. Here you will see how to handle this situation.

The class which inherits the properties of other is known as subclass derivedclass, childclass
and the class whose properties are inherited is known as superclass baseclass, parentclass.

extends Keyword

extends is the keyword used to inherit the properties of a class. Below given is the syntax of
extends keyword.

class Super
{
.....
.....
}
class Sub extends Super
{
.....
.....

182
 Chapter Four: Object Oriented Programming Concepts

Sample Code

Below given is an example demonstrating Java inheritance. In this example you can observe
two classes namely Calculation and My_Calculation. Using extends keyword the
My_Calculation inherits the methods addition and Subtraction of Calculation class.

class Calculation
{
int z;
public void addition(int x, int y)
{
z=x+y;
System.out.println("The sum of the given num bers:"+z);
}
public void Substraction(int x,int y)
{
z=x-y;
System .out.println("The difference between the given
num bers:"+z);
}
}
public class My_Calculation extends Calculation
{
public void m ultiplication(int x, int y)
{
z=x* y;
System .out.println("The product of the given num
bers:"+z);
}
public static void m ain(String args[])
{
int a=20, b=10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);

183
 Chapter Four: Object Oriented Programming Concepts

demo.Substraction(a, b);
demo.m ultiplication(a, b);
}
}

Compile and execute the above code as shown below

After executing the program it will produce the following result.

The sum of the given num bers:30

The difference between the given num bers:10

The product of the given num bers:200

In the given program when an object to My_Calculation class is created, a copy of the contents
of the super class is made with in it. That is why, using the object of the subclass you can access
the members of a super class.

The Superclass reference variable can hold the subclass object, but using that variable you can
access only the members of the superclass, so to access the members of both classes it is
recommended to always create reference variable to the subclass.

If you consider the above program you can instantiate the class as given below as well. But
using the superclass reference variable ( cal in this case ) you cannot call the method
multiplication, which belongs to the subclass My_Calculation.

Calculation cal=new My_Calculation();

demo.addition(a, b);
demo.Subtraction(a, b);

Note: A subclass inherits all the members fields, methods, andnestedclasses from its
superclass. Constructors are not members, so they are not inherited by subclasses, but the
constructor of the superclass can be invoked from the subclass.

The super keyword

The super keyword is similar to this keyword following are the scenarios where the super
keyword is used. It is used to differentiate the members of superclass from the members of
subclass, if they have same names. It is used to invoke the superclass constructor from subclass.

Differentiating the members

184
 Chapter Four: Object Oriented Programming Concepts

If a class is inheriting the properties of another class. And if the members of the superclass
have the names same as the sub class, to differentiate these variables we use super keyword as
shown below.

super.variable
super.method();

Sample Code

This section provides you a program that demonstrates the usage of the super keyword.

In the given program you have two classes namely Sub_class and Super_class, both have a
method named display with different implementations, and a variable named num with
different values. We are invoking display method of both classes and printlng the value of the
variable num of both classes, here you can observe that we have used super key word to
differentiate the members of super class from sub class.

class Super_class
{
int num =20; //display method of superclass
public void display()
{
System .out.println("This is the display method of
superclass");
}
}
public class Sub_class extends Super_class
{
int num =10; //display method of sub class
public void display()
{
System .out.println("This is the display method of
subclass");
}
public void my_method()
{
//Instantiating subclass

185
 Chapter Four: Object Oriented Programming Concepts

Sub_class sub=new Sub_class(); //Invoking the display()

method of sub class
sub.display(); //Invoking the display() method of
superclass
super.display(); //printlng the value of variable num
of subclass
System .out.println("value of the variable nam ed num
in sub class:"+ sub.num );
//printlng the value of variable num of superclass
System .out.println("value of the variable nam ed num
in super class:"+ super.num );
}
public static void m ain(String args[])
{
Sub_class obj = new Sub_class();
obj.my_method();
}
}

Compile and execute the above code using the following syntax.

javac Super_Demo

java Super

On executing the program you will get the following result:

This is the display method of subclass

This is the display method of superclass

value of the variable nam ed num in sub class:10

value of the variable nam ed num in super class:20

Invoking Superclass constructor

If a class is inheriting the properties of another class, the subclass automatically acquires the

default constructor of the super class. But if you want to call a parametrized constructor of the

super class, you need to use the super keyword as shown below.

186
 Chapter Four: Object Oriented Programming Concepts

super(values);

Sample Code

The program given in this section demonstrates how to use the super keyword to invoke the

parametrized constructor of the superclass. This program contains a super class and a sub class,

where the super class contains a parametrized constructor which accepts a string value, and we

used the super keyword to invoke the parametrized constructor of the super class.

Copy and paste the below given program in a file with name Subclass.java

class Superclass
{
int age;
Superclass(int age)
{
this.age=age;
}
public void getAge()
{
System .out.println("The value of the variable nam ed
age in super class is: " +age);
}
}
public class Subclass extends Superclass
{
Subclass(int age)
{
super(age);
}
public static void m ain(String argd[])
{
Subclass s= new Subclass(24);
s.getAge();
}
}

187
 Chapter Four: Object Oriented Programming Concepts

Compile and execute the above code using the following syntax.

javac Subclass

java Subclass

On executing the program you will get the following result:

The value of the variable nam ed age in super class is: 24

4.2. Encapsulation
Encapsulation is a programming mechanism that binds together code and the data it
manipulates, and that keeps both safe from outside interference and misuse. In an object-
oriented language, code and data can be bound together in such a way that a self-contained
black box is created. Within the box are all necessary data and code. When code and data are
linked together in this fashion, an object is created. In other words, an object is the device that
supports encapsulation.

Within an object, code, data, or both may be private to that object or public. Private code or
data is known to and accessible by only another part of the object. That is, private code or data
cannot be accessed by a piece of the program that exists outside the object. When code or data
is public, other parts of your program can access it even though it is defined within an object.
Typically, the public parts of an object are used to provide a controlled interface to the private
elements of the object. Java’s basic unit of encapsulation is the class.

Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance,
polymorphism, and abstraction.

Encapsulation in Java is a mechanism of wrapping the data variables and code acting on the
data methods together as as single unit. In encapsulation the variables of a class will be hidden
from other classes, and can be accessed only through the methods of their current class,
therefore it is also known as data hiding.

To achieve encapsulation in Java

• Declare the variables of a class as private.

• Provide public setter and getter methods to modify and view the variables values.

Example:

188
 Chapter Four: Object Oriented Programming Concepts

Below given is an example that demonstrates how to achieve Encapsulation in Java:

/* File name : EncapTest.java */

public class EncapTest
{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName()
{
return name;
}
public String getIdNum()
{
return idNum;
}
public void setAge( int newAge)
{
age = newAge;
}
public void setName(String newName)
{
name = newName;
}
public void setIdNum( String newId)
{
idNum = newId;
}
}

189
 Chapter Four: Object Oriented Programming Concepts

The public setXXX and getXXX methods are the access points of the instance variables of the
EncapTest class. Normally, these methods are referred as getters and setters. Therefore any
class that wants to access the variables should access them through these getters and setters.

The variables of the EncapTest class can be accessed as below::

/* File name : RunEncap.java */

public class RunEncap
{
public static void main(String args[]){
EncapTest encap = new EncapTest();
encap.setName("James");
encap.setAge(20);
encap.setIdNum("12343ms");
System.out.print("Name : " + encap.getName() + " Age :
" + encap.getAge());
}
}

This would produce the following result:

Name : James Age : 20

Benefits of Encapsulation:

• The fields of a class can be made read-only or write-only.

• A class can have total control over what is stored in its fields.

• The users of a class do not know how the class stores its data. A class can change the
data type of a field and users of the class do not need to change any of their code.

190
Chapter Four: Object Oriented Programming Concepts

191
 Chapter Four: Object Oriented Programming Concepts

Week Nine: Practical

Multilevel Inheritance Example

When there is a chain of inheritance, it is known as multilevel inheritance. As you can see in
the example given below, BabyDog class inherits the Dog class which again inherits the
Animal class, so there is a multilevel inheritance. (File: TestInheritance2.java)

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class BabyDog extends Dog{
void weep(){System.out.println("weeping...");}
}
class TestInheritance2{
public static void main(String args[]){
BabyDog d=new BabyDog();
d.weep();
d.bark();
d.eat();
}}

Output:

weeping...

barking...

eating...

192
 Chapter Four: Object Oriented Programming Concepts

Week Nine : Assesment

Part I: Multiple choice Questions

1. Which among the following best describes the Inheritance?

a) Using the data and functions into derived segment
b) Using already defined functions in a programming language
c) Using the code already written once
d) Copying the code already written

2. Single level inheritance supports _____________ inheritance.

a) Language independency c) Compile time

b) Multiple inheritance d) Runtime

3. Encapsulation and abstraction differ as ____________

a) Hiding and hiding respectively
b) Binding and Hiding respectively
c) Hiding and Binding respectively
d) Can be used any way

4. If data members are private, what can we do to access them from the class object?
a) Private data members can never be accessed from outside the class
b) Create public member functions to access those data members
c) Create private member functions to access those data members
d) Create protected member functions to access those data members
5. If in multiple inheritance, class C inherits class B, and Class B inherits class A. In
which sequence are their destructors called if an object of class C was declared?
a) ~A() then ~B() then ~C()
b) ~C() then ~A() then ~B()
c) ~C() then ~B() then ~A()
d) ~B() then ~C() then ~A()

6. Which feature can be implemented using encapsulation?

a) Polymorphism c) Inheritance
b) Overloading d) Abstraction

193
 Chapter Four: Object Oriented Programming Concepts

Part II: Practical assessment

1. Write a Java program to create a class called BankAccount with private instance variables
accountNumber and balance. Provide public getter and setter methods to access and modify
these variables.

2. Write a Java program to create a class called Employee with private instance variables
employee_id, employee_name, and employee_salary. Provide public getter and setter
methods to access and modify the id and name variables, but provide a getter method for
the salary variable that returns a formatted string.

194
 Chapter Four: Object Oriented Programming Concepts

Week Ten: Session

4.3. Polymorphism
4.3.1. Method overloading and overriding
Polymorphism (from Greek, meaning “many forms”) is the quality that allows one interface to
access a general class of actions. The specific action is determined by the exact nature of the
situation. A simple example of polymorphism is found in the steering wheel of an automobile.
The steering wheel (i.e., the interface) is the same no matter what type of actual steering
mechanism is used. That is, the steering wheel works the same whether your car has manual
steering, power steering, or rack-and- pinion steering. Therefore, once you know how to
operate the steering wheel, you can drive any type of car.

The same principle can also apply to programming. For example, consider a stack (which is a
first-in, last-out list). You might have a program that requires three different types of stacks.
One stack is used for integer values, one for floating-point values, and one for characters. In
this case, the algorithm that implements each stack is the same, even though the data being
stored differs. In a non-object-oriented language, you would be required to create three
different sets of stack routines, with each set using different names. However, because of
polymorphism, in Java you can create one general set of stack routines that works for all three
specific situations. This way, once you know how to use one stack, you can use them all.

More generally, the concept of polymorphism is often expressed by the phrase “one interface,
multiple methods.” This means that it is possible to design a generic interface to a group of
related activities. Polymorphism helps reduce complexity by allowing the same interface to be
used to specify a general class of action. It is the compiler’s job to select the specific action
(i.e., method) as it applies to each situation. You, the programmer, don’t need to do this
selection manually. You need only remember and utilize the general interface. Plays an
important role in allowing objects having different internal structures to share the same external
interface.

4.3.2. Types of polymorphism:

a) Overloading methods
b) Overriding methods, and
c) Dynamic method binding

195
 Chapter Four: Object Oriented Programming Concepts

a) Method Overloading in Java

If a class has multiple methods having same name but different in parameters, it is known as
Method Overloading. If we have to perform only one operation, having same name of the
methods increases the readability of the program.

Suppose you have to perform addition of the given numbers but there can be any number of
arguments, if you write the method such as a(int,int) for two parameters, and b(int,int,int) for
three parameters then it may be difficult for you as well as other programmers to understand
the behavior of the method because its name differs. So, we perform method overloading to
figure out the program quickly.

Advantage of method overloading

• Method overloading increases the readability of the program.

• Different ways to overload the method

There are two ways to overload the method in java

• By changing number of arguments

• By changing the data type

In java, Method Overloading is not possible by changing the return type of the method only.

1) Method Overloading: changing no. of arguments

In this example, we have created two methods, first add() method performs addition of two
numbers and second add method performs addition of three numbers.

In this example, we are creating static methods so that we don't need to create instance for
calling methods.

class Adder{
static int add(int a,int b){return a+b;}
static int add(int a,int b,int c){return a+b+c;}
}
class TestOverloading1{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}

196
 Chapter Four: Object Oriented Programming Concepts

Output:

22

33

2) Method Overloading: changing data type of arguments

In this example, we have created two methods that differs in data type. The first add method
receives two integer arguments and second add method receives two double arguments.

class Adder{
static int add(int a, int b){return a+b;}
static double add(double a, double b){return a+b;}
}
class TestOverloading2{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}

Output:

22

24.9

Q) Why Method Overloading is not possible by changing the return type of method only?

In java, method overloading is not possible by changing the return type of the method only
because of ambiguity. Let's see how ambiguity may occur:

class Adder{
static int add(int a,int b){return a+b;}
static double add(int a,int b){return a+b;}
}
class TestOverloading3{
public static void main(String[] args){
System.out.println(Adder.add(11,11));//ambiguity
}}
197
 Chapter Four: Object Oriented Programming Concepts

Output:

Compile Time Error: method add(int,int) is already defined in class Adder

System.out.println(Adder.add(11,11)); //Here, how can java determine which sum() method

should be called?

Note: Compile Time Error is better than Run Time Error. So, java compiler renders compiler
time error if you declare the same method having same parameters.

Can we overload java main() method?

Yes, by method overloading. You can have any number of main methods in a class by method
overloading. But JVM calls main() method which receives string array as arguments only. Let's
see the simple example:

class TestOverloading4{
public static void main(String[]
args){System.out.println("main with String[]");}
public static void main(String
args){System.out.println("main with String");}
public static void main(){System.out.println("main
without args");}
}

Output:

main with String[]

Method Overloading and Type Promotion

One type is promoted to another implicitly if no matching datatype is found. Let's understand
the concept by the figure given below:

As displayed in the diagram below, byte can be promoted to short, int, long, float or double.
The short datatype can be promoted to int,long,float or double. The char datatype can be
promoted to int,long,float or double and so on.

198
 Chapter Four: Object Oriented Programming Concepts

Figure 14: Example of Method Overloading with TypePromotion

class OverloadingCalculation1{
void sum(int a,long 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 long
obj.sum(20,20,20);
}
}

199
 Chapter Four: Object Oriented Programming Concepts

Output:

40

60

Example of Method Overloading with Type Promotion if matching found

If there are matching type arguments in the method, type promotion is not performed.

class OverloadingCalculation2
{
void sum(int a,int b)
{System.out.println("int arg method
invoked");}
void sum(long a,long b)
{System.out.println("long arg method
invoked");}
public static void main(String args[])
{
OverloadingCalculation2 obj=new
OverloadingCalculation2();
obj.sum(20,20);//now int arg sum() method gets invoked
}
}

Output:

int arg method invoked

Example of Method Overloading with Type Promotion in case of ambiguity

If there are no matching type arguments in the method, and each method promotes similar
number of arguments, there will be ambiguity.

class OverloadingCalculation3{
void sum(int a,long b){System.out.println("a method
invoked");}
void sum(long a,int b){System.out.println("b method
invoked");}
public static void main(String args[]){
200
 Chapter Four: Object Oriented Programming Concepts

OverloadingCalculation3 obj=new
OverloadingCalculation3();
obj.sum(20,20);//now ambiguity
}
}

Output:

Compile Time Error

b) Method Overriding in Java

If subclass (child class) has the same method as declared in the parent class, it is known as
method overriding in Java.

In other words, If a subclass provides the specific implementation of the method that has been
declared by one of its parent class, it is known as method overriding.

Usage of Java Method Overriding

• Method overriding is used to provide the specific implementation of a method which is

already provided by its superclass.

• Method overriding is used for runtime polymorphism

Rules for Java Method Overriding

1. The method must have the same name as in the parent class

2. The method must have the same parameter as in the parent class.

3. There must be an IS-A relationship (inheritance).

Understanding the problem without method overriding

Let's understand the problem that we may face in the program if we don't use method overriding.

//Java Program to demonstrate why we need method

overriding
//Here, we are calling the method of parent class with
child
//class object.
//Creating a parent class

201
 Chapter Four: Object Oriented Programming Concepts

class Vehicle{
void run(){System.out.println("Vehicle is running");}
}
//Creating a child class
class Bike extends Vehicle{
public static void main(String args[]){
//creating an instance of child class
Bike obj = new Bike();
//calling the method with child class instance
obj.run();
}
}

Output:

Vehicle is running

Problem is that I have to provide a specific implementation of run() method in subclass that is
why we use method overriding.

Example of method overriding

In this example, we have defined the run method in the subclass as defined in the parent class
but it has some specific implementation. The name and parameter of the method are the same,
and there is IS-A relationship between the classes, so there is method overriding.

//Java Program to illustrate the use of Java Method

Overriding
//Creating a parent class.
class Vehicle{
//defining a method
void run(){System.out.println("Vehicle is running");}
}
//Creating a child class
class Bike2 extends Vehicle{
//defining the same method as in the parent class
void run(){System.out.println("Bike is running
safely");}

202
 Chapter Four: Object Oriented Programming Concepts

public static void main(String args[]){

Bike2 obj = new Bike2();//creating object
obj.run();//calling method
}
}

Output:

Bike is running safely

A real example of Java Method Overriding

Consider a scenario where Bank is a class that provides functionality to get the rate of interest.
However, the rate of interest varies according to banks. For example, SBI, ICICI and AXIS
banks could provide 8%, 7%, and 9% rate of interest.

Figure 15: Java method overriding

Java method overriding is mostly used in Runtime Polymorphism which we will learn in next
pages.

//Java Program to demonstrate the real scenario of Java

Method Overriding
//where three classes are overriding the method of a
parent class.
//Creating a parent class.
class Bank
{

203
 Chapter Four: Object Oriented Programming Concepts

int getRateOfInterest()
{
return 0;
}
} //Creating child classes.
class SBI extends Bank
{
int getRateOfInterest()
{
return 8;
}
}
class ICICI extends Bank
{
int getRateOfInterest()
{
return 7;
}
}
class AXIS extends Bank
{
int getRateOfInterest()
{
return 9;
}
}
//Test class to create objects and call the methods
class Test2{
public static void main(String args[]){
SBI s=new SBI();
ICICI i=new ICICI();
AXIS a=new AXIS();
System.out.println("SBI Rate of Interest:
"+s.getRateOfInterest()); System.out.println("ICICI

204
 Chapter Four: Object Oriented Programming Concepts

Rate of Interest: "+i.getRateOfInterest());

System.out.println("AXIS Rate of Interest:
"+a.getRateOfInterest());
}
}

Output:

SBI Rate of Interest: 8

ICICI Rate of Interest: 7

AXIS Rate of Interest: 9

Can we override static method?

No, a static method cannot be overridden. It can be proved by runtime polymorphism, so we

will learn it later.

Why can we not override static method?

It is because the static method is bound with class whereas instance method is bound with an
object. Static belongs to the class area, and an instance belongs to the heap area.

Can we override java main method?

No, because the main is a static method. Method Overloading in Java with examples

Abstract class in Java

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

Abstraction in Java

Abstraction is a process of hiding the implementation details and showing only functionality
to the user. Another way, it shows only essential things to the user and hides the internal details,
for example, sending SMS where you type the text and send the message. You don't know the
internal processing about the message delivery.

Abstraction lets you focus on what the object does instead of how it does it.

Ways to achieve Abstraction

205
 Chapter Four: Object Oriented Programming Concepts

There are two ways to achieve abstraction in java

1. Abstract class (0 to 100%)

2. Interface (100%)

Abstract class in Java

A class which is declared as abstract is known as an abstract class. It can have abstract and
non-abstract methods. It needs to be extended and its method implemented. It cannot be
instantiated.

Points to Remember:

• An abstract class must be declared with an abstract keyword.

• It can have abstract and non-abstract methods.

• It cannot be instantiated.

• It can have constructors and static methods also.

• It can have final methods which will force the subclass not to change the body of the
method.

Figure 16: Rules for Java Abstract class

206
 Chapter Four: Object Oriented Programming Concepts

Example of abstract class

1. abstract class A{}

Abstract Method in Java

A method which is declared as abstract and does not have implementation is known as an
abstract method.

Example of abstract method

1. abstract void printStatus();//no method body and abstract

Example of Abstract class that has an abstract method

In this example, Bike is an abstract class that contains only one abstract method run. Its
implementation is provided by the Honda class.

1. abstract class Bike{

2. abstract void run();
3. }
4. class Honda4 extends Bike{
5. void run(){System.out.println("running safely");}
6. public static void main(String args[]){
7. Bike obj = new Honda4();
8. obj.run();
9. }
10. }

OutPut

running safely

Understanding the real scenario of Abstract class

In this example, Shape is the abstract class, and its implementation is provided by the Rectangle
and Circle classes.

Mostly, we don't know about the implementation class (which is hidden to the end user), and
an object of the implementation class is provided by the factory method.

207
 Chapter Four: Object Oriented Programming Concepts

A factory method is a method that returns the instance of the class. We will learn about the
factory method later.

In this example, if you create the instance of Rectangle class, draw() method of Rectangle class
will be invoked.

File: TestAbstraction1.java

abstract class Shape{

abstract void draw();
}
//In real scenario, implementation is provided by other
s i.e. unknown by end user
class Rectangle extends Shape{
void draw(){System.out.println("drawing rectangle");}
}
class Circle1 extends Shape{
void draw(){System.out.println("drawing circle");}
}
//In real scenario, method is called by programmer or u
ser
class TestAbstraction1{
public static void main(String args[]){
Shape s=new Circle1();//In a real scenario, object is p
rovided through method, e.g., getShape() method
s.draw();
}
}

Output

drawing circle

Another example of Abstract class in java

File: TestBank.java

AD

208
 Chapter Four: Object Oriented Programming Concepts

abstract class Bank{

abstract int getRateOfInterest();
}
class SBI extends Bank{
int getRateOfInterest(){return 7;}
}
class PNB extends Bank{
int getRateOfInterest(){return 8;}
}
class TestBank{
public static void main(String args[]){
Bank b;
b=new SBI();
System.out.println("Rate of Interest is: "+b.getRateOfI
nterest()+" %");
b=new PNB();
System.out.println("Rate of Interest is: "+b.getRateOfI
nterest()+" %");
}}

Output

Rate of Interest is: 7 %

Rate of Interest is: 8 %

Abstract class having constructor, data member and methods

An abstract class can have a data member, abstract method, method body (non-abstract method),
constructor, and even main() method.

File: TestAbstraction2.java

//Example of an abstract class that has abstract and no

n-abstract methods
abstract class Bike{
Bike(){System.out.println("bike is created");}
abstract void run();

209
 Chapter Four: Object Oriented Programming Concepts

void changeGear(){System.out.println("gear changed")

;}
}
//Creating a Child class which inherits Abstract class

class Honda extends Bike{

void run(){System.out.println("running safely..");}
}
//Creating a Test class which calls abstract and non-
abstract methods
class TestAbstraction2{
public static void main(String args[]){
Bike obj = new Honda();
obj.run();
obj.changeGear();
}
}

Output

bike is created

running safely..

gear changed

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

1. class Bike12{
2. abstract void run();
3. }

Output

compile time error

Rule: If you are extending an abstract class that has an abstract method, you must either provide
the implementation of the method or make this class abstract.

Another real scenario of abstract class

210
 Chapter Four: Object Oriented Programming Concepts

The abstract class can also be used to provide some implementation of the interface. In such
case, the end user may not be forced to override all the methods of the interface.

Note: If you are beginner to java, learn interface first and skip this example.

interface A{
void a();
void b();
void c();
void d();
}
abstract class B implements A{
public void c(){System.out.println("I am c");}
}
class M extends B{
public void a(){System.out.println("I am a");}
public void b(){System.out.println("I am b");}
public void d(){System.out.println("I am d");}
}
class Test5{
public static void main(String args[]){
A a=new M();
a.a();
a.b();
a.c();
a.d();
}}

Output

I am a

I am b

I am c

I am d

211
 Chapter Four: Object Oriented Programming Concepts

Week Ten: Practical

Write a Java program to create a class known as "BankAccount" with methods called deposit()
and withdraw(). Create a subclass called SavingsAccount that overrides the withdraw() method
to prevent withdrawals if the account balance falls below one hundred.

Sample Solution:

Java Code:
// BankAccount.java
// Parent class BankAccount
public class BankAccount {
private String accountNumber;
private double balance;
public BankAccount(String accountNumber, double
balance) {
this.accountNumber = accountNumber;
this.balance = balance;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) {
if (balance >= amount) {
balance -= amount;
} else {
System.out.println("Insufficient balance");
}
}
public double getBalance() {
return balance;
}
}
// SavingsAccount.java
// Child class SavingsAccount

212
 Chapter Four: Object Oriented Programming Concepts

public class SavingsAccount extends BankAccount {

public SavingsAccount(String accountNumber, double
balance) {
super(accountNumber, balance);
}
@Override
public void withdraw(double amount) {
if (getBalance() - amount < 100) {
System.out.println("Minimum balance of $100
required!");
} else {
super.withdraw(amount);
}
}
}
// Main.java
// Main class
public class Main {
public static void main(String[] args) {
System.out.println("Create a Bank Account
object (A/c No. BA1234) with initial balance of
$500:");
//Create a BankAccount object (A/c
No. "BA1234") with initial balance of $500
BankAccount BA1234 = new BankAccount("BA1234",
500);

// Deposit $1000 into account BA1234

System.out.println("Deposit $1000
into account BA1234:");
BA1234.deposit(1000);
System.out.println("New balance after
depositing $1000: $" + BA1234.getBalance());
// Withdraw $600 from account BA1234

213
 Chapter Four: Object Oriented Programming Concepts

System.out.println("Withdraw $600
from account BA1234:");
BA1234.withdraw(600);
System.out.println("New balance after
withdrawing $600: $" + BA1234.getBalance());
// Create a SavingsAccount object (A/c No.
"SA1234") with initial balance of $450
System.out.println("\nCreate a
SavingsAccount object (A/c No. SA1234) with initial
balance of $450:");
SavingsAccount SA1234 = new
SavingsAccount("SA1234",450);
// Withdraw $300 from SA1234
SA1234.withdraw(300);
System.out.println("Balance after trying to
withdraw $300: $" + SA1234.getBalance());
// Create a SavingsAccount object
(A/c No. "SA1000") with initial balance of $300
System.out.println("\nCreate a
SavingsAccount object (A/c No. SA1000) with initial
balance of $300:");
SavingsAccount SA1000 = new
SavingsAccount("SA1000",300);
// Withdraw $250 from SA1000 (balance falls
below $100)
System.out.println("Try to withdraw
$250 from SA1000!");
SA1000.withdraw(250);
System.out.println("Balance after trying to
withdraw $250: $" + SA1000.getBalance());
}
}

214
 Chapter Four: Object Oriented Programming Concepts

Sample Output:

Create a Bank Account object (A/c No. BA1234) with initial balance of $500:

Deposit $1000 into account BA1234:

New balance after depositing $1000: $1500.0

Withdraw $600 from account BA1234:

New balance after withdrawing $600: $900.0

Create a SavingsAccount object (A/c No. SA1234) with initial balance of $450:

Balance after trying to withdraw $300: $150.0

Create a SavingsAccount object (A/c No. SA1000) with initial balance of $300:

Try to withdraw $250 from SA1000!

Minimum balance of $100 required!

Balance after trying to withdraw $250: $300.0

Explanation:
The BankAccount class has a constructor that takes account number and balance as arguments.
It also has methods to deposit and withdraw money, and to check the account balance. The
SavingsAccount class is a subclass of BankAccount and overrides the withdraw() method. It
checks if the account balance falls below one hundred before allowing a withdrawal. The
method prints an error message if the balance is below one hundred. If the balance is greater
than or equal to one hundred, the method calls the withdraw() method of the superclass to
withdraw.

In Main() method -

The main method begins by creating an instance of the BankAccount class with an account
number of "BA1234" and an initial balance of $500. It then deposits $1000 into the account
and displays the new balance. It then withdraws $600 from the account and displays the new
balance.

215
 Chapter Four: Object Oriented Programming Concepts

Next, the method creates an instance of the SavingsAccount class with an account number of
"SA1234" and an initial balance of $450. It then attempts to withdraw $300 from the account
and displays the new balance. Since the balance remains above the minimum $150 balance
required for the account, the withdrawal is successful.

Finally, the method creates another instance of the SavingsAccount class with an account
number of "SA1000" and an initial balance of $300. It then attempts to withdraw $250 from
the account, which would bring the balance below the minimum balance required for the
account. The method displays the new balance after the attempted withdrawal, which should
still be $300 since the withdrawal was unsuccessful.

216
 Chapter Four: Object Oriented Programming Concepts

Week Ten : Assesment

Part I: Multiple choice Questions

1. Which of the following best describes member function overriding?

a) Member functions having the same name in derived class only

b) Member functions having the same name and different signature inside main

function

c) Member functions having the same name in base and derived classes

d) Member functions having the same name in base class only

2. Which feature of OOP is exhibited by the function overriding?

a) Polymorphism

b) Encapsulation

c) Abstraction

d) Inheritance

3. ___________ underlines the feature of Polymorphism in a class.

a) Virtual Function

b) Inline function

c) Enclosing class

d) Nested class

4. Which feature in OOP is used to allocate additional functions to a predefined operator

in any language?

a) Function Overloading

b) Function Overriding

c) Operator Overloading

d) Operator Overriding

217
 Chapter Four: Object Oriented Programming Concepts

Part II: Practical assessment

1. Write a Java program to create a class known as Person with methods called getFirstName()
and getLastName(). Create a subclass called Employee that adds a new method named
getEmployeeId() and overrides the getLastName() method to include the employee's job
title.

2. Write a Java program to create a class Employee with a method called calculateSalary().
Create two subclasses Manager and Programmer. In each subclass, override the
calculateSalary() method to calculate and return the salary based on their specific roles.

218
 Chapter Four: Object Oriented Programming Concepts

Reference
1. Java: A Beginner's Guide, Eighth Edition by Herbert Schildt
2. Java: How to Program, 9th Edition (Deitel)
3. https://www.javatpoint.com/

219
 Chapter Five: Exception Handling in Java

Chapter Five: Exception Handling in Java

Lesson Plan
1. Learning objectives

• Be able to Basic Concepts of Exception Handling.

• Be able to know principles and ttechniques of Exxception Handling

• Be able to use of the concept of try and catch

•
2. Motivation

• Outputs through Question and Answer; repetitive discussion of handling errors.

• Solving a problem using try,catch,throw and final.

• Controlling the flow control of instruction execution.

3. Expectations or Outcomes

 Define the terminologies, differentiate different programming paradigms, explain

Exception Handling concepts and techniques; the assessment standard attached at the
end of the job task sheet.
 Can write Object Oriented instructions using Java to solve any problem using
programming.
4. Equipment

• Desktop or Laptop computer.

• Java IDE (NetBeans) software

5. Practice contents/Activities/Safety

 Brief introduction of Java complete development life cycle (Java IDE).

 Active practice; on java input and output, writing (Editing), compiling, interprating.

6. Assessments

• How can you install Java IDE (Netbeans) software?

• How to create class and objects?
220
 Chapter Five: Exception Handling in Java

7. Clean-up

 After finishing practice, computers should be properly shut down.

8. Independent practice/Follow-up activities

• Learning through assignment (practical exercises)

9. Review/Reflection

• Review the outcome of the practice, improvement measure and previous reflected
opinions.

221
 Chapter Five: Exception Handling in Java

Week Eleven: Session

5.1. Exception Handling in Java

Exception Handling in Java is one of the effective means to handle runtime errors so that the
regular flow of the application can be preserved. Java Exception Handling is a mechanism to
handle runtime errors such as ClassNotFoundException, IOException, SQLException,
RemoteException, etc.

In Java, Exception is an unwanted or unexpected event, which occurs during the execution of
a program, i.e. at run time, that disrupts the normal flow of the program’s instructions.
Exceptions can be caught and handled by the program. When an exception occurs within a
method, it creates an object. This object is called the exception object. It contains information
about the exception, such as the name and description of the exception and the state of the
program when the exception occurred.

An Exception can be anything which interrupts the normal flow of the program. When an
exception occurs program processing gets terminated and doesn’t continue further. In such
cases we get a system generated error message. The good thing about exceptions is that they
can be handled.

Exception can occur at runtime (known as runtime exceptions) as well as at compile-time

(known Compile-time exceptions).

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

Dictionary Meaning: Exception is an abnormal condition

In Java, an exception is an event that disrupts the normal flow of the program. It is an
object which is thrown at runtime.

What is Exception Handling

Exception Handling is a mechanism to handle runtime errors such as

ClassNotFoundException, IOException, SQLException, RemoteException, etc.

Advantage of Exception Handling

The core advantage of exception handling is to maintain the normal flow of the
application. An exception normally disrupts the normal flow of the application that

222
 Chapter Five: Exception Handling in Java

is why we use exception handling. Let's take a scenario:

1. statement 1;
2. statement 2;
3. statement 3;
4. statement 4;
5. statement 5;//exception occurs
6. statement 6;
7. statement 7;
8. statement 8;
9. statement 9;
10. statement 10;
Suppose there are 10 statements in your program and there occurs an exception at
statement 5, the rest of the code will not be executed i.e. statement 6 to 10 will not be
executed. If we perform exception handling, the rest of the statement will be executed.
That is why we use exception handling in Java.

5.1.1. Difference between Error and Exception

Errors indicate serious problems and abnormal conditions that most applications should not try
to handle. Error defines problems that are not expected to be caught under normal
circumstances by our program. For example memory error, hardware error, JVM error etc.

Exceptions are conditions within the code. A developer can handle such conditions and take
necessary corrective actions. Few examples –

• DivideByZero exception

• NullPointerException

• ArithmeticException

• ArrayIndexOutOfBoundsException

5.1.2. Advantages of Exception Handling

• Exception handling allows us to control the normal flow of the program by using
exception handling in program.

• It throws an exception whenever a calling method encounters an error providing that

223
 Chapter Five: Exception Handling in Java

the calling method takes care of that error.

• It also gives us the scope of organizing and differentiating between different error types
using a separate block of codes. This is done with the help of try-catch blocks.

Why to handle exception?

If an exception is raised, which has not been handled by programmer then program execution
can get terminated and system prints a non user friendly error message.

Eg:- System generated exception

An exception generated by the system is given below

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

ExceptionDemo.main(ExceptionDemo.java:5)

ExceptionDemo : The class name

main : The method name

ExceptionDemo.java : The filename

java:5 : Line number

For a beginner user the above message won’t be easy to understand. In order to let them know
that what went wrong we use exception handling in java program. We handle such conditions
and then prints a user friendly warning message to user, which lets them correct the error as
most of the time exception occurs due to bad data provided by user.

5.1.3. Java Exception Keywords

There are 5 keywords which are used in handling exceptions in Java.

Table 0-17: Java Exception Keywords

Keyword Description

try The "try" keyword is used to specify a block where we should place
exception code. The try block must be followed by either catch or finally.
It means, we can't use try block alone.

224
 Chapter Five: Exception Handling in Java

catch The "catch" block is used to handle the exception. It must be preceded
by try block which means we can't use catch block alone. It can be
followed by finally block later.

finally The "finally" block is used to execute the important code of the program.
It is executed whether an exception is handled or not.

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

throws The "throws" keyword is used to declare exceptions. It doesn't throw an

exception. It specifies that there may occur an exception in the method.
It is always used with method signature.

5.1.4. Java Exception Handling Example

Let's see an example of Java Exception Handling where we using a try-catch statement to
handle the exception.

public class JavaExceptionExample{

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

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

rest of the code...

225
 Chapter Five: Exception Handling in Java

1. In the above example, 100/0 raises an ArithmeticException which is handled by a try-

catch block.

5.2. Java try and catch block

Java try block is used to enclose the code that might throw an exception. It must be used within
the method. If an exception occurs at the particular statement of try block, the rest of the block
code will not execute. So, it is recommended not to keeping the code in try block that will not
throw an exception. Java try block must be followed by either catch or finally block.

5.2.1. Syntax of Java try-catch

try{
//code that may throw an exception
}catch(Exception_class_Name ref){}
Syntax of try-finally block
try{
//code that may throw an exception
}finally{}

5.2.2. Java catch block

Java catch block is used to handle the Exception by declaring the type of exception within the
parameter. The declared exception must be the parent class exception ( i.e., Exception) or the
generated exception type. However, the good approach is to declare the generated type of
exception.
The catch block must be used after the try block only. You can use multiple catch block with a
single try block.
public class TryCatchExample2 {

public static void main(String[] args) {

try
{
int data=50/0; //may throw exception
}
//handling the exception
catch(ArithmeticException e)
{

226
 Chapter Five: Exception Handling in Java

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

Output:

java.lang.ArithmeticException: / by zero

rest of the code

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

Be careful doing in this way

In this example, we also kept the code in a try block that will not throw an exception.
public class TryCatchExample3 {

public static void main(String[] args) {

try
{
int data=50/0; //may throw exception
// if exception occurs, the re
maining statement will not exceute
System.out.println("rest of the code");
}
// handling the exception
catch(ArithmeticException e)
{
System.out.println(e);
}

227
 Chapter Five: Exception Handling in Java

Output:

java.lang.ArithmeticException: / by zero
Here, we can see that if an exception occurs in the try block, the rest of the block code will not
execute.
Let's see an example to resolve the exception in a catch block.
public class TryCatchExample6 {

public static void main(String[] args) {

int i=50;
int j=0;
int data;
try
{
data=i/j; //may throw exception
}
// handling the exception
catch(Exception e)
{
// resolving the exception in catch block

System.out.println(i/(j+2));
}
}
}

Output:

25

Let's see an example to handle another unchecked exception.

public class TryCatchExample9 {

public static void main(String[] args) {

228
 Chapter Five: Exception Handling in Java

try
{
int arr[]= {1,3,5,7};
System.out.println(arr[10]); //may throw except
ion
}
// handling the array exception
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e);
}
System.out.println("rest of the code");
}

Output:

java.lang.ArrayIndexOutOfBoundsException: 10

rest of the code

Let's see an example to handle checked exception.
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class TryCatchExample10 {

public static void main(String[] args) {

PrintWriter pw;
try {
pw = new PrintWriter("jtp.txt"); //may thro
w exception
pw.println("saved");

229
 Chapter Five: Exception Handling in Java

}
// providing the checked exception handler
catch (FileNotFoundException e) {

System.out.println(e);
}
System.out.println("File saved successfully");
}
}

Output:

1. File saved successfully

5.2.3. Internal working of java try-catch block

Figure 16: Internal working of java try-catch block

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:

o Prints out exception description.

o Prints the stack trace (Hierarchy of methods where the exception occurred).
o Causes the program to terminate.

230
 Chapter Five: Exception Handling in Java

But if exception is handled by the application programmer, normal flow of the application is
maintained i.e. rest of the code is executed.

5.2.4. Java Multi-catch block

A try block can be followed by one or more catch blocks. Each catch block must contain a
different exception handler. So, if you have to perform different tasks at the occurrence of
different exceptions, use java multi-catch block.

Points to remember

o At a time only one exception occurs and at a time only one catch block is executed.
o All catch blocks must be ordered from most specific to most general, i.e. catch for
ArithmeticException must come before catch for Exception.

Example 1

Let's see a simple example of java multi-catch block.

public class MultipleCatchBlock1 {

public static void main(String[] args) {

try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic Excep
tion occurs");
}
catch(ArrayIndexOutOfBoundsException e)

{
System.out.println("ArrayIndexOutOfB
ounds Exception occurs");
}
catch(Exception e)

231
 Chapter Five: Exception Handling in Java

{
System.out.println("Parent Exception
occurs");
}
System.out.println("rest of the code");

}
}
Arithmetic Exception occurs
rest of the code

Example 2

public class MultipleCatchBlock2 {

public static void main(String[] args) {

try{
int a[]=new int[5];

System.out.println(a[10]);
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic Excep
tion occurs");
}
catch(ArrayIndexOutOfBoundsException e)

{
System.out.println("ArrayIndexOutOfB
ounds Exception occurs");
}
catch(Exception e)
{

232
 Chapter Five: Exception Handling in Java

System.out.println("Parent Exception
occurs");
}
System.out.println("rest of the code");

}
}

Output:

ArrayIndexOutOfBounds Exception occurs

rest of the code

5.2.5. Java Nested try block

The try block within a try block is known as nested try block in java.

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.

Syntax:

....
try
{
statement 1; statement 2;
try
{
statement 1;
statement 2;
}
catch(Exception e)
{
}
}
catch(Exception e)
233
 Chapter Five: Exception Handling in Java

{
}
....

Java nested try example

Let's see a simple example of java nested try block.

class Excep6{
public static void main(String args[]){
try{
try{
System.out.println("going to divide");
int b =39/0;
}catch(ArithmeticException e){System.out.println(e)
;}

try{
int a[]=new int[5];
a[5]=4;
}catch(ArrayIndexOutOfBoundsException e){System.out
.println(e);}

System.out.println("other statement);
}catch(Exception e){System.out.println("handeled");}

System.out.println("normal flow..");
}
}

5.3. Java finally block

Java finally block is a block that is used to execute important code such as closing connection,
stream etc.
Java finally block is always executed whether exception is handled or not.
Java finally block follows try or catch block.
234
 Chapter Five: Exception Handling in Java

Figure 17: Java finally block

5.4. Why use java finally

o Finally block in java can be used to put "cleanup" code such as closing a file, closing
connection etc.

Usage of Java finally

Let's see the different cases where java finally block can be used.

Case 1

Let's see the java finally example where exception doesn't occur.
class TestFinallyBlock{

235
 Chapter Five: Exception Handling in Java

public static void main(String args[]){

try{
int data=25/5;
System.out.println(data);
}
catch(NullPointerException e){System.out.println(e);}

finally{System.out.println("finally block is always e

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

Output:5

finally block is always executed

rest of the code...

5.5. Difference between throw and throws in Java

There are many differences between throw and throws keywords. A list of differences between
throw and throws are given below:

Table :Difference between throw and throws i

No. throw throws

1) Java throw keyword is used to Java throws keyword is used to
explicitly throw an exception. declare an exception.

2) Checked exception cannot be Checked exception can be propagated

propagated using throw only. with 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.

5) You cannot throw multiple You can declare multiple exceptions

exceptions. e.g.
public void method()throws
IOException,SQLException.

236
 Chapter Five: Exception Handling in Java

Java throw keyword

The Java throw keyword is used to explicitly throw an exception.

We can throw either checked or uncheked exception in java by throw keyword. The throw
keyword is mainly used to throw custom exception. We will see custom exceptions later.
The syntax of java throw keyword is given below.
1. throw exception;
Let's see the example of throw IOException.
1. throw new IOException("sorry device error);
java throw keyword example

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.
public class TestThrow1{
static void validate(int age){
if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome to vote");
}
public static void main(String args[]){
validate(13);
System.out.println("rest of the code...");
}
}

Output:

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

Java throws keyword

The Java throws keyword is used to declare an exception. It gives an information to the
programmer that there may occur an exception so it is better for the programmer to provide the
exception handling code so that normal flow can be maintained.

237
 Chapter Five: Exception Handling in Java

Exception Handling is mainly used to handle the checked exceptions. If there occurs any
unchecked exception such as NullPointerException, it is programmers fault that he is not
performing check up before the code being used.

Syntax of java throws

return_type method_name() throws exception_class_name{

//method code
}

Which exception should be declared

Ans) checked exception only, because:

o unchecked Exception: under your control so correct your code.

o error: beyond your control e.g. you are unable to do anything if there occurs
VirtualMachineError or StackOverflowError.

Advantage of Java throws keyword

Now Checked Exception can be propagated (forwarded in call stack).

It provides information to the caller of the method about the exception.

Java throws example

Let's see the example of java throws clause which describes that checked exceptions can be
propagated by throws keyword.
import java.io.IOException;
class Testthrows1{
void m()throws IOException{
throw new IOException("device error");//checked exc
eption
}
void n()throws IOException{
m();
}
238
 Chapter Five: Exception Handling in Java

void p(){
try{
n();
}catch(Exception e){System.out.println("exception ha
ndled");}
}
public static void main(String args[]){
Testthrows1 obj=new Testthrows1();
obj.p();
System.out.println("normal flow...");
}
}

Output:

exception handled
normal flow...
5.6. Java Custom Exception
If you are creating your own Exception that is known as custom exception or user-defined
exception. Java custom exceptions are used to customize the exception according to user need.
By the help of custom exception, you can have your own exception and message.
Let's see a simple example of java custom exception.

class InvalidAgeException extends Exception{

InvalidAgeException(String s){
super(s);
}
}
class TestCustomException1{

static void validate(int age)throws InvalidAgeExcept

ion{
if(age<18)
throw new InvalidAgeException("not valid");
else

239
 Chapter Five: Exception Handling in Java

System.out.println("welcome to vote");
}

public static void main(String args[]){

try{
validate(13);
}catch(Exception m){System.out.println("Exception
occured: "+m);}

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

}
}

240
 Chapter Five: Exception Handling in Java

Week Eleven: Practical

Problem without exception handling

Let's try to understand the problem if we don't use a try-catch block.

Example 1:
TryCatchExample1.java

public class TryCatchExample1 {

public static void m
ain(String[] args) {
int data=50/0; //may throw exception
System.out.println("rest of the code");
}
}

Output:

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

As displayed in the above example, the rest of the code is not executed (in such case, the rest
of the code statement is not printed). There might be 100 lines of code after the exception. If
the exception is not handled, all the code below the exception won't be executed.
Solution by exception handling
Let's see the solution of the above problem by a java try-catch block.

Example 2:
TryCatchExample2.java

public class TryCatchExample2 {

public static void main(String[] args) {
try
{
int data=50/0; //may throw exception
}
//handling the exception
catch(ArithmeticException e)

241
 Chapter Five: Exception Handling in Java

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

Output:

java.lang.ArithmeticException: / by zero

rest of the code

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

Example 3:

In this example, we also kept the code in a try block that will not throw an exception.

TryCatchExample3.java

public class TryCatchExample3 {

public static void main(String[] args) {

try
{
int data=50/0; //may throw exception
// if exception occurs, the
remaining statement will not exceute
System.out.println("rest of the code");
}
// handling the exception
catch(ArithmeticException e)
{
System.out.println(e);
}

242
 Chapter Five: Exception Handling in Java

Output:

java.lang.ArithmeticException: / by zero

Here, we can see that if an exception occurs in the try block, the rest of the block code will not
execute.

Example 4

Here, we handle the exception using the parent class exception.

public class TryCatchExample4 {
public static void main(String[] args) {
try
{
int data=50/0; //may throw exception
}
// handling the exception by using
Exception class
catch(Exception e)
{
System.out.println(e);
}
System.out.println("rest of the code");
}
}

Output:

java.lang.ArithmeticException: / by zero

rest of the code

243
 Chapter Five: Exception Handling in Java

Week Eleven : Assesment

I. Practical

1. Write a Java program that throws an exception and catch it using a try-catch
block.

2. Write a Java program to create a method that takes an integer as a parameter and
throws an exception if the number is odd.

3. Write a Java program to create a method that reads a file and throws an exception
if the file is not found.

4. Write a Java program that reads a list of numbers from a file and throws an
exception if any of the numbers are positive.

5. Write a Java program that reads a file and throws an exception if the file is empty.

6. Write a Java program that reads a list of integers from the user and throws an
exception if any

244
 Chapter Five: Exception Handling in Java

Week Twelve: Session

5.7. Exception Hierarchy

All exception and error types are subclasses of the class Throwable, which is the base class of
the hierarchy. One branch is headed by Exception. This class is used for exceptional conditions
that user programs should catch. NullPointerException is an example of such an exception.
Another branch, Error is used by the Java run-time system(JVM) to indicate errors having to
do with the run-time environment itself(JRE). StackOverflowError is an example of such an
error.

Figure18: Exception Hierarchy

5.8. Types of Exception in Java

Java is an object-oriented programming language. It provides support for various mechanisms
such as exception handling. This feature of Java enables developers to manage the runtime
errors caused by the exceptions.

Exceptions are the unwanted errors or bugs or events that restrict the normal execution of a
program. Each time an exception occurs, program execution gets disrupted. An error message
is displayed on the screen.

245
 Chapter Five: Exception Handling in Java

There are several reasons behind the occurrence of exceptions. These are some conditions
where an exception occurs:

• Whenever a user provides invalid data.

• The file requested to be accessed does not exist in the system.

• When the Java Virtual Machine (JVM) runs out of memory.

• Network drops in the middle of communication.

Now let us explore different types of exceptions in Java.

The parent class of all the exception classes is the java.lang.Exception class. The Figure below
illustrates the different types of Java exceptions.

Figure 19: Different types of exceptions in Java.

Exception class, it is a subclass of the built-in Throwable class. There is another subclass
which is derived from the Throwable class i.e. Error as illustrated in Figure 1. The error can
be defined as an abnormal condition that indicates something has gone wrong with the
execution of the program. These are not handled by Java programs.

There are some important methods available in the Throwable class which are as follows:

• public String getMessage() – Provides information about the exception that has
occurred through a message, which is initialized in the Throwable constructor.

• public Throwable getCause() – Provides root cause of the exception as represented

246
 Chapter Five: Exception Handling in Java

by a Throwable object.

• public void printStackTrace() – Used to display the output of toString() along with
the stack trace to System.err (error output stream).

• public StackTraceElement [] getStackTrace() – Returns an array with each element

present on the stack trace. The index 0 element will symbolize the top of the call stack,
and the last element of array will identify the bottom of the call stack.

There are mainly two types of exceptions in Java as follows:

1. Checked exception

2. Unchecked exception

5.8.1. Checked exception

Checked exceptions are also known as compile-time exceptions as these exceptions are
checked by the compiler during the compilation process to confirm whether the exception is
handled by the programmer or not. If not, then the system displays a compilation error. For
example, SQLException, IOException, InvocationTargetException, and
ClassNotFoundException.

To illustrate the concept of checked exception, let us consider the following code snippet:

import java.io.*;
class demo1 {
public static void main(String args[]) {
FileInputStream input1 = null;
/* FileInputStream(File filename) is a
constructor that will throw
* FileNotFoundException (a checked
exception)
*/
input1 = new FileInputStream("D:/file.txt");
int m;

// The read() of FileInputStream will also

throw a checked exception
while(( m = input1.read() ) != -1) {
247
 Chapter Five: Exception Handling in Java

System.out.print((char)m);
}
// The close() will close the file input
stream, and it will also throw a exception
input1.close();
}
}

Output:

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

Unhandled exception type FileNotFoundException

Unhandled exception type IOException

Unhandled exception type IOException

throw keyword

It is clearly displayed in the output that the program throws exceptions during the compilation
process. There are two methods of resolving such issues. You can declare the exception with
the help of the throw keyword.

import java.io.*;
class demo1 {
public static void main(String args[]) throws
IOException {
FileInputStream input1 = null;
input1 = new FileInputStream("D:/file.txt");

int m;
while ((m = input1.read()) != -1) {
System.out.print((char)m);
}
input1.close();
}
}

248
 Chapter Five: Exception Handling in Java

Output:

The file will be displayed on the screen.

try-catch block
Apart from the above-mentioned method, there is another way to resolve exceptions. You can
manage them with the help of try-catch blocks.

import java.io.*;
class demo1 {
public static void main(String args[]) {
FileInputStream input1 = null;
try {
input1 = new
FileInputStream("D:/file.txt");
} catch(FileNotFoundException input2) {
system.out.println("The file does not " +
"exist at the location");
}
int m;
try {
while((m = input1.read()) != -1) {
System.out.print((char)m);
}
input1.close();
} catch(IOException input3) {
system.out.println("I/O error occurred: "+
input3);
}
}
}

249
 Chapter Five: Exception Handling in Java

Output:

The code will run smoothly and the file will be displayed.

Checked Exception Exapmples

SQLException
This type of exception occurs while executing queries on a database related to the SQL syntax.
For example, consider the following code snippet:

public void setClientInfo(String sname, String svalue)

throws SQLClientInfoException {
try {
checkClosed();
((java.sql.Connection)
this.mc).setClientInfo(sname, svalue);
} catch (SQLException sqlEx) {
try {
checkAndFireConnectionError(sqlEx);
} catch (SQLException sqlEx2) {
SQLClientInfoException client_Ex = new
SQLClientInfoException();
client_Ex.initCause(sqlEx2);
throw client_Ex;
}
}
}

Output:

This code will generate a SQLException.

IOException
This type of exception occurs while using file I/O stream operations. For example, consider the
following code snippet:

250
 Chapter Five: Exception Handling in Java

import java.io.*;
public class sample_IOException {
private static String filepath =
"D:\User\guest\Desktop\File2.txt";

public static void main(String[] args) {

BufferedReader br1 = null;
String curline;
try {
br1 = new BufferedReader(new
FileReader(filepath));
while ((curline = br1.readLine()) != null)
{
System.out.println(curline);
}
} catch (IOException e) {
System.err.println("IOException found :" +
e.getMessage());
} finally {
try {
if (br1 != null)
br1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Output:

This code will generate an IOException.

251
 Chapter Five: Exception Handling in Java

ClassNotFoundException
This type of exception is thrown when the JVM is not able to find the required class. It may be
due to a command-line error, a classpath issue, or a missing .class file. For example, consider
the following code snippet:

public class sample_ClassNotFoundException {

private static final String CLASS_TO_LOAD =
"main.java.Utils";
public static void main(String[] args) {
try {
Class loadedClass =
Class.forName(CLASS_TO_LOAD);
System.out.println("Class " + loadedClass +
" found!");
} catch (ClassNotFoundException ex) {
System.err.println("ClassNotFoundException
was found: " + ex.getMessage());
ex.printStackTrace();
}
}
}

Output:

This code will generate a ClassNotFoundException.

InvocationTargetException
This type of exception wraps an exception thrown by an invoked method or a constructor. The
thrown exception can be accessed with the help of the getTargetException method. For
example, consider the following code snippet:

package main.samplejava;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Example {
@SuppressWarnings("unused")

252
 Chapter Five: Exception Handling in Java

private int test_sample(String s1) {

if (s1.length() == 0)
throw new IllegalArgumentException("The
string should have at least one character!");
System.out.println("Inside test_sample:
argument's value equals to: "" + s1 + """);
return 0;
}

public static void main(String... args) {

try {
Class<?> c1 =
Class.forName("main.samplejava. Example");
Object t1 = c1.newInstance();
Method[] declared_Methods =
c1.getDeclaredMethods();
for (Method method : declared_Methods) {
String methodName = method.getName();
if (methodName.contains("main"))
continue;
System.out.format("Invoking %s()%n",
methodName);
try {
method.setAccessible(true);
Object returnValue =
method.invoke(t1, "");
System.out.format("%s()
returned: %d%n", methodName, returnValue);
} catch (InvocationTargetException ex)
{
System.err.println("An
InvocationTargetException was caught!");
Throwable cause = ex.getCause();

253
 Chapter Five: Exception Handling in Java

System.out.format("Invocation of %s
failed because of: %s%n",
methodName,
cause.getMessage());
}
}
} catch (ClassNotFoundException |
InstantiationException | IllegalAccessException ex) {
System.err.println("The following exception
was thrown:");
ex.printStackTrace();
}
}
}

Output:

Invoking testMethod()

An InvocationTargetException was caught!

Invocation of testMethod failed because of: The string must contain at least one character!

Output:

This code will generate an InstantiationException.

5.8.2. Unchecked exception

The unchecked exceptions are those exceptions that occur during the execution of the program.
Hence they are also referred to as Runtime exceptions. These exceptions are generally ignored
during the compilation process. They are not checked while compiling the program. For
example, programming bugs like logical errors, and using incorrect APIs.

To illustrate the concept of an unchecked exception, let us consider the following code snippet:

import java.util.Scanner;
public class Sample_RunTimeException {
public static void main(String[] args) {

254
 Chapter Five: Exception Handling in Java

// Reading user input

Scanner input_dev = new Scanner(System.in);
System.out.print("Enter your age in Numbers:
");
int age1 = input_dev.nextInt();
if (age1>20) {
System.out.println("You can view the
page");
} else {
System.out.println("You cannot view the
page");
}
}
}

Output 1:

Enter your age in Numbers: 21

You can view the page

Output 2:

Enter your age in Numbers: Twelve

Exception in thread “main” java.util.InputMismatchException

at java.util.Scanner.throwFor (Unknown Source)

at java.util.Scanner.next (Unknown Source)

at java.util.Scanner.nextInt (Unknown Source)

at java.util.Scanner.nextInt (Unknown Source)

at exceptiondemo.sample_runtimedemo.main(Sample_RunTimeExceptionDemo.java:11)

The following are some of other unchecked exceptions.

255
 Chapter Five: Exception Handling in Java

NullPointerException
This type of exception occurs when you try to access an object with the help of a reference
variable whose current value is null or empty. For example, consider the following code snippet:

// Program to demonstrate the NullPointerException

class SampleNullPointer {
public static void main(String args[]) {
try {
String a1 = null; // null value
System.out.println(a1.charAt(0));
} catch(NullPointerException e) {
System.out.println("NullPointerException is
found in the program.");
}
}
}

Output:

NullPointerException is found in the program.

ArrayIndexOutofBound
This type of exception occurs when you try to access an array with an invalid index value. The
value you are providing is either negative or beyond the length of the array.

For example, consider the following code snippet:

// Program to demonstrate the

ArrayIndexOutOfBoundException
class sample_ArrayIndexOutOfBound {
public static void main(String args[]) {
try {
int b[] = new int[6];
b[8] = 2; // we are trying to access 9th
element in an array of size 7
} catch(ArrayIndexOutOfBoundsException e) {

256
 Chapter Five: Exception Handling in Java

System.out.println("The array index is out

of bound");
}
}
}

Output:

The array index is out of bound

IllegalArgumentException
This type of exception occurs whenever an inappropriate or incorrect argument is passed to a
method. For example, if a method is defined with non-empty string as parameters. But you are
providing null input strings. Then, the IllegalArgumentException is thrown to indicate the user
that you cannot pass a null input string to the method.

Consider the following code snippet to demonstrate this type of exception:

import java.io.File;
public class Sample_IllegalArgumentException {
public static String createRelativePath(String par,
String f_name) {
if (par == null)
throw new IllegalArgumentException("You
cannot provide null parent path!");
if (f_name == null)
throw new IllegalArgumentException("Please
enter the complete filename!");
return par + File.separator + f_name;
}
public static void main(String[] args) {
// This command will be successfully executed.

system.out.println(IllegalArgumentExceptionExample.crea
teRelativePath("dir1", "file1"));
system.out.println();

257
 Chapter Five: Exception Handling in Java

// This command will throw an

IllegalArgumentException.

System.out.println(IllegalArgumentExceptionExample.crea
teRelativePath(null, "file1"));
}
}

Output:

This code will generate an IllegalArgumentException.

IllegalStateException
This type of exception occurs when the state of the environment does not match the operation
being executed. For example, consider the following code snippet, which demonstrates this
type of exception:

/**
* This code will publish the current book.
* If the book is already published, it will throw an
IllegalStateException.
**/
public void pub() throws IllegalStateException {
Date pub_at = getPub_at();
if (pub_at == null) {
setPub_at(new Date());
Logging.log(String.format("Published '%s'
by %s.", getTitle(), getAuthor()));
} else {
throw new IllegalStateException(
String.format("Cannot publish '%s' by %s
(already published on %s).",
getTitle(), getAuthor(), pub_at));
}
}

Output:
258
 Chapter Five: Exception Handling in Java

This code will generate IllegalStateException.

If a publication date already exists in the System. then it will produce an IllegalStateException
that indicates that the book cannot be published again.

NumberFormatException
This type of exception occurs when you pass a string to a method that cannot be converted to
a number. For example, consider the following code snippet:

// Program to demonstrate the NumberFormatException

class Sample_NumberFormat {
public static void main(String args[]) {
try {
// "Test" is not a number
int n = Integer.parseInt ("Test") ;
System.out.println(n);
} catch(NumberFormatException e) {
System.out.println("Number format
exception");
}
}
}

Output:

This code will generate NumberFormatException.

ArithmeticException
This type of exception occurs when you perform an incorrect arithmetic operation. For example,
if you divide any number by zero, it will display such an exception. Let us consider the
following code snippet:

// Program to demonstrate the ArithmeticException

class Sample_ArithmeticException {
public static void main(String args[]) {
try {
int p = 30, q = 0;

259
 Chapter Five: Exception Handling in Java

int r = p/q; // It cannot be divided by

zero
System.out.println("Result = " + r);
} catch(ArithmeticException e) {
System.out.println("Number cannot be
divided by 0");
}
}
}

Output:

This code will generate an ArithmeticException.

Java defines several types of exceptions that relate to its various class libraries. Java also allows
users to define their own exceptions.

260
 Chapter Five: Exception Handling in Java

Week Twelve: Practical

Write a Java program to create a method that takes an integer as a parameter and throws an exception
if the number is odd.

Sample Solution:

Java Code:

public class Exception_OddNumber {

public static void main(String[] args) {

int n = 18;

trynumber(n);

n = 7;

trynumber(n);

public static void trynumber(int n) {

try {

checkEvenNumber(n);

System.out.println(n + " is even.");

} catch (IllegalArgumentException e) {

System.out.println("Error: " + e.getMessage());

public static void checkEvenNumber(int number) {

if (number % 2 != 0) {

261
 Chapter Five: Exception Handling in Java

throw new IllegalArgumentException(number + " is

odd.");

Sample Output:

18 is even.

Error: 7 is odd.

Explanation:

In the above exercise,

• The Exception_OddNumber class is the main class.

• In the main method, an integer n is declared and assigned 18. The trynumber method is then
called with n as an argument.

• The trynumber method handles the exception. It contains a try-catch block. Inside the try block,
the method checkEvenNumber is called, passing n as an argument. If the number is even, the
message "[number] is even." is printed.

• If an exception occurs in the try block, it is caught by the catch block, which handles
IllegalArgumentException. In this case, the error message "Error: [exception message]" is
printed.

• After the first call to trynumber(n), the value of n is updated to 7, and the trynumber method is
called again. This time, since 7 is an odd number, an exception is thrown.

• The checkEvenNumber method checks if a given number is even or odd. If the number is odd,
it throws an IllegalArgumentException with the message "[number] is odd."

262
 Chapter Five: Exception Handling in Java

Week Twelve: Assesment

Part I: Multiple choice Questions

1. What is an exception in Java?

a) An error that occurs during compilation

b) An unexpected event that occurs during program execution

c) A warning issued by the Java compiler

d) A reserved keyword in the Java language

2. What is the purpose of exception handling in Java?

a) To prevent exceptions from occurring

b) To hide exceptions from the user

c) To gracefully handle and recover from exceptions

d) To terminate the program when an exception occurs

3. Which keyword is used to throw an exception explicitly in Java?

a) throw

b) catch

c) try

d) finally

4. What is the role of the finally block in a try-catch-finally statement?

a) To catch and handle exceptions

b) To specify the code that is always executed, regardless of whether an exception occurs or not

c) To specify the code that is executed when an exception occurs

d) To specify the code that is executed after the try block but before any catch block

5. What is exception propagation in Java?

a) The process of creating and throwing custom exceptions

b) The process of handling multiple exceptions in a single try-catch block

c) The process of passing an exception from one method to its calling method

d) The process of catching and handling exceptions in nested try-catch blocks

263
 Chapter Five: Exception Handling in Java

6. Which exception will the following throw?

public class Test {

public static void main(String[] args) {

Object obj = new Integer(3);
String str = (String) obj;
System.out.println(str);
}
}

A. ArrayIndexOutOfBoundsException
B. ClassCastException
C. IllegalArgumentException
D. NumberFormatException
E. None of the above.

7. Which of the following are checked exceptions? (Choose all that apply)
A. Exception
B. IllegalArgumentException
C. IOException
D. NullPointerException
E. NumberFormatException
F. StackOverflowError

8. What is the output of the following Java program?

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

A. Compiler Error

264
 Chapter Five: Exception Handling in Java

B. Compiles and runs fine

C. Compiles fine but throws ArithmeticException exception
D. None of above

9. Which of the following exceptions are thrown by the JVM? (Choose all that apply)
A. ArrayIndexOutOfBoundsException
B. ExceptionInInitializerError
C. java.io.IOException
D. NullPointerException
E. NumberFormatException

10. What is the output of the following program?

public class Laptop {

public void start() {
try {
System.out.print("Starting up ");
throw new Exception();
} catch (Exception e) {
System.out.print("Problem ");
System.exit(0);
} finally {
System.out.print("Shutting down ");
}
}
public static void main(String[] args) {
new Laptop().start();
}
}

A. Starting up
B. Starting up Problem
C. Starting up Problem Shutting down
D. Starting up Shutting down
E. The code does not compile.
F. An uncaught exception is thrown

265
 Chapter Five: Exception Handling in Java

Reference
1. Java: A Beginner's Guide, Eighth Edition by Herbert Schildt
2. Java: How to Program, 9th Edition (Deitel)
3. https://www.javatpoint.com/

266
 Chapter Five: Exception Handling in Java

267
 Chapter Six: AWT, Swing and Java Applets

Chapter Six: AWT, Swing and Java Applets

Lesson Plan
1. Learning objectives

• Be able to work with GUI Programming

• Be able to Identify the AWT class hierarchy

• Iintroduction to Swing

• Be able to differentiate between Swing Vs AWT

• Be able to use some Swing components

• Be able to Design the Layout management of components

• Be able to Handle Events

2. Motivation

• Outputs through Question and Answer; repetitive discussion of handling errors.

• Solving a problem using GUI components

• Handle event response to GUI Interactions.

3. Expectations or Outcomes

 Design and code an Interactive GUI

 Can write GUI design using Java to solve any problem using programming.
4. Equipment

• Desktop or Laptop computer.

• Java IDE (NetBeans) software

5. Practice contents/Activities/Safety

 Brief introduction of Java complete development life cycle (Java IDE).

 Active practice; on java input and output, writing (Editing), compiling, interprating.

6. Assessments

• How can you install Java IDE (Netbeans) software?

• How to create class and objects?

268
 Chapter Six: AWT, Swing and Java Applets

7. Clean-up

 After finishing practice, computers should be properly shut down.

8. Independent practice/Follow-up activities

• Learning through assignment (practical exercises)

9. Review/Reflection

• Review the outcome of the practice, improvement measure and previous reflected
opinions.

269
 Chapter Six: AWT, Swing and Java Applets

Week Thirteen: Session

6.1 Introduction
All of the programs in this book have been console-based. This means that they do not make
use of a graphical user interface (GUI). Although console-based programs are excellent for
teaching the basics of Java and for some types of programs, such as server- side code, most
real-world client applications will be GUI-based. At the time of this writing, the most widely
used Java GUI is Swing.

Swing defines a collection of classes and interfaces that support a rich set of visual components,
such as buttons, text fields, scroll panes, check boxes, trees, and tables, to name a few.
Collectively, these controls can be used to construct powerful, yet easy-to- use graphical
interfaces. Because of its widespread use, Swing is something with which all Java programmers
should be familiar. Therefore, this chapter provides an introduction to this important GUI
framework.

It is important to state at the outset that Swing is a very large topic that requires an entire book
of its own. It then introduces five commonly used Swing components: the label, push button,
text field, checkbox, and list.

Swing did not exist in the early days of Java. Rather, it was a response to deficiencies present
in Java’s original GUI subsystem: the Abstract Window Toolkit (AWT). The AWT defines a
basic set of components that support a usable, but limited, graphical interface. One reason for
the limited nature of the AWT is that it translates its various visual components into their
corresponding, platform-specific equivalents, or peers. This means that the look and feel of an
AWT component is defined by the platform, not by Java. Because the AWT components use
native code resources, they are referred to as heavyweight.

The use of native peers led to several problems. First, because of differences between operating
systems, a component might look, or even act, differently on different platforms. This potential
variability threatened the overarching philosophy of Java: write once, run anywhere. Second,
the look and feel of each component was fixed (because it is defined by the platform) and could
not be (easily) changed. Third, the use of heavyweight components caused some frustrating
restrictions. For example, a heavyweight component was always opaque.

270
 Chapter Six: AWT, Swing and Java Applets

Not long after Java’s original release, it became apparent that the limitations and restrictions
present in the AWT were sufficiently serious that a better approach was needed. The solution
was Swing. Introduced in 1997, Swing was included as part of the Java Foundation Classes
(JFC). Swing was initially available for use with Java 1.1 as a separate library. However,
beginning with Java 1.2, Swing (and the rest of JFC) was fully integrated into Java.

Swing addresses the limitations associated with the AWT’s components through the use of two
key features: lightweight components and a. pluggable look and feel. Although they are largely
transparent to the programmer, these two features are at the foundation of Swing’s design
philosophy and the reason for much of its power and flexibility. Let’s look at each.

With very few exceptions, Swing components are lightweight. This means that a component is
written entirely in Java. They do not rely on platform-specific peers. Lightweight components
have some important advantages, including efficiency and flexibility. Furthermore, because
lightweight components do not translate into platform-specific peers, the look and feel of each
component is determined by Swing, not by the underlying operating system. This means that
each component can work in a consistent manner across all platforms.

Note that Swing does not replace the AWT. Rather, Swing builds upon the foundation provided
by aspects of the AWT. Thus, portions of the AWT are still a crucial part of Java. Although
knowledge of the AWT is not required by this chapter, you need a solid understanding of its
structure and features if you seek full Swing mastery.

6.2 AWT
Java AWT (Abstract Window Toolkit) is an API to develop Graphical User Interface (GUI)
or windows-based applications in Java.
Java AWT components are platform-dependent i.e. components are displayed according to the
view of operating system. AWT is heavy weight i.e. its components are using the resources of
underlying operating system (OS).
The java.awt package provides classes for AWT API such as TextField, Label, TextArea,
RadioButton, CheckBox, Choice, List etc.
The AWT tutorial will help the user to understand Java GUI programming in simple and easy
steps.

271
 Chapter Six: AWT, Swing and Java Applets

Why AWT is platform independent?

Java AWT calls the native platform calls the native platform (operating systems) subroutine
for creating API components like TextField, ChechBox, button, etc.
For example, an AWT GUI with components like TextField, label and button will have
different look and feel for the different platforms like Windows, MAC OS, and Unix. The
reason for this is the platforms have different view for their native components and AWT
directly calls the native subroutine that creates those components.
In simple words, an AWT application will look like a windows application in Windows OS
whereas it will look like a Mac application in the MAC OS.

Java AWT Hierarchy

The hierarchy of Java AWT classes are given below.

Figure 21: Java AWT Hierarchy

Components

All the elements like the button, text fields, scroll bars, etc. are called components. In Java
AWT, there are classes for each component as shown in above diagram. In order to place every
component in a particular position on a screen, we need to add them to a container.

272
 Chapter Six: AWT, Swing and Java Applets

Container
The Container is a component in AWT that can contain another components like buttons,
textfields, labels etc. The classes that extends Container class are known as container such as
Frame, Dialog and Panel.
It is basically a screen where the where the components are placed at their specific locations.
Thus it contains and controls the layout of components.

Note: A container itself is a component (see the above diagram), therefore we can add a
container inside container.

Types of containers:
There are four types of containers in Java AWT:
1. Window
2. Panel
3. Frame
4. Dialog

Window
The window is the container that have no borders and menu bars. You must use frame, dialog
or another window for creating a window. We need to create an instance of Window class to
create this container.

Panel
The Panel is the container that doesn't contain title bar, border or menu bar. It is generic
container for holding the components. It can have other components like button, text field etc.
An instance of Panel class creates a container, in which we can add components.

Frame
The Frame is the container that contain title bar and border and can have menu bars. It can have
other components like button, text field, scrollbar etc. Frame is most widely used container
while developing an AWT application.

273
 Chapter Six: AWT, Swing and Java Applets

Useful Methods of Component Class

Table 0-18: Methods of Component Class

Method Description

public void add(Component c) Inserts a component on this component.

public void setSize(int width,int height) Sets the size (width and height) of the
component.

public void setLayout(LayoutManager Defines the layout manager for the component.
m)

public void setVisible(boolean status) Changes the visibility of the component, by

default false.

Java AWT Example

To create simple AWT example, you need a frame. There are two ways to create a GUI using
Frame in AWT.

1. By extending Frame class (inheritance)

2. By creating the object of Frame class (association)

AWT Example by Inheritance

Let's see a simple example of AWT where we are inheriting Frame class. Here, we are showing
Button component on the Frame.
AWTExample1.java
// importing Java AWT class
import java.awt.*;
// extending Frame class to our class AWTExample1
public class AWTExample1 extends Frame {
// initializing using constructor
AWTExample1() {
// creating a button
Button b = new Button("Click Me!!");
// setting button position on screen

274
 Chapter Six: AWT, Swing and Java Applets

b.setBounds(30,100,80,30);
// adding button into frame
add(b);
// frame size 300 width and 300 height
setSize(300,300);
// setting the title of Frame
setTitle("This is our basic AWT example");
// no layout manager
setLayout(null);
// now frame will be visible, by default it is no
t visible
setVisible(true);
}
// main method
public static void main(String args[]) {

// creating instance of Frame class

AWTExample1 f = new AWTExample1();
}
}

The setBounds(int x-axis, int y-axis, int width, int height) method is used in the above example
that sets the position of the awt button.

Output:

275
 Chapter Six: AWT, Swing and Java Applets

AWT Example by Association

Let's see a simple example of AWT where we are creating instance of Frame class. Here, we
are creating a TextField, Label and Button component on the Frame.
AWTExample2.java
// importing Java AWT class
import java.awt.*;
// class AWTExample2 directly creates instance of Frame
class
class AWTExample2 {
// initializing using constructor
AWTExample2() {
// creating a Frame
Frame f = new Frame();
// creating a Label
Label l = new Label("Employee id:");
// creating a Button
Button b = new Button("Submit");
// creating a TextField
TextField t = new TextField();
// setting position of above components in the fr
ame
l.setBounds(20, 80, 80, 30);
t.setBounds(20, 100, 80, 30);
b.setBounds(100, 100, 80, 30);
// adding components into frame
f.add(b);
f.add(l);
f.add(t);
// frame size 300 width and 300 height
f.setSize(400,300);
// setting the title of frame
f.setTitle("Employee info");
// no layout
f.setLayout(null);

276
 Chapter Six: AWT, Swing and Java Applets

// setting visibility of frame

f.setVisible(true);
}
// main method
public static void main(String args[]) {

// creating instance of Frame class

AWTExample2 awt_obj = new AWTExample2();
}
}

Output:

6.2.1 Event and Listener (Java Event Handling)

Changing the state of an object is known as an event. For example, click on button, dragging
mouse etc. The java.awt.event package provides many event classes and Listener interfaces for
event handling.

277
 Chapter Six: AWT, Swing and Java Applets

Java Event classes and Listener interfaces

Table 0-19: Java Event classes

Event Classes Listener Interfaces

ActionEvent ActionListener

MouseEvent MouseListener and MouseMotionListener

MouseWheelEvent MouseWheelListener

KeyEvent KeyListener

ItemEvent ItemListener

TextEvent TextListener

AdjustmentEvent AdjustmentListener

WindowEvent WindowListener

ComponentEvent ComponentListener

ContainerEvent ContainerListener

FocusEvent FocusListener

Steps to perform Event Handling

Following steps are required to perform event handling:

1. Register the component with the Listener

Registration Methods
For registering the component with the Listener, many classes provide the registration methods.
For example:

• Button
o public void addActionListener(ActionListener a){}
• MenuItem
o public void addActionListener(ActionListener a){}
• TextField

278
 Chapter Six: AWT, Swing and Java Applets

o public void addActionListener(ActionListener a){}

o public void addTextListener(TextListener a){}
• TextArea
o public void addTextListener(TextListener a){}
• Checkbox
o public void addItemListener(ItemListener a){}
• Choice
o public void addItemListener(ItemListener a){}
• List
o public void addActionListener(ActionListener a){}
o public void addItemListener(ItemListener a){}

Java Event Handling Code

We can put the event handling code into one of the following places:

1. Within class
2. Other class
3. Anonymous class

1. Java event handling by implementing ActionListener

import java.awt.*;
import java.awt.event.*;
class AEvent extends Frame implements ActionListener{
TextField tf;
AEvent(){
//create components
tf=new TextField();
tf.setBounds(60,50,170,20);
Button b=new Button("click me");
b.setBounds(100,120,80,30);
//register listener
b.addActionListener(this);//passing current instance
//add components and set size, layout and visibility
add(b);add(tf);

279
 Chapter Six: AWT, Swing and Java Applets

setSize(300,300);
setLayout(null);
setVisible(true);
}
public void actionPerformed(ActionEvent e){
tf.setText("Welcome");
}
public static void main(String args[]){
new AEvent();
}
}

public void setBounds(int xaxis, int yaxis, int width, int height); have been used in the above
example that sets the position of the component it may be button, textfield etc.

2. Java event handling by outer class

import java.awt.*;
import java.awt.event.*;
class AEvent2 extends Frame{
TextField tf;

280
 Chapter Six: AWT, Swing and Java Applets

AEvent2(){
//create components
tf=new TextField();
tf.setBounds(60,50,170,20);
Button b=new Button("click me");
b.setBounds(100,120,80,30);
//register listener
Outer o=new Outer(this);
b.addActionListener(o);//passing outer class instance
//add components and set size, layout and visibility
add(b);add(tf);
setSize(300,300);
setLayout(null);
setVisible(true);
}
public static void main(String args[]){
new AEvent2();
}
}
import java.awt.event.*;
class Outer implements ActionListener{
AEvent2 obj;
Outer(AEvent2 obj){
this.obj=obj;
}
public void actionPerformed(ActionEvent e){
obj.tf.setText("welcome");
}
}

3. Java event handling by anonymous class

import java.awt.*;
import java.awt.event.*;

281
 Chapter Six: AWT, Swing and Java Applets

class AEvent3 extends Frame{

TextField tf;
AEvent3(){
tf=new TextField();
tf.setBounds(60,50,170,20);
Button b=new Button("click me");
b.setBounds(50,120,80,30);

b.addActionListener(new ActionListener(){
public void actionPerformed(){
tf.setText("hello");
}
});
add(b);add(tf);
setSize(300,300);
setLayout(null);
setVisible(true);
}
public static void main(String args[]){
new AEvent3();
}
}

6.2.2 Java AWT Button

A button is basically a control component with a label that generates an event when pushed.
The Button class is used to create a labeled button that has platform independent
implementation. The application result in some action when the button is pushed.
When we press a button and release it, AWT sends an instance of ActionEvent to that button
by calling processEvent on the button. The processEvent method of the button receives the
all the events, then it passes an action event by calling its own method processActionEvent.
This method passes the action event on to action listeners that are interested in the action events
generated by the button.

282
 Chapter Six: AWT, Swing and Java Applets

To perform an action on a button being pressed and released, the ActionListener interface
needs to be implemented. The registered new listener can receive events from the button by
calling addActionListener method of the button. The Java application can use the button's
action command as a messaging protocol.

AWT Button Class Declaration

1. public class Button extends Component implements Accessible

Button Class Constructors

Following table shows the types of Button class constructors

Table 0-20: Button class constructors

Sr. Constructor Description

no.

1. Button( ) It constructs a new button with an empty string i.e. it has no

label.

2. Button (String text) It constructs a new button with given string as its label.

Button Class Methods

Table 0-21: Button Class Methods

Sr. Method Description

no.

1. void setText (String text) It sets the string message on the button

2. String getText() It fetches the String message on the button.

3. void setLabel (String label) It sets the label of button with the specified
string.

4. String getLabel() It fetches the label of the button.

5. void addNotify() It creates the peer of the button.

283
 Chapter Six: AWT, Swing and Java Applets

Sr. Method Description

no.

6. AccessibleContext It fetched the accessible context associated

getAccessibleContext() with the button.

7. void addActionListener(ActionListener It adds the specified action listener to get

l) the action events from the button.

8. String getActionCommand() It returns the command name of the action

event fired by the button.

9. ActionListener[ ] getActionListeners() It returns an array of all the action listeners

registered on the button.

10. T[ ] getListeners(Class listenerType) It returns an array of all the objects

currently registered as FooListeners upon
this Button.

11. protected String paramString() It returns the string which represents the
state of button.

12. protected void processActionEvent It process the action events on the button
(ActionEvent e) by dispatching them to a registered
ActionListener object.

13. protected void processEvent It process the events on the button

(AWTEvent e)

14. void removeActionListener It removes the specified action listener so

(ActionListener l) that it no longer receives action events
from the button.

15. void setActionCommand(String It sets the command name for the action
command) event given by the button.

Note: The Button class inherits methods from java.awt.Component and java.lang.Object
classes.

284
 Chapter Six: AWT, Swing and Java Applets

Java AWT Button Example

ButtonExample.java
// importing necessary libraries
import java.awt.*;
import java.awt.event.*;
public class ButtonExample3 {
public static void main(String[] args) {
// create instance of frame with the label
Frame f = new Frame("Button Example");
final TextField tf=new TextField();
tf.setBounds(50,50, 150,20);
// create instance of button with label
Button b=new Button("Click Here");
// set the position for the button in frame
b.setBounds(50,100,60,30);
b.addActionListener(new ActionListener() {
public void actionPerformed (ActionEvent e) {
tf.setText("Welcome to Javatpoint.");
}
});
// adding button the frame
f.add(b);
// adding textfield the frame
f.add(tf);
// setting size, layout and visibility
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}
}

Output:

285
 Chapter Six: AWT, Swing and Java Applets

6.2.3 Java AWT Label

The object of the Label class is a component for placing text in a container. It is used to display
a single line of read only text. The text can be changed by a programmer but a user cannot edit
it directly. It is called a passive control as it does not create any event when it is accessed. To
create a label, we need to create the object of Label class.

AWT Label Class Declaration

1. public class Label extends Component implements Accessible

AWT Label Fields

The java.awt.Component class has following fields:

1. static int LEFT: It specifies that the label should be left justified.
2. static int RIGHT: It specifies that the label should be right justified.
3. static int CENTER: It specifies that the label should be placed in center.

Label class Constructors

Table 0-22: Label class Constructors

Sr. Constructor Description

no.

1. Label() It constructs an empty label.

2. Label(String text) It constructs a label with the given string (left

justified by default).

3. Label(String text, int It constructs a label with the specified string and the
alignement) specified alignment.

Label Class Methods

Table 0-23: Label Class Methods

Sr. Method name Description
no.

1. void setText(String text) It sets the texts for label with the specified text.

286
 Chapter Six: AWT, Swing and Java Applets

Sr. Method name Description

no.

2. void setAlignment(int alignment) It sets the alignment for label with the
specified alignment.

3. String getText() It gets the text of the label

4. int getAlignment() It gets the current alignment of the label.

5. void addNotify() It creates the peer for the label.

6. AccessibleContext It gets the Accessible Context associated with

getAccessibleContext() the label.

7. protected String paramString() It returns the string the state of the label.

Method inherited
The above methods are inherited by the following classes:

• java.awt.Component
• java.lang.Object

6.2.4 Java AWT Label Example

Java AWT Label Example with ActionListener

In the following example, we are creating the objects of TextField, Label and Button classes
and adding them to the Frame. Using the actionPerformed() method an event is generated over
the button. When we add the website in the text field and click on the button, we get the IP
address of website.
LabelExample2.java
import java.awt.*;
import java.awt.event.*;
// creating class which implements ActionListener interface
and inherits Frame class
public class LabelExample2 extends Frame implements ActionLi
stener{
// creating objects of TextField, Label and Button class
TextField tf;

287
 Chapter Six: AWT, Swing and Java Applets

Label l;
Button b;
// constructor to instantiate the above objects
LabelExample2() {
tf = new TextField();
tf.setBounds(50, 50, 150, 20);
l = new Label();
l.setBounds(50, 100, 250, 20);
b = new Button("Find IP");
b.setBounds(50,150,60,30);
b.addActionListener(this);
add(b);
add(tf);
add(l);
setSize(400,400);
setLayout(null);
setVisible(true);
}
// defining actionPerformed method to generate an event
public void actionPerformed(ActionEvent e) {
try {
String host = tf.getText();
String ip = java.net.InetAddress.getByName(host).get
HostAddress();
l.setText("IP of "+host+" is: "+ip);
}
catch (Exception ex) {
System.out.println(ex);
}
}
// main method
public static void main(String[] args) {
new LabelExample2();
}
}

288
 Chapter Six: AWT, Swing and Java Applets

Output:

6.2.5 Java AWT TextField

The object of a TextField class is a text component that allows a user to enter a single line text
and edit it. It inherits TextComponent class, which further inherits Component class.
When we enter a key in the text field (like key pressed, key released or key typed), the event is
sent to TextField. Then the KeyEvent is passed to the registered KeyListener. It can also be
done using ActionEvent; if the ActionEvent is enabled on the text field, then the ActionEvent
may be fired by pressing return key. The event is handled by the ActionListener interface.

AWT TextField Class Declaration

1. public class TextField extends TextComponent

TextField Class constructors

Table 0-24: TextField Class constructors and Methods

Sr. Constructor Description

no.

1. TextField() It constructs a new text field component.

2. TextField(String text) It constructs a new text field initialized with the given
string text to be displayed.

3. TextField(int columns) It constructs a new textfield (empty) with given number

of columns.

289
 Chapter Six: AWT, Swing and Java Applets

Sr. Constructor Description

no.

4. TextField(String text, int It constructs a new text field with the given text and
columns) given number of columns (width).

TextField Class Methods

Sr. Method name Description

no.

1. void addNotify() It creates the peer of text field.

2. boolean echoCharIsSet() It tells whether text field has character set

for echoing or not.

3. void addActionListener(ActionListener l) It adds the specified action listener to

receive action events from the text field.

4. ActionListener[] getActionListeners() It returns array of all action listeners

registered on text field.

5. AccessibleContext It fetches the accessible context related to

getAccessibleContext() the text field.

6. int getColumns() It fetches the number of columns in text

field.

7. char getEchoChar() It fetches the character that is used for

echoing.

8. Dimension getMinimumSize() It fetches the minimum dimensions for

the text field.

9. Dimension getMinimumSize(int It fetches the minimum dimensions for

columns) the text field with specified number of
columns.

10. Dimension getPreferredSize() It fetches the preferred size of the text

field.

290
 Chapter Six: AWT, Swing and Java Applets

Sr. Method name Description

no.

11. Dimension getPreferredSize(int columns) It fetches the preferred size of the text
field with specified number of columns.

12. protected String paramString() It returns a string representing state of the

text field.

13. protected void It processes action events occurring in the

processActionEvent(ActionEvent e) text field by dispatching them to a
registered ActionListener object.

14. protected void processEvent(AWTEvent It processes the event on text field.

e)

15. void It removes specified action listener so

removeActionListener(ActionListener l) that it doesn't receive action events
anymore.

16. void setColumns(int columns) It sets the number of columns in text

field.

17. void setEchoChar(char c) It sets the echo character for text field.

18. void setText(String t) It sets the text presented by this text

component to the specified text.

Method Inherited

The AWT TextField class inherits the methods from below classes:
1. java.awt.TextComponent
2. java.awt.Component
3. java.lang.Object

291
 Chapter Six: AWT, Swing and Java Applets

6.2.6 Java AWT TextField Example

Java AWT TextField Example with ActionListener

TextFieldExample2.java
// importing necessary libraries
import java.awt.*;
import java.awt.event.*;
// Our class extends Frame class and implements ActionListen
er interface
public class TextFieldExample2 extends Frame implements Acti
onListener {
// creating instances of TextField and Button class
TextField tf1, tf2, tf3;
Button b1, b2;
// instantiating using constructor
TextFieldExample2() {
// instantiating objects of text field and button
// setting position of components in frame
tf1 = new TextField();
tf1.setBounds(50, 50, 150, 20);
tf2 = new TextField();
tf2.setBounds(50, 100, 150, 20);
tf3 = new TextField();
tf3.setBounds(50, 150, 150, 20);
tf3.setEditable(false);

292
 Chapter Six: AWT, Swing and Java Applets

b1 = new Button("+");
b1.setBounds(50, 200, 50, 50);
b2 = new Button("-");
b2.setBounds(120,200,50,50);
// adding action listener
b1.addActionListener(this);
b2.addActionListener(this);
// adding components to frame
add(tf1);
add(tf2);
add(tf3);
add(b1);
add(b2);
// setting size, layout and visibility of frame
setSize(300,300);
setLayout(null);
setVisible(true);
}
// defining the actionPerformed method to generate an ev
ent on buttons
public void actionPerformed(ActionEvent e) {
String s1 = tf1.getText();
String s2 = tf2.getText();
int a = Integer.parseInt(s1);
int b = Integer.parseInt(s2);
int c = 0;
if (e.getSource() == b1){
c = a + b;
}
else if (e.getSource() == b2){
c = a - b;
}
String result = String.valueOf(c);
tf3.setText(result);
}
// main method
public static void main(String[] args) {

293
 Chapter Six: AWT, Swing and Java Applets

new TextFieldExample2();
}
}

Output:

6.2.7 AWT Checkbox

The Checkbox class is used to create a checkbox. It is used to turn an option on (true) or off
(false). Clicking on a Checkbox changes its state from "on" to "off" or from "off" to "on".

AWT Checkbox Class Declaration

1. public class Checkbox extends Component implements ItemSelectable, Accessible

Checkbox Class Constructors

Table 0-25: Checkbox Class Constructors

Sr. Constructor Description

no.

1. Checkbox() It constructs a checkbox with no string as the

label.

2. Checkbox(String label) It constructs a checkbox with the given label.

294
 Chapter Six: AWT, Swing and Java Applets

Sr. Constructor Description

no.

3. Checkbox(String label, boolean It constructs a checkbox with the given label and
state) sets the given state.

4. Checkbox(String label, boolean It constructs a checkbox with the given label, set
state, CheckboxGroup group) the given state in the specified checkbox group.

5. Checkbox(String label, It constructs a checkbox with the given label, in

CheckboxGroup group, boolean the given checkbox group and set to the
state) specified state.

Method inherited by Checkbox

The methods of Checkbox class are inherited by following classes:
• java.awt.Component
• java.lang.Object
Checkbox Class Methods

Table 0-26: Checkbox Class Methods

Sr. Method name Description

no.

1. void addItemListener(ItemListener It adds the given item listener to get the

IL) item events from the checkbox.

2. AccessibleContext It fetches the accessible context of

getAccessibleContext() checkbox.

3. void addNotify() It creates the peer of checkbox.

4. CheckboxGroup It determines the group of checkbox.

getCheckboxGroup()

5. ItemListener[] getItemListeners() It returns an array of the item listeners

registered on checkbox.

6. String getLabel() It fetched the label of checkbox.

295
 Chapter Six: AWT, Swing and Java Applets

Sr. Method name Description

no.

7. T[] getListeners(Class listenerType) It returns an array of all the objects

registered as FooListeners.

8. Object[] getSelectedObjects() It returns an array (size 1) containing

checkbox label and returns null if
checkbox is not selected.

9. boolean getState() It returns true if the checkbox is on,

else returns off.

10. protected String paramString() It returns a string representing the state

of checkbox.

11. protected void It processes the event on checkbox.

processEvent(AWTEvent e)

12. protected void It process the item events occurring in

processItemEvent(ItemEvent e) the checkbox by dispatching them to
registered ItemListener object.

13. void It removes the specified item listener

removeItemListener(ItemListener l) so that the item listener doesn't receive
item events from the checkbox
anymore.

14. void It sets the checkbox's group to the

setCheckboxGroup(CheckboxGroup given checkbox.
g)

15. void setLabel(String label) It sets the checkbox's label to the string
argument.

16. void setState(boolean state) It sets the state of checkbox to the

specified state.

296
 Chapter Six: AWT, Swing and Java Applets

6.2.8 Java AWT Checkbox Example

Java AWT Checkbox Example with ItemListener
In the following example, we have created two checkboxes and adding them into the Frame.
Here, we are adding the ItemListener with the checkbox which displays the state of the
checkbox (whether it is checked or unchecked) using the getStateChange() method.
CheckboxExample2.java
// importing necessary packages
import java.awt.*;
import java.awt.event.*;
public class CheckboxExample2
{
// constructor to initialize
CheckboxExample2() {
// creating the frame
Frame f = new Frame ("CheckBox Example");
// creating the label
final Label label = new Label();
// setting the alignment, size of label
label.setAlignment(Label.CENTER);
label.setSize(400,100);
// creating the checkboxes
Checkbox checkbox1 = new Checkbox("C++");
checkbox1.setBounds(100, 100, 50, 50);
Checkbox checkbox2 = new Checkbox("Java");
checkbox2.setBounds(100, 150, 50, 50);
// adding the checkbox to frame
f.add(checkbox1);
f.add(checkbox2);
f.add(label);

// adding event to the checkboxes

checkbox1.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {

label.setText("C++ Checkbox: "

297
 Chapter Six: AWT, Swing and Java Applets

+ (e.getStateChange()==1?"checked":"unchecke
d"));
}
});
checkbox2.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent e) {

label.setText("Java Checkbox: "

+ (e.getStateChange()==1?"checked":"unchecke
d"));
}
});
// setting size, layout and visibility of frame
f.setSize(400,400);
f.setLayout(null);
f.setVisible(true);
}
// main method
public static void main(String args[])
{
new CheckboxExample2();
}
}

Output:

298
 Chapter Six: AWT, Swing and Java Applets

6.2.9 Java AWT Choice

The object of Choice class is used to show popup menu of choices. Choice selected by user is
shown on the top of a menu. It inherits Component class.

AWT Choice Class Declaration

1. public class Choice extends Component implements ItemSelectable, Accessible

Choice Class constructor

Sr. no. Constructor Description

1. Choice() It constructs a new choice menu.

Methods inherited by class

The methods of Choice class are inherited by following classes:

• java.awt.Component
• java.lang.Object

Choice Class Methods

Table 0-27: Choice Class Methods

Sr. Method name Description

no.

1. void add(String item) It adds an item to the choice menu.

2. void addItemListener(ItemListener It adds the item listener that receives item events
l) from the choice menu.

3. void addNotify() It creates the peer of choice.

4. AccessibleContext It gets the accessbile context related to the

getAccessibleContext() choice.

5. String getItem(int index) It gets the item (string) at the given index
position in the choice menu.

299
 Chapter Six: AWT, Swing and Java Applets

Sr. Method name Description

no.

6. int getItemCount() It returns the number of items of the choice

menu.

7. ItemListener[] getItemListeners() It returns an array of all item listeners registered

on choice.

8. T[] getListeners(Class Returns an array of all the objects currently

listenerType) registered as FooListeners upon this Choice.

9. int getSelectedIndex() Returns the index of the currently selected item.

10. String getSelectedItem() Gets a representation of the current choice as a

string.

11. Object[] getSelectedObjects() Returns an array (length 1) containing the

currently selected item.

12. void insert(String item, int index) Inserts the item into this choice at the specified
position.

13. protected String paramString() Returns a string representing the state of this
Choice menu.

14. protected void It processes the event on the choice.

processEvent(AWTEvent e)

15. protected void processItemEvent Processes item events occurring on this Choice
(ItemEvent e) menu by dispatching them to any registered
ItemListener objects.

16. void remove(int position) It removes an item from the choice menu at the
given index position.

17. void remove(String item) It removes the first occurrence of the item from
choice menu.

18. void removeAll() It removes all the items from the choice menu.

300
 Chapter Six: AWT, Swing and Java Applets

Sr. Method name Description

no.

19. void removeItemListener It removes the mentioned item listener. Thus is

(ItemListener l) doesn't receive item events from the choice
menu anymore.

20. void select(int pos) It changes / sets the selected item in the choice
menu to the item at given index position.

21. void select(String str) It changes / sets the selected item in the choice
menu to the item whose string value is equal to
string specified in the argument.

6.2.10 Java AWT Choice Example

Java AWT Choice Example with ActionListener
In the following example, we are creating a choice menu with 5 items. Along with that we are
creating a button and a label. Here, we are adding an event to the button component using
addActionListener(ActionListener a) method i.e. the selected item from the choice menu is
displayed on the label when the button is clicked.
ChoiceExample2.java
// importing necessary packages
import java.awt.*;
import java.awt.event.*;
public class ChoiceExample2 {
// class constructor
ChoiceExample2() {
// creating a frame
Frame f = new Frame(); // creating a fi
nal object of Label class
final Label label = new Label(); // sett
ing alignment and size of label component
label.setAlignment(Label.CENTER);
label.setSize(400, 100); // creating a b
utton

301
 Chapter Six: AWT, Swing and Java Applets

Button b = new Button("Show"); // setting

the bounds of button
b.setBounds(200, 100, 50, 20); // creatin
g final object of Choice class
final Choice c = new Choice(); // setting
bounds of choice menu
c.setBounds(100, 100, 75, 75); // adding 5
items to choice menu
c.add("C");
c.add("C++");
c.add("Java");
c.add("PHP");
c.add("Android");
// adding above components into the frame
f.add(c);
f.add(label);
f.add(b);
// setting size, layout and visibility of frame
f.setSize(400, 400);
f.setLayout(null);
f.setVisible(true);
// adding event to the button
// which displays the selected item from the list wh
en button is clicked
b.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

String data = "Programming language Selected: "+ c.

getItem(c.getSelectedIndex());
label.setText(data);
}
});
}

// main method
public static void main(String args[])
{

302
 Chapter Six: AWT, Swing and Java Applets

new ChoiceExample2();
}
}

Output:

303
 Chapter Six: AWT, Swing and Java Applets

Week Thirteen : Practical

Activity: AWTCounter

Write an AWT GUI application (called AWTCounter) as shown in the Figure. Each time the
"Count" button is clicked, the counter value shall increase by 1.

The program has three components:

1. a java.awt.Label "Counter";
2. a non-editable java.awt.TextField to display the counter value; and
3. a java.awt.Button "Count".

The components are placed inside the top-level AWT container java.awt.Frame, arranged in
FlowLayout.

import java.awt.*; // Using AWT container and

component classes
import java.awt.event.*; // Using AWT event classes and
listener interfaces

// An AWT program inherits from the top-level container

java.awt.Frame
public class AWTCounter extends Frame {
private Label lblCount; // Declare a Label component
private TextField tfCount; // Declare a TextField
component
304
 Chapter Six: AWT, Swing and Java Applets

private Button btnCount; // Declare a Button component

private int count = 0; // Counter's value

// Constructor to setup GUI components and event handlers

public AWTCounter () {
setLayout(new FlowLayout());
// "super" Frame, which is a Container, sets its
layout to FlowLayout to arrange
// the components from left-to-right, and flow to
next row from top-to-bottom.

lblCount = new Label("Counter"); // construct the

Label component
add(lblCount); // "super" Frame
container adds Label component

tfCount = new TextField(count + "", 10); // construct

the TextField component with initial text
tfCount.setEditable(false); // set to read-only
add(tfCount); // "super" Frame
container adds TextField component

btnCount = new Button("Count"); // construct the

Button component
add(btnCount); // "super" Frame
container adds Button component

BtnCountListener listener = new BtnCountListener();

btnCount.addActionListener(listener);
// "btnCount" is the source object that fires an
ActionEvent when clicked.
// The source object adds an instance of
BtnCountListener as an ActionEvent listener,
// which provides an ActionEvent handler called
actionPerformed().
// Clicking "Count" button calls back
actionPerformed().

305
 Chapter Six: AWT, Swing and Java Applets

setTitle("AWT Counter"); // "super" Frame sets its

title
setSize(300, 100); // "super" Frame sets its
initial window size

// For inspecting the Container/Components objects

// System.out.println(this);
// System.out.println(lblCount);
// System.out.println(tfCount);
// System.out.println(btnCount);
setVisible(true); // "super" Frame shows
// System.out.println(this);
// System.out.println(lblCount);
// System.out.println(tfCount);
// System.out.println(btnCount);
}

// The entry main() method

public static void main(String[] args) {
// Invoke the constructor to setup the GUI, by
allocating an instance
AWTCounter app = new AWTCounter();
// or simply "new AWTCounter();" for an anonymous
instance
}

// Define an inner class to handle the "Count" button-

click
private class BtnCountListener implements ActionListener
{
// ActionEvent handler - Called back upon button-
click.
@Override
public void actionPerformed(ActionEvent evt) {
++count; // Increase the counter value

306
 Chapter Six: AWT, Swing and Java Applets

// Display the counter value on the TextField

tfCount
tfCount.setText(count + ""); // Convert int to
String
}
}
}

You have to use control-c, or "close" the CMD shell, or hit the "terminate" button on Eclipse's
Console to terminate the program. This is because the program does not process the
WindowEvent fired by the "window-close" button.

TRY:

1. Modify the program (called AWTCounterDown) to count down, with an initial value of
88, as shown.
2. Modify the program (called AWTFactorial) to display n and factorial of n, as shown.
Clicking the "Next" button shall increase n by 1. n shall begin at 1.

307
 Chapter Six: AWT, Swing and Java Applets

Week Thirteen : Assesment

Part I: Multiple choice Questions

1) What does AWT stand for in Java?

a. Abstract Window Toolkit
b. Advanced Window Technology
c. Application Widget Toolkit
d. Automatic Window Tool
2) Which package provides AWT classes in Java?
a. java.awt
b. java.swing
c. java.io
d. java.net
3) Which of the following is not a component in AWT?
a. Button
b. Checkbox
c. Table
d. TextArea
4) What is the parent class of all AWT components?
a. java.awt.Panel
b. java.awt.Component
c. java.awt.Container
d. java.awt.Frame
5) Which method is used to add a component to a container in AWT?
a. add()
b. setComponent()
c. addComponent()
d. setLayout()

6) Which method is used to remove a component from a container in AWT?

a. remove()
b. deleteComponent()
c. removeComponent()

308
 Chapter Six: AWT, Swing and Java Applets

d. destroy()

7) Which layout manager arranges components in a grid of rows and columns?

a. FlowLayout
b. BorderLayout
c. GridLayout
d. CardLayout

8) Which layout manager arranges components in a single row or column?

a. FlowLayout
b. BorderLayout
c. GridLayout
d. BoxLayout

9) Which event is generated when a user clicks a button in AWT?

a. MouseEvent
b. ActionListener
c. KeyEvent
d. WindowEvent

10) Which event is generated when a user types a key in AWT?

a. MouseEvent
b. ActionListener
c. KeyEvent
d. WindowEvent

309
 Chapter Six: AWT, Swing and Java Applets

Week 14: Session

6.3 Swing
Java Swing tutorial is a part of Java Foundation Classes (JFC) that is used to create window-
based applications. It is built on the top of AWT (Abstract Windowing Toolkit) API and
entirely written in java. Unlike AWT, Java Swing provides platform-independent and
lightweight components.
The javax.swing package provides classes for java swing API such as JButton, JTextField,
JTextArea, JRadioButton, JCheckbox, JMenu, JColorChooser etc.

Difference between AWT and Swing

There are many differences between java awt and swing that are given below.

Table 0-28: Java AWT Vs Swing

No. Java AWT Java Swing

1) AWT components are platform-dependent. Java swing components are platform-

independent.

2) AWT components are heavyweight. Swing components are lightweight.

3) AWT doesn't support pluggable look and Swing supports pluggable look and feel.
feel.

4) AWT provides less components than Swing. Swing provides more powerful
components such as tables, lists, scrollpanes,
colorchooser, tabbedpane etc.

5) AWT doesn't follows MVC(Model View Swing follows MVC.

Controller) where model represents data, view
represents presentation and controller acts as
an interface between model and view.

What is JFC

The Java Foundation Classes (JFC) are a set of GUI components which simplify the
development of desktop applications.

310
 Chapter Six: AWT, Swing and Java Applets

6.3.1 Hierarchy of Java Swing classes

The hierarchy of java swing API is given below.

Figure 22: Hierarchy of Java Swing classes

Commonly used Methods of Component class
The methods of Component class are widely used in java swing that are given below.

Method Description

public void add(Component c) add a component on another component.

public void setSize(int width,int sets size of the component.

height)

public void sets the layout manager for the component.

setLayout(LayoutManager m)

public void setVisible(boolean b) sets the visibility of the component. It is by

default false.

311
 Chapter Six: AWT, Swing and Java Applets

Java Swing Examples

There are two ways to create a frame:
o By creating the object of Frame class (association)
o By extending Frame class (inheritance)
We can write the code of swing inside the main(), constructor or any other method.

Simple Java Swing Example

Let's see a simple swing example where we are creating one button and adding it on the JFrame
object inside the main() method.
File: FirstSwingExample.java
import javax.swing.*;
public class FirstSwingExample {
public static void main(String[] args) {
JFrame f=new JFrame();//creating instance of JFrame
JButton b=new JButton("click");//creating instance of JButto
n
b.setBounds(130,100,100, 40);//x axis, y axis, width, height

f.add(b);//adding button in JFrame

f.setSize(400,500);//400 width and 500 height
f.setLayout(null);//using no layout managers
f.setVisible(true);//making the frame visible
}
}

OutPut

312
 Chapter Six: AWT, Swing and Java Applets

Example of Swing by Association inside constructor

We can also write all the codes of creating JFrame, JButton and method call inside the java
constructor.
File: Simple.java
import javax.swing.*;
public class Simple {
JFrame f;
Simple(){
f=new JFrame();//creating instance of JFrame
JButton b=new JButton("click");//creating instance of JButto
n
b.setBounds(130,100,100, 40);
f.add(b);//adding button in JFrame
f.setSize(400,500);//400 width and 500 height
f.setLayout(null);//using no layout managers
f.setVisible(true);//making the frame visible
}
public static void main(String[] args) {
new Simple();
}
}

The setBounds(int xaxis, int yaxis, int width, int height)is used in the above example that sets
the position of the button.

Simple example of Swing by inheritance

We can also inherit the JFrame class, so there is no need to create the instance of JFrame class
explicitly.

import javax.swing.*;
public class Simple2 extends JFrame{//inheriting JFrame
JFrame f;
Simple2(){
JButton b=new JButton("click");//create button
b.setBounds(130,100,100, 40);

313
 Chapter Six: AWT, Swing and Java Applets

add(b);//adding button on frame

setSize(400,500);
setLayout(null);
setVisible(true);
}
public static void main(String[] args) {
new Simple2();
}}

314
 Chapter Six: AWT, Swing and Java Applets

Week Fourteen : Practical

Activity: SwingAdder

Write a Swing application called SwingAdder as shown. The "ADD" button adds the two integers
and display the result. The "CLEAR" button shall clear all the text fields.

Hints: Set the content-pane to 4x2 GridLayout. The components are added from left-to-right,
top-to-bottom.

import java.awt.*; // Using AWT's layouts

import java.awt.event.*; // Using AWT's event classes and
listener interfaces
import javax.swing.*; // Using Swing's components and
container

// A Swing application extends from javax.swing.JFrame

public class SwingAdder extends JFrame {
private JTextField tfNumber1, tfNumber2, tfResult;
private JButton btnAdd, btnClear;
private int number1, number2, result;

// Constructor to set up UI components and event handlers

public SwingAdder() {
// Swing components should be added to the content-
pane of the JFrame.
Container cp = getContentPane();

315
 Chapter Six: AWT, Swing and Java Applets

// Set this Container to grid layout of 4 rows and 2

columns
cp.setLayout(new GridLayout(4, 2, 10, 3));

// Components are added from left-to-right, top-to-

bottom
cp.add(new JLabel("First Number ")); // at (1, 1)
tfNumber1 = new JTextField(10);
tfNumber1.setHorizontalAlignment(JTextField.RIGHT);
cp.add(tfNumber1); // at (1, 2)
.......
.......

btnAdd = new JButton("ADD");

cp.add(btnAdd); // at (4, 1)
btnAdd.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent evt) {
number1 = Integer.parseInt(tfNumber1.getText());
......
}
});

btnClear = new JButton("CLEAR");

cp.add(btnClear); // at (4,
2)
btnClear.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent evt) {
......
}
});

setDefaultCloseOperation(EXIT_ON_CLOSE); // for the

"window-close" button
setTitle("Swing Adder");
setSize(300, 170);

316
 Chapter Six: AWT, Swing and Java Applets

setVisible(true);
}

// The entry main() method

public static void main(String[] args) {
// For thread safety, use the event-dispatching thread
to construct UI
javax.swing.SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run() {
new SwingAdder(); // Let the constructor does
the job
}
});
}
}

317
 Chapter Six: AWT, Swing and Java Applets

Week Fourteen : Assesment

Part II: Practical Excersise

1. Modify the above exercise (called SwingArithmetics) to include buttons "+", "-", "*",
"/","%" (remainder) and "CLEAR" as shown.

Part I: Multiple choice Questions

1) What is Swing in Java?

A. A programming language
B. A type of dance
C. A graphical user interface (GUI) toolkit
D. A data structure

2) Which class is the base class for all Swing components?

A. java.awt.Component
B. java.awt.Container
C. javax.swing.JComponent
D. javax.swing.JPanel

3) Which of the following is not a Swing container?

A. JFrame
B. JDialog
C. JButton
D. JTabbedPane

318
 Chapter Six: AWT, Swing and Java Applets

4) Which layout manager arranges components in a grid?

A. BorderLayout
B. FlowLayout
C. GridLayout
D. CardLayout

5) What is the purpose of the GroupLayout layout manager?

A. To arrange components in a grid
B. To arrange components in a circular layout
C. To arrange components in a nested layout
D. To arrange components based on their preferred sizes

6) Which of the following is not a Swing component?

A. JTextArea
B. JLabel
C. JScrollPane
D. JPanel

7) Which of the following components can display images?

A. JTextArea
B. JTable
C. JList
D. JLabel

8) Which of the following components can be used to select a color?

A. JSlider
B. JColorChooser
C. JSpinner
D. JCheckBox

9) Which of the following events is fired when a component gains focus?

A. mouseClicked
B. mouseEntered
C. focusGained
D. focusLost

319
 Chapter Six: AWT, Swing and Java Applets

10) Which of the following events is fired when a button is clicked?

A. mousePressed
B. mouseReleased
C. actionPerformed
D. keyPressed

11) Which of the following methods is used to add a component to a container?

A. addComponent()
B. addContainer()
C. addComponentToContainer()
D. add()

12) Which of the following methods is used to set the size of a component?
A. setSize()
B. setPreferredSize()
C. setBounds()
D. setMinimumSize()

13) Which of the following methods is used to set the layout manager of a container?
A. setLayoutManager ()
B. setLayout()
C. setContainerLayout()
D. setComponentLayout()

14) Which of the following methods is used to get the selected item from a JComboBox?
A. getSelectedItem()
B. getSelectedIndex()
C. getItemAt()
D. setSelectedItem()

15) Which of the following methods is used to set the title of a JFrame?
A. setTitle()
B. setLabel()
C. setText()
D. setCaption()

320
 Chapter Six: AWT, Swing and Java Applets

16) Which of the following methods is used to create a new JMenuBar object?
A. new JMenuBar()
B. createMenuBar()
C. makeMenuBar()
D. getMenuBar()

17) Which of the following methods is used to add a menu to a JMenuBar object?
A. addMenu()
B. createMenu()
C. makeMenu()
D. add()

18) Which of the following methods is used to create a new JMenuItem object?
A. new JMenuItem()
B. createMenuItem()
C. makeMenuItem()
D. getMenuItem()

19) Which of the following methods is used to add an ActionListener to a JButton object?
A. addAction()
B. addActionListener()
C. addListener()
D. addEventHandler()

20) Which of the following methods is used to display a JOptionPane dialog box?
A. showMessageDialog()
B. showInputDialog()
C. showOptionDialog()
D. showConfirmDialog()

321
 Chapter Six: AWT, Swing and Java Applets

Week Fifteen: Session

6.4 Applet
Applet is a special type of program that is embedded in the webpage to generate the dynamic
content. It runs inside the browser and works at client side.

Advantage of Applet
There are many advantages of applet. They are as follows:

• It works at client side so less response time.

• Secured
• It can be executed by browsers running under many plateforms, including Linux,
Windows, Mac Os etc.

Drawback of Applet

• Plugin is required at client browser to execute applet.

6.4.1 Hierarchy of Applet

Figure 23: Hierarchy of Applet

322
 Chapter Six: AWT, Swing and Java Applets

As displayed in the above diagram, Applet class extends Panel. Panel class extends Container
which is the subclass of Component.

Lifecycle of Java Applet

1. Applet is initialized.
2. Applet is started.
3. Applet is painted.
4. Applet is stopped.
5. Applet is destroyed.

Figure 24: Lifecycle of Java Applet

Lifecycle methods for Applet:

The java.applet.Applet class 4 life cycle methods and java.awt.Component class provides 1 life
cycle methods for an applet.

java.applet.Applet class

For creating any applet java.applet.Applet class must be inherited. It provides 4 life cycle
methods of applet.
1. public void init(): is used to initialized the Applet. It is invoked only once.

323
 Chapter Six: AWT, Swing and Java Applets

2. public void start(): is invoked after the init() method or browser is maximized. It is
used to start the Applet.
3. public void stop(): is used to stop the Applet. It is invoked when Applet is stop or
browser is minimized.
4. public void destroy(): is used to destroy the Applet. It is invoked only once.

java.awt.Component class

The Component class provides 1 life cycle method of applet.

1. public void paint(Graphics g): is used to paint the Applet. It provides Graphics class object
that can be used for drawing oval, rectangle, arc etc.

Who is responsible to manage the life cycle of an applet?

Java Plug-in software.

How to run an Applet?

There are two ways to run an applet

1. By html file.
2. By appletViewer tool (for testing purpose).

Simple example of Applet by html file:

To execute the applet by html file, create an applet and compile it. After that create an html file
and place the applet code in html file. Now click the html file.

//First.java
import java.applet.Applet;
import java.awt.Graphics;
public class First extends Applet{
public void paint(Graphics g){
g.drawString("welcome",150,150);
}
}

Note: class must be public because its object is created by Java Plugin software that resides on
the browser.

myapplet.html

324
 Chapter Six: AWT, Swing and Java Applets

<html>
<body>
<applet code="First.class" width="300" height="300">
</applet>
</body>
</html>

Simple example of Applet by appletviewer tool:

To execute the applet by appletviewer tool, create an applet that contains applet tag in comment
and compile it. After that run it by: appletviewer First.java. Now Html file is not required but
it is for testing purpose only.

//First.java
import java.applet.Applet;
import java.awt.Graphics;
public class First extends Applet{
public void paint(Graphics g){
g.drawString("welcome to applet",150,150);
}
}
/*
<applet code="First.class" width="300" height="300">
</applet>
*/

To execute the applet by appletviewer tool, write in command prompt:

c:\>javac First.java
c:\>appletviewer First.java

6.4.2 Displaying Graphics in Applet

java.awt.Graphics class provides many methods for graphics programming.

Commonly used methods of Graphics class:
1. public abstract void drawString(String str, int x, int y): is used to draw the specified
string.

325
 Chapter Six: AWT, Swing and Java Applets

2. public void drawRect(int x, int y, int width, int height): draws a rectangle with the
specified width and height.
3. public abstract void fillRect(int x, int y, int width, int height): is used to fill rectangle
with the default color and specified width and height.
4. public abstract void drawOval(int x, int y, int width, int height): is used to draw
oval with the specified width and height.
5. public abstract void fillOval(int x, int y, int width, int height): is used to fill oval
with the default color and specified width and height.
6. public abstract void drawLine(int x1, int y1, int x2, int y2): is used to draw line
between the points(x1, y1) and (x2, y2).
7. public abstract boolean drawImage(Image img, int x, int y, ImageObserver
observer): is used draw the specified image.
8. public abstract void drawArc(int x, int y, int width, int height, int startAngle, int
arcAngle): is used draw a circular or elliptical arc.
9. public abstract void fillArc(int x, int y, int width, int height, int startAngle, int
arcAngle): is used to fill a circular or elliptical arc.
10. public abstract void setColor(Color c): is used to set the graphics current color to the
specified color.
11. public abstract void setFont(Font font): is used to set the graphics current font to the
specified font.

Example of Graphics in applet:

import java.applet.Applet;
import java.awt.*;
public class GraphicsDemo extends Applet{
public void paint(Graphics g){
g.setColor(Color.red);
g.drawString("Welcome",50, 50);
g.drawLine(20,30,20,300);
g.drawRect(70,100,30,30);
g.fillRect(170,100,30,30);
g.drawOval(70,200,30,30);
g.setColor(Color.pink);
g.fillOval(170,200,30,30);
g.drawArc(90,150,30,30,30,270);

326
 Chapter Six: AWT, Swing and Java Applets

g.fillArc(270,150,30,30,0,180);
}
}

myapplet.html

<html>
<body>
<applet code="GraphicsDemo.class" width="300" height="300">

</applet>
</body>
</html>

Displaying Image in Applet

Applet is mostly used in games and animation. For this purpose image is required to be
displayed. The java.awt.Graphics class provide a method drawImage() to display the image.
Syntax of drawImage() method:
1. public abstract boolean drawImage(Image img, int x, int y, ImageObserver
observer): is used draw the specified image.

How to get the object of Image:

The java.applet.Applet class provides getImage() method that returns the object of Image.
Syntax:
1. public Image getImage(URL u, String image){}
Other required methods of Applet class to display image:
1. public URL getDocumentBase(): is used to return the URL of the document in which
applet is embedded.
2. public URL getCodeBase(): is used to return the base URL.

Example of displaying image in applet:

import java.awt.*;
import java.applet.*;
public class DisplayImage extends Applet {
Image picture;
public void init() {

327
 Chapter Six: AWT, Swing and Java Applets

picture = getImage(getDocumentBase(),"sonoo.jpg");
}
public void paint(Graphics g) {
g.drawImage(picture, 30,30, this);
}
}

In the above example, drawImage() method of Graphics class is used to display the image.
The 4th argument of drawImage() method of is ImageObserver object. The Component class
implements ImageObserver interface. So current class object would also be treated as
ImageObserver because Applet class indirectly extends the Component class.

myapplet.html

<html>
<body>
<applet code="DisplayImage.class" width="300" height="300">
</applet>
</body>
</html>

6.4.3 Animation in Applet

Applet is mostly used in games and animation. For this purpose image is required to be moved.

Example of animation in applet:

import java.awt.*;
import java.applet.*;
public class AnimationExample extends Applet {
Image picture;
public void init() {
picture =getImage(getDocumentBase(),"bike_1.gif");
}
public void paint(Graphics g) {
for(int i=0;i<500;i++){
g.drawImage(picture, i,30, this);
try{Thread.sleep(100);}catch(Exception e){}
}
}

328
 Chapter Six: AWT, Swing and Java Applets

In the above example, drawImage() method of Graphics class is used to display the image.
The 4th argument of drawImage() method of is ImageObserver object. The Component class
implements ImageObserver interface. So current class object would also be treated as
ImageObserver because Applet class indirectly extends the Component class.

myapplet.html

<html>
<body>
<applet code="DisplayImage.class" width="300" height="300">

</applet>
</body>
</html>

6.4.4 EventHandling in Applet

As we perform event handling in AWT or Swing, we can perform it in applet also. Let's see
the simple example of event handling in applet that prints a message by click on the button.

Example of EventHandling in applet:

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class EventApplet extends Applet implements ActionLis
tener{
Button b;
TextField tf;
public void init(){
tf=new TextField();
tf.setBounds(30,40,150,20);
b=new Button("Click");
b.setBounds(80,150,60,50);
add(b);add(tf);
b.addActionListener(this);
setLayout(null);
}

329
 Chapter Six: AWT, Swing and Java Applets

public void actionPerformed(ActionEvent e){

tf.setText("Welcome");
}
}

In the above example, we have created all the controls in init() method because it is invoked only once.

myapplet.html

<html>
<body>
<applet code="EventApplet.class" width="300" height="300">
</applet>
</body>
</html>

6.4.5 Java Applet Security

A Java applet downloaded from the Web runs in either a Java-enabled Web browser or a Java
appletviewer, which is provided in the J2SE bundle. From a security standpoint, Java applets
downloaded from the Internet or from any remote sources are restricted from reading and
writing files and making network connections on client host systems. They are also restricted
from starting other programs, loading libraries, or making native calls on the client host system.
In general, applets downloaded from a network or remote sources are considered untrusted. An
applet can be considered trusted, based on the following factors:

Applets installed on a local filesystem or executed on a localhost.

Signed applets provide a way to verify that the applet is downloaded from a reliable source and
can be trusted to run with the permissions granted in the policy file.

In a Web browser, a Java plug-in provides a common framework and enables secure
deployment of applets in the browser using the JRE. While downloading an applet, the Java
plug-in enables the browser to install all the class files and then render the applet. A security
manager (SecurityManager implementation) will be automatically installed during startup
whenever an applet starts running in a Java-enabled Web browser. No downloaded applets are
allowed to access resources in the client host unless they are explicitly granted permission using
an entry in a Java security policy file.

330
 Chapter Six: AWT, Swing and Java Applets

Example below is source code for an applet named WriteFileApplet that attempts to create and
to write to a file named AppletGenrtdFile in the local directory.

Example. WriteFileApplet.java
import java.awt.*;
import java.io.*;
import java.lang.*;
import java.applet.*;
public class WriteFileApplet extends Applet
String myFile = "/tmp/AppletGenrtdFile";
File f = new File(myFile);
DataOutputStream dos;
public void init() {
String osname = System.getProperty("os.name");
if (osname.indexof("Windows") != -1) {
myFile="C:" + file.separator + "AppletGenrtdFile";
}
}
public void paint(Graphics g) {

try {
dos = new DataOutputStream(new BufferedOutputStream
(new FileOutputStream(myFile),128));
dos.writeChars("This is an Applet generated file\n");
dos.flush();
g.drawString("Success: Writing file"
+ myFile, 10, 10);
}
catch (SecurityException se) {
g.drawString("Write Failed: Security exception:
" + se, 10, 10);
}
catch (IOException ioe) {
g.drawString("Write Failed:I/O exception" + ioe, 10, 10);
}
}
}

331
 Chapter Six: AWT, Swing and Java Applets

To run the applet, you need to compile the source code using javac and then you may choose
to deploy this applet class along with an HTML page in a Web server. To do so, create an
HTML file (see Example below) called WriteFileApplet.html.

Example. WriteFileApplet.html
<html><head>
<title> Core Security Patterns Example: Applet
Security</title></head><body>
<h1> WriteFileApplet: Writing Files in the Client host </h1>
<hr>
<APPLET CODE = WriteFileApplet.class WIDTH=400 HEIGHT=40>
</APPLET>
<hr></body>
</html>

To execute this applet using an appletviewer, run the following :

appletviewer

http://coresecuritypatterns.com/WriteFileApplet.html

When executing this applet, you should receive the SecurityException in the applet window.
This applet shouldn't be able to write the file, because it does not have a security policy with a
file permission to write in the user's home directory.

Now, let's use the following policy file WriteAppletPolicy, which grants a write permission.
To do so, create a policy file (see Example below) called WriteAppletPolicy.policy in the
working directory:

Example. WriteAppletPolicy.policy
grant {
permission java.io.FilePermission "<<ALL FILES>>","write";
};

To test the applet using an appletviewer, you may choose to use the -J-
Djava.security.policy=WriteAppletPolicy.policy option on the JVM command line, or you can
explicitly specify your policy file in the JVM security properties file in the
<JAVA_HOME>/jre/lib/security directory:

policy.url.3=file:/export/xyz/WriteAppletpolicy.policy

332
 Chapter Six: AWT, Swing and Java Applets

Example below shows running the WriteFileApplet applet with the WriteAppletPolicy policy
file from the command-line interface.

Example . Running appletviewer using a Java security policy

appletviewer

-J-Djava.security.policy=WriteAppletPolicy.policy

http://coresecuritypatterns.com/WriteFileApplet.html

You should be able to run the WriteFileApplet applet successfully without a SecurityException,
and it should also be able to create and write the file AppletGenrtdFile in the client's local
directory. Now let's explore the concept of signed applets.

Signed Applets

The Java 2 platform introduced the notion of signed applets. Signing an applet ensures that an
applet's origin and its integrity are guaranteed by a certificate authority (CA) and that it can be
trusted to run with the permissions granted in the policy file. The J2SE bundle provides a set
of security tools that allows the end users and administrators to sign applets and applications,
and also to define local security policy. This is done by attaching a digital signature to the
applet that indicates who developed the applet and by specifying a local security policy in a
policy file mentioning the required access to local system resources.

The Java 2 platform requires an executable applet class to be packaged into a JAR file before
it is signed. The JAR file is signed using the private key of the applet creator. The signature is
verified using its public key by the client user of the JAR file. The public key certificate is sent
along with the JAR file to any client recipients who will use the applet. The client who receives
the certificate uses it to authenticate the signature on the JAR file. To sign the applet, we need
to obtain a certificate that is capable of code signing. For all production purposes, you must
always obtain a certificate from a CA such as VeriSign, Thawte, or some other CA.

The Java 2 platform introduced new key management tools to facilitate support for creating
signed applets:

• The keytool is used to create pairs of public and private keys, to import and display
certificate chains, to export certificates, and to generate X.509 v1 self-signed
certificates.

• The jarsigner tool is used to sign JAR files and also to verify the authenticity of the
signature(s) of signed JAR files.
333
 Chapter Six: AWT, Swing and Java Applets

• The policytool is used to create and modify the security policy configuration files.

Let's take a look at the procedure involved in creating a signed applet using our previous
WriteFileApplet applet example. The following steps are involved on the originating host
environment responsible for developing and deploying the signed applet:

1. Compile the Applet source code to an executable class. Use the javac command to
compile the WritefileApplet.java class. The output from the javac command is the
WriteFileApplet.class.

2. javac WriteFileApplet.java

3. Package the compiled class into a JAR file. Use the jar utility with the cvf option to
create a new JAR file with verbose mode (v), and specify the archive file name (f).

4. jar cvf WriteFileApplet.jar WriteFileApplet.class

5. Generate key pairs. Using the keytool utility, create the key pair and self-signed
certificate (for testing purposes only). The JAR file is signed with the creator's private
key and the signature is verified by the communicating peer of the JAR file with the
public key in the pair.

6. keytool -genkey -alias signapplet -keystore mykeystore

7. -keypass mykeypass

8. -storepass mystorepass

This keytool -genkey command generates a key pair that is identified by the alias signapplet.
Subsequent keytool commands are required to use this alias and the key password (-keypass
mykeypass) to access the private key in the generated pair. The generated key pair is stored in
a keystore database called mykeystore (-keystore mykeystore) in the current directory and is
accessed with the mystorepass password (-storepass mystorepass). The command also prompts
the signer to input information about the certificate, such as name, organization, location, and
so forth.

9. Sign the JAR file. Using the jarsigner utility (see Example 3-14), sign the JAR file and
verify the signature on the JAR files.

Example 3-14. Signing an applet using jarsigner tool

jarsigner -keystore mykeystore -storepass mystorepass

334
 Chapter Six: AWT, Swing and Java Applets

-keypass mykeypass -signedjar SignedWriteFileApplet.jar

WriteFileApplet.jar signapplet

The -storepass mystorepass and -keystore mykeystore options specify the keystore database
and password where the private key for signing the JAR file is stored. The -keypass mykeypass
option is the password to the private key, SignedWriteFileApplet.jar is the name of the signed
JAR file, and signapplet is the alias to the private key. jarsigner extracts the certificate from
the keystore and attaches it to the generated signature of the signed JAR file.

1. Export the public key certificate. The public key certificate will be sent with the JAR
file to the end user who will use it to authenticate the signed applet. To have trusted
interactions, the end user must have a copy of those public keys in its keystore. This is
accomplished by exporting the public key certificate from the originating JAR signer
keystore as a binary certificate file and then importing it into the client's keystore as a
trusted certificate. Using the keytool, export the certificate from mykeystore to a file
named mycertificate.cer as follows:

2. keytool -export -keystore mykeystore

3. -storepass mystorepass

4. -alias signapplet -file mycertificate.cer

5. Deploy the JAR and certificate files. They should be deployed to a distribution
directory on a Web server. Additionally, create a Web page embedding the applet and
the JAR. As shown in Example 3-15, the applet tag must use the following syntax.

Example . Deploying a signedapplet Jar

<applet code=WriteFileApplet.class
archive="SignedWriteFileApplet.jar"
codebase="/export/home/ws/"
width=400 height=40>
</applet>

In addition to the previous steps, the following steps are involved in the client's environment:

1. Import certificate as a trusted certificate. To download and execute the signed applet,
you must import the trusted public key certificate (provided by the issuer) into a
keystore database. The Java runtime will use this client-side keystore to store its trusted

335
 Chapter Six: AWT, Swing and Java Applets

certificates and to authenticate the signed applet. Using the Keytool utility, import the
trusted certificate provided by the issuer (see Example 3-16).

Example . Importing a certificate

keytool -import -alias clientcer –file mycertificate.cer

-keystore clientstore -storepass clientpass

1. Create the policy file. Create a policy file client.policy, which grants the applet to have
permission for creating and writing to the file "AppletGenrtdFile" in the client's local
directory (see Example 3-17).

Example . Sample policy file (Client.policy)

keystore "/export/home/clientstore";
grant SignedBy "clientcer" {
permission java.io.FilePermission "<<ALL FILES>>",
"write";
};

2. Run and test the applet using appletviewer. The appletviewer tool runs the HTML
document specified in the URL, which displays the applet in its own window. To run
the applet using the client policy file, enter the following at the command line (see
Example 3-18).

Example . Testing the applet using the client policy

appletviewer -J-Djava.security.policy=client.policy

http://coresecuritypatterns.com/SignedWriteFileApplet.html

336
 Chapter Six: AWT, Swing and Java Applets

Week Fifteen : Practical

Activity: AWTAccumulatorApplet (Obsolete)

NOTE: Most browsers today do not support Java applets anymore. Keep this section for
nostalgia.

An Java applet is a graphics program run inside a browser. Write a Java applet (called
AWTAccumulatorApplet) which contains:

1. a label "Enter an integer:",

2. a TextField for user to enter a number.
3. The applet shall accumulate all the integers entered and show it on the status bar of
the browser's window.

import java.applet.Applet;
import java.awt.*; // Using AWT's containers and
components
import java.awt.event.*; // Using AWT's event classes and
listener interfaces

// An applet extends java.applet.Applet

public class AWTAccumulatorApplet extends Applet implements
ActionListener {
private TextField tfInput; // The input TextField
private int sum = 0; // The accumulated sum,
init to 0

337
 Chapter Six: AWT, Swing and Java Applets

// init() runs when the applet is loaded. Setup the UI

components and event handlers.
public void init() {
add(new Label("Enter an integer")); // anonymous
Label

tfInput = new TextField(10);

add(tfInput);
tfInput.addActionListener(this);
// Hitting enter key on tfInput invokes
actionPerformed()
}

// ActionEvent handler - Called back when enter key was

hit on TextField.
public void actionPerformed( ActionEvent evt) {
int numberIn =
Integer.parseInt(evt.getActionCommand());
// getActionCommand() returns the String entered.
sum += numberIn;
tfInput.setText(""); // Clear input TextField
showStatus("The accumulated sum is: " + sum);
// show the sum on the status bar of the browser's
window
}
}

Note that: An applet extends from java.applet.Applet, whereas a standalone GUI

application extends from java.awt.Frame. You cannot setTitle() and setSize() on
Applet.

Applet uses init() to create the GUI, while standalone GUI application uses the constructor
(invoked in main()).

338
 Chapter Six: AWT, Swing and Java Applets

HTML codes: AWTAccumulatorApplet.html

Applet runs inside a web browser. A separate HTML script (says

AWTAccumulatorApplet.html) is required, which uses an <applet> tag to embed the applet as

follows:

<html>
<head>
<title>An AWT Applet</title>
</head>
<body>
<p>A simple applet which accumulates the number entered
into
a TextField and displays the accumulated sum on the
status bar</p>
<applet code="AWTAccumulatorApplet.class" width="300"
height="60">
</applet>
</body>
</html>

339
 Chapter Six: AWT, Swing and Java Applets

Week Fifteen: Assessment

Part I: Practical Excersise

1. Modify the applet to run the "Counter" application (as in AWTCounter).

2. Modify the applet to run the "Factorial" application (as in AWTFactorial).

Part I: Multiple choice Questions

1. An applet is a Java class that extends the?

A. java.Applet class
B. java class
C. Applet class
D. java.applet.Applet class

2. Applets are designed to be embedded within an __________.

A. Javascript
B. Css
C. HTML
D. SQL

3. Which of the following is required to view an applet?

A. JCM
B. JDM
C. JVM
D. Java class

4. Which method is automatically called after the browser calls the init method?

A. start
B. stop
C. destroy
D. paint

340
 Chapter Six: AWT, Swing and Java Applets

5. Which method is only called when the browser shuts down normally?

A. start
B. stop
C. destroy
D. paint

6. Which of these operators can be used to get run time information about an object?

A. getInfo
B. Info
C. instanceof
D. getinfoof

7. Which method causes the audio clip to replay continually?

A. public void play()

B. public void loop()
C. public void stop()
D. None of the above

8. paint() is an abstract method defined in AWT.

A. TRUE
B. FALSE
C. Can be true or false
D. Can not say

9. ___________ method is defined in Graphics class, it is used to output a string in an applet.

A. display()
B. Print()
C. drawString()
D. transient()

10. What will be output for the following code?

import java.awt.*;
import java.applet.*;
public class myapplet extends Applet
{
public void paint(Graphics g)

341
 Chapter Six: AWT, Swing and Java Applets

{
g.drawString(""A Simple Applet"", 20, 20);
}
}

A. A Simple Applet
B. A Simple Applet 20 20
C. Compilation Error
D. Runtime Error

342
 Chapter Six: AWT, Swing and Java Applets

Reference

1. Java: A Beginner's Guide, Eighth Edition by Herbert Schildt

2. Java: How to Program, 9th Edition (Deitel)
3. https://www.javatpoint.com/

343
 This textbook was developed by TVTI faculties through KOICA
project “Capacity Development for TVET Leaders and
Trainers in Ethiopia”

FDRE Technical and Vocational Training Institute

Yeka Subcity, Woreda 9, Addis Ababa, Ethiopia
Phone: 011-646-4455, Fax: 011-646-5675/5678
E-mail: info@ftveti.edu.et, Website: http://www.ftveti.edu.et