Introduction To Java

Introduction to Java
© Copyrights aurionPro Solutions Ltd.

Java’s Lineage
 C language was result of the need for structured,
efficient, high-level language replacing assembly
language
 C++, that followed C, became the common (but not the
first) language to offer OOP features, winning over
procedural languages such as C
 Java, another object oriented language offering OOP
features, followed the syntax of C++ at most places, but
offered many more features
© Copyright aurionPro Solutions Ltd.

Features of Java
 Completely Object-Oriented
 Simple
 Distributed : full support for TCP/IP protocol,

developing distributed applications is easy
 Robust : Strongly typed language
 Secure

Features of Java
 Architecture Neutral : Platform independent
 Interpreted and Compiled
 Dynamic
 Multithreaded : Concurrent running tasks

Features added in Java 1.1
 Java-Beans : Component Technology
 Serialization
 Remote Method Invocation
 JDBC
 Java Native Interface
 Inner classes

Features added in
Java 2 (Java 1.2)
 Java Swing
 CORBA : Common Object Request Broker Architecture
 Digital Certificates : ensures security policies
 Collection API : e.g. linked list, dynamic array

Features added in
Java 1.3
 XML Processing
 JDBC 3.0 API
 Swing Drag and drop
 Internationalization
 Performance Improvement in Reflection APIs
 JNDI
 Java Print service API

Features added in 1.4
 New Security certificates added

 New Swing Features
 Regular expressions
 New I/O API
 Logging
 Secure Sockets
 Assertions

Features added in
1.5
 Ease of Development
generic types, metadata, auto boxing, an enhanced for loop, enumerated types, static import, C style
formatted input/output, variable arguments, concurrency utilities, and simpler RMI interface
generation
 Scalability and Performance

Introduction of class data sharing in the Hot Spot JVM
 Monitoring and Manageability

The JVM Monitoring & Management API specifies a comprehensive set of instrumentation of JVM
internals to allow a running JVM to monitored.
 Desktop Client
 Miscellaneous Features
 Core XML Support
 Supplementary Character Support
 JDBC RowSets

Platform Independence
Unix on Pentium System
Macintosh PowerPC system
.java file Class Loader
Bytecode PowerPC
verifier machine level
Java JIT compiler instructions
compiler
Class file
containing Windows Pentium PC system
Bytecodes Class Loader
Bytecode Pentium
Class Loader Verifier machine level
Bytecode JIT compiler instructions
verifier
JIT compiler

Platform Independence (Contd.)
 Platform independence primarily helps Java
Applets to be executed on any platform
 Allows execution of Applet class files compiled on
remote system, downloaded over the internet
 Typically, however, on Java based Web-applications
(i.e. J2EE applications), Java classes are compiled
and executed on the same platform

Difference between JRE and
JDK
 JRE is the ‘Java Runtime Environment'. It is
responsible for creating a Java Virtual Machine to
execute Java class files (i.e run Java programs)
 JDK is the ‘Java Development Kit'. It contains tools
for Development of Java code (e.g. Java Compiler)
and execution of Java code (e.g. JRE)
 JDK is a superset of JRE. It allows you to both write
and run programs

Relation between Java and Sun
 Sun Microsystems defined and published Java
Language Specification
 Sun also offers freely downloadable reference
implementation of Java Language in the form of
Sun JDK and Sun JRE
 Other companies can also provide implementation
of Java Specification
 Few examples of companies who provide their own
JRE are: IBM, Microsoft, BEA

Technologies
(JDK, J2EE,J2ME,….)
 Java SE - Java SE Development Kit (JDK)

 Java EE -Java EE 5 SDK
 Java ME
 Connected Device Configuration (CDC)
 Sun Java Wireless Toolkit for CLDC,
 JavaFX
 JavaFX Script
 JavaFX Mobile

First Simple
Program
//this is my first program

class Example {
/* the execution starts here */
public static void main(String args[]) {
System.out.println(“Welcome to Java “);
}
}

Compile and Run
Program
 To compile the program:
c:\javac Example.java
 To run it:
c:\java Example

Language Fundamentals

Variables
 Basic unit of storage in a Java program
 Three types of variables:
 Instance variables
 Static variables
 Local variables
 Parameters
 Each variable type has different scope
 Formal parameters (i.e. arguments to function) are
similar to local variables

Data types
Type Size/Format Description
byte 8-bit Byte-length integer

short 16-bit Short Integer
int 32-bit Integer
long 64-bit Long Integer
float 32-bit IEEE 754 Single precision floating point
double 64-bit IEE 754 Double precision floating point
char 16-bit A single character

boolean 1-bit True or False

Default Values
 Integer : 0
 Character : ‘\u0000’
 Decimal : 0.0
 Boolean : false
 Object Reference : null

Operators
 Arithmetic operators:
 +, - , * , / ,%
 ++, --
 +-, -=, *= , /= , %=
 Relational operators:
 == , != , >=,>,<=,<
 assignment(=), ternary(?)

Operators
Precedence
Postfix expr++ expr—
Unary ++expr --expr +expr -expr ~ !
Multiplicative * / %
Additive +-
Shift << >> >>>
Relational < > <= >= instanceof
Equality == !=
bitwise &^|
logical && ||
Ternary ?:
Assignment = += -= *= /= %= &= ^= |= <<=
>>= >>>=
Control Flow
Statements
 if-then
 if-then-else
 switch
 while
 do-while
 for
 Branching Statements
 break
 continue
 return

Memory
Management
 Dynamic and Automatic
 No delete operator
 Implemented by Garbage Collector
 Garbage Collector is the Lowest Priority Daemon
Thread
 It runs in the background when JVM starts
 Collects all the unreferenced objects
 Frees the space occupied by these objects
 System.gc() method can be called to “hint” the JVM
that it should invoke garbage collector, however, there
is no guarantee that it would be invoked. It is
implementation dependent

Arrays
 A group of like-typed variables referred by common
name
 Declaring an array
 int arr [];
 arr = new int[10]
 int arr[] = {2,3,4,5};
 int two_d[][] = new int[4][5];
 Java arrays are asymmetrical arrays

Arrays
 Arrays of objects too can be created
 Example 1 :
 Box Barr[] = new Box[3];
 Barr[0] = new Box();
 Example 2:
 String[] Words = new String[2];
 Words[0]=new String(“Bombay”);
 Words[1]=new String(“Pune”);

OOP Concepts

Encapsulation
 Encapsulation describes the ability of an object to
hide its data and methods from the rest of the world
- one of the fundamental principles of OOP (Object
Oriented Programming)
 Encapsulation is implemented using different
access specifiers such as private, protected, public
etc

Introduction to
Classes
The general form of a class
class < class_name>{
type var1;…..
Type method_name(arguments ){
body
}…..
} //class ends.

Introduction to
Classes
A Simple Class
class Box{
double width;
double height;
double depth;
double volume(){
return width*height*depth;
} //method volume ends.
}//class box ends.

Declaring Objects
class impl{
public static void main(String a[]){
//declare a reference to object
Box b;
//allocate a memory for box object.
b = new Box();
// call a method on that object.
b.volume(); }
} © Copyright aurionPro Solutions Ltd.
Types of class
members
 default access members (No access specifier)
 private members
 public members
 protected members

Inheritance
 One of the major pillars of OO approach
 Allows creation of hierarchical classification
 Advantage is reusability of the code
 Once a class is defined & debugged , same class can be
used to create further derived classes
 Already written code can be extended as and when
required to adopt different situations

Inheritance (Contd.)
 Inherited members can be used with the super
keyword
 super() ;// calls parent class constructor
 super.overriden() ;// calls an overriden method of the
base class

Inheritance
(Contd.)
Class Base {
public void meth1() {
System.out.println(“Method1 of Base”);
}
}
Class Derived {
public void meth1() {
super.meth1();
System.out.println(“Method1 of Derived”);
}
}
Inheritance
(Contd.)
class Test
{
public static void main(String args[]){
Derived d1=new Derived();
d1.meth1();
}
}

