Programming in java

B.Sc. V Semester
2023-2024

Lecturer in Computer Science

Outcome of the course:

 Java is useful for the design of desktop and web

applications.

 To learn how to design a graphical user interface (GUI)

with Java Swing.

 To understand how to design applications with threads in

Java
Outcome

On completion of the course students should be able to:

 Use object oriented programming concepts to solve

real world problems

 Explain the concept of class and objects with access

control to represent real world entities

 Use multithreading concepts to develop inter process

communication
Outcomes… cont
 Understand the process of graphical user interface
design and implementation using AWT or swings.

 Build the internet-based dynamic applications using

the concept of applets.

 Knowledge on usage of graphical IDE for design and

implementation of real time applications in java.

 Possess the knowledge and skills for employability.

SUGGESTED READINGS:

Sachin Malhotra, Saurabh Choudhary, Programming in

Java (2e)

Herbert Schildt, Java: The Complete Reference (9e)

Bruce Eckel, Thinking in Java (4e)

Paul Deitel, Harvey Deitel, Java: How To Program (10e)

 Prerequisites for learning Java

• In fact, you can directly start learning Java without any prior knowledge of
programming language.

• But, the syntax in Java is similar to the syntax of the C programming

language, therefore, Knowing C language helps to get hold of Java quickly.

• Having introduced to object-oriented principles before starting Java, also

helps in the understanding of the language so, having an idea on object-
oriented languages such as C++ also helps.

• In short, if you know C or C++ it will be a little bit easier to cope with Java
technology.
 Unit-I: BASIC CONCEPTS

Introduction: Java Essentials,JVM, Java Features,

Creation and Execution of Programs

DataTypes, Structure of Java Program

Type Casting,Conditional Statements, Loops

Classes, Objects, Class Declaration, Creating Objects

 Objectives
 This unit gives the idea of basic concepts on Java.

 Be able to understand Creation and Execution of Programs

 Be able to understand Structure of Java Program

 Be able to create Classes, Objects.

Java Features

 Compiled and Interpreted

 Platform independent and portable

 object-oriented

 Robust and Secure

 Distributed

 High Performance

 Dynamic and Extensible

How Java Differs from C and C++
 Java does not include the C unique statement keywords sizeof and
typedef.
 Java does not contain the data types struct and union.
 Java does not define the type modifers keywords
auto,extern,register,signed and unsigned.
 Java does not use pointers.
 Java does not have a preprocessor and therefore we cannot use
# define,# include and # ifdef statements.
 Java requires that the functions with no arguments must be
declared with empty parenthesis and not with the void keyword as
done in C.
 Java does not support operator overloading.
 Java does not have template classes as in C++.
 Java does not support multiple inheritance of classes.
 Java has replaced the destructor function with a finalize() function.
Understanding the concept of Java Classes and Objects with an example
Object :- Any entity that has state and behavior is known as an object. For example, a chair, pen, table,
keyboard, bike, etc. It can be physical or logical.

An Object can be defined as an instance of a class.

An object contains an address and takes up some space in memory.

Objects can communicate without knowing the details of each other's data or code.
The only necessary thing is the type of message accepted and the type of response returned by the objects.

Example: A dog is an object because it has states like color, name, breed, etc. as well as behaviors like
wagging the tail, barking, eating, etc.

Class :- Collection of objects is called class. It is a logical entity.

A class can also be defined as a blueprint from which you can create an individual object. Class doesn't
consume any space.

Syntax of Class in Java.

class <class_name>
{
field ;
method ;
}
 syntax of creating object in java

ClassName ReferenceVariable = new ClassName();

Ex : Abc o1 = new Abc();

new Abc() is an object, o1 is a refers to object

 Accessing class variables

o1. fieldname;

 Accessing class Methods

o1.methodName();
Understanding the concept of Java Classes and Objects with another
example.

• Let’s take an example of dogs.

• Some Common Characteristics shared by these dogs are
Breed,Size,Age and Color can form a data members of object.

