You are on page 1of 166

JAVA BASICS For more tutorials visit www.roshinionline.


Basic Java ± Session Outline
Session 1
Features of Java, What is JVM & JRE, First Java Code, Data Type, Wrapper Class, Variables

Session 2
Variables, Arrays, Operators, Conditional Statements, Constructors, Destructors

Session 3
Inheritance, Super Reference, Packages, Access Modifiers, Overloading & Overriding, Polymorphism in Java

Session 4
Java Streams, Serialization, Abstract Classes, Interfaces, Collections

Session 5
Exceptions, Threads, Synchronized Methods

Session 6
AWT, Introduction to Swing, Event Handling, Listeners, Adapters, Inner classes, Applets

Basic Java ± Session 1

Features of Java What is JVM & JRE First Java Code Data Type Wrapper Class Variables

Why Java?

Need for platform neutral language for Consumer Electronic devices Java and Internet


Simple Object Oriented Robust Multi-threaded Architecture Neutral Interpreted Distributed Dynamic

JVM & JRE make it Cross Platform
Java Source Code

Byte Code


Java Virtual Machine Java Runtime Environment Native OS

JVM ± Java Virtual Machine

Often misunderstood as an interpreter An emulator which emulates the intermediate machine architecture Java application binds to a JVM and JVM binds to a specific platform JVM does not require a chip or silicon based implementation to operate

JRE ± Java Runtime Environment

Java Runtime acts as an Operating System, loading required classes into JVM for execution Interface between JVM and Native OS The support classes required by the Java executables reside in the runtime environment and are fetched by the JVM as needed

Java Runtime Environment Java Support Classes JVM Executables

Native OS


Application ± create stand-alone application that runs on the local machine Applets ± A Java program that runs on the web

Java Object Oriented

Unlike C++, purely Object Oriented Represent real life instances Classes ± template for an object Object ± instance of a class

A Simple Java Program

class HelloWorld { public static void main(String[] args) { System.out.println(³Hello World´); } }

Check out

To compile: javac

To run: java HelloWorld

Hello World Applet

import java.applet.Applet; import java.awt.Graphics; public class HelloWorld extends Applet { public void paint(Graphics g) { g.drawString(³Hello World´,50,25); } }


<HTML> <APPLET CODE=³HelloWorld.class´ WIDTH=150 HEIGHT=25> </APPLET> </HTML>

Check out

To compile: javac

To run: HelloWorld

Data Types

class Employee { int empno; String empname; int empsal; String job; public int getEmpNo() { return empno; } public void setEmpNo(int eno) { empno=eno; } « };

Attributes Or Object State

Methods Or Object Behavior

Primitive Data Types
byte short int long float double char boolean


Floating point

Signed, Positive and Negative values Java does not support unsigned, positive only integers
Type byte short int long Width 8 bits 16 bits 32 bits 64 bits Range -128 to 127 -32,768 to 32,767 -2,147,483,648 to 2,147,483,647 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Floating Point Types
Real numbers, used when evaluating expression that require a fractional precision

Type float double

Width 32 bits 64 bits

Range -3.4e-38 to 3.4e38 -1.7e-308 to 1.7e308


Uses 16 bit Unicode to represent characters Unicode defines a character set that can represent all characters found in all human languages Range is 0 to 65,536 There are no negative characters ASCII is a subset of Unicode character set ASCII ranges from 0 to 127


A simple type for logical values Only 2 possible values ± true or false Provides a 1 bit storage for representing true or false values


Strings are implemented as array of characters Strings are object types All String assignment and manipulation facilities are provided by means of the String class Everything from character level manipulation to pattern searching methods is encapsulated in String class

Wrapper classes

Encapsulates or wraps simple types like int and char Simple types are not part of object hierarchy Enumeration classes store only objects in them ± so have to wrap the simple types


Basic unit of storage Declaration type identifier[=value][,identifier[=value],«]; e.g. int x=10, y=25;

Basic Java ± Session 2

Variables Arrays Operators Conditional Statements Constructors Destructors

Scope of Variables

Class scope Methods scope Scopes can be nested When outer scope encloses an inner scope, objects declared in outer scope is accessible to inner scope, but reverse is not true