Inheritance
(Contd.)
Output:
Method1 of Base
Method1 of Derived

Polymorphism
 An objects ability to decide what method to apply to
itself depending on where it is in the inheritance
hierarchy
 Can be applied to any method that is inherited from
a super class
 Allows to design & implement systems that are more
easily extensible

Abstract class
 A class that provides common behavior across a set
of subclasses, but is not itself designed to have
instances that work
 One or more methods are declared but may or may
not be defined
 Advantages:
 Reusability of code
 Help at places where implementation is not available

Abstract class
(Contd.)
 Any class that has even one method as abstract
should be declared abstract
 Abstract classes can’t be instantiated
 Abstract modifier cant be used for constructors &
static methods
 Any sub class of an abstract class should implement
all methods or declare itself to be abstract
 An abstract class need not have only abstract
methods; can have concrete methods too

Important Classes and Keywords
in Java

Constants
 Use the final keyword before the variable
declaration and include an initial value for that
variable
Eg:-
final float pi = 3.141592;
final boolean debug = false;
final int maxsize = 30000;

Final Classes and Methods
 Final Classes
 Final classes cannot be inherited
 All methods in a final class are implicitly final
 Final Methods
 final methods cannot be overridden
 Methods declared as static are implicitly final
 Also methods declared private are implicitly final

Members
 You can declare both methods and variables to be
static
 Static methods has got following restrictions
 They can call only static methods
 They can access static data only
 Cannot refer to this or super
 Static methods can access non-static variables and
non-static methods, provided explicit instance
variable is made available to the method

Nested classes
 Class within another class
 The scope of a nested class is bounded by the scope
of its enclosing class
 Nested classes are of two types:
 Static
 Non-static
 Nested classes should be used to reflect and enforce
the relationship between two classes

Anonymous
Inner classes
 These classes do not have a name
 Are defined at the location they are instantiated
using additional syntax with the new operator
 Typically used to create objects “on the fly” in
contexts such as return value of a method, an
argument in a method call or in initialization of
variables

Object Superclass
 Cosmic super class
 Ultimate ancestor – every class in Java implicitly
extends Object
 A variable of type Object can be used to refer to objects
of any type
 Eg. Object obj = new Emp();
 Methods in Object class are :
 void finalize()
 Class getClass()
 String toString()

The System Class
 The System class is the class used to interact with any
of the system resources
 It can not be instantiated
 Contains a lot of methods and variables to handle
system I/O
 Among the facilities provided by the System class are
standard input, standard output, and error output
streams

The System Class
 Some of the methods in System class:
 System.gc(): is a suggestion and not a command
 It is not guaranteed to cause the garbage collector to
collect
everything
 System.exit(0);

String Handling
 String is handled as an object of class String and not
as an array of characters
 String class is a better and a convenient way to
handle any operation
 But one main restriction with this class is that once
an object of this class is created, the contents cannot
be changed

Some methods of
String class
 length() : length of String
 indexOf() : searches for the occurrence of a char, or
String within other String
 substring() : retrieves substring from the object
 trim() : to remove spaces
 valueOf() : converts data to String

The String Class
String str = new String(“Pooja”);
String str1 = new String(“Sam”);
Heap Stack
Pooja
str
Sam
str1
String str = new String(“Pooja”);
String str1 = str;
Pooja str
str1
StringBuffer Class
 Peer class of String class that represents fixed length,
immutable char sequence
 StringBuffer represents growable and writeable
character sequence
 Insertions at particular positions are possible through
this class

Wrapper Classes
 Primitives are not a part of object hierarchy
 Primitives are passed by value
 Object representation of primitives is required
 Wrapper classes provide a way to encapsulate simple
values as objects
 Integer, Double, Float, Character are all wrapper
classes

Casting of Variables
 To convert one variable value to other, wherein two
variables correspond to two different data types
 Double d = 10.5;
 float f = (float) b;
 Widening does not require casting
 Casting of References can be done, if two classes are
related to each other by inheritance relationship
 If the casting is not proper, it throws
ClassCastException

UpCasting &
DownCasting
 Upcasting
 Object o = new String(“HELLO”);
 Serializable s = new String(“New”);
 DownCasting
 String s1 = (String) o;
 String s2 = (Serializable) s

Parameter
Passing
 Parameters or arguments passed to a function are
passed by value for primitive data-types (e.g. int, char)
 Parameters or arguments passed to a function are
passed by reference for non-primitive data-types (e.g.
All Java objects)
 Java does not have concept of passing parameters by
address or pointers, similar to what we have in C or
C++ (using * to denote a pointer to object)

Packages and Interfaces

Interfaces – Their need
 Interface defines a data-type without implementation
 The interface approach is sometimes known as
programming by contract
 It’s essentially a collection of constants & abstract
methods
 An interface is used via the keyword "implements"
Thus a class can be declared as
 class MyClass implements Sun, Fun{
 ... }

Interfaces
 A Java interface definition looks like a class
definition that has only abstract methods, although
the abstract keyword need not appear in the
definition
 public interface Testable {

 void method1();
 void method2(int i, String s);
}

Declaring and Using
Interfaces
public interface simple_cal {
int add(int a, int b);
int i=10;
}
//Interfaces are to be implemented.
class calci implements simple_cal {
int add(int a, int b){
return a+b;
}}

Interfaces - rules
 Methods in an interface are always public & abstract
 Data members in a interface are always public, static
& final
 A sub class can only have a single super class in Java
 But a class can implement any number of interfaces
 Thus flexibility is introduced in usage of
polymorphism

Interfaces &
Abstract classes
 Abstract classes are used only when there is a “is-a”
type of relationship between the classes
 You cannot extend more than one abstract class
 Abstract class can contain abstract as well as
implemented methods

Packages
 Are a named collection of classes
 Are a way of grouping related classes & interfaces
 A package can contain any number of classes that are
related in purpose, in scope or by inheritance
 Convenient for organizing your work & separating
your work from code libraries provided by others

Packages : Their
need
 Allow to organize classes into units
 Reduce problems with naming conflicts
 Allow to protect classes, variables & methods in a
larger way than on a class-to-class basis

Using packages
 To use a public class of a package, simple use the full
package name
E.g. Java.util.Date = new java.util.Date();
 import statement: allows to import all the public
classes in a package
E.g. import java.awt.*;
 If the required class is in java.lang package, it can be
used directly

Defining A Package
package com.patni.trg.demo;
// import statements here.
public class Balance {
String name;
double bal;
public Balance(String n, double b) {
name = n;
bal = b;
}

Defining A
Package
public void show() {
if(bal<0)
System.out.print("-->> ");
System.out.println(name + ": $"
+ bal);
}
}

Compiling A
Package
 Specify the path of the directory, where com directory
is to be created
 Example
 javac –d . Balance.java
 javac –d E:\JavaAss\MyAss Balance.java

Package scope
access
 Default: features of a class having default scope can
be accessed by all classes in the same package
 Protected: enables a feature to be accessed by classes

or interfaces of the same package or by subclasses of
the class in which it is declared

Access Specifiers
Private No Modifier Protected Public
Same class Y Y Y Y
Same Package Subclass N Y Y Y
Same Package non-sub class N Y Y Y
Different Package Subclass N N Y Y
Diffrent Package non-subclass N N N Y

Access Specifiers
Package P1
Class A
Package P2
Class B Class C Class G Class F

Classpath
 For java to be able to use a class, it has to be able to
find that class on the file system
 Otherwise, the runtime flags an exception that the
class does not exist
 Java uses 2 elements to find classes

 The package name
 The directories listed in classpath variable

Classpath(Contd.)
 classpath : points to various places where java classes
live
 The specific location that Java compiler considers as
root of an package hierarchy is controlled by
classpath
e.g.
classpath = c:\jdk1.2.2\bin; c:\jdk1.4.2_03; d:\java;