• Some Common behaviors of these dogs like eat,sleep,sit and run etc . So these will be
the Common actions of our software objects.

We have defined following things

• Class - Dogs
• Data members - size,age,color,breed etc
• Methods - eat,sleep,sit and run
 DOG
class

Breed
Size
Age
Color
Data Members

Eat()
Sleep()
Sit()
Run() methods

Now, for different values of data members (Breed,Size, Age and Color) in
Java class, you will get different Dog objects.
// Class Declaration
public class Dog
{
// Instance Variables
String breed;
String size;
int age;
String color;
// method 1
public String getInfo()
{
return ("Breed is: "+breed+" Size is:"+size+" Age is:"+age+" color is: "+color);
}
public static void main(String[] args)
{
Dog maltese = new Dog();
maltese.breed="Maltese";
maltese.size="Small";
maltese.age=2;
maltese.color="white";
System.out.println(maltese.getInfo());

}
}

Output:
Breed is: Maltese Size is:Small Age is:2 color is: white
 Unit-II: Method Declaration, Inheritance and Packages

• Method Declaration, Method overloading,

Constructors, Constructor overloading

• Inheritance, Types of Inheritance, Abstract classes,

Interfaces

• Packages :creating and using packages

Objectives
 This unit gives the idea of Method
overloading,constructors,constructor overloading.

 Able to learn and Implement Inheritance, Interfaces

Able to create and use of Packages.

 .

Method Signature: Every method has a method signature. It is a part of the method declaration. It includes the method name and
parameter list.

Access Specifier: Access specifier or modifier is the access type of the method. It specifies the visibility of the method. Java
provides four types of access specifier:

Public: The method is accessible by all classes when we use public specifier in our application.

Private: When we use a private access specifier, the method is accessible only in the classes in which it is defined.

Protected: When we use protected access specifier, the method is accessible within the same package or subclasses in a different
package.

Default: When we do not use any access specifier in the method declaration, Java uses default access specifier by default. It is
visible only from the same package only.

Return Type: Return type is a data type that the method returns. It may have a primitive data type, object, void, etc. If the method
does not return anything, we use void keyword.
Method Name: It is a unique name that is used to define the name of a method.
It must be corresponding to the functionality of the method. Suppose, if we are
creating a method for subtraction of two numbers, the method name must be
subtraction(). A method is invoked by its name.

Parameter List: It is the list of parameters separated by a comma and enclosed

in the pair of parentheses. It contains the data type and variable name. If the
method has no parameter, left the parentheses blank.

Method Body: It is a part of the method declaration. It contains all the actions to
be performed. It is enclosed within the pair of curly braces.
 Method Overloading in Java
•Method Overloading allows different methods to have the same name, but different
signatures where the signature can differ by the number of input parameters or type of input
parameters, or a mixture of both.

•Method overloading is also known as Compile-time Polymorphism, Static

Polymorphism, or Early binding in Java.

• In Method overloading compared to parent argument, child argument will get the highest
priority.

Example

// Overloaded sum(). This sum takes two int parameters

public int sum(int x, int y) { return (x + y); }

// Overloaded sum(). This sum takes three int parameters

public int sum(int x, int y, int z)
{
return (x + y + z);
}

// Overloaded sum(). This sum takes two double

// parameters
public double sum(double x, double y)
{
return (x + y);
}
 Java Constructor
A constructor in Java is a special method whose name is same as class name, that
is used to initialize objects. The constructor is called when an object of a class is
created.

 when an instance of the class is created. At the time of calling the constructor,
memory for the object is allocated in the memory.

 It is a special type of method that is used to initialize the object.

 Every time an object is created using the new keyword, at least one constructor
is called.

There are 3 Types of Constructors in Java

•Default Constructor
•Parameterized Constructor
•Copy Constructor

Example :
abc() //Default Constructor
abc(String name,int id) //Parametized Constructor
abc(Geek obj2) // copy constructor – It is passed with another object
Inheritance : Inheritance in Java is a mechanism in which one object acquires all
the properties and behaviors of a parent object.

