Core Java

HISTORY OF JAVA
• Java is developed by SUN Microsystems in 1991.
• Created by James Gosling, Patrick Naughton,, Chris
worth, Ed Frank Mike Sheridan.
• Initially it is called as “OAK” and renamed as “JAVA” in
1995
• Java is an object oriented and multi threaded
programming language.
PRIMARY MOTIVATION
 General purpose Language, language used for embedded
systems.
 Initially used for Consumer Devices like microwave ovens,

televisions, hand-held remote control named Star 7.

FEATURES OF JAVA
• Simple
• Secure
• Portable
• Object-oriented
• Robust
• Multithreaded
• Architecture-neutral
• Interpreted
• High performance
• Distributed
• Dynamic
• Simple:
– Java was designed to be easy for the professional
programmer to learn and use effectively.
– If you already understand the basic concepts of object-
oriented programming, learning Java will be even easier.
– In Java, there are a small number of clearly defined ways
to accomplish a given task.
• Secure
– Java does not use memory pointers explicitly. All the
programs in java are run under an area known as the sand
box.
– Security manager determines the accessibility options of a
class like reading and writing a file to the local disk.
– Java uses the public key encryption system to allow the
java applications to transmit over the internet in the
secure encrypted form.
– The bytecode Verifier checks the classes after loading.
• Portable
– The feature Write-once-run-anywhere makes the java language
portable provided that the system must have interpreter for the
JVM.
– Java also have the standard data size irrespective of operating
system or the processor. These features makes the java as a
portable language.
• Object Oriented
– Java supports object oriented approach whose important
feature is reusability of code
• Robust
– Java has the strong memory allocation and automatic garbage
collection mechanism.
– It provides the powerful exception handling and type checking
mechanism as compare to other programming languages.
– Compiler checks the program whether there any error and
interpreter checks any run time error and makes the system
secure from crash.
• Multithreading
– Java was designed to meet the real-world requirement of creating
interactive, networked programs.

– To accomplish this, Java supports multithreaded programming,

which allows you to write programs that do many things
simultaneously.

– Multithreading means a single program having different threads

executing independently at the same time.

– Multiple threads execute instructions according to the program

code in a process or a program.

– Multithreading works the similar way as multiple processes run

on one computer.

– In multithreaded programs not even a single thread disturbs the

execution of other thread. Threads are obtained from the pool of
available ready to run threads and they run on the system CPUs.

– This is how Multithreading works in Java.

• Platform Independent
– The concept of Write-once-run-anywhere (known as the
Platform independent) is one of the important key feature of
java language that makes java as the most powerful language.
Not even a single language is idle to this feature but java is
more closer to this feature. The programs written on one
platform can run on any platform provided the platform must
have the JVM.

• Architecture Neutral
– The feature “write once; run anywhere, any time, forever.”
makes the java language portable provided that the system
must have interpreter for the JVM.
– Java also have the standard data size irrespective of operating
system or the processor.
• Interpreted
– Java enables the creation of cross-platform programs by
compiling into an intermediate representation called Java
bytecode.
– This code can be interpreted on any system that provides a
Java Virtual Machine.

• Performance
– Java uses native code usage, and lightweight process called
threads. In the beginning interpretation of bytecode resulted
the performance slow but the advance version of JVM uses the
adaptive and just in time compilation technique that improves
the performance.
• Distributed

– The widely used protocols like HTTP and FTP are

developed in java. Internet programmers can call
functions on these protocols and can get access the files
from any remote machine on the internet rather than
writing codes on their local system.

• Dynamic

– While executing the java program the user can get the
required files dynamically from a local drive or from a
computer thousands of miles away from the user just by
connecting with the Internet.
A Simple Java Program – The Set Up

 Before we learn about writing a simple java program, let us

understand what preparations are needed for running a java
program from console.

 We have to define PATH and CLASSPATH parameters and

create necessary directories (folders) where we will be
storing all our program files.
PAT
H
 PATH is an environmental variable in DOS(Disk Operating System),
Windows and other operating systems like Unix.

 PATH tells the operating system which

directories(folders) to search for executable files, in
response to commands issued by a user

 It is a convenient way of executing files without bothering about

providing the absolute path to the folder, where the file is located.
 How to set PATH ?

1.Right Click My Computer

2.Select Properties
3.You willget to see the Properties
Page of My Computer
4.Select Advanced Tab
5.Select Environment Variables
6.You will see Environment
Variables Page as displayed here.
 How to set PATH ? (Contd.).

3. Insert the path to your jdk/bin folder

(e.g. C:\Program Files\Java\JDK
1.6.0_05\bin;

4.
1. Select Click on
Path OK

2. Click on
Edit 5.
Click
on OK
CLASSPATH

• CLASSPATH is a parameter which tells the JVM or the Compiler,

where to locate classes that are not part of Java Development
ToolKit(JDK).

• CLASSPATH is set either on command-line or through environment

variable.

• CLASSPATH set on command-line is temporary in nature, while the

environment variable is permanent.
How to set CLASSPATH ?

1.Right Click My Computer

2.Select Properties
3.You will get to see the
Properties Page of My
Computer
4.Select Advanced Tab
5.Select Environment
Variables
6.You will see Environment
Variables Page as displayed
How to set CLASSPATH ? (Contd.).
2. Enter “CLASSPATH” as
the variable Name

3. Enter “.” as the Variable

1. Click on New
value
A Simple Java Program
Our first Java Program:

public class Welcome {

public static void main(String args[]) {
System.out.println(“Welcome..!”);
}
} This program displays the output
“Welcome..!”
on the console

Create Source File: Welcome.java

Compile : javac Welcome.java
Execute : java Welcome
Executing your first Java Program
 Before executing the program, just check whether the PATH and the
CLASSPATH
parameters are properly set, by typing in the commands as shown in the screen below:
Executing your first Java Program (Contd.).
 Now compile and execute your program as given
below :
Public static void main(String args[]) - Means
Public- it is access specifiers from anywhere we can access it
Static- it is access modifier we can call the methods directly by class name without
creating its objects
Void- it is the return type
Main- it is a method name
String[]args- in java we accept only the string type of argument and store it.
Access Specifier:- This can be understood as the access you provide to your code in Java
whether other classes can access your code or not.
E.g. public, private, protected and default.
Access Modifier:- Java provides both Access Specifier and Access Modifiers for creating
access to your Java code for other classes. Here modifier is also used to do the same task
but there are limitations.
Class Modifier:
abstract :- This defines the restriction such that objects cannot be created.
final:- This restricts a class from being inherited.
strictfp:- it is related to the checking of floating point values irrespective of OS.
Variable Modifier:
static:no object creation required
final: cannot be reassigned
transient: it is not serialized
volatile: the values are liable for change
 JAVA ARCHITECHTURE
COMPILE TIME RUN TIME ENVIRONMENT
ENVIRONMENT
Step 3 JAVA
CLASS
Step 1 CLASS
LOADER
JAVA LIBRARIES
SOURCE
CODE Step 4 BYTE
CODE
Java Bytecodes
VERIFIER
Step 2 move locally or Step 5
through
JAVA COMPILER network JUST IN
JAVA TIME
INTERPRETER
COMPILER

JVM
JAVA
RUN TIME SYSTEM
BYTE
CODE
(.class)
OPERATING SYSTEM

HARDWARE
Java Architecture (Contd.).

Step1:
Create a java source code with .java extension

Step2:
Compile the source code using java compiler, which will
create bytecode file with .class extension

Step3:
Class loader reads both the user defined and library classes
into the memory for execution
Java Architecture (Contd.).

Step4:
Bytecode verifier validates all the bytecodes are valid and
do not violate Java’s security restrictions

Step5:
JVM reads bytecodes and translates into machine code for
execution. While execution of the program the code will
interact to the operating system and hardware
The 5 phases of Java Programs
Java programs can typically be developed in five stages:
1. Edit
Use an editor to type Java program (Welcome.java)
2. Compile
• Use a compiler to translate Java program into
an intermediate language called bytecodes,
understood by Java interpreter (javac Welcome.java)
• Use a compiler to create .class file, containing bytecodes
(Welcome.class)
3. Loading
Use a class loader to read bytecodes from .class file into memory
The 5 phases of Java Programs (Contd.).

4. Verify
Use a Bytecode verifier to make sure bytecodes are valid and do not
violate security restrictions
5. Execute
• Java Virtual Machine (JVM) uses a combination of interpretation
and just-in-time compilation to translate bytecodes into machine
language
• Applications are run on user's machine, i.e. executed by
interpreter with java command (java Welcome)
Java Virtual Machine

• The output of the compiler is

bytecode
• The bytecodes are executed by
JVM
• It is an interpreter which converts
the specific byte code to machine
instructions and executes
• JVM is platform specific
 Keywords

Java reserves some words, which cannot be used as class, method or

variable names.
Good Programming Practices
Naming Conventions
Class Names
 Class names should be nouns, in mixed case with the first
letter of each internal word capitalized
 Class names should be simple and descriptive
 Eg: class Student, class TestStudent

Variable Names
 The variables are in mixed case with a lowercase first letter
 Variable names should not start with underscore _ or dollar sign $
characters, even though both are allowed
 Variable names should be small yet meaningful
 One-character variable names should be avoided except for
temporary “throwaway” variables
 Eg: int y,myWidth;
Good Programming Practices(Contd.).
Naming Conventions
Method Names
 Methods should be verbs, in mixed case with the first letter lowercase, with the
first letter of each internal word capitalized
 Eg: void run(), void getColor()
Comments

Block Comments
(optional)
 Block
comments
are used to
provide
descriptions
of files,
methods,
*/ data
Good Programming Practices(Contd.).

Comments
Single line Comment
Single line comments can be written using
// Single line
Number per Line
One declaration per line is recommended
int height;
int width;
is preferred over
int height,width;
Do not put different
types on the same line
 Error Types
8 Syntax error / Compile errors
– caught at compile time.
– compiler did not understand or compiler does not
allow
8 Runtime error
– something “Bad” happens at runtime. Java
breaks these into Errors and Exceptions
8 Logic Error
– program compiles and runs, but does not do
what you intended or want
 Operators

Java provides a rich set of operators that can be

categorized under 6 groups of operators
• Arithmetic Operator
• Relational Operator
• Logical Operator
• Unary Operator
• Bitwise Operator
• Assignment Operator
 Arithmetic operator

Operator Name of the Operator Example

+ Addition n = n + 1;
- Subtraction n = n-1;
* Multiplication n = n * 1;
/ Division n = n / 1;
% Modulus [Reminder] n = n % 1;
Arithmetic Operators - QUIZ

Output:
class Sample{
a + b = 13
public static void main(String[ ] args){ a-b=7
int a = 10; a * b = 30
int b = 3; a/b=3
System.out.println("a + b = " + (a + b) ); a%b=1
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a *
b) ); System.out.println("a / b = " +
(a / b) ); System.out.println("a % b = "
+ (a % b) );
}
}
 Relational operator

Operator Name of the Operator Example

== Equal to a == b
!= Not Equal to a != b
> Greater Than a>b
>= Greater Than or equal to a >= b
< Lesser Than a<b
<= Lesser than or equal to a <=b
Relational Operators - QUIZ

class Sample{
public static void main(String[] args){
int a = 10;
int b = 20; Output:
System.out.println("a == b = " + (a == b) );
a == b = false
System.out.println("a != b = " + (a != b) ); a != b = true
System.out.println("a > b = " + (a > b) ); a > b = false
System.out.println("a < b = " + (a < b) ); a < b = true
System.out.println("b >= a = " + (b >= a) ); b >= a = true
System.out.println("b <= a = " + (b <= b <= a = false
a) );
}
}
 Logical operator & Unary operator

Operator Name of the Operator Example

&& Logical AND a && b
|| Logical OR a || b
! Logical NOT !(a &&b)

Operator Name of the Operator Example

+ Unary plus operator int number = +1;
- Unary minus operator number = - number;
++ Increment operator ++ number;
-- decrement operator -- number;
Logical Operators - QUIZ