How compiler locates a file
 Compiler searches through all directories specified in
the classpath variable
 If . is specified in classpath, then it also checks current
directory
 If compiler still does not locate the file, it flags a
ClassNotFound Exception

Eclipse, an IDE

What is an IDE?
 An application or set of tools that allows a programmer
to write, compile, edit, and in some cases test and
debug within an integrated, interactive environment
 IDE combines the editor, compiler, runtime
environment and debugger – all in the single
integrated application.
(e.g. When one attempts to compile code with syntax
errors, IDE shows the error messages, and lets one
jump to that line by clicking on error message)

Some examples
of an IDE
 Eclipse
 JDeveloper
 WSAD (WebSphere Studio Application Developer)
 JBuilder

Using Eclipse as
an IDE
 The Eclipse Project is an open source software
development project dedicated to providing a robust,
full-featured, commercial-quality, industry platform for
the development of highly integrated tools and rich
client applications

Using Eclipse as
an IDE
 Our objective is to code Java programs faster with
Eclipse 3.0 as an IDE
 Eclipse3.0 features include:

 Creation and maintenance of the Java project
 Developing Packages
 Debugging a java program with variety of tools
available
 Running a Java program

Using Eclipse as
an IDE
 Developing the Java program will be easier as Eclipse
editor will provide:
 Syntax highlighting
 Content/code assist
 Code formatting
 Import assistance
 Quick fix

Eclipse-Plugins
 Lomboz
 Checkstyle
 JDepend
 PMD
 Ant

Exception Handling

Exception
Handling
 Exception is an object that describes an exceptional
condition
 Java Exception handling is managed by 5 keywords
try, catch
finally
throw
throws

Exception
Handling
Throwable
Exception Error
RunTime Exception Compile Time Exception
Unchecked Exception Checked Exception

Some Examples
 Checked Exceptions include:
 IOException
 SQLException
 ClassNotFoundException
 Unchecked Exceptions include:

 ArithmaticException
 NullPointerException
 ArrayIndexOutOfBoundsException

Using try and catch
class demo {
public static void main(String a[]) {
try {
int d = 0;
int a = 42 /d;
} catch(ArithmeticException ae) {
System.out.println(ae);
}
}}

Throw and Throws
clause
 It is a way to throw an exception explicitly
 Must be an object of Throwable or it’s subclasses
Example:
public void passgrade(int a, int total) {
if (a > total)
throw new ArithmeticException();
}

Throws clause
 If method is capable of throwing an exception, then
caller needs to be informed, so that they can guard
themselves against the exception
 public void passgrade(int a, int total) throws
ArithmeticException {
 if (a > total)
 throw new ArithmeticException();
 }
 Throws clause is not commonly used for Exceptions of

type Error, RuntimeException, or its subclasses
Finally clause
 Finally clause creates a block of code that will be executed