we use inheritance in java

 For Method Overriding (so runtime polymorphism can be achieved).
 For Code Reusability.

Terms used in Inheritance

Class: A class is a group of objects which have common properties. It is a template

or blueprint from which objects are created.

Sub Class/Child Class: Subclass is a class which inherits the other class. It is also
called a derived class, extended class, or child class.

Super Class/Parent Class: Superclass is the class from where a subclass inherits
the features. It is also called a base class or a parent class.
Reusability: As the name specifies, reusability is a mechanism which facilitates you
to reuse the fields and methods of the existing class when you create a new class.
You can use the same fields and methods already defined in the previous class.

The syntax of Java Inheritance

class Subclass-name extends Superclass-name

{
// fields and methods
}

The extends keyword indicates that you are making a new class that derives from
an existing class. The meaning of "extends" is to increase the functionality.
 Types of Inheritance

1.Single Inheritance

2.Multilevel Inheritance

3.Hierarchical Inheritance

4.Multiple Inheritance

5.Hybrid Inheritance

1.Single Inheritance
In single inheritance, subclasses inherit the features of one superclass. In the image below, class A
serves as a base class for the derived class B.

2.Multilevel Inheritance
In Multilevel Inheritance, a derived class will be inheriting a base class, and as well as the derived class
also acts as the base class for other classes. In the below image, class A serves as a base class for the
derived class B, which in turn serves as a base class for the derived class C. In Java, a class cannot
directly access the grandparent’s members.
3.Hierarchical Inheritance

In Hierarchical Inheritance, one class serves as a superclass (base class) for more than one
subclass. In the below image, class A serves as a base class for the derived classes B, C, and D.
4. Multiple Inheritance (Through Interfaces)

In Multiple inheritances, one class can have more than one superclass and inherit
features from all parent classes. Please note that Java does not support
multiple inheritances with classes. In Java, we can achieve multiple inheritances
only through Interfaces. In the image below, Class C is derived from interfaces A and
B.
5. Hybrid Inheritance(Through Interfaces)
It is a mix of two or more of the above types of inheritance. Since Java doesn’t
support multiple inheritances with classes, hybrid inheritance is also not possible
with classes. In Java, we can achieve hybrid inheritance only through Interfaces.
 Abstraction in Java

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

functionality to the user.

Another way, it shows only essential things to the user and hides the internal
details, for example, sending SMS where you type the text and send the message.
You don't know the internal processing about the message delivery.

There are two ways to achieve abstraction in java

1. Abstract class
2. Interface

Abstract class : A class which is declared with the abstract keyword is known as an
abstract class in java. It can have abstract and non-abstract methods (method with
the body). It needs to be extended and its method implemented. It cannot be
instantiated.
Example : abstract class Bank{
abstract int getRateOfInterest();
}
class SBI extends Bank{
int getRateOfInterest() {return 7;}
}
class PNB extends Bank{
int getRateOfInterest() {return 8;}
}

class TestBank{
public static void main(String args[]) {
‘ Bank b=new SBI();

System.out.println("Rate of Interest is: "+b.getRateOfInterest()

+" %");
b=new PNB();

System.out.println("Rate of Interest is: "+b.getRateOfInterest()

+" %");
} }
Output : Rate of Interest is : 7%
 Interface
Interface is just like a class, which contains only abstract methods. To achieve an interface java provides a keyword called
implements.

1) Interface methods are by default public and abstract

2) Interface variables are by default public+static+final
3) Interface method must be overridden inside the implementing classes
4) Interface is nothing but deals between client and developer.

Ex: import java.util.Scanner;