class Sample{
public static void main(String[] args){
boolean a = true;
boolean b = false;
System.out.println("a && b= " + (a&&b));
System.out.println("a || b= " + (a||b));
System.out.println("!(a && b)= "+!a&&b));
}
} Output:
a && b = false
a || b = true
!(a && b) = true
Unary Operator - QUIZ

class Sample{
public static void main(String args[]) Output:
{ int a = 10;
int b = 20; ++a = 11
System.out.println(“++a=”+ (++a));
--b = 19
System.out.println(“--b=”+ (--b));
}
}
Quiz-2

What will be the result, if we try to compile and execute the following code?

class Test {
public static void main(String [ ] args) {
int x=10;
int y=5;
System.out.pri
ntln(++x+(+
+y));
}
}
OUTPUT: 17
 bitwise operator

Operator Description Example

~ Unary bitwise complement ~op2
& Bitwise AND Op1 & Op2
| Bitwise inclusive OR Op1 | Op2
^ Bitwise exclusive OR Op1 ^ Op2
<< Signed left shift Op1 << Op2
>> Signed right shift Op1 >> Op2
 Bitwise operator
~  Compliment &  AND
^  XOR |  OR

0 0 1 0 1 1 0 1

~ 0 1 0 0 1 1 1 1 & 0 1 0 0 1 1 1 1

1 0 1 1 0 0 0 0 0 0 0 0 1 1 0 1

0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1

^ 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 1
|
0 1 1 0 0 0 1 0 0 1 1 0 1 1 1 1
 Right-Shift and left-shift Operators
• Arithmetic or signed right shift (>>)
operator:
– Examples are:
• 128 >> 1 returns 128/21 = 64
• 256 >> 4 returns 256/24 = 16
• -256 >> 4 returns -256/24 = -16
– The sign bit is copied during the shift.

• Left-shift (<<) operator works as follows:

– 128 << 1 returns 128 * 21 = 256
– 16 << 2 returns 16 * 22 = 64
 Example
class BitwiseOper {
public static void main(String args[]) {
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c );
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c );
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c );
c = ~a; /*-61 = 1100 0011 */
System.out.println("~a = " + c );
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c );
c = a >> 2; /* 15 = 1111 */
}
}
Right Shift Operator >> QUIZ
class ShiftExample1 {
public static void main(String[] args) {
int x = 16;
System.out.println("The original value of x:"+x);
x = x >> 3;
System.out.println("After >> 3,new value:"+x);
}
}

The original value of x: 16

After >> 3, new value: 2
Left Shift Operator << QUIZ
class ShiftExample2 {
public static void main(String[] args) {
int x =8;
System.out.println("The original value:"+x);
x = x << 4;
System.out.println("After << 4,new value:"+x);
}
}

The original value: 8

After << 4, new value: 128
 Assignment operator
Operator Description Equivalent Expression
= x = y;
+= x += y; x = (x + y);
-= x -= y; x = (x - y);
*= x *= y; x = (x * y);
/= x /= y; x = (x / y);
%= x %= y; x = (x % y);
&= x &= y; x = (x & y);
|= x != y; x = (x ! y);
^= x ^= y; x = (x ^ y);
<<= x <<= y; x = (x << y);
>>= x >>= y; x = (x >> y);
 Example
class CompAssignDemo{
public static void main(String[] args) {
int x=5;
int y=10; x += y;
System.out.println("The addition is:"+ x);
x -= y;
System.out.println("The subtraction is:"+ x);
x *= y;
System.out.println("The multiplication is:"+ x);
x /= y;
System.out.println("The division is"+ x);
x %= y;
System.out.println("The remainder is:"+x);
x &= y;
System.out.println("The result of AND operation :"+ x);
x |= y;
System.out.println("The result of Bitwise inclusive OR operation :"+ x);
x <<= y;
System.out.println("The result of Signed left shift operation :"+ x);
}
}
 DATATYPES
There are eight primitive data types supported by Java
1. byte:
Byte data type is an 8-bit signed two's complement integer. Minimum
value is -128 (-2^7)
Maximum value is 127 (inclusive)(2^7 -1) Default value is 0
Byte data type is used to save space in large arrays, mainly in place of
integers, since a byte is four times smaller than an int.
Example: byte a = 100 , byte b = -50

2. short:
Short data type is a 16-bit signed two's complement integer.
Minimum value is -32,768 (-2^15)
Maximum value is 32,767 (inclusive) (2^15 -1)
Short data type can also be used to save memory as byte data type. A
short is 2 times smaller than an int Default value is 0.
Example: short s = 10000, short r = -20000
3. int:
Int data type is a 32-bit signed two's complement integer.
Minimum value is - 2,147,483,648.(-2^31)
Maximum value is 2,147,483,647(inclusive).(2^31 -1)
Int is generally used as the default data type for integral values
unless there is a concern about memory. The default value is 0.
Example: int a = 100000, int b = -200000

4. long:
Long data type is a 64-bit signed two's complement integer.
Minimum value is -9,223,372,036,854,775,808.(-2^63)
Maximum value is 9,223,372,036,854,775,807 (inclusive). (2^63 -1)
This type is used when a wider range than int is needed.
Default value is 0L.
Example: long a = 100000L, int b = -200000L
5. float:
Float data type is a single-precision 32-bit floating point.
Float is mainly used to save memory in large arrays of floating
point numbers. Default value is 0.0f.
Example: float f1 = 234.5f

6. double:
double data type is a double-precision 64-bit floating point.
This data type is generally used as the default data type for
decimal values, generally the default choice.
Default value is 0.0d.
Example: double d1 = 123.4d
7. boolean:
Boolean data type represents one bit of information. There are
only two possible values: true and false.
This data type is used for simple flags that track true/false
conditions. Default value is false.
Example: boolean one = true

8. char:
char data type is a single Unicode character. Minimum value is '\
u0000' (or 0). 16-bit
Maximum value is '\uffff' (or 65,535 inclusive). Char data type is
used to store any character.
Example: char letterA ='A'
 Quiz

What will be the result, if we try to compile and execute the following code?

class Test
{
public static void main(String [ ] ar)
{
int for=2;
System.out.println(for);
}
}
Quiz

class Test {
public static void main(String [ ]arg)
{
byte b=128;
System.out.println(b);
}
}
Quiz
class Test {
public static void main(String ar[])
{ float f=1.2;
boolean b=1;
System.out.println(f);
System.out.println(b);
}
}
Quiz(Contd.).

class Test {
public static void
main(String ar[])
{ double d=1.2d;
System.out.println(d);
}
}

OUTPUT: 1.2
Quiz(Contd.).

class Test {
public static void main(String [ ] args)
{
int 9A=10;
System.out.println(9A);
}
}
Types of Variables

The Java programming language defines the following kinds of Variables:

 Local Variables

 Tied to a method

 Scope of a local variable is within the method

 Instance Variables (Non-static)

 Tied to an object

 Scope of an instance variable is the whole class

 Static Variables

 Tied to a class

 Shared by all instances of a class

Local Variables
Instance Variables
public class StaticVariable
{ Static Variables
private static String color;
public static String car=“Benz”;

public static void main(String args[])

{
color=“red”;
System.out.println(car+ “ Color: “+color);
}
}
class Mahesh3
{
int a;
private static int b; Static Variables
void fun1()//object member method
{
b=25;
}
void fun2()
{
System.out.println(b);
}
void fun3()
{
b=45;
}
}
class Mahesh2Static
{
public static void main(String args[])
{
Mahesh3 m3=new Mahesh3();
m3.fun1();
m3.fun3();
m3.fun2();
}
}
class Mahesh1Static
{
static void fun1() Static Variables
{
System.out.println("A");
}
static void fun2()
{
System.out.println("B");
}
public static void main(String arg[])
{
System.out.println("C");
fun1();
fun2();
}
}
 Arrays - Introduction
• An array is a group of contiguous or related data items
that share a common name.

• Used when programs have to handle large amount of data

• Each value is stored at a specific position

• Position is called a index or superscript. Base index = 0

• The ability to use a single name to represent a collection

of items and refer to an item by specifying the item
number enables us to develop concise and efficient
programs.
`

int a[] = new int[5];

5 length
a

0 1 2 3 4

a[0], a[1], a[2], a[3], a[4], a.length=5

`
Example:
myList = new double[10];

myList[0] references the first element in the array.

myList[9] references the last element in the array (or)
myList[n-1] references the last element in the array
 Declaration of Arrays
• Like any other variables, arrays must declared and created
before they can be used. Creation of arrays involve three
steps:
– Declare the array
– Create storage area in primary memory.
– Put values into the array (i.e., Memory location)

Declaration of Arrays:
– Form 1:
Type arrayname[]
– Form 2:
Type [] arrayname;

– Examples:
int[] students;
int students[]; 73
• Declaration:
int myArray [];

• Creation:

myArray = new int[10]; // OR

int myArray [] = new int[10];

 Arrays – Length
• Arrays are fixed length
• Length is specified at create time
• In java, all arrays store the allocated size in a variable named
“length”.
• We can access the length of arrays as arrayName.length:
e.g. int x = reading.length; // x = 7
• Accessed using the index
e.g. int x = reading [1]; // x = 40

Example
int[] reading = {5, 40, 13, 2, 19, 62, 35};
System.out.println(reading.length);

Output:- displays 7, the length of the array reading

75
 Program
import java.util.*;
class Array_Demo
{
public static void main(String args[])
{
int arr[]=new int[5];
Scanner sc1 = new Scanner(System.in);
int i;
int s=0;
System.out.println("Enter the five number");
for(i=0;i<arr.length;i++)
{
arr[i]=sc1.nextInt();
}
for(i=0;i<arr.length;i++)
{
System.out.println("array number shown"+arr[i]);
s=s+arr[i];
}
System.out.println("average no"+s/arr.length);
}
76
}
 Initializing Array Elements in a Loop
• A for loop is commonly used to initialize array
elements
• For example:
int i;//loop counter/array index
int[] a = new int[10];
for(i = 0; i < a.length; i++)
a[i] = 0;
– note that the loop counter/array index goes from 0
to length - 1
– it counts through length = 10
iterations/elements using the zero-numbering of the
array index
 Trace Program with Arrays
public class Test {
public static void main(String[] args) {
int[] values = new int[5];
for (int i = 1; i < 5; i++) {
values[i] = i+ values[i-1];
}
values[0] = values[1] + values[4];
}
}

78
 Trace Program with Arrays
Declare array variable values, create an
array, and assign its reference to values

public class Test {

public static void main(String[] args) { After the array is created
int[] values = new int[5];
for (int i = 1; i < 5; i++) { 0 0
values[i] = i + values[i-1]; 1 0
} 2 0
values[0] = values[1] + values[4]; 3 0
} 4 0
}

79
 Trace Program with Arrays
i becomes 1
public class Test {
public static void main(String[]
args) {
After the array is created
int[] values = new int[5];
for (int i = 1; i < 5; i++) { 0 0
values[i] = i + values[i-1];
1 0
}
2 0
values[0] = values[1] +
values[4]; 3 0

} 4 0

}
80
 Trace Program with Arrays
i (=1) is less than 5

public class Test {

public static void main(String[]
args) { After the array is created

int[] values = new int[5]; 0 0

for (int i = 1; i < 5; i++) { 1 0
values[i] = i + values[i-1]; 2 0
} 3 0
values[0] = values[1] + values[4]; 4 0

}
}
81
 Trace Program with Arrays
After this line is executed, value[1] is 1

public class Test {

public static void main(String[] After the first iteration
args) {
int[] values = new int[5]; 0 0
1
for (int i = 1; i < 5; i++) { 1

2 0
values[i] = i + values[i-1]; 0
3
} 4 0
values[0] = values[1] +
values[4];
}
}
82
 Trace Program with Arrays
After i++, i becomes 2

public class Test {

public static void main(String[] args) {
int[] values = new int[5]; After the first iteration

for (int i = 1; i < 5; i++) {

0 0
values[i] = i + values[i-1]; 1 1

} 2 0

values[0] = values[1] + values[4]; 3 0

4 0
}
}

83
 Trace Program with Arrays