whether or not an exception is thrown
Usage:
try {
int j = 0;
int i = d/j;
} catch (ArithmeticException ae) {
System.out.println(ae);
} finally {
System.out.println(“Always Executed”);
Application Specific
Exceptions
class ApplicationException extends Exception {
private int detail;
ApplicationException(int a)
{ detail = a;}
ApplicationException(String args) {
super(args); }
public String toString(){ return "ApplicationException["+detail+"]";}
}

Documenting in Java -
javadoc

What is javadoc?
 Javadoc is a tool that parses the declarations and
documentation comments in a set of source files and
produces a set of HTML pages describing the classes,
inner classes, interfaces, constructors, methods, and
fields
 To generate javadocs for the class some commenting
styles must be followed in the program

Javadoc
Comments
 A general javadoc comment
/**
* This is the typical format of a simple
documentation *comment that spans two lines
*/
Documentation comments are recognized only
when enclosed between /** and */ and placed
immediately before class, interface, constructor,
method, or field declarations

Comments
(Contd.)
 Class and interface Documentation tags
 @see,@deprecated,@author,@version and more
 Example:
 /** * A class representing a window on the screen.
 * For example:
 * @author patni
 * @see java.awt.BaseWindow
 */
 class Window extends BaseWindow { ... }

Comments
(Contd.)
 Field Documentation tags:
 @see,@deprecated,@since,@serial and more
 Example:
 /**
 * The X-coordinate of the component.
 *
 * @see #getLocation() */ int x = 1263732;

Comments
(Contd.)
 Constructor and Method Documentation Tags
 @see,@param,@return,@since,@throws,@exception
and more
 /**
 * Returns the character at the specified index. An index
 * @param index the index of the desired character

Comments
(Contd.)
 * @return the desired character.
 * @exception StringIndexOutOfRangeException
 * if the index is not in the range <code>0</code>
 * to <code>length()-1</code>.
 * @see java.lang.Character#charValue()
 */
 public char charAt(int index) { ... }

Coding Conventions
 Every project in aurionPro MUST follow consistent
Java Coding Conventions, unless overridden by
client for that project
 Coding conventions (also known as “Coding
Guidelines”) are set of suggestive guidelines defined
for a project, that helps to enforce consistent coding
style across developers within the project
 For example, it ensures consistent and readable
names of variables, classes or methods across
application

Coding Conventions (Contd.)
 Examples of Coding Conventions Guidelines
 Class level member variable should be m_x<varname> where
m indicates member variable,
 x should be replaced with i for integer, s for String etc.
 e.g. m_sUserName // String that stores User Name
 Function Arguments variables (formal parameters) should be
a_x<varname> where
a indicates argument variable,
 x should be replaced with i for integer, s for String etc.
 e.g. a_iProjectCode // integer argument to hold proj-code
 First letter of every class should always be in upper case.
 Variable names such as “String string1 = new String()” should
be avoided. Instead, sensible
© Copyright variable
aurionPro Solutions Ltd. name should used
 How do Coding Conventions help the project?
 Helps to define the consistent ways of naming a
variable or a class or a method within application
 Improves readability of the code
 Helps during defect fixing and maintenance phase,
since variable names are indicative of its scope, type
etc
 Makes debugging of code person-independent
 Saves efforts on documentation, since
variable/method or class names becomes self-
describing

 How to use Coding Conventions on the project?

 Typically defined by client or senior team member or PL
before the start of the coding phase
 If not defined for a project, refer to conventions defined
by Sun (http://java.sun.com/docs/codeconv/index.html)
 Should be read and understood by every developer before
starting the code (to avoid rework later on)
 Should be adopted as part of the coding-culture itself, and
not as add-on activity applied after functional coding is
done
 Should come naturally to every developer
 Should get caught during code-reviews, if not followed
 Coding Conventions can be found on our QMS
-> 4.4 Tables
-> GL 1 - Guidelines for Coding
 Conventions defined by Sun

http://java.sun.com/docs/codeconv/index.html
that can be used for rest of the assignments within this
course

Reviews
 Being ISO-9001:2000 company, reviews are part of
the life in aurionPro
 Reviews do take place for every work product
created in SDLC of a project (e.g. Design review,
test case review, code review etc.)
 Various types of reviews in Patni
 Self-Review
 Peer-to-peer review
 Peer review

Peer to Peer
Code Reviews
 Code is reviewed by Peer (colleague)
 Why Peer to Peer Reviews are required?
 Everyone has a blind spot. Can’t catch one’s own mistake
 Helps to catch the defect early in the life-cycle
 Defects found in reviews may be difficult or impossible
to find in testing (e.g. coding convention defects)
 It takes more efforts to find the same defect during
testing (Cost of finding defect in testing is higher than
cost of finding defect in reviews)
 Enforces consistency amongst developers and clarifies
misunderstood points during review discussions

Java Code
Review Checklist
 Code reviews should be done using a checklist, and
should cover functional reviews too
 Typically code-review checklists are created senior team
member (GL) or PL or sometimes provided by client too
 If not defined for a project, refer to checklists available
on Patni KC
 Should be read and understood by every developer
before starting the code creation and code reviews
 Checklist must be used by code-creator for self-review.
This will reduce the efforts during peer-to-peer review
 Should be adopted as part of the coding-culture itself

Review Checklist
(Contd.)
 Typically Java Code Review checklist looks like this
 Sample Java Code review checklist
 One of the important points that code-review
checklist ensures is enforcing coding conventions (or
coding guidelines) discussed in earlier slides
 Review Findings of code-review should be captured as
code-review defects. Defects should be fixed by code-
creator, and re-verified by the person reporting the
defect

Java Property files

Java Property files
 java.util.Properties is a platform-independent
generalization of the DOS SET environment, or the
Windows *.INI files. In Java, even each object could
have its own list of properties. A program can
determine if an entry is missing in the property file
and provide a default to using it its place

Java Properties
Java.util.Properties class:
 The Properties class represents a persistent set of
properties. The Properties can be saved to path from
where the properties file would be picked up. Each key
and its corresponding value in the property list is a
string

Types of
properties
 Property files provide a means of storing key-value
pair,which could be used by the programs in execution
 Properties can be categorized as:
 User specific properties

 System properties

Types of
properties
 User specific properties:
These properties are part of the Application.properties
containing a key value pair, which can be mentioned
by the program in run
 #application.properties file contents password=tiger

url=jdbc:oracle:thin:@192.168.12.16:1521:oracle8i
driver=oracle.jdbc.driver.OracleDriver
username=scott

Types of
properties
 System properties:
System properties give information about the
environment of the program ,in which it is running
such as JVM it is running in, Operating System name
and version, java home and many more properties

System Properties
 System properties are read from System class, which
give information about the environment of the Java
program in which it is running, such as:
Java.vm
Java.version
User.language
Java.home
User.region etc

Files and Streams

Streams
 Files are necessary for persisting data
 Java views each file as a sequential stream of bytes
 Stream is generic term for ‘flow of data’
 Different streams are used to represent different kinds
of data flow
 When a file is opened, an object is created and a
stream is associated with the object

Streams(Contd.)
 Thus, an object from which we can read a sequence of
bytes is input stream
 Thus, an object to which we can write a sequence of
bytes is output stream
 The source or destination of data can be files, network
connections or even blocks of memory
 The Java I/O class libraries allows user to handle any
data in the same way

Java.io package
 Provides an extensive set of classes for handling I/O
to & from various devices
 Contains many classes each with a variety of
member variables & methods
 It is layered ie. It does not attempt to put too much
capability into 1 class
 Instead a programmer can get the features he wants
by layering one class over another

I/O Handling
 All Java programs automatically import java.lang
package
 This package defines a class called System, which
encapsulates several aspects of run-time environment
 It contains three predefined stream variables called
in,out, and err (public static)

Input streams

Output streams

InputStream class
 An abstract class that defines methods for performing
I/p
 Serves as base class for all other InputStream classes
 Defines a basic interface for reading streamed bytes
of information
 Data in InputStream is transmitted one byte at a time

InputStream class : some
methods
 int read() : Returns an integer representation of the
next available byte of input
 int read(byte buffer[]):
 int read(byte buffer[], int offset, int numbytes)
 int available()
 void close()
 void mark(int numbytes)

Using the Stream variables
import java.io.*;
class ReadKeys {
public static void main (String args[]) {
StringBuffer sb = new StringBuffer();
char c;
try {
while((ch =(char)System.in.read()) != '\n')) {
sb.append(c);
}
} catch (Exception e) { ... }
String s = new String(sb);
OutputStream
 void write (int b): Writes a single byte to an output
stream
 void write(byte buffer[])
 void write(byte buffer[], int offset, int noBytes)
 void flush()
 void close()

FileInputStream
 The FileInputStream class creates an InputStream that
you can use to read the contents of a file. It has two
constructors:
 FileInputStream(String filepath) throws
FileNotFoundException
 FileInputStream(File fileobj) throws
FileNotFoundException

FileOutputStream
 The FileOutputStream class creates an OutputStream
that you can use to read the contents of a file. It has
two constructors:
 FileOutputStream(String filepath)
FileOutputStream(File fileobj)

ByteArrayInputStream
 ByteArrayInputStream is an implementation of an
input stream that uses a byte array as the source. This
class has two constructors , each of which requires a
byte array to provide the data source
 ByteArrayInputStream(byte array[])
 ByteArrayInputStream(byte array[],int start,int

numbytes)

Chaining of
streams
 Each class accesses the output of the previous class
through the in variable
 Example
 FileOutputStream fos = new
FileOutputStream(c:\a.txt”);
 DataOutputStream dos = new DataOutputStream(fos);

Streams:
Readers/Writers
 Reader and Writer classes are designed for character
streams
 Reader is an input character stream that reads a
sequence of Unicode characters
 Writer is an output character stream that writes a
sequence of Unicode characters

Reader hierarchy

Writer hierarchy

File class
 File class doesn’t operate on streams
 Represents the pathname of a file or directory in the
host file system
 Used to obtain or manipulate the information
associated with a disk file, such as permissions, time,
date, directory path etc
 An object of File class provides a handle to a file or
directory and can be used to create, rename or delete
the entry

File class
 Some methods
 canRead()
 exists()
 isFile()
 isDirectory()
 getAbsolutePath()
 getName()

File class
methods (Contd.)
 getPath()
 getParent()
 Length() : returns length of file in bytes as long
 lastModified()
 Mkdir()
 List() : obtain listings of directory contents

Serialization
 Serializability of a class is enabled by the class
implementing the java.io.Serializable interface.
Classes that do not implement this interface will not
have any of their state serialized or deserialized. All
subtypes of a serializable class are themselves
serializable. The serialization interface has no
methods or fields and serves only to identify the
semantics of being serializable

Object Serialization
 Allows an object to be transformed into a sequence of
bytes that can be later re-created into an original
object
 After deserialization, the object has the same state as it
had when it was serialized(barring any data members
that are not serialized)
 For a object to be serialized, the class must implement
the Serializable interface

RandomAccessFile
 RandomAccessFile encapsulates a random-access
file
 RandomAccessFile(String FileObj, String access);
 RandomAccessFile(String filename, String access)
 access can be r or rw
 void seek( long newPos);

Multithreading in Java

Multithreading
 A multithreaded program contains two or more parts
that can run concurrently. Each part of that program
is called thread, and each thread defines a separate
path of execution
 There are two distinct types of multitasking: process
based & thread based
 Thread is also known as lightweight process

Multithreading
 The Main thread
 When a Java program starts up, there is already one
thread running
 It is the thread from which other “child” threads will be
spawned
 It must be the last thread to finish execution. When
the main thread stops, your program terminates
 If the main thread finishes before a child thread has
completed, then the Java run-time system may hang

Main Thread
 Although the main thread is called automatically when program
starts, it can be controlled by a thread object
 How? Obtain a reference to it by calling the method currentThread()

(a public static member of Thread class)
 static Thread currentThread(){ }
 This returns a reference to the thread in which it is called. Once a

reference to the main thread is obtained, it can be controlled just like
any other thread

Multithreading
 Creating new Threads
 java.lang.Thread
 Creating a thread involves two steps: writing the code
that is executed in the thread and writing the code
that starts the thread
 There are two ways to create a thread
 Implementing Runnable interface
 Extending Thread class

Runnable
interface
 Need to implement run()
 public abstract void run()
 Instantiate an object of type Thread within that class
Thread defines several constructors
 Thread ( Runnable threadOb, String threadName );
 The new thread will not start running until its start()
method isn’t invoked
 In turn, start() executes a call to run().
 synchronized void start ( )

Extending Thread
class
 The extending class must override the run() method,
which is the entry point for the new thread
 It must also call start() to begin execution of the new
thread

LifeCycle of Thread
Start Ready to run Leaving non-runnable
scheduling
Entering Non-runnable state

Running Waiting Sleeping Blocked
non-runnable
Terminates
Dead

States of Java Thread
 Not Runnable
 Still alive, but it is not eligible for execution
 It can move to not runnable stage because of following
reasons:
1. The thread is waiting for an I/O operation to complete

2. The thread has been put to sleep for a certain period of
time (using the sleep() method)
3. The wait() method has been called
4. The thread has been suspended (using suspend()
method)

States of Java
Thread
 Dead
When a thread terminates, it is DEAD. Threads can be DEAD
in a variety of ways which include
1.When its run() method returns

2. When stop() or destroy() method is called

Methods invoked on Threads
 interrupt() : interrupts a thread
 interrupted() : true if current thread has been

interrupted and false otherwise
 isInterrupted() : determines if a particular thread is

interrupted
 stop() : stops a thread by throwing a ThreadDeath

object which is a subclass of error

The Thread Class Methods
 getPriority(): Obtains thread priority
 start(): To start the operation of a thread
 sleep(): suspends the thread for some time
 run(): body of the thread
 suspend()/resume(): suspends a thread & resumes

Methods invoked on Threads
 getName(): returns the name of the thread
 toString(): returns a string consisting of the name of
the thread, priority of the thread and the thread’s
group
 currentThread(): returns a reference to the current
Thread
 join(): waits for the thread to which the message is
sent to die before the current thread can proceed

Methods invoked
on Threads
 isAlive(): returns true if start has been called but stop
has not
 setName(): sets the name of the thread
 Yield(): Causes the currently executing thread object
to temporarily pause and allow other threads to
execute

Pre-emptive VS
Nonpre-emptive
 Pre-emptive : The OS interrupts programs without
consulting them
 Non pre-emptive: The programs are interrupted only
when they are ready to yield control

Scheduling & Priority
 Thread-scheduling: A mechanism used to determine
how runnable threads are allocated CPU time
 A Thread-scheduling mechanism is either preemptive
or non preemptive
 Scheduling can be controlled through priorities
 setPriority() getPriority()
 Three types of priorities can be set viz MIN_PRIORITY,
NORM_PRIORITY, MAX_PRIORITY

Scheduling &
Priority
 The job of Java scheduler is to keep a highest priority
thread running at all times
 If timeslicing is available, it ensures that several
equally high - priority threads execute for a quantum
in a round - robin fashion

Multithreading – JVM
implementation dependent
 The early Solaris Java platform runs a thread of a given
priority to completion or until a higher priority thread
becomes ready
 At that point preemption occurs, I.e the processor is
given to the higher - priority thread while the
previously running thread must wait

Multithreading policies
 In 32-bit Java implementations for Win ‘95 & Win NT,
threads are time sliced
 Each thread is given a limited amount of time to
execute on a processor
 When that time expires the thread is made to wait
while other threads of equal priority get their chance
to use their quantum in round - robin fashion

Multithreading
policies
 Thus, on Win ‘95 and Win NT, a running thread can
be pre - empted by a thread of equal priority
 Whereas on the early solaris implementation, a
running thread can only be pre-empted by a higher
priority thread

Thread Synchronization
 Implemented using synchronized keywords
 A method can be synchronized so that only one
thread at a time can access the method
 This is possible using a technique called as object
monitor
 Even an object can be synchronized

Inter thread Communication
 final void wait(): tells the calling thread to give up the
monitor and go to sleep until some other thread
enters the same monitor and calls notify()
 final void notify(): wakes up the first thread that

called wait() on the same object
 final void notifyall(): wakes up all the threads that

called wait() on the same object. The highest
priority thread will run first

Networking

Networking Basics
 Computers running on the Internet communicate to
each other using either the Transmission Control
Protocol (TCP) or the User Datagram Protocol (UDP).
 When you write Java programs that communicate
over the network, you are programming at the
application layer.
 You can use the classes in the java.net package.

TCP
 When two applications want to communicate to each
other reliably, they establish a connection and send
data back and forth over that connection.
 TCP guarantees that data sent from one end of the
connection actually gets to the other end and in the
same order it was sent. Otherwise, an error is
reported.
 The Hypertext Transfer Protocol (HTTP), File Transfer
Protocol (FTP), and Telnet are all examples of
applications that require a reliable communication
channel.

UDP
 UDP (User Datagram Protocol) is a protocol that
sends independent packets of data, called datagrams,
from one computer to another with no guarantees
about arrival. UDP is not connection-based like TCP.
 e.g. An application which sends current time.

Understanding
Ports
 A computer has a single physical connection to the network. All
data destined for a particular computer arrives through that
connection. However, the data may be intended for different
applications running on the computer. So how does the
computer know to which application to forward the data?
Through the use of ports.
 The computer is identified by its 32-bit IP address, which IP
uses to deliver data to the right computer on the network. Ports
are identified by a 16-bit number, which TCP and UDP use to
deliver the data to the right application.
 Port numbers range from 0 to 65,535 because ports are
represented by 16-bit numbers. The port numbers ranging from
0 - 1023 are restricted; they are reserved for use by well-known
services such as HTTP and FTP and other system services.

java.net
 The URL, URLConnection, Socket, and ServerSocket
classes all use TCP to communicate over the network.
The DatagramPacket, DatagramSocket, and
MulticastSocket classes are for use with UDP.

Socket
 A socket is one endpoint of a two-way communication
link between two programs running on the network.
A socket is bound to a port number so that the TCP
layer can identify the application that data is destined
to be sent.

Abstract Window
Toolkit

Introduction to AWT
 AWT: Abstract Windows Toolkit package
 Number of classes and interfaces to create and manage
windows
 A standard way to provide graphical user
interface(GUI) in Java
 AWT supports even the GUI based applications

Window Fundamentals
 The awt defines the various kinds of windows
according to class hierarchy that adds functionality
and specificity at each level
 At the highest level of hierarchy is Component class
 An abstract class encapsulating all attributes of a visual
component
 All methods regarding the painting displaying the
component, positioning, resizing, event handling are
defined in this class

Windows class
hierarchy
Java.lang.object
GUI control components are

Components concrete subclasses of this class.
(abstract)
Container
(abstract)
Panel Window
Java.applet.Applet Dialog Frame

GUI Control Components
 Button
 Canvas
 Checkbox
 Choice
 Label
 List
 Scrollbar
 TextField
 TextArea

Menu Components
Java.lang.object
Menu Component
(abstract)
Menubar MenuItem
Menu CheckboxMenuItem
PopupMenu

Layouts
 FlowLayout
 GridLayout
 BorderLayout
 CardLayout
 BoxLayout

BoxLayout
 BoxLayout either stacks its components on top of each
other (with the first component at the top) or places
them in a tight row from left to right
 Demo : ListDialog.java
 Using Fillers : Glue, RigidArea

GridBagLayout
 A GridBagLayout places components in a grid of rows
and columns, allowing specified components to span
multiple rows or columns
 Constraints
 Gridx,gridy: Specify the row and column at the upper
left of the component
 gridwidth, gridheight: Specify the number of columns
(for gridwidth) or rows (for gridheight) in the
component's display area

GridBagLayout
 Fill: Used when the component's display area is larger
than the component's requested size to determine
whether and how to resize the component

GridBagLayout
 Constraints
 ipadx, ipady : Specifies the internal padding: how much
to add to the minimum size of the component
 insets : specifies the external padding of the component
-- the minimum amount of space between the
component and the edges of its display area
 anchor : used when the component is smaller than its
display area to determine where (within the area) to
place the component
 weightx, weighty : Weights are used to determine how to
distribute space among columns (weightx) and among
rows (weighty)
Rendering graphics
 Graphics
 Font
 FontMetrics
 Color
 GraphicsEnvironment
 GraphicsEnvironment gEnv =
GraphicsEnvironment.getLocalGraphicsEnvironment
();
 String envfonts[] =
gEnv.getAvailableFontFamilyNames();

Rendering
graphics
 Toolkit
 Image
 Double-buffering

Handling
Mechanisms
 Ignore the event
 Have the event handled by the component from where
the event originated
 Delegate the event handling to some other object or
objects, called listeners

Event Delegation
 Event classes that can encapsulate information about
different types of user interaction
 Event source objects that inform event listeners about
events when these occur and supply the necessary
information about these events
 Event listener objects that are informed by an event
source when designated events occur, so that they can
take appropriate action

Inheritance diagram of the event
classes
Event
Object
AWT Event
Action Adjustment Component Item Text

Event Event Event Event Event
Container Focus Input Paint Window

Event Event Event Event Event
Key Mouse
Event Event
Event sources,classes &
interfaces
Event Type Event Source Listener registration Event listener
and removal methods interface
provided by the implemented by
source a listener
ActionEvent Button addActionListener ActionListener
List removeActionListener
MenuItem
TextField
Adjustment Scrollbar addAdjustmentListener AdjustmentListene
Event removeAdjustmentListe r
ner
ItemEvent Choice addItemListener ItemListener
Checkbox removeItemListener
CheckboxMenuItm
List
TextEvent TextArea addTextListener TextListener
TextField removeTextListener
Key Event Component addKeyListener KeyListener

removeKeyListener

Event sources,classes &
interfaces
MouseEvent Component addMouseListener MouseListener
removeMouseListener MouseMotionListener
addMouseMotionLister
removeMouseMotionListener
WindowEvent Window addWindowListener WindowListener

removeWindowListener
FocusEvent Component addFocusListener FocusListener
removeFocusListener
ComponentEv Component addComponentListener ComponentListener
ent removeComponentListener
ContainerEve Component AddContainerListener ContainerListener
nt removeContainerListener

Event listeners and methods
Event Listener Event Listener Methods
Interface
ActionListener actionPerformed( ActionEvent evt)
AdjustmentListener adjustmentValueChanged(AdjustmentEvent
evt)
ItemListener itemStateChanged(ItemEvent evt)
TextListener textValueChanged(TextEvent evt)
WindowListener windowActivated(WindowEvent evt)
windowClosed(WindowEvent evt)
windowIconified(WindowEvent evt)
windowDeiconified(WindowEvent evt)
windowDeactivated(WindowEvent evt)
windowOpened(WindowEvent evt)
windowClosing(WindowEvent evt)
MouseMotionListener mouseMoved(MouseEvent evt)

mouseDragged(MouseEvent evt)

Event listeners and methods
MouseListener mouseClicked(MouseEvent evt)
mousePressed(MouseEvent evt)
mouseReleased(MouseEvent evt)
mouseEntered(MouseEvent evt)
mouseExited(MouseEvent evt)
KeyListener keyPressed(Keyevent evt)
keyReleased(Keyevent evt)
keyTyped(Keyevent evt)
FocusListener focusGained(focusEvent evt)

focusLost(focusEvent evt)
ContainerListener componentAdded( ComponentEvent evt)

componentRemoved( ComponentEvent evt)
ComponentListen componentHidden( ComponentEvent evt)
er componentMoved( ComponentEvent evt)
componentResized( ComponentEvent evt)
componentShown( ComponentEvent evt)

Event Adapter
Low level event listener Low level event listener
interface adapter
ComponentListener ComponentAdapter
ContainerListener ContainerAdapter
FocusListener FocusAdapter
KeyListener KeyAdapter
MouseListener MouseAdapter
MouseMotionListener MouseMotionAdapter
WindowListener WindowAdapter
• Event Listeners as anonymous inner classes

What is Swing?
 Swing is advertised as a set of customizable
graphical components whose look-and-feel can be
dictated at runtime
 Swing is built on top of the core 1.1 and 1.2 AWT
libraries
 In JDK 1.1, the Swing classes must be downloaded
separately and included as an archive file on the
classpath (swingall.jar). JDK 1.2 comes with a Swing
distribution

Swing features:
 Pluggable Look & Feel
 Swing is capable of emulating several look-and-feels,
and currently includes support for Windows 98 and
Unix Motif
 Lightweight Components
 Components are not dependent on native peers to render
themselves. Instead, they use simplified graphics
primitives to paint themselves on the screen and can
even allow portions to be transparent

Swing
Components
 There are various swing components available
 Some of them are mentioned below:
 JButton, JLabel, JTextfield, JComboBoxes etc.
 JTable, JList, JTree, JSliderPane, JOptionPane etc.
 Containers – JFrame, JApplet, JPanel etc.

Swing Hierarchy
Java.lang.object
GUI control components are

JComponent concrete subclasses of this class.
(abstract)
JContainer
(abstract)
JPanel JWindow
Java.applet.Applet Dialog Frame

JComponent Class
 Tool tips: setToolTipText method
 Painting and borders: The setBorder method allows
you to specify the border that a component displays
around its edges
 Application-wide pluggable look and feel
 Double buffering: Double buffering smooths on-
screen painting
 Key bindings

JComponent API
 Customizing Component Appearance: Border,
Foreground, Background, Font etc.
 Setting and Getting Component State
 Handling Events: add Listener methods
 Painting Components: repaint, revalidate
 Dealing with the Containment Hierarchy: add, remove
 Laying Out Components: getPreferedSize

Top Level
Container
 Swing provides three generally useful top-level container
classes: JFrame, JDialog, and JApplet
 Points to remember
 every GUI component must be part of a containment
hierarchy
 Each GUI component can be contained only once
 Each top-level container has a content pane

Demo : First Swing Program
SwingApplication.java

Demo : Top Level Container
FrameDemo.java

Frames API
 Creating and Setting Up a Frame : defaultOperations,
IconImage etc.
 Setting the Window Size and Location : pack, setSize,
setBounds etc.

Demo : Frame Demo
FrameDemo2.java

What is an applet
?
 Applets are small programs stored over web server
 Transported over the net
 Installed automatically
 Run as a part of web page
 Need an environment of web browser

Applet basics
 Any applet has to inherit from an Applet class
 The methods in the Applet class are
 init()
 start()
 paint(Graphics g)
 stop()
 destroy()

Applet basics(Contd.)
 Adding an applet to html document
 <html>
 <applet code=“myapplet.class” width=400
height=400>
 </applet>
 </html>
 Running an Applet
c:\appletviewer ex.html

Applet
basics(Contd.)
 Applets do not have a main method
 Applets must run under the environment of web
browser
 Applets do not have the right/permission to access the
file system on client machine
 They can not perform any I/O operation

A Simple Applet
import java.applet.Applet;
import java.awt.*;
public class simpleapp extends Applet {
public void init(){ //any initialization
setBackground(Color.black);
setForeground(Color.yellow);
} public void paint(Graphics g){
g.drawString(“Hello World”,100,100);
}
}
Other Applet
methods
 repaint(): to request painting again
 update()
 showStatus(String)
 getDocumentBase(): URL of HTML file
 getCodeBase(): URL of applet file
 getParameter(String): to retrieve the parameter value
from HTML document

JAR files
< applet archive=”appletbundle.jar”
code=”appletname.class” width=w
height=h></applet>
 JAR files can be made by using the jar tool
 Jar cf appletbundle.jar *. class image.* ………
 To display the content of the jar file
 Jar tf appletbundle.jar
 To extract the content of the jar file
 Jar xvf appletbundle.jar

Applets
 Applet Life Cycle
 Features
 You add components to a Swing applet's content pane,
not directly to the applet
 The default layout manager for a Swing applet's content
pane is BorderLayout
 You should not put painting code directly in a JApplet
object

Applets (Contd.)
 Threads in Applet
 It's generally considered safe to create and manipulate
Swing components directly in the init method

Applets (Contd.)
 Embedding an Applet in an HTML Page
<applet code="TumbleItem.class" codebase="example-
1dot4/" archive="tumbleClasses.jar tumbleImages.jar"
width="600" height="95">
<param name="maxwidth" value="120">
<param name="nimgs" value="17">
<param name="offset" value="-57">
<param name="img" value="images/tumble">

Applets (Contd.)
 Your browser is completely ignoring the
 <applet> tag! </applet>

Demo : Applet Demo
HelloSwingApplet.java

Painting
 JFrame- Content Pane – JPanel – JButton, JLabel
 The top-level container, JFrame, paints itself
 The content pane first paints its background and it
paints its border, it then tells the JPanel to paint itself,
finally the panel asks its children to paint themselves

Design Goals
 To build a set of extensible GUI components to enable
developers to more rapidly develop powerful Java front
ends for commercial applications
 Be implemented entirely in Java to promote cross-
platform consistency and easier maintenance

Design Goals
 Provide a single API capable of supporting multiple
look-and-feels so that developers and end-users would
not be locked into a single look-and-feel
 Enable the power of model-driven programming
without requiring it in the highest-level API
 Adhere to JavaBeans design principles to ensure that
components behave well in IDEs and builder tools

Roots in MVC
 MVC architecture calls for a visual application to be
broken up into three separate parts:
 A model that represents the data for the application
 The view that is the visual representation of that data
 A controller that takes user input on the view and
translates that to changes in the model

The delegate
 Different view and controller became a difficult
proposition
 So the three entities collapsed into two with a single
UI (user-interface) object
 Component and UI delegate object

What MVC
facilitates?
 Separating the model definition from a component
facilitates model-driven programming in Swing
 The ability to delegate some of a component's

view/controller responsibilities to separate look-and-
feel objects provides the basis for Swing's pluggable
look-and-feel architecture

Separable model
architecture
Model Component
Interface
ButtonModel Jbutton, JCheckBox, JRadioButton,
JMenuItem
BoundedRangeMod JProgressBar, JScrollBar, JSlider
el
Document JTextField, JTextArea, JTextPane etc.

Types of Models
 GUI-state models define the visual status of a GUI
control
 relevant only in the context of a graphical user interface
(GUI)
 Useful if multiple GUI controls are linked to a common
state e.g. shared white board programs
 E.g ButtonModel, BoundedRangeModel

Types of Models(Contd.)
 Application-data models
 represents some quantifiable data that has meaning
primarily in the context of the application
 Like the value of a cell in a table
 E.g. TableModel, Document, ListModel,
ComboBoxMdel

The separable
model API
 Implemented as a JavaBeans bound property for the
component
 If you don't set your own model, a default is created
and installed internally in the component
 For more complex models like Jlist or Jtable abstract
model implementations are provided

Model change
notification
 Models must be able to notify any interested parties
(such as views) when their data or value changes
 Swing models use the JavaBeans Event model
 Two Approaches for notification
 Lightweight Notification
 a single event instance can be used for all notifications from a
particular model

Model change
notification
 Stateful Notification
 describes more precisely how the model has changed

Demos
 Button, CheckBox, RadioButton
 Labels
 ComboBoxes
 Menus
 ProgressBars, Sliders, Spinners

Split and Scroll
Pane Pane
 Split
 Places 2 or more components side by side in a single
frame
 Pane can horizontal or vertical
 Scroll
 Provide automatic scrolling facility
 Horizontal and vertical headers are possible

List Component
 List component consists of three parts
 List data is assigned to a model i.e. ListModel
 User Selection : User Selection Model
 Visual Appearance : Cell Renderer
 Demo : SimpleList.java
 List model is a simple interface used to access data in
the list
 Demo : ListModelExample.java

List Component
 Cell Rendering
 ListExample.java. BookCellRenderer.java

Table Component
 JTable class : demo SimpleTable.java
 The classes and interfaces involved are
 TableColumn, TableColumnModel
 TableModel
 TableCellEditor
 TableCellRenderer

Table Columns
 The basic unit in swing table is a column and not a
cell
 Classes involved : TableColumn , TableColumnModel
 TableColumn : It’s a starting point for building
columns in the table
 Properties : cellEditor, cellRenderer,HeaderRenderer
 TableColumnModel manages the column selections
and column spacing
 Demo of TableColumnModel : ColumnExample.java,SortinColumnModel.java

Table Data
 The actual data that’s displayed in JTable is stored in a
TableModel
 TableModel interface : has access to all cell values in a
table
 columnCount, rowCount
 Cell methods
 Object getValueAt(int, int)
 boolean isCellEditable(int,int)
 void setValueAt(Object,int,int)

Table Data
 SubClasses : AbstractTableModel, DefaultTableModel

Editing and
Rendering
 Possible to build customized editors and renderers for
the cell
 Default are:
 Boolean - JCheckBox
 Number - right aligned JTextField
 Object - JTextField
 ImageIcon

Rendering
(contd..)
 TableCellRenderer
 Componet getTableCellRendererComponent(..)
 Demo : FileTable2.java, FileModel.java, BigRenderer.java
 TableCellEditor
 Componet getTableCellEditorComponent(..)
 Selecting Table Entries
 Uses ListSelectionModel
 Row and Column selection models are different objects

Tree Terminology
 Path : A list of nodes leading from one node
to another
 Collapsed : Invisible children
 Expanded : Visible children

Tree Models
 Two interfaces are particularly important
 TreeModel : describes how to work with tree data
 TreeSelectionModel : describes how to select the modes
 DefaultTreeModel class puts together a basic tree
model using TreeNode objects
 Each node’s data is really just an Object reference,
pointing to just about any object

Tree Models
(contd.)
 MutableTreeNode defines the requirements for a tree
node object that can change -- by adding or removing
child nodes, or by changing the contents of a user
object stored in the node
 DefaultMutableTreeNode
 Mutation Methods: insert, remove etc
 Structure Methods : provides methods to modify and
querying the structure
 Enumeration Methods

Tree Selections
 Selections are based on rows and paths
 Path contains the list of nodes from the root of the
tree to another node
 Rows are completely dependent on the visual display
of the tree
 Depending on the application the row or path
selection can be used

Demo : Tree Demo
TreeDemo.java

Java Database
Connectivity

Java Database Connectivity
 JavaSoft worked with D/B tool vendors to provide
DBMS independent mechanism to write client side
applications
 The result is JDBC API
 JDBC API is designed to allow developers to create
database front ends without having to continually
rewrite the code
 An API that is D/B independent and uniform across
databases

Java Database
Connectivity
 A standard to write which takes all app. designs into
account
 This is possible through a set of interface that are
implemented by the driver
 Driver is responsible for converting a standard JDBC
call to a native call

What is JDBC
 Java Database Connectivity (JDBC) is a standard SQL
database access interface, providing uniform access to
a wide range of relational databases
 JDBC provides a common base on which higher level

tools and interfaces can be built

What does JDBC Do ?
JDBC makes it possible to do three things:
1) Establish a connection with a database

2) Send SQL statements
3) Process the results