interface Client
{
void input(); // by default public + abstract
void output(); // by default public + abstract
}
Class Raju implements Client
{
String name;
double sal;
public void input()
{
Scanner r = new Scanner(System.in);
System.out.println(“Enter UserName: “);
name=r.nextline();
System.out.println(“Enter Salary: “);
Sal=r.nextDouble();
}
public void output()
{
System.out.println(name+” “ +sal);
}
public static void main(String args[])
{
Client c = new Raju();
c.input();
c.output();
 Packages

• Package in Java is a mechanism to encapsulate a group of classes, sub packages and

interfaces.
• Preventing naming conflicts. For example there can be two classes with name Employee
in two packages, college.staff.cse.Employee and college.staff.ee.Employee
• Making searching/locating and usage of classes, interfaces, enumerations and annotations
easier
• Providing controlled access: protected and default have package level access control. A
protected member is accessible by classes in the same package and its subclasses. A
default member (without any access specifier) is accessible by classes in the same
package only.
• Packages can be considered as data encapsulation (or data-hiding).
 Unit-III: Exception,Multithreading and Input/output

• Exception : Introduction, Types of Exception, Handling Techniques.

• Multithreading : Introduction, Main Thread and creation of New Threads –

By Inheriting the Thread class or Implementing the Runnable Interface,
Thread Lifecycle, Thread Priority and Synchronization.

• Input/Output : Introduction,java.io package, File Streams,FileInputStreams

Class,FileOutputStream Class,Scanner Class,BufferedInputStream Class,
BufferedOutputStream Class,RandomAccessFile Class
Objectives :
 This unit gives the idea of Exception and its Types and How to
handle Exceptions.

 Be able to understand Multithreading, creation of New Threads

 Be able to understand Input/Output , File Streams,

FileInputStream Class, FileOutputStream Class, Scanner Class,
BufferedInputStream Class, BufferedOutputStream Class,
RandomAccessFile Class.
 Exception: Exception is an abnormal condition.

• In Java, an exception is an event that disrupts the normal

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

• What is Exception Handling?

Exception Handling is a mechanism to handle runtime
errors such as ClassNotFoundException, IOException,
SQLException, RemoteException, etc.
 Advantage of Exception Handling
• The core advantage of exception handling is to maintain the normal flow of the
application. An exception normally disrupts the normal flow of the application; that is why
we need to handle exceptions. Let's consider a scenario:

1. statement 1;
2. statement 2;
3. statement 3;
4. statement 4;
5. statement 5;//exception occurs
6. statement 6;
7. statement 7;
8. statement 8;
9. statement 9;
10. statement 10;

• Suppose there are 10 statements in a Java program and an exception occurs at statement
5; the rest of the code will not be executed, i.e., statements 6 to 10 will not be executed.
However, when we perform exception handling, the rest of the statements will be
executed. That is why we use exception handling in Java.
 Types of Java Exceptions

• There are mainly two types of exceptions: checked and unchecked. An error is
considered as the unchecked exception. However, according to Oracle, there are
three types of exceptions namely:

1. Checked Exception
2. Unchecked Exception
3. Error

1) Checked Exception
The classes that directly inherit the Throwable class except RuntimeException and
Error are known as checked exceptions. For example, IOException, SQLException, etc.
Checked exceptions are checked at compile-time.

2) Unchecked Exception
The classes that inherit the RuntimeException are known as unchecked exceptions. For
example, ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException,
etc. Unchecked exceptions are not checked at compile-time, but they are checked at
runtime.

3) Error
Error is irrecoverable. Some example of errors are OutOfMemoryError,
VirtualMachineError,
AssertionError etc.
 Exception Handling Techniques

List of different approaches to handle exceptions in Java.

• try...catch block
• finally block
• throw and throws keyword
1) try…. Catch block : The try-catch block is used to handle exceptions in java
try{
// code
}
catch(Exception e) {
// code

}
Here, we have placed the code that might generate an exception
inside the try block. Every try block is followed by a catch block.
When an exception occurs, it is caught by the catch block.
The catch block cannot be used without the try block.
2. Java finally block

In Java, the finally block is always executed no matter whether there is an exception or
not.
The finally block is optional. And, for each try block, there can be only one finally block.

