Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
92 views

Basics of Java Presentation

The document outlines 6 sessions on basic Java topics. Session 1 covers features of Java, JVM, JRE, data types, wrapper classes, and variables. Session 2 covers variables, arrays, operators, conditional statements, constructors, and destructors. Session 3 covers inheritance, super reference, packages, access modifiers, overloading, overriding and polymorphism. Session 4 covers streams, serialization, abstract classes, interfaces and collections. Session 5 covers exceptions and threads. Session 6 covers AWT, Swing, event handling and listeners.

Uploaded by

Manjunath HS
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
92 views

Basics of Java Presentation

The document outlines 6 sessions on basic Java topics. Session 1 covers features of Java, JVM, JRE, data types, wrapper classes, and variables. Session 2 covers variables, arrays, operators, conditional statements, constructors, and destructors. Session 3 covers inheritance, super reference, packages, access modifiers, overloading, overriding and polymorphism. Session 4 covers streams, serialization, abstract classes, interfaces and collections. Session 5 covers exceptions and threads. Session 6 covers AWT, Swing, event handling and listeners.

Uploaded by

Manjunath HS
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 165

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
Java

Simple
Object Oriented
Robust
Multi-threaded
Architecture Neutral
Interpreted
Distributed
Dynamic
JVM & JRE make it Cross Platform

Java Source Code X.java

Byte Code X.class

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
Java

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 HelloWorld.java

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);
}
}
Hello.html

<HTML>
<APPLET CODE=HelloWorld.class WIDTH=150 HEIGHT=25>
</APPLET>
</HTML>
Check out

To compile:

javac HelloWorld.java

To run:

HelloWorld
class Employee
{
int empno;
Attributes
String empname;
Data Types Or
int empsal;
String job;
Object State

public int getEmpNo()


{
return empno;
} Methods
public void setEmpNo(int eno) Or
{ Object Behavior
empno=eno;
}

};
Primitive Data Types

byte
short Integers
int
long

float Floating point


double

char
boolean
Integers

Signed, Positive and Negative values


Java does not support unsigned, positive only integers

Type Width Range


byte 8 bits -128 to 127
short 16 bits -32,768 to 32,767
int 32 bits -2,147,483,648 to
2,147,483,647
long 64 bits -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 Width Range


float 32 bits -3.4e-38 to 3.4e38
double 64 bits -1.7e-308 to 1.7e308
Characters

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
Boolean

A simple type for logical values


Only 2 possible values true or false
Provides a 1 bit storage for representing true or false values
String

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
Variables

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
Arrays

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

00 01 02 03

10 11 12 13

20 21 22 23

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


Operators

Arithmetic +, -, *, /, %

Relational >, <, >=, <=, !=, ==

Logical !, &&, ||

Bit Manipulation ~, &, |, ^, <<, >>, >>>

Assignment =

Increment, Decrement ++, --

Compound Assignment +=, *=, etc.

Miscellaneous (type), instanceof, new, ?:


if else

if (boolean expression)
{
statement1
statement2

}
else
{
statement3
statement4
}
switch

switch (integer expression)


{
case value1: statement1;
statement2;

break;
case value2: statement3;
statement4;

break;
default: default statement;
}
dowhile

do
{
statement1;
statement2;

} while (boolean expression);

The do-while look executes at least once


while

while (boolean expression)


{
statement1;
statement2;

}
for loop

for (initialization; condition; increment or decrement)


{
statement1;
statement2;

}
break

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;
}
}
continue

Skips to the end of the loops 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);
}
return

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
Constructors

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)
{
this.id=id;
this.name=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
// SuperDemo.java
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, amity.com.util)
java.lang, java.util, java.net, 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 classs 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
Polymorphism

Class Student
{
int id;
String name;
void printNextID()
{
System.out.println(Student.printNextID());
}
}
Polymorphism
Class HardworkingStudent extends Student
{
String name;
int id;
void printNextID()
{
System.out.println(HardworkingStudent.printNextID());
}
}
Polymorphism
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

reads
A stream
Source Program

A stream

writes dest
Program
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
example

import java.io.*;

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

import java.io.*;

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 = in.read()) != -1)
out.write(c);
in.close();
out.close();
}
}
example

import java.io.*;

public class CopyFiles


{
public static void main(String[]args) throws IOException
{
BufferedInputStream in = new BufferedInputStream(new
FileInputStream(Customer.txt));
int c;
while((c = in.read()) != -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 objects state to a file


FileOutputStream fos = new FileOutputStream(tmp);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(obj);

//restoring the objects 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 //AbstractDemo.java
{ 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;
}
}
//AbstractDemo.java
Class BblStat extends Stat
{
BblStat(int numbers[])
{
super(numbers);
}
public void sort()
{
System.out.println(Sorted the numbers using the Bubble Sort method);
}
}
//AbstractDemo.java
Class QckStat extends Stat
{
QckStat(int numbers[])
{
super(numbers);
}
public void sort()
{
System.out.println(Sorted the numbers using the Quick Sort method);
}
}
//AbstractDemo.java
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);
}
}
Interfaces

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
// InterfaceDemo.java
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;
}
// InterfaceDemo.java
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
//InterfaceDemo.java
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
COLLECTIONS
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
Collection Map

Set List SortedMap

SortedSet

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 Map

Set List Hashtable HashMap

HashSet SortedSet ArrayList LinkedList SortedMap

Vector
TreeSet TreeMap
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);
Vectors

The class Vector has been retrofitted to implement the


Collection interface

Vector supplies add(Object) and iterator() methods (among


others)

Lets 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(iter.next());
}

Results:
one
two
three
Basic Java Session 5

Exceptions
Threads
Synchronized Methods
Exceptions

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
Exceptions

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
Exceptions

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
// NoCatch.java
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


- offlineEnroller.java
Implementing Runnable
- onlineEnroller.java
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

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 dont depend on a
particular window size or screen resolution
Java.lang.Object

CheckboxGroup TextComponent TextField

Component Button

FlowLayout Label

BorderLayout Checkbox

GridLayout List

Choice

Container

Window Panel

Frame
Java.awt.Component

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)
Java.awt.Container

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
Java.awt.Window

Window class creates the top level window


Sits directly on the desktop, cannot be contained in any other object
Generally, you wont 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(Color.green);

Buttons : Most useful components


Generate action events

Button submitButton=new Button(submit);


CheckBoxes

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
CheckBoxGroup

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
Layouts

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

...contd.
...contd.

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


More...

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 programs 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 dont 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(
com.sun.java.swing.plaf.windows.WindowsLookAndFeel);
How to change the Look and Feel

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

SwingUtilities.updateComponentTreeUI(frame);

frame.pack();
IDE

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.
ActionListener

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);
}
}
ItemListener

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);
}
}
Adapters

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
WindowAdapter

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

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 instance.new 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
Applets

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 applets 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);
AppletContext

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 browsers 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

You might also like