Why JDBC ?
 Java is a write once, run anywhere language
 Java based clients are thin client
 Suited for network centric models
 It provide a clean , simple, uniform vendor
independent interface
 JDBC support all the advance features of latest version
ANSI SQL
 JDBC API provides a rich set of methods

Database
Connectivity
 JDBC
 ODBC

ODBC Architecture
Application Application Application
ODBC API
ODBC Driver Manager
Oracle SQL Server DB 2 Service

Driver Driver Driver Provider
SQL * Net Net Lib ESQL/DRDA API
Oracle SQL
DB 2
Database Server

JDBC Architecture
Application Application JDBC API
Application
JDBC Driver Manager
Oracle SQL Server JDBC -ODBC

Driver Service
Driver Driver
Provider
SQL * Net Net Lib
API
ODBC Driver
Oracle
SQL Server
Database Sybase

use ODBC from
Java?
 ODBC relies on the multiple use of void * pointers and
other C features that are not natural in java
 ODBC driver manager and drivers must be manually
installed on every client machine. JDBC code is
automatically installable, portable, and secure
 ODBC is procedure oriented, while JDBC is object
oriented

Two-tier and Three-tier
Models
JDBC API supports both two-tier and three-tier models for database
access
JAVA Application Client Java Applet or

GUI HTML browser
JDBC
HTTP,RMI,CORBA
Application
Propriety server (JAVA) Business
protocol logic
Database JDBC
server
Propriety protocal
DBMS
Two-tier JDBC Three-tier JDBC