Syntax :
try
{
//code
}
catch(ExceptionType1 e1)
{
//catch block
}
finally {
// finally block always executes
}
If an exception occurs, the finally block is executed after the try… catch block .
Otherwise, it is executed after the try block. For each try block, there can be
Only one finally block.
3.3. The
Javajava Throw
throw keyword
keyword
The Java throw keyword is used to explicitly throw a single exception.
When we throw an exception, the flow of the program moves from the try block to
the catch block.

Example: Exception handling using Java throw

class Main {
public static void divideByZero()
{
// throw an exception
throw new ArithmeticException(“Trying to divide by 0”);
}
public static void main(String[] args) {
divideByZero();
}
}
In the above example, we are explicitly throwing the ArithmeticException
using the throw keyword.
4.The throws keyword is used to declare the type of exceptions that
Throws keyword
might occur within
the method. It is used in the method declaration.
Example :
class Main {
//declaring the type of exception
public static void findFile() throws IOException {
// code that may generate IOException
File newFile = new File(“test.txt”);
FileInputStream stream = new FileInputStream(newFile);
}
public static void main(String[] args) {
try {
findFile();
}
catch(IOException e) {
System.out.println(e);
}
}
}

Output : java.io.FileNotFoundException : text.txt

(The system cannot find the file specified)
 Multithreading
• Multithreading in java is a process of executing multiple threads
simultaneously.
• A thread is a lightweight sub-process, the smallest unit of processing.
Multiprocessing and multithreading, both are used to achieve multitasking.
• However, we use multithreading than multiprocessing because threads use
a shared memory area. They don't allocate separate memory area so saves
memory, and context-switching between the threads takes less time than
process.
• Java Multithreading is mostly used in games, animation, etc.
• Advantages of Java Multithreading
• 1) It doesn't block the user because threads are independent and you can
perform multiple operations at the same time.
• 2) You can perform many operations together, so it saves time.
• 3) Threads are independent, so it doesn't affect other threads if an
exception occurs in a single thread.
 Thread
• A thread is a lightweight subprocess, the smallest unit of processing. It is a
separate path of execution.
• Threads are independent. If there occurs exception in one thread, it doesn't
affect other threads. It uses a shared memory area.

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

There is context-switching between the threads. There can be multiple
processes inside the OS, and one process can have multiple threads.
• Note: At a time one thread is executed only.
 Life cycle of a Thread (Thread States)

• In Java, a thread always exists in any one of the following states. These states are:
• New
• Active
• Blocked / Waiting
• Timed Waiting
• Terminated

• New: Whenever a new thread is created, it is always in the new state.

• Active: When a thread invokes the start() method, it moves from the new state to the
active state.

i) Runnable: A thread, that is ready to run is then moved to the runnable state.
Ii) Running: When the thread gets the CPU, it moves from the runnable to the
running state.
• Blocked/Waiting: Blocked or Waiting: Whenever a thread is inactive for a span of
time (not permanently) then, either the thread is in the blocked state or is in the
waiting state.

• Timed Waiting: Sometimes, waiting for leads to starvation. For example, a thread (its
name is A) has entered the critical section of a code and is not willing to leave that
critical section. In such a scenario, another thread (its name is B) has to wait forever,
which leads to starvation. To avoid such scenario, a timed waiting state is given to
thread B. Thus, thread lies in the waiting state for a specific span of time, and not
forever. A real example of timed waiting is when we invoke the sleep() method
on specific thread.

• Terminated: A thread reaches the termination state because of the following reasons:
i) When a thread has finished its job, then it exits or terminates normally.
ii) Abnormal termination: It occurs when some unusual events such as an
unhandled exception or segmentation fault.
 create a thread in Java

• There are two ways to create a thread:

i) By extending Thread class
ii) By implementing Runnable interface.

i) By extending Thread class

• Example :
class Multi extends Thread
{
• public void run(){
• System.out.println("thread is running...");
• }
• public static void main(String args[])
• {
• Multi t1=new Multi();
• t1.start();
• }
• }
ii) By implementing Runnable interface.

