Java Basics

JAVA BASICS For more tutorials visit www.roshinionline.
com
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
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
Integers
Floating point
Integers
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
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;
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 Miscellaneous +, -, *, /, % >, <, >=, <=, !=, == !, &&, || ~, &, |, ^, <<, >>, >>> = ++, -+=, *=, etc. (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
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(); } }
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
Source
A stream reads
Program
A stream
Program
writes
dest
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 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);
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
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)}
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 Component FlowLayout BorderLayout GridLayout TextComponent Button Label Checkbox List Choice Container TextField
Window Frame
Panel
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 toplevel 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

Java Basics

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Java Basics

Enviado por

Direitos autorais:

Formatos disponíveis

JAVA BASICS For more tutorials visit www.roshinionline.

Basic Java Session Outline

Basic Java Session 1

JVM & JRE make it Cross Platform

Java Virtual Machine Java Runtime Environment Native OS

JVM Java Virtual Machine

JRE Java Runtime Environment

Java Runtime Environment Java Support Classes JVM Executables

Java Object Oriented

A Simple Java Program

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

To compile: javac HelloWorld.java

To run: java HelloWorld

Hello World Applet

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

To compile: javac HelloWorld.java

Attributes Or Object State

Methods Or Object Behavior

Primitive Data Types

Floating Point Types

Type float double

Width 32 bits 64 bits

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

Basic Java Session 2

Variables Arrays Operators Conditional Statements Constructors Destructors

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

while (boolean expression) { statement1; statement2; }

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

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

Basic Java Session 3

The super reference

Object and Class classes

Object and Class classes

Package level access

Importing classes from packages

The Classpath variable

Method overriding rules

Parameter passing in Java

Basic Java Session 4

Java Streams Serialization Abstract Classes Interfaces

Java Streams and Object Serialization

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

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

The Collections Framework

Java also supplies some collection-like things:

Collection Set HashSet SortedSet TreeSet ArrayList List Hashtable LinkedList

The Collection interface

Some bulk Collection methods:

* Returns true if the Collection was changed, false otherwise

A simple map: Hashtable

The Iterator interface

Basic Java Session 5

Exceptions Threads Synchronized Methods

When to use Exceptions

Extending the Thread class - offlineEnroller.java Implementing Runnable - onlineEnroller.java

Basic Java Session 6

Labels and Buttons

Note: Now , Go to Sample Code

Label Button TextField TextArea Choice List MenuBar, Menu, MenuItem

How to set the Look and Feel

How to change the Look and Feel

Inner classes Sample Code

Applet - start() / stop()