JDBC API - java.sql
Driver
Connection ResultSet
Interfaces
in java.sql
DatabaseMetaData ResultSetMetaData
Statement PreparedStatement CallableStatement

JDBC components
Driver Manager
Driver
Connection
PreparedStatement Statement CalllableStatement
ResultSet ResultSet ResultSet

Database access
from Java
 Steps Involved
 Loading the Driver
 Establishing the connection
 Passing Sql Query

Loading Drivers
Class.forName()throws ClassNotFoundException
- sun.jdbc.odbc.JdbcOdbcDriver
- jdbc.driver.oracle.OracleDriver
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}catch(ClassNotFoundException e) {
System.out.println(“Exception : “ + e);}

Types of Driver
 Type I : Jdbc-Odbc Bridge Driver
 Type II : Partly Java, partly native code
implementing Vendor specific API
 Type III : Pure Java driver requesting either to
type I or II as another layer
 Type IV : Pure Java requesting directly to the
database

Establishing Connection
 A JDBC URL has the following syntax
String url= jdbc:<subprotocol>:<subname>
// for odbc
String url= “jdbc:odbc:employee” ;
// for jdbc
String url= “jdbc:oracle:thin:@tech:1521:ORCL” ;
Connection con = DriverManager.getConnection
(“url,"myLogin", "myPassword")