i (= 2) is less than 5
public class Test {
public static void main(String[] args) {
int[] values = new int[5];
for (int i = 1; i < 5; i++) { After the first iteration
values[i] = i + values[i-1];
} 0 0

1 1
values[0] = values[1] + values[4]; 0
2
} 3 0
} 4 0

84
 Trace Program with Arrays
After this line is executed,
values[2] is 3 (2 + 1)

public class Test {

public static void main(String[] args) { After the second iteration
int[] values = new int[5];
for (int i = 1; i < 5; i++) { 0 0

values[i] = i + values[i-1]; 1 1

} 2 3

values[0] = values[1] + values[4]; 3 0

} 4 0

85
 Trace Program with Arrays

After this, i becomes 3.

public class Test {

public static void main(String[] args) {
int[] values = new int[5]; After the second iteration
for (int i = 1; i < 5; i++) {
values[i] = i + values[i-1]; 0 0
}
1 1
values[0] = values[1] + values[4];
} 2 3
} 0
3

4 0

86
 Trace Program with Arrays

i (=3) is still less than 5.

public class Test {

public static void main(String[] args) {
After the second iteration
int[] values = new int[5];
for (int i = 1; i < 5; i++) {
values[i] = i + values[i-1]; 0 0
} 1 1
values[0] = values[1] + values[4];
2 3
}
} 3 0

4 0

87
 Trace Program with Arrays

After this line, values[3] becomes 6 (3 + 3)

public class Test {

public static void main(String[] args) { After the third iteration
int[] values = new int[5];
for (int i = 1; i < 5; i++) { 0 0
values[i] = i + values[i-1]; 1 1
} 2 3
values[0] = values[1] + values[4]; 6
3
}
4 0
}

88
 Trace Program with Arrays
After this, i becomes 4

public class Test {

public static void main(String[] args) {
After the third iteration
int[] values = new int[5];
for (int i = 1; i < 5; i++) {
values[i] = i + values[i-1]; 0 0
} 1 1
values[0] = values[1] + values[4]; 2 3
}
3 6
}
4 0

89
 Trace Program with Arrays
i (=4) is still less than 5

public class Test {

public static void main(String[] args) { After the third iteration
int[] values = new int[5];
for (int i = 1; i < 5; i++) {
0 0
values[i] = i + values[i-1];
1
} 1

values[0] = values[1] + values[4]; 2 3

} 3 6
} 4 0

90
 Trace Program with Arrays
After this, values[4] becomes 10 (4 + 6)

public class Test {

public static void After the fourth iteration
main(String[] args) {
int[] values = new int[5]; 0 0
for (int i = 1; i < 5; i++) { 1 1
values[i] = i + values[i-1]; 2 3
} 3 6
values[0] = values[1] + 10
4
values[4];
}
}
91
 Trace Program with Arrays

After i++, i becomes 5

public class Test {
public static void
main(String[] args) {
int[] values = new int[5]; After the fourth iteration
for (int i = 1; i < 5; i++) {
values[i] = i + values[i-1];
0 0
}
values[0] = values[1] + 1 1
values[4]; 2 3
}
3 6
}
4 10

92
 Trace Program with Arrays
i ( =5) < 5 is false. Exit the loop

public class Test {

public static void main(String[] After the fourth iteration
args) {
int[] values = new int[5]; 0 0

for (int i = 1; i < 5; i++) { 1 1

values[i] = i + values[i-1]; 2 3

} 3 6

values[0] = values[1] + 4 10
values[4];
}
}
93
 Trace Program with Arrays
After this line, values[0] is 11 (1 + 10)

public class Test {

public static void main(String[] args)
{
int[] values = new int[5]; 0 11
for (int i = 1; i < 5; i++) { 1 1
values[i] = i + values[i-1]; 2 3
} 3 6
values[0] = values[1] + values[4]; 4 10
}
}
94
 Copying Arrays
Often, in a program, you need to duplicate an array or a part of an
array. In such cases you could attempt to use the assignment statement
(=), as follows:

list2 = list1;
Before the assignment After the assignment
list2 = list1; list2 = list1;

list1 list1
Contents Contents
of list1 of list1

list2 list2
Contents Contents
of list2 of list2
Garbage

Liang, Introduction to Java Programming, Sixth Edition, (c) 2007 Pearson Education, Inc. All
rights reserved. 0-13-222158-6
 Copying Arrays
Using a loop:
int[] sourceArray = {2, 3, 1, 5, 10};
int[] targetArray = new int[sourceArray.length];

for (int i = 0; i < sourceArrays.length; i++)

targetArray[i] = sourceArray[i];

Liang, Introduction to Java Programming, Sixth Edition, (c) 2007 Pearson Education, Inc. All
rights reserved. 0-13-222158-6
96
 Table as a 2-Dimensional Array
• The table assumes a starting balance of $1000
• First dimension: row identifier - Year
• Second dimension: column identifier - percentage
• Cell contains balance for the year (row) and percentage (column)
• Balance for year 4, rate 7.00% = $1311

Balances for Various Interest Rates

Compounded Annually
(Rounded to Whole Dollar Amounts)
Year 5.00% 5.50% 6.00% 6.50% 7.00% 7.50%
1 $1050 $1055 $1060 $1065 $1070 $1075
2 $1103 $1113 $1124 $1134 $1145 $1156
3 $1158 $1174 $1191 $1208 $1225 $1242
4 $1216 $1239 $1262 $1286 $1311 $1335
5 $1276 $1307 $1338 $1370 $1403 $1436
… … … … … … …
9
 Column Index 4
Table as a 2-D Array (5th column)

Indexes 0 1 2 3 4 5
0 $1050 $1055 $1060 $1065 $1070 $1075
1 $1103 $1113 $1124 $1134 $1145 $1156
2 $1158 $1174 $1191 $1208 $1225 $1242
3 $1216 $1239 $1262 $1286 $1311 $1335
Row Index 3 4 $1276 $1307 $1338 $1370 $1403 $1436
(4th row) … … … … … … …

• Generalizing to two indexes: [row][column]

• First dimension: row index
• Second dimension: column index
• Cell contains balance for the year/row and percentage/column
• All indexes use zero-numbering
– Balance[3][4] = cell in 4th row (year = 4) and 5th column (7.00%)
– Balance[3][4] = $1311 (shown in yellow)

9
 Java Code to Create a 2-D Array
• Syntax for 2-D arrays is similar to 1-D arrays

• Declare a 2-D array of ints named table

– the table should have ten rows and six columns
int[][] table = new int[10][6];
 int a[][] = new int[3][4];

a 0 1 2

int a[][] = new int[][4]; //error

int a[][] = new int[3][];
int a[0]=new int[3];
int a[1]=new int[3];
int a[2]=new int[4];
a.length=3; a[0].length=3;a[1].length=3;a[2].length=4;
 Declaring Variables of Two-dimensional
Arrays and Creating Two-dimensional
Arrays

int[][] matrix = new int[3][];

or
int matrix[][] = new int[3][];
matrix[0] = new int[2];
Matrix[1]=new int[3];
Matrix[2]=new int[4];

for (int i = 0; i < matrix.length; i++)

for (int j = 0; j < matrix[i].length; j++)
matrix[i][j] = (int)(Math.random() * 1000);
101
Declaring, Creating, and Initializing Using Shorthand Notations

You can also use an array initializer to declare, create and

initialize a two-dimensional array. For example,

int[][] array = { int[][] array = new int[4][3];

{1, 2, 3}, Same as array[0][0] = 1; array[0][1] = 2; array[0][2] = 3;
{4, 5, 6}, array[1][0] = 4; array[1][1] = 5; array[1][2] = 6;
{7, 8, 9}, array[2][0] = 7; array[2][1] = 8; array[2][2] = 9;
{10, 11, 12} array[3][0] = 10; array[3][1] = 11; array[3][2] = 12;
};

102
Lengths of Two-dimensional Arrays

int[][] x = new int[3][4];

103
 Command Line Argument
• The java command-line argument is an argument
i.e. passed at the time of running the java
program.
• The arguments passed from the console can be
received in the java program and it can be used
as an input.
 Command Line Argument
class CMD
{
public static void main(String args[])
{
System.out.println(args[0]);
System.out.println(args[1]);
System.out.println(args[2]);
System.out.println(args[3]);
System.out.println(args.length);
for(int i=0;i<args.length;i++)
{
System.out.println("args value"+Integer.parseInt(args[i]));
}

}
}
 CLASS AND OBJECT
 Class
A template that describes the kinds of state and
behavior that objects of its type support.
 A class is a blueprint or prototype from which
objects are created.
 A class is a collection of fields (data) and methods
(procedure or function) that operate on that data.
 Object
 Object is an instance of a class.
 An object is a software bundle of related state and
behavior.
 Each object will have its own state, and access to
all of the behaviors defined by its class.
 CLASS
 A class is a collection of fields (data) and
methods (procedure or function) that operate
on that data.

Circle
centre
Instance radius knows
variable
(state)
setInput()
circumference( does
Methods )
(behavior)
area()
CLASS
 Class is declared using the keyword class.
 The data or variables, defined within a class

are called as INSTANCE VARIABLES.

 Collectively the methods & the variables are

called the members of that class.

 Basic Syntax for class definition

class ClassName [extends SuperClassName]

{
[fields declaration]
[methods declaration]
}
OBJECTS AND CLASS
Some of the real world objects are,

Class

class Mobile
// Data Members
String model
String make
String Color
// Methods
call()
receive()

Object
 OBJECT PROPERTIES
 Identity

The property of an object that distinguishes it from

other objects

 State (instance variables)

Describes the data stored in the object. Each object
(instance of a class) will have its own unique set of
instance variables as defined in the class.
Collectively, the values assigned to an object's
instance variables make up the object's state.

 Behavior (methods)
Describes the methods in the object's interface by
which the object can be used.
ADDING FIELDS:
 Add fields

public class Circle {

public double x, y; // centre coordinate
public double r; // radius of the circle

 The fields (data) are also called the instance

varaibles.
 INTRODUCING METHODS
A method is a collection of statements that are
grouped together to perform an operation.
ADDING METHODS
A class with only data fields has no life.
Objects created by such a class cannot
respond to any messages.
 Methods are declared inside the body of

the class but immediately after the

declaration of data fields.
 The general form of a method
declaration is:
type MethodName (parameter-
list)
{
Method-body;
}
ADDING METHODS TO CLASS CIRCLE
public class Circle {

public double x, y; // centre of the circle

public double r; // radius of circle

//Methods to return circumference and area

public double circumference() {
return 2*3.14*r;
} Method Body
public double area() {
return 3.14 * r * r;
}
}
 CALLING METHODS

pass j
pass i
public static void main(String[] public static int max(int num1, int
args) { num2)
int i = 5; {
int j = 2; int result;
int k = max(i, j);
if (num1 > num2)
System.out.println("The maximum result = num1;
between" +i+ "and“ +j+ "is“ + k); else
} result = num2;

return result;
}
The main method pass 5 The max method

i: 5 num1: 5
pass 2
parameters

j: 2 num2: 2

k: 5 result: 5
 Method Overloading
If a class has multiple methods having same name but
different in parameters, it is known as Method
Overloading

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

• By changing number of arguments
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; }
} OUTPUT
class TestOverloading1 22
{ 33
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}
}
• By changing the data type
class Adder{
static int add(int a, int b)
{ return a+b; } OUTPUT
static double add(double a, double b) 22
{ return a+b; } 24.9
}
class TestOverloading2{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}
Method Overriding
 Declaring a method in sub class which is
already present in parent class is known as
method overriding.

 The method in parent class is called

overridden method and the method in child
class is called overriding method.
Method Overriding Example
class Human{
//Overridden method
public void eat()
{
System.out.println("Human is eating"); OUTPUT:
} Boy is eating
}
class Boy extends Human{
//Overriding method
public void eat(){
System.out.println("Boy is eating");
}
public static void main( String args[]) {
Boy obj = new Boy();
//This will call the child class version of eat()
obj.eat();
}}
Advantage of method overriding

The main advantage of method overriding is that the

class can give its own specific implementation to a
inherited method without even modifying the
parent class code.
REAL EXAMPLE OF METHOD OVERRIDING
class Bank{
int getRateOfInterest(){ return 0; }
}