Example :
class Multi3 implements Runnable
{
public void run(){
System.out.println("thread is running...");
}

public static void main(String args[])

{
Multi3 m1=new Multi3();
Thread t1 =new Thread(m1); // Using the constructor Thread(Runnable r)
t1.start();
}
}
 Synchronization in Java

• Synchronization in Java is the capability to control the access of multiple threads to

any shared resource.

• Java Synchronization is better option where we want to allow only one thread to
access the shared resource.

• The synchronization is mainly used to

i) To prevent thread interference.
ii) To prevent consistency problem.

Types of Synchronization

There are two types of synchronization

• Process Synchronization
• Thread Synchronization
• Process Synchronization :- The process means a program in execution and runs
independently isolated from other processes. CPU time, memory, etc resources are
allocated by the operating system.

• Thread synchronization:- It refers to the concept where only one thread is executed
at a time while other threads are in the waiting state. This process is called thread
synchronization. It is used because it avoids interference of thread and the problem of
inconsistency. In java, thread synchronization is further divided into two types:

i) Mutual exclusive- it will keep the threads from interfering with each other while
sharing any resources.

ii) Inter-thread communication- It is a mechanism in java in which a thread running

in the critical section is paused and another thread is allowed to enter or lock the
same critical section that is executed.
 Input/Output
Java I/O (Input and Output) is used to process the input and produce the output.

• Java uses the concept of a stream to make I/O operation fast. The java.io package
contains all the classes required for input and output operations.
• We can perform file handling in Java by Java I/O API.

Stream :- A stream is a sequence of data. In Java, a stream is composed of bytes. It's

called a stream because it is like a stream of water that continues to flow .

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

• 1) System.out: standard output stream

• 2) System.in: standard input stream
• 3) System.err: standard error stream

Let's see the code to print output and an error message to the console.
• System.out.println("simple message");
• System.err.println("error message");
 OutputStream and InputStream
• OutputStream
Output streams are used to write the data to various output devices like monitor, file,
network, etc.

• InputStream
Input streams are used to read the data from various input devices like keyboard, file,
network, etc.
 I/O Streams

• Java I/O stream is the flow of data that you can either read from, or you can write to.
It is used to perform read and write operations in file permanently. Java uses streams
to perform these tasks. Java I/O stream is also called File Handling, or File I/O. It is

available in java.io package .

• FileInputStream is meant for reading streams of raw bytes such as image data

•
FileOutputStream is meant for writing streams of raw bytes such as image data .
Java BufferedInputStream Class

• Java BufferedInputStream class is used to read information from stream. It internally

uses buffer mechanism to make the performance fast.

• The important points about BufferedInputStream are:

• When the bytes from the stream are skipped or read, the internal buffer automatically
refilled from the contained input stream, many bytes at a time.
• When a BufferedInputStream is created, an internal buffer array is created
• Java BufferedOutputStream Class

• Java BufferedOutputStream class is used for buffering an output stream. It internally

uses buffer to store data. It adds more efficiency than to write data directly into a
stream. So, it makes the performance fast.

• RandomAccessFile in java is a class that lets the user read and write to a file at the
same time. It extends the Object class and implements DataInput and DataOutput
interfaces. These interfaces facilitate the conversion of primitive type data to a
sequence of bytes and bytes to specified type data. It is used to read and write data
to a file simultaneously. The file acts as a large array of bytes stored in the file
system.

• Methods of this class usually throw EOFException i.e. End of File Exception if the
end of the file is reached before the desired number of bytes are read. It is a type
of IOException.

• IOException is thrown if any error occurs other than EOFException like if the byte
cannot be read or written.
 Unit-IV: Applets, Event Handling AWT and Swings

• Applet : Introduction, Example, Life Cycle, Applet Class,

Common Methods Used in Displaying the Output (Graphics
Class).

• Event Handling: Introduction, Types of Events, Example.

• AWT : Introduction, Components, Containers, Button, Label,

Checkbox, Radio Buttons, Container Class, Layouts.

• Swings : Introduction, Differences between Swing and AWT,