Retrieving Data from Table
 ResultSet executeQuery( String sql) throws
SQLException
 ResultSet rs = stmt.executeQuery("SELECT name, age
FROM student");
 Retrieving data from Resultset
 boolean next( ) throws SQLException
 void Close ( ) throws SQLException
 XXX getXXX( int index ) throws SQLException

Retrieving data
from ResultSet
 String query = " SELECT name, age FROM student ";
 ResultSet rs = stmt.executeQuery(query);
 while (rs.next()) {
 String s = rs.getString("name");
 BigDecimal n = rs.getBigDecimal("age");
 System.out.println(s + " " + n);
 }
 The output will look something like this:

 Smith 20
 Rahul 19

RowSets
 A RowSet object contains a set of rows from a result set
or some other source of tabular data, like a file or
spreadsheet. Because a RowSet object follows the
JavaBeans model for properties and event notification,
it is a JavaBeans component that can be combined with
other components in an application

Types of RowSets
 JdbcRowSet: A connected scrollable ,updatable
RowSet
 CachedRowset:A disconnected RowSet
 WebRowSet:A connected RowSet that uses the HTTP
protocol internally to talk to a Java Servlet that
provides data access

Inserting Data into Tables
executeUpdate( ) throws SQLException
Statement stmt = con.createStatement();
stmt.executeUpdate("INSERT INTO student " + "VALUES (1,
'Smith', ' Bombay' , 20, 7646234 ) )";
stmt.executeUpdate("INSERT INTO st_ course " +
"VALUES (1, 1, 01-01-1999, 'Very Good' )");