class scope { public static void main(String[] args) { int x; //known to all code within main x=10; if(x==10) { // starts a new scope int y=20; // known only to this block // x and y are both known here System.out.println(³x and y :´ + x + ³ ´ + y); x=y*2; } // end of if y=100; //error: y is not known here // x is still known here System.out.println(³x is :´ + x); } };

Java Arrays

Arrays are also objects, with a fixed length Arrays of primitive data types are different from arrays of references Size of the array is mentioned only when the array is created Array indexes run from 0 to the length of the array minus 1 (n-1) Accessing beyond the end of the array results in a runtime error

Integer array int marks[]=new int[2]; marks[0]=75; String array String[] names=new String[2]; names[0]=³Changepond´; Array of references Student[] students=new Student[2]; students[0]=new Student(³Mathew´);

Array initialization

int[] intArray1={1,2,3}; int[] intArray2=new int[]{1,2,3}; Student[] studArray=new Students[] {new Student(³Mickey´),new Student(³Donald´)}; String[] months={³January´,³February´,³March´«); char string=³Java´; //error

Multi-dimensional Arrays

Array of Arrays int twoD=new int[2][3]; int twoD=new int[3][]; int twoD[0]=new int[4]; int twoD[1]=new int[4]; int twoD[2]=new int[4];

Multi-dimensional Arrays













Given: int twoD[][]=new int[3][4];

Arithmetic Relational Logical Bit Manipulation Assignment Increment, Decrement Compound Assignment Miscellaneous +, -, *, /, % >, <, >=, <=, !=, == !, &&, || ~, &, |, ^, <<, >>, >>> = ++, -+=, *=, etc. (type), instanceof, new, ?:

if« else«
if (boolean expression) { statement1 statement2 « } else { statement3 statement4 }

switch (integer expression) { case value1: statement1; statement2; « break; case value2: statement3; statement4; « break; default: default statement; }


do { statement1; statement2; « } while (boolean expression); The do-while look executes at least once


while (boolean expression) { statement1; statement2; « }

for loop

for (initialization; condition; increment or decrement) { statement1; statement2; « }


Used to exit a block, usually based on a condition Used to break out of innermost loop for (int i=0; i<10; i++) { if(i==5) break; }

Labelled break

nestedloop: for (int i=0; i<10; i++) { for (int j=0; j<10; j++) { if(j==5) break nestedloop; } }


Skips to the end of the loop¶s body Evaluates the boolean expression that controls the loop int x=0; while (x<10) { ++x; if(x==5) continue; system.out.println(³x is : ³ + x); }


Used to terminate the execution of a method If a method has a return type, then return must include an expression that could be assigned to the return type


Initializes the state of an object as soon as it is created Has the same name as the class Has no return type

Default Constructor

Class Student { int id; String name; Student() {} }

Parameterized constructors

Class Student { int id; String name; Student(int id, String name) {;; } }

Garbage Collection

Automatic deallocation of memory No explicit need to destroy objects as in C++ when no references to objects exists, it is assumed that it is no longer needed, memory occupied is deallocated It occurs periodically during execution of the program

Object Destruction

finalize() defines actions that will occur when an object is about to be reclaimed by a garbage collector used to free the non-java resources that an object holds. Eg: file handle The Java Runtime calls this method whenever it is about to recycle an object of this class

Basic Java ± Session 3

Inheritance Super Reference Packages Access Modifiers Overloading & Overriding Polymorphism in Java

Java Inheritance

Single inheritance v/s multiple inheritance Subclasses inherit all the fields and methods in the super-class extending classes Overriding methods

Class Hardworking Student extends Student { public void refreshPortions() { //added behavior System.out.println(this + ´refreshed the portions´); } public void prepareForTests() { //overridden method refreshPortions(); } }

The super reference

Subclasses normally augment the behavior of the super-class An overriden method in a subclass invokes the super class method, then adds behavior specific to itself The super reference super constructors

// class HardworkingStudent extends Student { HardworkingStudent(String name){ super(name); } public void refreshPortions(){//added behavior System.out.println(this+ ³:refreshed the portions´); } public void prepareForTests() { //Overridden method super.prepareForTests(); refreshPortions(); } public static void main(String args[]) { HardworkingStudent s=new HardworkingStudent(³vinod´); s.prepareForTests(); } }

Object and Class classes
All classes are directly or indirectly derived from the class java.lang.Object Any reference can be converted to a Object reference (arrays too) Object class - getClass, equals(Object o), toString() Class class - encapsulates the run time state of an object or interface.

Object and Class classes

Objects of type Class are created automatically, when classes are loaded you cannot explicitly declare a Class Object getName(), getInterfaces(), getSuperClass(), toString()

Java Packages

Related classes can be put in a package Used to separate unrelated classes from each other Used to hide implementation specific classes from classes in other packages(eg:java.util.Vector) Prevent name space pollution(amity.student, java.lang, java.util,, java.awt, java.applet

Package level access

Default access in java is package level access Public classes Classes that are not public cannot be accessed from other packages Public classes have to be put in a java source file with the same name The package statement

package another; class PackageDemo { public static void main(String args[]) { Trainer t=new Trainer(³ajai´); t.teach(); } }

Importing classes from packages

Qualified name of String is java.lang.String How are we able to refer to it as String? The import statement No runtime overhead associated with import Classes in java.lang are automatically imported to the default unnamed package

import ccjiTeacher; //all classes in a package can be imported using import package.*; class PackageDemo { public static void main(String args[]) { Teacher t=new Teacher(³ajai´); t.teach(); } }

The Classpath variable

Java runtime searches for referenced classes in directories specified in CLASSPATH Package names & class file directory organization Java source file organization

Access Modifiers
Who has access to use the class? Who has access to inherit the class¶s properties? Modifier Visibility public unrestricted protected Accessible only from within the package, but extensible anywhere default Accessible and extensible only from within the package private Accessible only from within declared class file

class AccessDemo {
public static void main(String args[]) {
Student s1=new Student(1,´ajai´); Student s2=new Student(2,´vijai´);

} }

Method overriding rules

Overridden methods in subclasses should have atleast the same access as declared in the superclass - public in super class should be public in subclass too - protected in super class, protected or public in subclass - package level should not be declared private

final - Keyword

Can be used as declaration modifier for either class, methods or variables Any class declared as final may not be subclassed Methods declared as final may not be overridden Variables declared as final are similar to const in C/C++ final variables must be initialized when declared

static - Keyword

Used as field and method modifier to specify a permanent nature If the field is declared as static, all instances of the class share the same variable memory storage region instance independent - hence called as Class variable and Class method static variables and methods can be accessed without creating an instance of the class

static - Keyword

They can only call other static methods They must only access static data They cannot refer to µthis¶ or µsuper¶

class Student { private int id; private String name; private static int nextID=0; Student(String studName)

id=++nextID; name=studName;

public String toString() { return ³[³ + name + ´,´ + id + ³]´; public static void main(String args[]) {
Student s1= new Student(³ajai´); Student s2= new Student(³vijai´); System.out.println(³s1 is:´ +s1); System.out.println(³s2 is:´ +s2);



class StaticMethodDemo {
public static void main(String[]args) { Student s1=new Student(³ajai´); Student s2=new Student(³vijai´); Student.printNextID(); } }

Method overloading

It is possible to define two or more methods within the same class that share the same name if the parameters are different Java uses type and /or number of arguments to determine which method to call overloaded methods may have different return types, but return type alone is insufficient to distinguish the different versions overloaded constructors

Method overloading

class OverloadDemo { private int data; OverloadDemo() { System.out.println(³Default constructor´); } //overloaded constructor OverloadDemo(int id) { data=id; System.out.println(³overloaded constructor´); }

Method overloading
void test() { System.out.println(³No parameters´); } // overloaded method void test(int a, int b) { System.out.println(³a and b: ³ +a,b); } double test(double a) { System.out.println(³double a: ³+a); return a*a; } }

Parameter passing in Java

Pass by value and pass by reference Java supports only pass by value Java reference has to be explicitly set to refer an object of that class or its subclasses, if it has no reference by default it is null. Unlike Java, C++ references by default implicitly creates an instance of the class eg: String s; Can be thought of as safe pointers

Polymorphism in Java

All super class methods that are accessible to subclass exhibit polymorphic behavior if overridden Polymorphism should never be confused with method overloading Enables overridden methods to be invoked using super class references Dynamic binding/ method dispatch

Polymorphism - Details

A super class reference can refer to subclass object(widening reference conversion) If the reference indeed refers to an object of the subclass, then invoking an overridden method results in the subclass method to be invoked Understanding polymorphism is the key to understanding object oriented design concepts

Class Student {
int id; String name; void printNextID() { System.out.println(³Student.printNextID()´); } }

Class HardworkingStudent extends Student { String name; int id; void printNextID() { System.out.println(³HardworkingStudent.printNextID()´); } }

Class HardworkingStudent extends Student { public static void main(String args[]) { Student s=new HardworkingStudent(³vinod´,12); s.prepareForTests(); s.printNextID(); } }

Basic Java ± Session 4

Java Streams Serialization Abstract Classes Interfaces

Java Streams and Object Serialization

Object serialization is used to make Java objects persistent JDK 1.1 provides native support for object serialization Its major use is to transmit objects across the network, the so-called passing objects by value The Java RMI does this in a automatic transparent way

Java Streams

A network connection, memory buffer, or disk file can be manipulated by the Java IO classes ± handled by the abstraction Stream Stream is a logical entity that either produces or consumes information A Stream is linked to a physical device by the Java IO system

Java Streams
A stream reads


A stream




Java Streams

Character Streams - Reader and Writer are the abstract super classes for character streams - Reads and writes characters - eg: FileReader, FileWriter, BufferedReader, BufferedWriter Byte Streams - InputStream and OutputStream are abstract super classes for byte streams - Reads and Writes bytes

Java Streams
IO Streams - Input Streams allow to read data from a source, Output streams allow to write data to a destination - InputStream and OutputStream are abstract classes that define the fundamental ways to read and write stream of bytes Data Streams - read and write primitive data types - DataInputStream and DataOutputStream classes provide methods for reading and writing primitive data types

Java Streams
File Streams - used to read from and write to a file - FileInputStream and FileOutputStream - FileReader and FileWriter Filter Streams - Allows you to do some additional processing when reading and writing data - Used to implement complex streams with added functionality - Base class is FilterStream, BufferInputStream is derived from FilterInputStream


import*; class ReadData { public static void main(String[]args) throws IOException { DataInputStream din = new DataInputStream(System in); String name = din.readLine(); } }

import*; public class CopyFiles { public static void main(String[]args) throws IOException { FileReader in = new FileReader (³Customer.txt´); FileWriter out = new FileWriter(³CustomerData.txt´); int c; while((c = != -1) out.write(c); in.close(); out.close(); } }

import*; public class CopyFiles { public static void main(String[]args) throws IOException { BufferedInputStream in = new BufferedInputStream(new FileInputStream(³Customer.txt´)); int c; while((c = != -1) System.out.print((char)c); in.close(); out.close(); } }

Object Serialization

Object serialization extends the core Java streams classes with support for objects Object serialization involves saving the state of objects in a serialized form into a stream sufficient to reconstruct the objects Objects to be saved may support either Serializable or Externalizable For Serializable objects, the serialized form automatically includes sufficient information to restore the objects state For Externalizable objects, the class is solely responsible for the content of the serialized form

Code Sample
//just mark the objects to be saved as implements Serializable //saving the object¶s state to a file FileOutputStream fos = new FileOutputStream(³tmp´); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(obj); //restoring the object¶s state from the file FileInputStream fis = new FileInputStream(³tmp´); ObjectIntputStream ois= new ObjectIntputStream (fis) ; Object obj =ois.readObject();

Abstract classes

Implementation of certain methods are left to subclasses Design of frameworks, where general algorithm is known (eg : InputStream) Abstract methods do not have an implementation

Abstract classes

Classes having abstract methods has to be declared abstract Abstract classes cannot be instantiated Subclasses that do not implement all the abstract methods have also to be declared abstract

abstract class Stat // { protected int numbers[]; Stat(int numbers[]) { this.numbers = numbers; } protected abstract void sort(); public int median() { int median; sort(); //Call abstract method, implemented by subclasses int middle = numbers.length / 2; if(numbers.length % 2) median = numbers[middle]; else median =(numbers[middle] + numbers[middle+1] )/ 2; return median; } }

// Class BblStat extends Stat { BblStat(int numbers[]) { super(numbers); } public void sort() { System.out.println(³Sorted the numbers using the Bubble Sort method´); } }

// Class QckStat extends Stat { QckStat(int numbers[]) { super(numbers); } public void sort() { System.out.println(³Sorted the numbers using the Quick Sort method´); } }

// Class AbstractDemo { static void doIt(Stat s) { int median = s.median(); System.out.println(³median is´ + median); } public static void main(String args[]) { Stat s = new QckStat(); doIt(s); } }


Protocol of behavior, which must be adhered by the class implementing it Pure design concept, no associated implementation Component technologies(COM, COBRA) Programming to an interface

Java Interfaces

Set of public abstract methods(and static final attributes) expression of pure design, can never carry implementation details, hence per object fields can never be a part of an interface Multiple interface inheritance Classes implement interfaces

// Interface StudEnumeration { boolean hasMoreStudents(); Student nextStudent(); }

Class BatchStudEnumerator implements StudEnumeration { private Student[] students; private int nStudents; private int currentIndex; BatchStudEnumerator(Batch b) { students = b.students; nStudents = b.nStudents; currentIndex = 0; } public boolean hasMoreStudents() { if(currentIndex == nStudents) return false; else return true; }

// public Student nextStudent() { return students[currentIndex++]; } }

Class Batch { String courseName; Student[] students; int nStudents; public Batch(String cName, int maxStudents) { courseName = cName; students=new Student[maxStudents]; nStudents=0; } public void addStudent(Student newStudent) { students[nStudents++] =newStudent; } StudEnumeration getStudents() { return new BatchStudEnumerator(this); } } //a reference to an interface can be substituted for a reference to an object // implementing the interface

// Class EnumerationTest { public static void main(String args[]) { Batch b= new Batch(³J1´,2); b.addStudent(new Student(³murali´)); b.addStudent(new Student(³ajai´)); StudEnumeration e = b.getStudents(); while(e.has MoreStudents()) { Student s=e.nextStudent(); System.out.println(³I got: ³+ s); } } }

The Collections Framework

An Introduction

A collection is a structured group of objects
± An array is a kind of collection ± A Vector is a kind of collection ± A linked list is a kind of collection

‡ Java 1.2 introduced the Collections Framework and provided many great implementations
± Vectors have been redefined to implement Collection ± Trees, linked lists, stacks, hash tables, and other classes are implementations of Collection ± Arrays do not implement the Collection interfaces

Types Of Collection
Java supplies several types of Collection:
Set: cannot contain duplicate elements, order is not important SortedSet: like a Set, but order is important List: may contain duplicate elements, order is important

Java also supplies some ³collection-like´ things:
Map: a ³dictionary´ that associates keys with values, order is not important SortedMap: like a Map, but order is important






There are two groups: Collections of single elements, and Maps containing key/value pairs These are all interfaces, but there are classes implementing each interface

Collection Set HashSet SortedSet TreeSet ArrayList List Hashtable LinkedList

Map HashMap

SortedMap TreeMap

Vector Stack

Each class (in green) implements one or more interfaces (in Black), hence implements all the methods declared in those interfaces We will look at the interface methods

The Collection interface
Some simple Collection methods:
int size( ) boolean isEmpty( ) boolean contains(Object e) boolean add(Object e)* boolean remove(Object e)* Iterator iterator( )

Some ³bulk´ Collection methods:
boolean containsAll(Collection c) boolean addAll(Collection c)* boolean removeAll(Collection c)* boolean retainAll(Collection c)* void clear( )

* Returns true if the Collection was changed, false otherwise

A simple map: Hashtable
To create a Hashtable, use:
import java.util.*; Hashtable table = new Hashtable();

To put things into a Hashtable, use: table.put(key, value); To retrieve a value from a Hashtable, use: value = (type)table.get(key);

The class Vector has been retrofitted to implement the Collection interface Vector supplies add(Object) and iterator() methods (among others) Let¶s look at creating a Vector and iterating through the elements

The Iterator interface
interface iterator { // java.lang.util boolean hasNext(); // Returns true if the iteration has more // elements. Object next(); // Returns the next element in the // interation. void remove(); // Removes from the underlying collection // the last element returned by the // iterator (optional operation).

Using a Vector
Collection numerals = new Vector(); numerals .add("one"); numerals .add("two"); numerals .add("three"); Iterator iter = numerals.iterator(); while (iter.hasNext()) { System.out.println(; } Results: one two three

Basic Java ± Session 5

Exceptions Threads Synchronized Methods


Signify abnormal conditions during the execution of the program Separates program logic from error handling logic Errors: Checked & Unchecked Exceptions Unchecked exceptions are derived from a subclass of Throwable called RuntimeException


Runtime exceptions denote a class of exceptions that is not specific to a method, can occur when evaluating any java code Checked exceptions are more specific to a method ± the method throws an instance of the checked exception on abnormal conditions Methods must not be vague about the exceptions that they throw


Complier checks - whether the method is throwing an exception that it not declared in the throws clause whether appropriate handlers are setup to catch the exceptions

// class NoCatch { public static void main(String[] args) { Batch b = new Batch(³J1´, 2); b.addStudent(new Student(³ajai´)); System.out.println(³Added ajai to the batch´); b.addStudent(new Student(³vijai´)); System.out.println(³Added vijai to the batch´); b.addStudent(new Student(³vinod´)); System.out.println(³Added vinod to the batch´); } }

class ItsCatching { public static void main(String[] args) { Batch b = new Batch(³J1´, 2); try { b.addStudent(new Student(³ajai´)); System.out.println(³Added ajai to the batch´); b.addStudent(new Student(³vijai´)); System.out.println(³Added vijai to the batch´); b.addStudent(new Student(³vinod´)); System.out.println(³Added vinod to the batch´); }catch(ArrayIndexOutOfBounceException e) { System.out.println(³Caught an exception: ³ +e); } } }

More on Exceptions

Declaring a new exception type The finally block - is entered whether exception is thrown or not - used for necessary clean up before returning from a method eg: open file stream is closed in a finally block

class CourseFilledException extends Exception { CourseFilledException() { super(); } CourseFilledException(String s) { super(); } } //class Batch void addStudent(Student newStudent)throws CourseFilledException { if(nStudents == students.length) throw new CourseFilledException(³Max Students:´ + students.length); Students[nStudents++] = newStudent; }

class FinallyDemo { public static void main(String[]args) { Batch b =new Batch(³P1´,3); try { b.addStudent(new Student(³ajai´)); System.out.println(³Added ajai to the batch´); b.addStudent(new Student(³vijai´)); System.out.println(³Added vijai to the batch´); b.addStudent(new Student(³vinod´)); System.out.println(³Added vinod to the batch´); }catch(CourseFilledException e) { System.out.println(³Caught and exception: ³+ e); } finally{ System.out.println(³Reached Finally Block´); } } }

When to use Exceptions

Do not use exceptions to report simple errors which can be checked by return value from a method use it to provide more information than simple return values eg: it would be a serious error to add a student to a batch, who already has been added

Java Threads

Threads are merely separate execution paths sharing memory address space increase application performance by optimizing the machine resources Single Threading v/s Multithreading support for multithreading and synchronization is built into the language - java.lang.Thread

Creating Threads

Extending the Thread class - Implementing Runnable -

class OfflineEnroller extends Thread { private Batch batch; OfflineEnroller(Batch b) { batch = b; } public void run() { int name = 0; try{ while(true) { ++name; Student s=new Student(³OffLineStudent(³+name+´)´); if(batch.addStudent(s)==false) break; System.out.println(³added: ³+s); } }catch(StudentExistsException e){ System.out.println(³Caught: ³+e); }

public static void main(String args[]) { Batch b=new Batch(³J1´, 15); Thread t=new OfflineEnroller(b); t.start(); } }

class OnlineEnroller implements Runnable { private Batch batch; OnlineEnroller(Batch b) { batch = b; } public void run() { int name = 0; try{ while(true) { ++name; Student s=new Student(³OnLineStudent(³+name+´)´); if(batch.addStudent(s)==false) break; System.out.println(³added: ³+s); } }catch(StudentExistsException e){ System.out.println(³Caught: ³+e); } }

public static void main(String args[]) { Batch b=new Batch(³J1´, 15); Thread t=new Thread(new OnlineEnroller(b)); t.start(); } }

synchronized methods

Thread that is currently executing a synchronized method in an object owns the object monitor other threads are prevented from invoking a synchronized method on this object till the monitor becomes free(ie. These threads are blocked) other threads can invoke non-synchronized methods on this object other threads can be executing the same or other synchronized method of another object

synchronized statements

Locks an object, without executing a synchronized method of that object public static void abs(int[] array) { synchronized(array)}

Basic Java ± Session 6

AWT Introduction to Swing Event Handling Listeners Adapters Inner classes Applets


AWT features include a rich set of user interface components a robust event-handling model graphics and imaging tools, including shape, color, and font classes layout managers, for flexible window layouts that don¶t depend on a particular window size or screen resolution

Java.lang.Object CheckboxGroup Component FlowLayout BorderLayout GridLayout TextComponent Button Label Checkbox List Choice Container TextField

Window Frame


A component is an object having a graphical representation that can be displayed on the screen and that can interact with the user Examples of components are buttons, checkboxes , and scrollbars of a typical graphical user interface Some methods of Component: setVisible(boolean) isEnabled() setBackground(Color)


A generic container object is a component that can contain other AWT components Use the add(component) method to add a component to a container getComponents() would return all the components in a container


Window class creates the top level window Sits directly on the desktop, cannot be contained in any other object Generally, you won¶t create a Window object directly, instead a subclass of Window called Frame Creation of a window requires associating it with an owner(Frame or Window)

Labels and Buttons

Labels : Simplest of AWT components Display only; hence do not generate an action event Label nameLb1= new Label(³Name´); nameLb1.setForeground(; Buttons : Most useful components Generate action events Button submitButton=new Button(³submit´);


Similar to buttons, but used as on/off switches Contains two parts - a label(text displayed on the checkbox) - a state(state of the checkbox - false/true) CheckBox chBox1=new CheckBox(³Yes/No´); Use checkBox.getState() method to find out if a checkBox is selected or not


A special case of CheckBox; a set of CheckBoxes put together in a group so that only one could be selected at a point of time CheckBoxGroup group1=new CheckBoxGroup(); CheckBox chBox1=new CheckBox(³Red/Blue´,group1,false); CheckBox chBox2=new CheckBox(³Yellow/Green´,group1,true); To obtain user selection Use getState() on each checkBox or Use getSelectedCheckBox() on the CheckBoxGroup

Layout Manager

Interface that know how to layout components BorderLayout, CardLayout , FlowLayout, GridLayout, GridBagLayout implement the LayoutManager interface Default layout manager for all cantainers is FlowLayout - just aligns the components from left to right


BorderLayout - has 4 narrow fixed - width components at the edges and one large area in the center, represented by ³North´, ³South´, ³East´, ³West´, and ³Center´ GridLayout - lays out components in a 2 dimensional grid CardLayout - helps in having hidden layouts, activating them when needed



GridBagLayout places components in a grid of rows and columns, allowing specified components to span multiple rows or columns. Not all rows necessarily have the same height. Similarly, not all columns necessarily have the same width

Note: Now , Go to Sample Code


Label Button TextField TextArea Choice List MenuBar, Menu, MenuItem

Swing - AWT
Swing components are implemented with absolutely no native code You can specify which look and feel your program¶s GUI uses. By contrast, AWT components always have the look and feel of the native platform Swing components with state use models to keep the state You don¶t add components directly to a top-level container such as a JFrame. Instead, you add components to a container(called the content pane) that is itself contained by the JFrame - getContentPane().add(component);

How to set the Look and Feel

When a program does not its look and feel, the Swing UI manager must figure out which look and feel to use To programmatically specify a look and feel, use the UIManager.setLookAndFeel(«) method UIManager.setLookAndFeel( ³´);

How to change the Look and Feel

To make existing components reflect the new look and feel, invoke the SwingUtilities updateComponentTreeUI method once per toplevel container For example UIManager.setLookAndFeel(lnfname); SwingUtilities.updateComponentTreeUI(frame); frame.pack();


Integrated Development Environments minimize the time needed to create Java applications/applets/beans/servlets GUIs drastically All IDEs do not guarantee 100% pure Java code. Some popular IDEs - Visual Age For Java2.x,IBM - JBuilder2,Inprise - Visual J++, Microsoft - Symantee Café, Symantee Corporation

Event Handling

AWT provides a set of listener interfaces that event handlers have to implement AWT components notify the occurrence of events by generating event objects that should be handled by a event listener Events could be clicking on a button, using the mouse on a components, selecting items from a list, etc.

Handles Button events in the actionPerformed(ActionEvent ev) method Creates an ActionEvent object and submits to the handler aButton.addActionListener(new ActionListener) { public void actionPerformed(ActionEvent ev) { System.out.println(³hello world´); } }

Handles Item(List, ComboBox) events in the itemStateChanged(ItemEvent ev)method Creates an ItemEvent object and submits to the handler aCombo.addItemListener(new ItemListener) { public void itemStateChanged(ItemEvent ev) { System.out.println(³hello world´); } }


MouseListener, WindowListener comes bundled with more than one method Classes using such listeners need to implement all the methods, or atleast provide stubs Adapter classes provide stubs for all the methods in such Listener interfaces Extend from Adapter classes and override the methods instead of implementing interfaces


Sample code addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent ev) { System.exit(0); } }); An anonymous WindowAdapter class is used here


Sample code addMouseListener(new MouseAdapter() { public void mouseClicked(WindowEvent ev) { if(ev.isPopupTrigger()) System.out.println(³Right mouse click´); } }); An anonymous MouseAdapter class is used here

Inner classes

Classes enclosed within a class Scope always remains along with the enclosing class Static inner class is a nested class Created when u need to write classes with little functionality needed for use only in the scope of a main class Inner class created by EnclosingClass InnerClass();

Inner classes ± Sample Code
public class MainClass extends Frame{ « addWindowListener(new InnerClass()); public class InnerClass extends WindowAdapter { public void windowClosing(WindowEvent ev) { System.exit(0); } } }

Events: How to«

To handle events, use Listeners and Adapters Steps involved: Implement the listener or extend the Adapter Provide implementation for the methods in the interface or override the methods in the Adapter


Applet is a class that is derived from java.applet.Applet Can be embedded in an HTML page and the class file gets downloaded to the client along with the HTML page Milestones during the lifetime of an applet ± init(), stop(), start(), destroy(), paint() showStatus(String text) displays message on the status bar of the applet

Applet ± init()

This is the method which is called by the browser when an instance of applet is created and loaded Initialization of the applet could be done here No argument constructors are allowed

Applet - start() / stop()

start() Called whenever user returns to the page or maximizes the window Usually overridden to resume the suspended threads stop() Called everytime the user leaves the page or the window is iconified Generally overridden to suspend running threads

Applet - destroy() / paint()

destroy() Called by the browser when the applet is about to be unloaded paint() Called when the applet begins execution Called each time the applet¶s output must be redrawn has one parameter of type Graphics ± contains graphics context used whenever output to the applet is required

Applet - update()
Update() fills an applet with the default background color and then calls paint() Override update so that it displays without flashing public void paint(Graphics g){ update(g); } public void update(Graphics g){ Color bg = getBackground(); Color fg = getForeground(); g.setColor(bg); g.fillRect(x,y,w,h); g.setColor(fg); }

Applet parameters

Applet can be passed parameters using <PARAM> tag in HTML file <PARAM NAME = ³printString´ VALUE = ³Hello´> Use the getParameter(paramName) in the applet code to retrieve the value associated String textToBePrinted = getParameter(³printString´);


A link to the browser itself, actually controls the browser environment in which the applet resides - getAppletContext() returns the AppletContext environment To change the displayed web page, use the getAppletContext().showDocument(Url url)method Use codebase and documentbase properties in the html file to let the environment know where to look for classes at runtime

Applet Security

Easily downloadable over the internet, hence needs to be restricted To prevent access to system resources in client machine, browser or applet viewer installs a security manager ± which prevents the applet from - accessing system properties - making network connection to any other host other than the originating host - loading of local libraries

Points to note

When an applet uses java extension classes the browser¶s java environment might/might not support it Java plug-in for Internet Explorer and Netscape Navigator could be used Plug-in has to be identified in the html file Package the files needed by an applet into a jar(Java Archive) and load over the internet Java console could be opened using the plug-in for informative debugging messages