JFrame, JApplet, JPanel, Components in Swings, Layout
Managers, JTable.
.
 Unit -IV: objectives

• This unit gives the idea of Applets, Life Cycle of Applet

• This unit gives the idea of creating Button,

Label, Checkbox, Radio Buttons and Layouts.

• Creating the window-based applications using swings.

 Applets
• Applet is a special type of program that is embedded in the
webpage to generate the dynamic content. It runs inside the
browser and works at client side.

• Advantage of Applet
There are many advantages of applet. They are as follows:

• It works at client side so less response time.

• Secured
• It can be executed by browsers running under many platforms,
including Linux, Windows, Mac Os etc.

• Drawback of Applet
Plugin is required at client browser to execute applet.
 Lifecycle of Java Applet

.
 Lifecycle methods for Applet:
The java.applet.Applet class provides 4 life cycle methods and java.awt.Component
class provides 1 life cycle methods for an applet
a) java.applet.Applet class
• For creating any applet java.applet.Applet class must be inherited. It provides 4 life
cycle methods of applet.

1) public void init(): is used to initialized the Applet. It is invoked only once.
2) public void start(): is invoked after the init() method or browser is maximized. It is
used to start the Applet.
3) public void stop(): is used to stop the Applet. It is invoked when Applet is stop or
browser is minimized.
4) public void destroy(): is used to destroy the Applet. It is invoked only once

b) java.awt.Component class
• The Component class provides 1 life cycle method of applet.
• public void paint(Graphics g): is used to paint the Applet. It provides Graphics class
object that can be used for drawing oval, rectangle, arc etc
Running an Applet
There are two ways to run an applet
• By html file.
• By appletViewer tool (for testing purpose).

• Graphics class is a part of the java. awt package and it provides several methods for
drawing and displaying output on the screen.
 Event Handling

Event : Changing the state of an object is known as an event.

For example, click on button, dragging mouse etc. The java.awt.event package provides
many event classes and Listener interfaces for event handling.

The Java core consists of 12 event types defined in java.awt.events:

• ActionEvent
• AdjustmentEvent
• ComponentEvent
• ContainerEvent
• FocusEvent
• InputEvent
• ItemEvent
• KeyEvent
• MouseEvent
• PaintEvent
• TextEvent
• WindowEvent
 AWT(Abstract Window Toolkit)

• Java AWT (Abstract Window Toolkit) is an API to develop Graphical User Interface
(GUI) or windows-based applications in Java.

• Java AWT components are platform-dependent i.e. components are displayed

according to the view of operating system.

• The java.awt package provides classes for AWT API such as TextField,

Label,TextArea, RadioButton,CheckBox,Choice, List etc .

• Java AWT Containers : Containers are integral part of AWT GUI components. A
container provides a space where a component can be located.

A Container in AWT is a component itself and it adds the capability to add component

to itself.
• Example : Panel, window, Frame
 Swings
• Java Swing is a part of Java Foundation Classes (JFC) that is used to create
window-based applications. It is built on the top of AWT (Abstract Windowing Toolkit)
API and entirely written in java.

• Unlike AWT, Java Swing provides platform-independent and lightweight components.

• The javax.swing package provides classes for java swing API such as JButton,
JTextField, JTextArea, JRadioButton, JCheckbox, JMenu, JColorChooser etc.

• Difference between AWT and Swings

• Java JFrame
• The javax.swing.JFrame class is a type of container which inherits the
java.awt.Frame class. JFrame works like the main window where components like
labels, buttons, textfields are added to create a GUI.
• Unlike Frame, JFrame has the option to hide or close the window with the help of
setDefaultCloseOperation(int) method.

• JApplet class in Applet

• As we prefer Swing to AWT. Now we can use JApplet that can have all the controls of
swing. The JApplet class extends the Applet class.

• Java JPanel
• The JPanel is a simplest container class. It provides space in which an application
can attach any other component. It inherits the JComponents class.
• It doesn't have title bar.

• JPanel class declaration

• Public class JPanel extends JComponent implements Accessible
Thank you