Updating Tables
executeUpdate()
Statement stmt = con.createStatement();
stmt.executeUpdate( "UPDATE course”+ “SET fees =
fees+2000.00" );

Using PreparedStatement
PreparedStatement prep = con.prepareStatement(
"UPDATE"+
" course values set fees = ? WHERE c-id = ?");
prep.setInt(1, 2);
prep.setBigDecimal(2, 8000.00);
prep.executeUpdate ( );
prep.setInt(1, 4);
prep.setBigDecimal(2, 9000.00);prep.executeUpdate ( );

Connection
Pooling
 DataSource:The JDBC 2.0 extension API introduced
the concept of data sources, which are standard,
general-use objects for specifying databases or other
resources to use

What is a
DataSource?
 A DataSource object is the representation of a data
source in the Java programming language. In basic
terms, a data source is a facility for storing data. It can
be as sophisticated as a complex database for a large
corporation or as simple as a file with rows and
columns. A data source can reside on a remote server,
or it can be on a local desktop machine

What is a
DataSource?
 Applications access a data source using a connection,
and a DataSource object can be thought of as a factory for
connections to the particular data source that the
DataSource instance represents

DriverManager
and DataSource
 While directly creating a connection by calling
DriverManager.getConnection(..) , you are creating a
connection by yourself and when closing close() on
it, the link to database is lost. On the other hand we
get a connection from a datasource, when you call the
close() on it, it will not close the link to database, but
will return to a connection pool where it can be
reused by some other classes

DataSource(Cont
d.)
 It is always better to use a connection pool because
creating connections are expensive. DataSource has
its usability in the distributed computing
environment,as it can be used with JNDI lookups
 Another major advantage is that the DataSource
facility allows developers to implement a
DataSource class to take advantage of features like
connection pooling and distributed transactions

Using Callable Statement
String sql=“execute getEmployes ? ”;
CallableStatement call=con.prepareCall(sql);
call.registerOutParameter(1,Types.INTEGER);
call.execute();
int val=call.getInt(1);
System.out.println(“There are ” +val + “ employees”);

Using Transactions
con.setAutoCommit(boolean commit)
con.commit()
con.rollback()
try {
con.setAutoCommit(false);
// perform transactions
con.commit()
con.setAutoCommit(true);
} catch (SQLException e) {
con .rollback() ;}
Collections Framework
in Java

What is Collections
Framework?
 A Collection is a group of objects
 Collections framework provide a a set of standard
utility classes to manage collections
 Collections Framework consists of three parts:
 Core Interfaces
 Concrete Implementation
 Algorithms such as searching and sorting

Collections
Hierarchy

Collection – Basic
Operations
 int size();
 boolean isEmpty();
 boolean contains(Object element);
 boolean add(Object element);
 boolean remove(Object element);
 Iterator iterator();

Collection – Bulk
Operations
 boolean containsAll(Collection c);
 boolean addAll(Collection c);
 boolean removeAll(Collection c);
 boolean retainAll(Collection c);
 void clear();

Collection –Array
Operations
 Object[] toArray();
 Object[] toArray(Object a[]);

Collection Interfaces
Interfaces Description
Collection Defines the operations that all classes that maintain
collections typically implement
Set Maintains a set of unique elements.
SortedSet Maintains the elements in sorted order.
List An ordered collection (i.e. sequence). Duplicates

and multiple null values allowed.
Map For classes implementing key-value pair kind pf
mappings. Can not contain duplicate keys.
SortedMap Map is in the sorted key order.

Concrete
Implementations
Interfaces
Data Set SortedSet List Map SortedMap
Structures
Hashtable Hash Hash
Set Map
Resizable Array
Array List
Balanced TreeSet TreeMap
Tree
Linked List Linked
List

The Classes
 Legacy classes
 Vector
 HashTable
 Stack

Thank you

Introduction To Java

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Introduction To Java

Transféré par

Droits d'auteur :

Formats disponibles

Introduction to Java

© Copyrights aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

 Distributed : full support for TCP/IP protocol,

 Robust : Strongly typed language

© Copyright aurionPro Solutions Ltd.

 Interpreted and Compiled

 Multithreaded : Concurrent running tasks

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

 New Security certificates added

© Copyright aurionPro Solutions Ltd.

 Scalability and Performance

 Monitoring and Manageability

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

 Java SE - Java SE Development Kit (JDK)

© Copyright aurionPro Solutions Ltd.

//this is my first program

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyrights aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

byte 8-bit Byte-length integer

double 64-bit IEE 754 Double precision floating point

char 16-bit A single character

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyrights aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyrights aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.

© Copyright aurionPro Solutions Ltd.