class SBI extends Bank { Output:

int getRateOfInterest() { return 8; } } SBI Rate of Interest : 8
class ICICI extends Bank{ ICICI Rate of Interest: 7
int getRateOfInterest() { return 7; } AXIS Rate of Interest: 9
}

class AXIS extends Bank{

int getRateOfInterest() { return 9; }
}

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 Rate of Interest: "+i.getRateOfInterest());
System.out.println("AXIS Rate of Interest: "+a.getRateOfInterest());
} }
 Inheritance
• Inheritance allows a software developer to derive a new
class from an existing one.
• The existing class is called the parent class, or
superclass, or base class.
• The derived class is called the child class or subclass.
• As the name implies, the child inherits characteristics of
the parent.
• That is, the child class inherits the methods and data
defined for the parent class.

125
 Inheritance
• Inheritance relationships often are shown
graphically in a UML class diagram, with an
arrow with an open arrowhead pointing to the
parent class
Vehicle

Car

Inheritance should create an is-a relationship, meaning the

child is a more specific version of the parent

126
 Results of Inheritance
public class A
public class B extends A
• the sub class inherits (gains) all instance
variables and instance methods of the super
class, automatically
• additional methods can be added to class B
(specialization)
• the sub class can replace (redefine, override)
methods from the super class
Syntax
class Super
{
.....
.....
}
class Sub extends Super
{
.....
.....
}
class Calculation {
int z;

public void addition(int x, int y) {

z = x + y;
System.out.println("The sum of the given numbers:"+z);
}

public void Subtraction(int x, int y) {

z = x - y;
System.out.println("The difference between the given
numbers:"+z);
}
}
public class My_Calculation extends Calculation {
public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]) {
int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b); Output
}}
The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200
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.
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 Output
Sub_class sub = new Sub_class();
This is the display method of subclass
// Invoking the display() methodThis
of sub class
is the display method of superclass
sub.display(); value of the variable named num in sub class:10
value of the variable named num in super class:20
// Invoking the display() method of superclass
super.display();

// printing the value of variable num of subclass

System.out.println("value of the variable named num in sub class:"+ sub.num);

// printing the value of variable num of superclass

System.out.println("value of the variable named num in super class:"+ super.num);
}

public static void main(String args[]) {

Sub_class obj = new Sub_class();`
obj.my_method();
}
}
NOTE:

 this(argument list) statement invokes the

constructor of the same class

 first line of a constructor must EITHER be a

super (call on the super class constructor)
OR a this (call on the constructor of same
class)
QUIZ:
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println("A1's constructor "+ a); }
}
class B1 extends A1{
B1(){System.out.println("B1's no arg constructor"); }
B1(int b){super(1000);
System.out.println("B1's constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println("C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println("C1's constructor "+ c); }
}
class TestingInheritance{ OUTPUT
public static void main(String args[]) A1's no arg constructor
{ B1's no arg constructor
C1 ca = new C1();
} C1's no arg constructor
class A1 { QUIZ:
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println("A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println("B1's constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println("C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println("C1's constructor "+ c); }
}
class TestingInheritance{ OUTPUT:
public static void main(String args[]){ A1's constructor 1000
C1 ca = new C1(10);
} B1's constructor 100
} C1's constructor 10
 Constructors in java
• Constructors are used to initialize the state of an object
when it is created.

• Constructors are invoked while creating objects, usually

after the new keyword.

• A child class may also invoke a super constructor

using the super keyword to initialize the parent object.

• Constructors are similar in syntax to methods, but

without any return type and have the same name as
that of the class (case sensitive).
Rules for defining constructors
1. Constructors have the same name as that of the class.
2. Constructors are similar to methods in syntax, but constructors
do not have a return type; should not even specify void.
A). If you specify return type, then the supposed to be
constructor will become a method and will not be
considered as a constructor.
3. You can have a method with the same name as a constructor.
A). If you specify return type, then it will be considered a
method and will not be invoked during initialization; you need
to invoke it like just any other method.

4. Constructors can also be overloaded just like methods.

A). You may invoke the correct one based on arguments

supplied.
5. A default constructor is a constructor that takes no arguments,
and mostly does nothing.

6. A default constructor with no parameters is automatically added

by Java for a class if there are no user defined constructors.
Example of default constructor

//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();
} Output:
}
Bike is created
class Student3{
int id; Example of default constructo
String name;
//method to display the value of id and name
void display(){System.out.println(id+" "+name);}

public static void main(String args[]){

//creating objects
Student3 s1=new Student3();
Student3 s2=new Student3(); Output:
0 null
//displaying values of the object 0 null
s1.display();
s2.display();
} }
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
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); }

public static void main(String args[]) {

//creating objects and passing values
Student4 s1 = new Student4(111,"Karan"); OUTPUT
Student4 s2 = new Student4(222,"Aryan");
//calling method to display the values of object
111 Karan
s1.display(); 222 Aryan
s2.display();
} }
Constructor Overloading in Java
• A constructor is just like a method but without return
type. It can also be overloaded like Java methods.

• Constructor overloading in Java is a technique of having

more than one constructor with different parameter
lists.

• They are arranged in a way that each constructor

performs a different task.

• They are differentiated by the compiler or by the

number of parameters in the list and their types.
class Student5{
int id;
String name;
int age;
//creating two arg constructor
Student5(int i, String n){
id = i; Output:
name = n; 111 Karan 0
}
//creating three arg constructor 222 Aryan 25
Student5(int i, String n, int a){
id = i;
name = n;
age=a;
}
void display(){System.out.println(id+" "+name+" "+age);}

public static void main(String args[]){

Student5 s1 = new Student5(111,"Karan");
Student5 s2 = new Student5(222,"Aryan",25);
s1.display();
s2.display();
}
}
0 0
class A1 {
int i;
public void show(){
System.out.println("A1 (i)="+ i);
}
}
class TestingInheritance{

public static void main(String args[]){

A1 a = new A1();
a.show();
}

}
class A1 {
int i;
public void show(){
System.out.println("A1 (i)="+ i);
}
}

class B1 extends A1{

int j;
public void show(){
System.out.println(“B1 (j)="+ j);
}
}

class TestingInheritance{

public static void main(String args[]){

B1 b = new B1();
b.show();
A1 a = new A1();
a.show();
}
class A1 {
int i;
public void show(){
System.out.println("A1 (i)="+ i);
}
}

class B1 extends A1{

int j;
public void show(){
super.show();
}
}

class TestingInheritance{

public static void main(String args[]){

B1 b = new B1();
b.show();
A1 a = new A1();
a.show();
}
class A1 {
A1(){ System.out.println("A1's no arg constructor"); }
A1(int a){ System.out.println("A1's constructor "+ a); }
}
class B1 extends A1{
B1(){ System.out.println("B1's no arg constructor"); }
B1(int b){ super(1000);
System.out.println("B1's constructor "+ b); }
}
class C1 extends B1{
C1() {System.out.println("C1's no arg constructor"); }
C1(int c){ super(100);
System.out.println("C1's constructor "+ c); }
}
class TestingInheritance{
public static void main(String args[]){
C1 ca = new C1(10);
}
}
public class Animal{
String name;
int age;
int weight;
Animal(String name, int age,int weight){
this.name = name;
this.age=age;
this.weight=weight;
}
void display(){
System.out.println(“Name="+name+“ \n Age= "+age+” \n weight=”+weight);
}

public static void main(String args[]){

Animal a1 = new Animal();
Animal a2 = new Animal(“Goat”,2,10);
a1.display();
a2.display();
}
}
class Animal{
String name;
int age;
int weight;
Animal(String name, int age, int weight){
this.name = name;
this.age=age;
this.weight=weight;
}
void display(){
System.out.println(“Name="+name+“ \n Age= "+age+” \n weight=”+weight);
}
}
public class Goat extends Animal{
Goat(int a, int w){
age=a; // this , super ?
weight=w; // this , super ?
name=“Goat”;
}
public static void main(String args[]){
// Animal a1 = new Animal();
Goat g = new Goat(2,10);
//a1.display();
g.display();
abstract class Animal{
String name;
int age;
int weight;
Animal(String n, int a,int w){
name = n;
age=a;
weight=w;
}
abstract void display();
}
Public class Goat extends Animal{
Goat(in a, int w){
age=a; // this , super
weight=w; // this , super
}
void display(){
System.out.println(“Name= Goat \n Age= "+age+” \n weight=”+weight);
}
public static void main(String args[]){
// Animal a1 = new Animal();
Goat g = new Goat(2,10);
g.display();
}
abstract class Animal{ Class Cow extends Animal{
String name; Cow(int a, int w){
int age; age=a; // this , super
int weight; weight=w; // this , super
Animal(String n, int a,int w){ }
name = n; void display(){
age=a; System.out.println(“Name= Cow \n
weight=w; Age= "+age+” \n weight=”+weight);
} }
abstract void display(); }
}
Class Goat extends Animal{
Goat(int a, int w){
age=a; // this , super
public class Test{
weight=w; // this , super
public static void main(String args[]){
}
Goat g = new Goat(2,10);
void display(){
g.display();
System.out.println(“Name= Goat \n
Cow c = new Cow(15,200);
Age= "+age+” \n weight=”+weight);
c.display();
}
}
}
}
Multiple inheritance

G C

M
class Animal{ Class Cow extends Animal{
String name; Cow(int a, int w){
int age; age=a; // this , super
int weight; weight=w; // this , super
Animal(String n, int a,int w){ }
name = n; void display(){
age=a; System.out.println(“Name= Cow \n
weight=w; Age= "+age+” \n weight=”+weight);
} }
void display(){} }
} Class Mammals extends Goat, Cow{
Class Goat extends Animal{

x
String type;
Goat(int a, int w){ Mammals(){
age=a; // this , super //- -----------
weight=w; // this , super }
} }
void display(){
public class Test{
System.out.println(“Name= Goat \n
public static void main(String args[]){
Age= "+age+” \n weight=”+weight);
Mammals m = new Mammals();
}
m.display();
}
}
}
 Interfaces
• The general format of an interface definition:
public interface InterfaceName
{
(Method headers...)
}
• All methods specified by an interface are
public by default.
• A class can implement one or more interfaces.
 Defining an Interface
 An interface is syntactically similar to a class

 It’s general form is:

public interface FirstInterface {

int addMethod(int x, int y);
float divMethod(int m, int n);
void display();
int VAR1 = 10;
float VAR2 = 20.65;
}
 Implementing Interfaces
• A class implements an interface
• A class can implement more than one interface by giving a comma- separated list of
interfaces
class MyClass implements FirstInterface{
public int addMethod(int a, int b)
{ return(a+b);
}
public float divMethod(int i, int j){
return(i/j);
}

public void display()

{ System.out.println(“Variable 1 :”
+VAR1); System.out.println(“Variable 2 :”
+VAR2);
}
}
Multiple inheritance

G C

M
Applying Interfaces (Contd.).
interface IntDemo{
void display();
}
class classOne implements IntDemo{
void add(int x, int y){
System.out.println("The sum
is :" +(x+y));
}
public void display()
{ System.out.println("Welcome to
Interfaces");
}
}
 Applying Interfaces (Contd.).
class classTwo implements IntDemo{
void multiply(int i,int j, int k)
{ System.out.println("The result:" +(i*j*k)
);
}
public void display()
{ System.out.println("Welcome to Java
");
}
}
class DemoClass{
public static void main(String args[]) {
classOne c1= new classOne();
c1.add(10,20);
c1.display();
classTwo c2 = new classTwo();
c2.multiply(5,10,15);
c2.display();
}
}

© 2017 Wipro wipro.com confidential 19

 Interface References
 When you create objects, you refer them through the class references. For example :
 ClassOne c1= new classOne(); /* Here, c1 refers to the object of the class
classOne. */
 You can also make the interface variable refer to the objects of the class that implements the
interface
 The exact method will be invoked at run time
 It helps us achieve run-time polymorphism

© 2017 confid
wipro.com 1
Wipro ential
 Interface References (Contd.).
interface IntDemo{
void display();
}
class classOne implements IntDemo{
void add(int x, int y){
System.out.println("The sum is :" +(x+y));
}
public void display(){
System.out.println("Class one display method ");
}
}

© 2017 confid
wipro.com 1
Wipro ential
 Interface References (Contd.).
class classTwo implements IntDemo {
void multiply(int i,int j, int k){
System.out.println("The result:" +
(i*j*k) );
}
public void display(){
System.out.println("Class two
display method" );
}
}
class DemoClass{
public static void main(String args[]){
IntDemo c1= new classOne();
c1.display();
c1 = new classTwo();
c1.display();
}
}

© 2017 confid
wipro.com 1
Wipro ential
 Methods of Object class
public final Class getClass() returns the Class class object of this object. The Class
class can further be used to get the metadata of this class.

public int hashCode() returns the hashcode number for this object.

public boolean equals(Object obj) compares the given object to this object.

protected Object clone() throws creates and returns the exact copy (clone) of this object.
CloneNotSupportedException
public String toString() returns the string representation of this object.

public final void notify() wakes up single thread, waiting on this object's monitor.

public final void notifyAll() wakes up all the threads, waiting on this object's monitor.

public final void wait(long timeout)throws causes the current thread to wait for the specified
InterruptedException milliseconds, until another thread notifies (invokes notify()
or notifyAll() method).

public final void wait(long timeout,int nanos)throws causes the current thread to wait for the specified
InterruptedException milliseconds and nanoseconds, until another thread
notifies (invokes notify() or notifyAll() method).

public final void wait()throws InterruptedException causes the current thread to wait, until another thread
notifies (invokes notify() or notifyAll() method).

protected void finalize()throws Throwable is invoked by the garbage collector before object is being
garbage collected.
 Java packages
• Package: A collection of related classes.
 Can also "CONTAIN" sub-packages.
 Sub-packages can have similar names,
but are not actually contained inside.
• java.awt does not contain java.awt.event

• Uses of Java packages:

 group related classes together
 as a namespace to avoid name collisions
 provide a layer of access / protection
 keep pieces of a project down to a manageable size
169
 Why Using Packages?
• Programmers can easily determine that these classes
and interfaces are related.
• Programmers know where to find classes and interfaces
that provide graphics-related functions.
• The names of classes won’t conflict with class names in
other packages, because the package creates a new
namespace.
• Allow classes within the package to have unrestricted
access to one another yet still restrict access for classes
outside the package.

170
Java Foundation Packages
• Java provides a large number of classes grouped into
different packages based on their functionality.
• The six foundation Java packages are:
 java.lang
• Contains classes for primitive types, strings, math functions, threads, and
exception
 java.util
• Contains classes such as vectors, hash tables, date etc.
 java.io
• Stream classes for I/O
 java.awt
• Classes for implementing GUI – windows, buttons, menus etc.
 java.net
• Classes for networking
 java.applet
• Classes for creating and implementing applets
171
 Using System Packages
• The packages are organised in a hierarchical structure. For example,
a package named “java” contains the package “awt”, which in turn
contains various classes required for implementing GUI (graphical
user interface).
java
lang “java” Package containing
“lang”, “awt”,.. packages;
Can also contain classes.
awt
Graphics awt Package containing
Font classes
Classes containing
Image
methods
…

172
 Accessing Classes from
Packages
• There are two ways of accessing the classes stored in
packages:
 Using fully qualified class name
• java.lang.Math.sqrt(x);
 Import package and use class name directly.
• import java.lang.Math
• Math.sqrt(x);
• Selected or all classes in packages can be imported:

import package.class;
import package.*;
• Implicit in all programs: import java.lang.*;
• package statement(s) must appear first
173
 Creating Packages
• Java supports a keyword called “package” for creating user-defined
packages. The package statement must be the first statement in a
Java source file (except comments and white spaces) followed by
one or more classes.

package myPackage;
public class ClassA {
// class body
}
class ClassB {
// class body
• Package name is “myPackage” and classes are considered as part
}
of this package; The code is saved in a file called “ClassA.java” and
located in a directory called “myPackage”.
• C://……../JAVA_Code/myPackage/ClassA.java

174
 Creating Sub Packages
• Classes in one or more source files can be part of the
same packages.
• As packages in Java are organised hierarchically, sub-
packages can be created as follows:
 package myPackage.Math
 package myPackage.secondPackage.thirdPackage
• Store “thirdPackage” in a subdirectory named
“myPackage\secondPackage”. Store “secondPackage”
and “Math” class in a subdirectory “myPackage”.
• C://……../JAVA_Code/ myPackage/secondPackage/thirdPackage/..

175
 Accessing a Package
• As indicated earlier, classes in packages can be
accessed using a fully qualified name or using a
short-cut as long as we import a corresponding
package.
• The general form of importing package is:
 import package1[.package2][…].classname
 Example:
• import myPackage.ClassA;
• import myPackage.secondPackage
 All classes/packages from higher-level package can be
imported as follows:
• import myPackage.*;

176
 Using a Package
• Let us store the code listing below in a file named
“ClassA.java” within subdirectory named “myPackage”
within the current directory (say “JAVA_Codes”).
package myPackage;
public class ClassA {
// class body
public void display()
{
System.out.println("Hello, I am ClassA");
}
}
class ClassB {
// class body }
177
 Using a Package
• Within the current directory (“JAVA_Codes”) store the following
code in a file named “ClassX.java”

import myPackage.ClassA;

public class ClassX

{
public static void main(String args[])
{
ClassA objA = new ClassA();
objA.display();
}
}

178
 Compiling and Running
• When ClassX.java is compiled, the compiler
compiles it and places .class file in current
directory. If .class of ClassA in subdirectory
“myPackage” is not found, it complies ClassA
also.
• Note: It does not include code of ClassA into
ClassX
• When the program ClassX is run, java loader
looks for ClassA.class file in a package called
“myPackage” and loads it.
179
 Using a Package
• Let us store the code listing below in a file named “ClassA.java”
within subdirectory named “secondPackage” within the current
directory.
package secondPackage;
public class ClassC {
// class body
public void display()
{
System.out.println("Hello, I am ClassC");
}
}

180
 Using a Package
• Within the current directory (“JAVA_Codes”) store the following
code in a file named “ClassX.java”
import myPackage.ClassA;
import secondPackage.ClassC; Output
public class ClassY Hello, I am ClassA
{ Hello, I am ClassC

public static void main(String args[])

{
ClassA objA = new ClassA();
ClassC objC = new ClassC();
objA.display();
objC.display();
}
}
181
Adding a Class to a Package
• Consider an existing package that contains a class called
“Teacher”: package pack1;
public class Teacher
{
// class body
}
• This class is stored in “Teacher.java” file within a directory
called “pack1”.
• How do we a new public class called “Student” to this
package.

182
 Adding a Class to a
Package
• Define the public class “Student” and place the package
statement before the class definition as follows:
package pack1;
package pack1;
public class Student
{
class Teacher
// class body
} class Student
• Store this in “Student.java” file under the directory
“pack1”.
• When the “Student.java” file is compiled, the class file
will be created and stored in the directory “pack1”. Now,
the package “pack1” will contain both the classes
“Teacher” and “Student”.
183
 Packages and Name
Clashing
• When packages are developed by different organizations, it is
possible that multiple packages will have classes with the same
name, leading to name classing.
package pack1; package pack2;

class Teacher class Student

class Student class Courses

• We can import and use these packages like:

 import pack1.*;
 import pack2.*;
 Student student; // Generates compilation error

184
 Handling Name Clashing
• In Java, name classing is resolved by accessing classes
with the same name in multiple packages by their fully
qualified name.
• Example:
import pack1.*;
import pack2.*;
pack1.Student student1;
pack2.Student student2;
Teacher teacher1;
Courses course1;

185
 Extending a Class from
Package
• A new class called “Professor” can be created by
extending the “Teacher” class defined the package
“pack1” as follows:

import pack1.Teacher;
public class Professor extends Teacher
{
// body of Professor class
// It is able to inherit public and protected members,
// but not private or default members of Teacher class.
}

186
Member access modes
in Java
Specifier Class Package Subclass World

Private Y N N N

No Specifier Y Y N N

Protected Y Y Y N

Public Y Y Y Y

187
Member access modes in
Java

188
 Abstract Classes
• An Abstract class serves as a superclass for other classes.
• The abstract class represents the generic or abstract form
of all the classes that are derived from it.
• A class becomes abstract when you place the abstract key
word in the class definition.
public abstract class ClassName

189
 Abstract Methods
• An abstract method has no body and must be
overridden in a subclass.
• An abstract method is a method that appears in
a superclass, but expects to be overridden in a
subclass.
• An abstract method has only a header and no
body.
AccessSpecifier abstract ReturnType MethodName(ParameterList);

190
 Abstract Methods
• Notice that the key word abstract appears in
the header, and that the header ends with a
semicolon.
public abstract void setValue(int value);
• Any class that contains an abstract method is
automatically abstract.
• If a subclass fails to override an abstract method, a
compiler error will result.
• Abstract methods are used to ensure that a
subclass implements the method.
191
/ An abstract class without any abstract method

bstract class Base {

void fun()
System.out.println("Base fun() called"); }
}

lass Derived extends Base { }

lass Main {
public static void main(String args[]) {
Derived d = new Derived();
d.fun();
}
Output:
Base fun() called
An abstract class with abstract method
//abstract parent class
abstract class Animal{ Output:
//abstract method
public abstract void sound(); Bark..!
}
//Dog class extends Animal class
public class Dog extends Animal{

public void sound(){

System.out.println(“Bark..!"); }
public static void main(String args[]) {
Animal obj = new Dog();
obj.sound();
} }
 Interface
 An interface is similar to an abstract class that has all abstract
methods.
 An interface looks similar to a class, except:
the keyword interface is used instead of the keyword class,
and the methods that are specified in an interface have no bodies,
only headers that are terminated by semicolons.
 An interface has comes with the following exceptions:
All methods defined in an interface are abstract.
Interfaces can contain no implementation
Interfaces cannot contain instance variables. However,
they can contain public static final variables (ie. constant
class variables)
 The purpose of an interface is to specify behavior for other
classes.
 Interfaces
• The general format of an interface definition:
public interface InterfaceName
{
(Method headers...)
}
• All methods specified by an interface are
public by default.
• A class can implement one or more interfaces.
Defining an Interface

 An interface is syntactically similar to a class

 It’s general form is:

public interface FirstInterface {

int addMethod(int x, int y);
float divMethod(int m, int n);
void display();
int VAR1 = 10;
float VAR2 = 20.65;
}
Implementing Interfaces
• A class implements an interface
• A class can implement more than one interface by giving a comma- separated list of
interfaces
class MyClass implements FirstInterface{
public int addMethod(int a, int b){
return(a+b);
}
public float divMethod(int i, int j){
return(i/j);
}

public void display()

{ System.out.println(“Variable 1 :”
+VAR1); System.out.println(“Variable
2 :” +VAR2);
}
}
Applying Interfaces

© 2017 Wipro wipro.com confidential 20

2
Applying Interfaces

 Software development is a process where constant changes are likely to happen

 There can be changes in requirement, changes in design, changes in implementation

 Interfaces support change

 Programming through interfaces helps create software solutions that are reusable, extensible,
and maintainable

© 2017 Wipro wipro.com confidential 20

3
Applying Interfaces (Contd.).
interface IntDemo{
void display();
}
class classOne implements IntDemo{
void add(int x, int y){
System.out.println("The sum
is :" +(x+y));
}
public void display()
{ System.out.println("Welcome to
Interfaces");
}
}

© 2017 Wipro wipro.com confidential 20

4
Applying Interfaces (Contd.).
class classTwo implements IntDemo{
void multiply(int i,int j, int k)
{ System.out.println("The result:" +(i*j*k)
);
}
public void display()
{ System.out.println("Welcome to Java
");
}
}
class DemoClass{
public static void main(String args[]) {
classOne c1= new classOne();
c1.add(10,20);
c1.display();
classTwo c2 = new classTwo();
c2.multiply(5,10,15);
c2.display();
}
}

© 2017 Wipro wipro.com confidential 19

Interface References

 When you create objects, you refer them through the class references. For example :
 ClassOne c1= new classOne(); /* Here, c1 refers to the object of the class
classOne. */
 You can also make the interface variable refer to the objects of the class that implements the
interface
 The exact method will be invoked at run time
 It helps us achieve run-time polymorphism

© 2017 Wipro wipro.com confidential 20

6
Interface References (Contd.).

interface IntDemo{
void display();
}
class classOne implements IntDemo{
void add(int x, int y){
System.out.println("The sum is :" +(x+y));
}
public void display(){
System.out.println("Class one display method ");
}
}

© 2017 Wipro wipro.com confidential 20

7
Interface References (Contd.).
class classTwo implements IntDemo {
void multiply(int i,int j, int k){
System.out.println("The result:" +
(i*j*k) );
}
public void display(){
System.out.println("Class two
display method" );
}
}
class DemoClass{
public static void main(String args[]){
IntDemo c1= new classOne();
//classOne c1= new classOne();

c1.display();
c1 = new classTwo();
c1.display();
}
}

© 2017 Wipro wipro.com confidential 20

8
// A nested interface example.
// This class contains a member interface.
class A {
// this is a nested interface
public interface NestedIF {
boolean isNotNegative(int x);
}
}
// B implements the nested interface.
class B implements A.NestedIF {
public boolean isNotNegative(int x) {
return x < 0 ? false: true;
}
}
class NestedIFDemo {
public static void main(String args[]) {
// use a nested interface reference
A.NestedIF nif = new B();
if(nif.isNotNegative(10))
System.out.println("10 is not negative");
if(nif.isNotNegative(-12))
System.out.println("this won't be displayed");
}
}
Extending Interfaces

 Just as classes can be inherited, interfaces can also be inherited

 One interface can extend one or more interfaces using the keyword extends

 When you implement an interface that extends another interface, you should provide
implementation for all the methods declared within the interface hierarchy
Interface A{}
Interface B{}
Interface C extends A, B{

© 2017 Wipro wipro.com confidential 21

0
Abstract Classes v/s Interfaces

Abstract Classes Interfaces

Abstract classes can have non-final Variables declared within an
non-static variables. interface are always static and final.

Abstract Classes can have abstract Interfaces can have only method
methods declarations(abstract methods).

You can declare any member of an Interface members are by default

abstract class as private, default, public. You cannot have private or
protected or public. Members can protected members. Interface
also be static. methods cannot be static.

Abstract class is extended by An interface is “implemented” by

another class using a java class using “implements”
“extends” keyword. keyword .
Cont
d..

© 2017 Wipro wipro.com confidential 21

5
Abstract Classes v/s Interfaces (Contd.).

Abstract Classes Interfaces

An abstract class can extend An interface can extend one or more
another class and it can interfaces but cannot extend a
implement one or more class. It cannot implement an
interfaces. interface.

An abstract class can have You cannot define constructors

constructors defined within it. within an interface.

An abstract class cannot be An interface cannot be

instantiated using “new” instantiated.
Keyword

You can execute(invoke) an You cannot execute an

abstract class, provided it has interface
public static void main(String[]
args) method declared within
it.

© 2017 Wipro wipro.com confidential 21

6
Member access modes in Java

Specifier Class Package Subclass World

Private Y N N N

No Specifier Y Y N N

Protected Y Y Y N

Public Y Y Y Y
 Comparable interface
• This interface imposes a total ordering on the objects of
each class that implements it. This ordering is referred to
as the class's natural ordering, and the class's compareTo
method is referred to as its natural comparison method.

int compareTo (Object o)

• Compares this object with the specified object for order.
Returns a negative integer, zero, or a positive integer as
this object is less than, equal to, or greater than the
specified object.
 Comparable Interface Example

1. System.out.println(new Integer(3).compareTo(new Integer(5)));

2. System.out.println("ABC".compareTo("ABE"));
3. java.util.Date date1 = new java.util.Date(2013, 1, 1);
java.util.Date date2 = new java.util.Date(2012, 1, 1);
System.out.println(date1.compareTo(date2));

220
 EXCEPTION
• An exception is an error condition that changes the normal flow of
control in a program
• Exceptions in Java separates error handling from main business
logic
• When an exception occurs, the statement that would normally
execute next is not executed.

Some typical causes of errors:

• Memory errors (i.e. memory incorrectly allocated, memory
leaks, “null pointer”)
• File system errors (i.e. disk is full, disk has been removed)
• Network errors (i.e. network is down, URL does not exist)
• Calculation errors (i.e. divide by 0)
Error handling used for

• Processing exceptional situations

• Processing exceptions for components that cannot handle
them directly
• Processing exceptions for widely used components
(libraries, classes, methods) that should not process their
own exceptions
• Large projects that require uniform error processing
 Approaches to handling an exception

1. Prevent the exception from happening

2. Catch it in the method in which it occurs, and
either
a. Fix up the problem and resume normal execution
b. Rethrow it
c. Throw a different exception

3. Declare that the method throws the exception

 Exception Classes
ClassNotFoundException

IOException
ArithmeticException
Exception AWTException
NullPointerException
RuntimeException
IndexOutOfBoundsException
Object Throwable Several more classes
IllegalArgumentException

LinkageError Several more classes

VirtualMachineError
Error
AWTError

Several more classes

 The Basics of Java Exception Handling

• Exception handling
– Method detects error which it cannot deal with
• Throws an exception
– Exception handler
• Code to catch exception and handle it
– Exception only caught if handler exists
• If exception not caught, block terminates
import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

public static void main(String args[]) {

File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
} Output
C:\>javac FilenotFound_Demo.java
} FilenotFound_Demo.java:8: error: unreported exception
FileNotFoundException; must be caught or declared to be
thrown

FileReader fr = new FileReader(file);

// File Name : ExcepTest.java
import java.io.*;
public class ExcepTest {

public static void main(String args[]) {

try {
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
Output
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block
 public class UsingExceptions {
public static void main( String args[] )
{
Call method1, which calls
try { 1. main
method1(); method2, which calls
} method3, which throws 1.1antry
catch ( Exception e ) { exception.
System.err.println( e.getMessage() + "\n" );
1.2 getMessage
e.printStackTrace(); getMessage prints the
} 1.3
String the Exception printStackTrace
}
was initialized with.
public static void method1() throws Exception
1. main
2. method1
1.1 try

{ printStackTrace prints the

1.2 getMessage

method2();
1.3 printStackTrace

}
methods in this order: 3. method2
2. method1

3. method2

method3
4. method3

4.1 throw

public static void method2() throws method2

Exception 4. method3
{ method1
method3();
main 4.1 throw
}
(order they were called when exception
public static void method3() throws occurred)
Exception
{
throw new Exception( "Exception thrown in method3" );
} }
 Output
Exception thrown in method3
java.lang.Exception: Exception thrown in method3
at UsingExceptions.method3(UsingExceptions.java:28)
at UsingExceptions.method2(UsingExceptions.java:23)
at UsingExceptions.method1(UsingExceptions.java:18)
at UsingExceptions.main(UsingExceptions.java:8)
 Thread
• Thread: single sequential flow of control
within a program
• Single-threaded program can handle one task
at any time.
• Multitasking allows single processor to run
several concurrent threads.
• Most modern operating systems support
multitasking.

230
 Threads Concept
Multiple T hread 1

threads on
T hread 2
T hread 3

multiple
CPUs

Multiple T hread 1

threads
T hread 2
T hread 3

sharing a
single CPU

231
 Threads in Java
Creating threads in Java:

• Extend java.lang.Thread class

OR
• Implement java.lang.Runnable interface

232
Why Multithreading?

• Make the UI more responsive

• Take advantage of multiprocessor systems

• Simplify program logic when there are multiple

independent entities

• Perform asynchronous or background

processing
 Using Runnable interface
 Implement Runnable on your class.
class MyThreadClass implements Runnable{…}
 Keep the code to be executed by thread in void run()
public void run(){ // code to be executed comes here }

 Create an object of Thread class and pass a Runnable object (an object of
your class) to it’s constructor.
Thread myThread = new Thread( new MyThreadClass() );
 Invoke start method on this object of Thread Class
myThread.start();

 Calling start() method twice will throw IllegalThreadStateException

 Using Thread class
 Extend your class with Thread Class
class myThreadClass extends Thread{…}
 Override the run() method of Thread Class
public void run(){ //Code to be executed by the
thread }

 Create an object of your class (to initialize the thread by invoking the
superclass constructor)
myThreadClass myThread = new myThreadClass();
 Invoke the inherited start() method which makes the thread eligible for running
myThread.start();
Thread Life Cycle

run() destroy()
Ready to
Running Dead
Run/Runnabl
e

notify/ sleep/wait/blocked
Blocking over

Blocked
/
Waiting/
Sleeping
Born
Thread States Dead

Ready Or Executing
or
Runnabl running
run() destroy() or
e
start() Execution
complete

sleep sleep(n)
interval
expires Sleeping

notify() wait()
notifyAll()

Waitin
g
I/O Operation
I/O completed

Blocked
 sleep() method
 Thread.sleep() is a static method. It delays the executing thread for a
specified period of time (milliseconds or milliseconds plus nanoseconds)

 Thread.sleep() throws a checked InterruptedException if it is interrupted by

another
Thread.

try {
Thread.sleep ( 1000 );
} catch ( InterruptedException e ) {
e.printStackTrace();
}

 When a thread is asleep, or otherwise blocked on input of some kind, it

doesn't consume CPU time or compete with other threads for processing.
 Thread Priorities
 The Thread scheduler which is part of JVM chooses which thread to
run
according to a “fixed priority algorithm”

 Threads with higher priorities are run to completion before Threads with
lower priorities get a chance of CPU time

 The algorithm is preemptive, so if a lower priority thread is running,

and a higher priority thread becomes runnable, the high priority thread
will pre-empt the lower priority thread

 All Java threads have a priority in the range 1-10.

 Thread.MIN_PRIORITY - 1
 Thread.MAX_PRIORITY - 10
 Thread.NORM_PRIORITY - 5
 Thread Priority
 When a new Java thread is created it has the same priority as the
thread which created it.
 Thread priority can be changed by the setPriority() method.
t1.setPriority(Thread.NORM_PRIORITY + 1); //priority 6
t2.setPriority(Thread.NORM_PRIORITY -1);//priority
4 t3.setPriority(Thread.MAX_PRIORITY - 1);//priority
9
t1.start();
t2.start();
t3.start();
} Will execute last
Will execute second

Will execute first

4 6
9
 Joins
 The join method allows one thread to wait for the completion of another.
 If t1 is a Thread object whose thread is currently executing, t1.join(); causes
the current thread to pause execution until the thread t1 terminates.

 Join is dependent on the OS for timing, so do not assume that join will
wait exactly as long as you specify.

public class ThreadExampleMain

{
public static void main(String[] args) {
Thread myThread = new ThreadExample(“my
data”); myThread.start();
System.out.println(“I am the main thread”);

myThread.join();
System.out.println(“This line is printed after
myThread finishes execution”);
}
}
 Synchronization
 Sometimes, multiple threads may be accessing the same resources
concurrently
 Reading and / or writing the same file
 Modifying the same object / variable

 Synchronization controls thread execution order

 Synchronization eliminates data races

 Java has built in primitives to facilitate this coordination

Synchronization

cook()
{
//itemName := Userinput

//query database for recipe

//cook as per the recipe

//serve
}
Synchronization
synchronized cook()
{
//itemName := Userinput

//query database for recipe

//cook as per the recipe

//serve
}
 wait() & notify()
 Threads can communicate using wait() and notify() methods of Object
class.

 Both of them can be invoked only within a synchronized context

 When a thread calls the wait() method:

• The thread releases the lock for the object.
• The state of the thread is set to be blocked.
• The thread is placed in the wait set for the object.

 When a thread calls the notify() method:

• An arbitrary thread is picked from the list of threads in the wait set.
• Moves the selected thread from the wait set to the entry set.
• Sets the state of the selected thread from blocked to runnable.

• notifyall() will move all waiting threads to Runnable state

 wait() & notify()
Burger

synchronized takeOrder() synchronized prepareOrder()

{ {
try{ if(! if(!orderTaken)
orderPrepared) { wait();
{ wait(); }
} orderPrepared =
orderTaken = true; true;
orderPrepared=false; orderTaken=false;
notify(); notify();
} catch(InterruptedException ie) }catch(InterruptedException ie)
{ ie.printStackTrace(); { ie.printStackTrace();
} }
} }
 I/O Application

Typically, there are three ways a developer may use input

and output:
Files and
Directories

Console:
(standard-in,
standard-
out)

Socket-
based
sources
Introduction to Streams
 A stream is an abstraction that helps a java program to work with external
data
• local file
• user input
• network.

Java Program InputStream

{ File.txt
…..
…..
…..
…..
} OutputStream
I/O Streams
• A program uses an input stream to read data from a source,
one item at a time.

• A program uses an output stream to write data to a

destination (sink), one item at time.
 Types of Streams
 Byte Stream
• Byte streams provide an abstraction to read/write bytes, e.g. binary data

• InputStream and OutputStream are the abstract classes which represent Byte
Streams

 Character Stream

• Usually works for Characters & Strings

• Follows the Unicode to support internationalization

• Reader and Writer are the abstract classes which represent

Character Streams
Stream Byte Streams Character Streams
Source streams InputStream Reader

Sink streams OutputStream Writer

IO Class Hierarchy

Object

OutputStream InputStream Reader Writer

Byte-Oriented Character-Oriented Streams

Streams
Stream Hierarchy
I/O Streams

Byte Oriented Streams Unicode Character Oriented Streams

InputStream OutputStream Reader Writer

FileInputStream, FileOutputStream,
InputStreamReader OutputStreamWriter
DataInputStream DataOutputStrea
m
FileReade FileWriter
r

May be buffered or
unbuffered  Abstract Classes
Predefined Stream Objects
 The three predefined stream objects in Java are byte streams:
 System.out & System.err:

• System.out refers to standard output stream and System.err refers

to standard error stream
• The default device for both these streams is console

 System.in
• System.in is the standard input stream.
• The default device is keyboard.
Reading Console Input
 Character-oriented stream can be used to read console input

 The keyboard sends data to the InputStream (System.in)which is connected

to InputStreamReader stream which is further connected to a
BufferedReader stream.

BufferedReader stdin = new BufferedReader(new

InputStreamReader(System.in));

Java
Program

Note: java.util.Scanner can also be used for reading

inputs
File class
 Objects of type File are used to represent the actual files or directories on
the disk

 File class is not actually used to read/write data

 It is used for operations like making a new empty file, searching for
files, deleting files, making directories etc
 Few noteworthy methods in File class
 boolean exists() – Returns true if it can find the actual file
 boolean createNewFile() – Creates a new file if it doesn’t exist
 boolean mkdir() – Creates an empty directory
 boolean delete() – Deletes a file
File Streams
 File streams are primitive streams whose sources or destinations are
files.
 The base file stream classes in java.io package are:
• FileInputStream - binary file input base class
• FileOutputStream - binary file output base class
• FileReader - read text files
• FileWriter - write to text files

 All classes provide the read() and write() methods for I/O
operations
File IO Streams
 An input stream from a file can be created with:
File file_in = new File ("data.dat");
FileInputStream in = new FileInputStream(file_in);

 Output streams to files are opened like:

File file_out = new File("tmp.dat");
FileOutputStream out = new FileOutputStream
(file_out);

 To append to an existing file use the overloaded

constructor:
File file_out = new File ("old.dat");
FileOutputStream out =new
FileOutputStream(file_out, true);
 Buffered IO Streams
 We can wrap a BufferedInputStream or BufferedOutputStream around the
FileInputStream or FileOutputStream for reading & storing large chunks of data
in a buffer at once for later use

FileInputStream fin = new FileInputStream(“data.dat”);

BufferedInputStream bins = new BufferedInputStream(fin);

Java Program
{
BufferedInputStream …..
File FileInputStream …..
Internal Buffer
…..
…..
}
The BufferedInputStream reads We can then read data
data from the File in large from the
chunks and stores the data in BufferedInputStream.
an internal buffer Data is read from the buffer
instead of directly from the file
on each read
Data Streams
 The DataInputStream and DataOutputStream allow to read and write
primitive data types to input and output streams respectively, rather than just
bytes or characters

 Data streams are buffered. They process more than single byte at a time.

 It supports operations like readInt, writeInt, readFloat, writeFloat etc,

DataOutputStream

DataInputStream
 DataOutputStream
 DataOutputStream extends FilterOutputStream,which extends OutputStream

 It implements DataOutput interface.

 This interface defines methods that convert value of primitive type into a byte
and then writes to underlying stream.

 DataOutputStream must be attached to some other OutputStream.

 Example:
DataOutputStream is attached to a FileOutputStream to write to a file on the file
system named File1.txt
DataOutputStream dos = new DataOutputStream(new
FileOutputStream(“File1.txt"));
 DataInputStrea
mDataInputStream is complement of DataOutputStream

 It extends FilterInputStream, which extends InputStream.

 It implements DataInput interface.

 This interface reads a sequence of bytes and convert them into values
of primitive type.

 Example:
DataInputStream is attached to a FileInputStream to read a file on the
file system named File1.txt

DataInputStream dis = new DataInputStream(new

FileInputStream(“File1.txt
"));
 Java Applet
• Java applications
– Run in stand-alone mode
– No additional software required (such as a Web browser)

• Java applets
– Compiled Java class files
– Run within a Web browser (or an appletviewer)
– Loaded from anywhere on the Internet
Methods are called in this order

• init and destroy are only

init()
called once each
• start and stop are called
start()
whenever the browser enters and
leaves the page
paint
do other work • do some work is code called by your
listeners
stop() • paint is called again when the
applet needs to be repainted
destroy()
 Application vs Applets
Application Applet
• Inherits from JFrame • Inherits from JApplet

• Has a constructor • Uses an init method that

performs the same operations
as a constructor.

• Requires calls to setSize, • An applet does not have a

setDefaultCloseOperation, window of its own so it does
and setVisible to establish NOT require calls to these
window methods.

• Requires a static main • There is no main() method --

method to create an the browser creates an instance
instance of the application. of the class automatically.
 Different Parts of An Applet
Inherit applet methods from class JApplet
JApplet
public void init( )
YourApplet public void start()

public void paint(Graphics g) public void paint(Graphics g)

public void init( ) public void stop()

public void start() public void destroy()

showstatus( String)
JApplet methods that the applet container calls during execution
init( ) Called once by browser when applet is loaded
- initialization of instance variables and GUI components
start( ) Called after init() is finished and every time the browser
returns to HTML page
- starting animations
paint(Graphics g) -called after init() is finished and start() has started, and
every time the applet needs to be repainted. (ie. window
moves.)
-Drawing with the Graphics object
stop ( ) Called when the applet should stop executing (i.e. browser
leaves HTML page.)
Stopping animations
destroy( ) Called when applet is removed from memory (i.e. browser
exists)
- destroy resources allocated to applet
 Sample Graphics methods
 A Graphics is something you can paint on

g.drawString(“Hello”, 20, 20); Hello

g.drawRect(x, y, width, height);
g.fillRect(x, y, width, height);

g.drawOval(x, y, width, height);

g.fillOval(x, y, width, height);

g.setColor(Color.red);
 Drawing Strings
g.drawString("A Sample String", x, y)
1 // Fig. 3.6: WelcomeApplet.java Outline
2 // A first applet in Java.
3
4 // Java coreimport
packages
allows us to use
5 import java.awt.Graphics; // import class Graphics
6 predefined classes (allowing
7 us to usepackages
// Java extension applets and
8 import javax.swing.JApplet; // import
graphics, in this case). class JApplet
9
10 public class WelcomeApplet extends JApplet {
11
12 // draw text on applet’s background extends allows us to inherit the
13 public void paint( Graphics g ) capabilities of class JApplet.
14 {
15 // call inherited version of method paint
16 super.paint( g );
17 Method paint is guaranteed to
18 // draw a String at x-coordinate 25 and y-coordinate 25
19
be called in all applets. Its
g.drawString( "Welcome to Java Programming!", 25, 25 );
first
20 line must be defined as above.
21 } // end method paint
22
23 } // end class WelcomeApplet

 2002 Prentice Hall.

 2002 Prentice Hall. All rights reserved. All rights reserved.
 Running Applets

– In command prompt, change to demo subdirectory of applet

cd c:\jdk1.3\demo\applets
cd appletDirectoryName
– There will be an HTML file used to execute applet
– Type appletviewer example1.html
• appletviewer loads the html file specified as its
command-line argument
• From the HTML file, determines which applet to load (more
section 3.3)
– Applet will run, Reload and Quit commands under
Applet menu

 2002 Prentice Hall. All rights reserved.

1 // WelcomeApplet.java
2 // A first applet in Java
3 import javax.swing.JApplet; // import class JApplet
4 import java.awt.Graphics; // import class Graphics
5
6 public class WelcomeApplet extends JApplet {
7 public void paint( Graphics g )
8 { super.paint(g);
9 g.drawString( "Welcome to Java Programming!", 25, 25 );
10 }
11 }

1 <html>

2 <applet code="WelcomeApplet.class" width=300 height=30>

3 </applet>

4 </html>
 Strings
String is a sequence of characters enclosed in quotes.
E.g. “Hello”
• String processing is one of the most important and
most frequent applications of a computer
• Java recognizes this fact and therefore provides
special support for strings to make their use
convenient
• Every string is an instance of Java’s built in
String class, thus, Strings are objects.
 String
class String_Demo
{
public static void main(String args[])
{
System.out.print("welocome 2025");

System.out.println("Hello world");
int a=23;
float b=23.23489f;
System.out.printf("int=%d and flo=%f",a,b);
System.out.println(a+"welocome 2025"+b);

}
Declaration
Like any object, a string can be created using new as in the following
example:

String str1 = new String(“Hello there”);

However, as an extra support, Java allows String object to be created

without the use of new, as in:

String str2=”How are you”;

 Substring
String objects are represented as a sequence of characters
indexed from 0.
Example: String greeting = “Hello, World!”;
• Java provides two methods for this operation
1. substring(start);
Returns the substring from start to the end of the string
2. substring(start, end);
Returns a substring from start to end but not including the
character at end.
 The first character's index is always 0
 The last character's index is 1 less than the string's length

H e l l o , W o r l d !

0 1 2 3 4 5 6 7 8 9 10 11 12

Examples:
String sub = greeting.substring(0, 4);  “Hell”
String w = greeting.substring(7, 12);  “ World”
String tail = greeting.substring(7);  “ World!”
 String Concatenation
• Another common operation on String is concatenation.
• As another special support for String, Java overloaded the +
operator to be used to concatenate two String objects to get a
bigger one.
String firstName = “Computer”;
String lastName = “Science”;
String fullName = firstName+” “+lastName;

OUTPUT “Computer Science”

• If one of the operands of the + operator is a string, the other is
automatically converted to string and the two strings are then
concatenated.
String course = “RCSE”;
int code = 12;
String courseCode = course+code
OUTPUT  “RCSE12”
 Methods of the String Class
int length() returns the number of
characters in this String
String toUpperCase() returns a new String,
String toLowerCase() equivalent to the
Upper/lower case of this
String
boolean equals(s) returns true if s the same as
boolean this String.
equalsIgnoreCase(s)
int compareTo(String s) returns +ve number, 0, or -ve
int compareToIngoreCase(s) number if this String is
greater than, equal to or less
than s.
char charAt(index) returns the char in this
String, at the index
position.
int indexOf(ch) Returns the index of the
int lastIndexOf(ch) first / last occurrence of ch
in this string, If not fount-1
is returned
String trim() returns a String, obtained
by removing spaces from
the start and end of this
string.
static String valueOf (any Returns a String
primitive type) representation of the
argument
public class MakePassword {
public static void main(String[] args) {
String firstName = “Computer";
String middleName = "Science";
String lastName = "Engineering";

//extract initials
String initials =firstName.substring(0,1)+ Output
middleName.substring(0,1)+ Your Password=cse20
lastName.substring(0,1);

//append age
int age = 20;

String password = initials.toLowerCase()+age;

System.out.println("Your Password ="+password);

} }
String s1 = "Stuart Reges";
String s2 = "Marty Stepp";

System.out.println(s1.length());
System.out.println(s1.indexOf("e"));
System.out.println(s1.substring(7, 10));
String s3 = s2.substring(2, 8);
System.out.println(s3.toLowerCase());
OUTPUT
12
8
Reg
rty st
 Strings as parameters
public class StringParameters {
public static void main(String[] args) {
sayHello(“Sam");

String teacher = "Helene";

sayHello(teacher);
}
public static void sayHello(String name) {
System.out.println("Welcome, " + name);
}
}

Output:
Welcome, Sam
Welcome, Helene
String Tokenizer

• StringTokenize
r class in
Java is used to
break a string
into tokens
based on
delimiters.
• A delimiter is a
character or set
of characters
that separate
tokens in the
string.
import java.util.StringTokenizer;

public class Geeks {

public static void main(String[] args) {

String s = "Hello Geeks how are you";

StringTokenizer st = new StringTokenizer(s, " ");

int c = st.countTokens();
System.out.println(c);
// Tokenize the string and print each token
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
}
}
}
 Split method
• The split method in Java is a powerful tool for
dividing a string into an array of substrings based on
a specified delimiter.
• public String[] split(String regex)
• It can handle empty strings when you
need to parse empty tokens
like ant, bat, pat
• It returns an array of substrings.
 Split method
public class SplitExample
{
public static void main(String[] args)
{
String sentence = "Java is a versatile
programming language";
String[] words = sentence.split(" ");
for (String word : words)
{
System.out.println(word);
}
}
}
 Split method
public class SplitExample {
public static void main(String[]
args) {
String data = "apple, orange; banana
grape";
String[] fruits = data.split("[,; ]");
for (String fruit : fruits) {
System.out.println(fruit);
}
}
}
AWT
Containers and Components
Container (Applet)

Containers (Panels)

Component (Canvas)

Components (Buttons)

Components (TextFields)

Components (Labels)

291
 Some types of components
Button Checkbox
Label

Choice Scrollbar

TextField List TextArea

Button

Radio
Radio Button Group
Button
 Component Class Hierarchy

AWTEvent Container
Panel Applet
Button
Font Window
Canvas Frame

FontMetrics
TextComponent
TextField ScrollPane

Object Color List

TextArea Dialog
Choice
Graphics
Checkbox

Component Label

Scrollbar
LayoutManager
293
 Arranging components
• Every Container has a layout manager
• The default layout for a Panel is FlowLayout
• An Applet is a Panel
• Therefore, the default layout for a Applet is
FlowLayout
• You could set it explicitly with
setLayout (new FlowLayout( ));
• You could change it to some other layout manager

294
 Example: FlowLayout
import java.awt.*;
import java.applet.*;
public class FlowLayoutExample extends
Applet {
public void init () {
setLayout (new FlowLayout ()); // default
add (new Button ("One"));
add (new Button ("Two"));
add (new Button ("Three"));
add (new Button ("Four"));
add (new Button ("Five"));
add (new Button ("Six"));
}
}

296
 BorderLayout
• At most five components can be
added
• If you want more components, add a
Panel, then add components to it.
• setLayout (new
BorderLayout());

add (new Button("NORTH"), BorderLayout.NORTH);

297
 BorderLayout with five
Buttons
public void init() {
setLayout (new BorderLayout ());
add (new Button ("NORTH"), BorderLayout.NORTH);
add (new Button ("SOUTH"), BorderLayout.SOUTH);
add (new Button ("EAST"), BorderLayout.EAST);
add (new Button ("WEST"), BorderLayout.WEST);
add (new Button ("CENTER"), BorderLayout.CENTER);
}

298
 Using a Panel

Panel p = new Panel();

add (p,
BorderLayout.SOUTH);
p.add (new Button ("Button
1"));
p.add (new Button ("Button
2"));

299
 GridLayout
• The GridLayout manager divides the container up
into a given number of rows and columns:

setLayout(new GridLayout(rows, columns));

• All sections of the grid are equally sized and as large as

possible

300
 Example: GridLayout
import java.awt.*;
import java.applet.*;
public class GridLayoutExample extends
Applet {
public void init () {
setLayout(new GridLayout(2, 3));
add(new Button("One"));
add(new Button("Two"));
add(new Button("Three"));
add(new Button("Four"));
add(new Button("Five"));
}
}

301
How to Use Buttons?
This class represents a push-button which displays some
specified text.

Panel aPanel = new Panel();

Button okButton = new Button("Ok");
Button cancelButton = new Button("Cancel");

aPanel.add(okButton));
aPanel.add(cancelButton));

okButton.addActionListener(controller2);
cancelButton.addActionListener(controller1);
How to Use Labels?
public class TestLabel extends Frame {
public TestLabel(String title){
super(title);
Label label1 = new Label();
label1.setText("Label1");
Label label2 = new Label("Label2");
label2.setAlignment(Label.CENTER);
Label label3 = new Label("Label3");

add(label1,"North");
add(label2,"Center");
add(label3,"South");
}
}
How to Use Checkboxes?
public class TestCheckbox extends Frame {
public TestCheckbox(String title){
super(title);

CheckboxGroup cbg = new CheckboxGroup();

Checkbox cb1 = new Checkbox("American Express",cbg,false);
Checkbox cb2 = new Checkbox("Visa",cbg,false);
Checkbox cb3 = new Checkbox("Mastercard",cbg,true);
add(cb1,"North");
add(cb2,"Center");
add(cb3,"South");
}
…
}
304
How to Use Choices?

public class TestChoice extends Frame {

public TestChoice(String title){
super(title);

Choice fruits = new Choice();

fruits.add(“Mango");
fruits.add(“Apple");
fruits.add(“Grapes");
add(fruits);
}
`
305
How to Use TextField & TextArea
public class TestText extends Frame {
public TestText(String title){
super(title);

TextField textField = new TextField(20);

TextArea textArea = new TextArea(5, 20);

textField.setText("TextField");
textArea.setText("TextArea Line1 \n TextArea Line2");

add(textField,"North");
add(textArea,"South");
}
…}
How to Use Lists?
public class TestList extends Frame {
public TestList(String title){
super(title);
List Li = new List(2, true); //prefer 2 items visible
Li.add("zero");
Li.add(“one”);
Li.add(“two");
Li.add("three");
Li.add(“four");
Li.add(“five");
Li.add("six");
Li.add("seven");
Li.add(“eight");
Li.add(“nine");
Li.add(“ten"); add(Li); } 307
drawLine(x1,y1,x2,y2)

class MyCanvas extends Canvas {

public void paint(Graphics g){
g.setColor(Color.blue);
int x1 = 161, (x1,y1)
y1 = 186,
x2 = 181,
y2 = 206; (x2,y2)

g.drawLine(x1,y1,x2,y2);
}

308
fillOval(x,y,w,h)
drawOval(x,y,w,h)
g.setColor(Color.blue);
{
int x = 239,
y = 186,
w = 48,
h = 32;
g.fillOval(x,y,w,h);
}

309
fillRect(x,y,w,h)
drawRect(x,y,w,h)

g.setColor(Color.pink);
{
int x = 239,
y = 248,
w = 48,
h = 32;
g.fillRect(x,y,w,h);
}
fillRoundRect(x,y,w,h,rw,rh)
drawRoundRect(x,y,w,h,rw,rh)

g.setColor(Color.yellow);
{
int x = 161,
y = 248,
w = 48,
h = 32,
roundW = 25,
roundH = 25;
g.fillRoundRect(x,y,w,h,roundW,roundH);
}
Event handling

For the user to interact with a GUI, the underlying operating system
must support event handling.
1)Operating systems constantly monitor events such as keystrokes,
mouse clicks, voice command, etc.
2) Operating systems sort out these events and report them to the
appropriate application programs
3) Each application program then decides what to do in response
to these events
Events
• An event is an object that describes a state change in a
source.
• It can be generated as a consequence of a person
interacting with the elements in a graphical user interface.
• Some of the activities that cause events to be generated
are pressing a button, entering a character via the
keyboard, selecting an item in a list, and clicking the
mouse.
• Events may also occur that are not directly caused by
interactions with a user interface.
• For example, an event may be generated when a timer
expires, a counter exceeds a value, a software or
hardware failure occurs, or an operation is completed.
• Events can be defined as needed and appropriate by
application.
 Event Classes in java.awt.event
• ActionEvent
• AdjustmentEvent
• ComponentEvent
• ContainerEvent
• FocusEvent
• InputEvent
• ItemEvent
• KeyEvent
• MouseEvent
• TextEvent
• WindowEvent
Action Events on Buttons

ActionEvent

actionPerformed(..)

Button ActionListener
 Example
import java.awt.*;
import java.awt.event.*;
public class TestButtonAction {
public static void main(String[] args){
Frame f = new Frame("TestButton");
f.setSize(200,200);
Button hw = new Button(“Exit!");
f.add(hw);

hw.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
System.exit(0);
}
}
f.setVisible(true);
}
}
Some classes and
methods in the event EventObject
hierarchy.

AWTEvent

ActionEvent ComponentEvent
String getActionCommand()

InputEvent WindowEvent
Window getWindow()

MouseEvent KeyEvent
int getX() char getKeyChar()
319
 Adapter Class
Adapter Class Listener Interface
ComponentAdapter ComponentListener
ContainerAdapter ContainerListener
FocusAdapter FocusListener
KeyAdapter KeyListener
MouseAdapter MouseListener
MouseMotionAdapter
MouseMotionListener
WindowAdapter WindowListener
 MouseAdapter
class MouseAdapter implements MouseListener {
public void mouseClicked(MouseEvent e){}

public void mouseEntered(MouseEvent e){}

public void mouseExited(MouseEvent e){}

public void mousePressed(MouseEvent e){}

public void mouseReleased(MouseEvent e){}

}
 Mouse Event Example-1
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class TestMouseListener {
public static void main(String[] args){
Frame f = new Frame("TestMouseListener");
f.setSize(500,500);

f.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent e){
System.out.println("Mouse clicked: ("+e.getX()+","+e.getY()+")");
}
....
}
import java.applet.Applet;
import java.awt.event.MouseEvent;
Example 2
import java.awt.event.MouseListener;

class MouseSpy implements MouseListener

{ public void mouseClicked(MouseEvent event)
{ System.out.println("Mouse clicked. x = " + event.getX() +
" y = " + event.getY());
}
public void mouseEntered(MouseEvent event)
{ System.out.println("Mouse entered. x = " + event.getX() +
" y = " + event.getY());
}
public void mouseExited(MouseEvent event)
{ System.out.println("Mouse exited. x = " + event.getX() +
" y = " + event.getY()); 323
}
 public void mousePressed(MouseEvent event)
{ System.out.println("Mouse pressed. x = " + event.getX() +
" y = " + event.getY());
}
public void mouseReleased(MouseEvent event)
{ System.out.println("Mouse released. x = " + event.getX() +
" y = " + event.getY());
}
}

public class MouseSpyApplet extends Applet

{ public MouseSpyApplet()
{ MouseSpy listener = new MouseSpy();
addMouseListener(listener);
}
} 324
 The WindowAdapter class

public abstract class WindowAdapter implements

WindowListener {

public void windowClosing(WindowEvent e) { }

public void windowClosed(WindowEvent e) { }
public void windowOpened(WindowEvent e) { }
public void windowIconified(WindowEvent e) { }
public void windowDeiconified(WindowEvent e) { }
public void windowActivated(WindowEvent e) { }
public void windowDeactivated(WindowEvent e) { }
}

325
 Example
import javax.swing.*;
import java.awt.event.*;
public class CloseDemo2 extends WindowAdapter {
public static void main(String[] args) {
JFrame f = new JFrame("Example");
f.setSize(400,100);
f.setVisible(true);
f.addWindowListener(new CloseDemo2());
}
public void windowClosing(WindowEvent e) {
System.exit(0);
}
326
}