Java Powerful Fundamental

1
CONTEXT
No. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. Subject Introduction to Java Getting Started with Java Basic Language Elements Java Operators Java Control Statements Java Access Modifiers Classes and Objects Java Constructors Object Serialization Java Class Inheritance Java Object Casting Abstract class and Interface Java Method Overriding Java String Class Java toString() Method Java String Comparison Java StringBuffer Java Exception Handling Java Singleton Design Pattern Java Threads Tutorial Java Collections Framework Java Date Util Java Swing Tutorial Java JDBC Tutorial Page No. 7 10 14 19 28 38 43 48 54 61 64 71 79 82 90 92 94 97 108 111 129 150 155 239
Created By: Jignesh S. Prajapati
Javabeginner Tutorial
Table of Contents
Introduction to Java
About Java Platform Independence Java Virtual Machine Object Oriented Programming Java Features Java Applications
Getting Started with Java

Java Architecture Compiling and Running an Application Java Development Kit javadoc JAR Files PATH and CLASSPATH Introduction to Java 1.5
Basic Language Elements

Keywords Comments Variable, Identifiers and Data Types Classes Objects Interface Instance Members Static Members Arrays
Java Operators
Java Operators Assignment operators Arithmetic operators Relational operators
3
Logical operators Bitwise operators Compound operators Conditional operators Operator Precedence
Java Control Statements

Introduction to Control Statements Selection Statements Iteration Statements Transfer Statements
Java Access Modifiers

Introduction to Java Access Modifiers public access modifier private access modifier protected access modifier default access modifier
Classes and Objects

Class Variables Static Fields Class Methods Static Methods Instance Variables Final Variable, Methods and Classes Introduction to Java Objects Method Overloading
Java Constructors
Overloaded Constructors Constructor Chaining
Object Serialization
Introduction to Object Serialization Transient Fields and Serialization Input and Output Object Streams
Java Class Inheritance

Java Class Inheritance
4
this and super keywords
Java Object Casting

Object Reference Type Casting instanceof Operator
Abstract class and Interface

Abstract Class in java Java Interface Polymorphism
Java Method Overriding Java String Class

String Class Creation of Strings String Equality String Functions
Java toString() Method

Java toString() Method
Java String Comparison

Compare String objects to determine Equality
Java StringBuffer
StringBuffer Class Creation of StringBuffer's StringBuffer Functions
Java Exception Handling

Exceptions in Java Exception Classes Exception Statement Syntax Rules for try, catch and finally Blocks try, catch and finally Defining new Exceptions
5
throw, throws statement Handling Multiple Exceptions
Java Singleton Design Pattern

Singleton Implementing the Singleton Pattern
Java Threads Tutorial

Introduction to Threads Thread Creation Thread Synchronization Synchronized Methods Synchronized Blocks Thread States Thread Priority Thread Scheduler Yielding Sleeping and Waking Up Waiting and Notifying Joining Deadlock
Java Collections Framework

Core Collection Interfaces Concrete Classes Standard utility methods and algorithms How are Collections Used Java ArrayList Java LinkedList Java TreeSet Java HashMap Java Vector Java HashTable Java HashSet
Java Date Util

Java Date API Java Date Source Code
Java Swing Tutorial

Intoduction to Java Swing JFrame JInternalFrame JWindow JOptionPane JLabel JTextField JPasswordField JTextArea JButton JRadioButton JCheckBox JComboBox JList JTabbedPane JMenuBar Scrollable JPopupMenu JToolBar BorderLayout FlowLayout GridLayout GridBagLayout Java Look and Feel Swing Calculator Swing Address Book
Introduction to Java Programming

Introduction to Computer Science using Java
Java is a simple and yet powerful object oriented programming language and it is in many respects similar to C++. Java originated at Sun Microsystems, Inc. in 1991. It was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc. It was developed to provide a platform-independent programming language. This site gives you an Introduction to Java Programming accompanied with many java examples. Its a complete course in java programming for beginners to advanced java.
Platform independent
Unlike many other programming languages including C and C++ when Java is compiled, it is not compiled into platform specific machine, rather into platform independent byte code. This byte code is distributed over the web and interpreted by virtual Machine (JVM) on whichever platform it is being run.
Java Virtual Machine

What is the Java Virtual Machine? What is its role? Java was designed with a concept of write once and run everywhere. Java Virtual Machine plays the central role in this concept. The JVM is the environment in which Java programs execute. It is a software that is implemented on top of real hardware and operating system. When the source code (.java files) is compiled, it is translated into byte codes and then placed into (.class) files. The JVM executes these bytecodes. So Java byte codes can be thought of as the machine language of the JVM. A JVM can either interpret the bytecode one instruction at a time or the bytecode can be compiled further for the real microprocessor using what is called ajust-in-time compiler. The JVM must be implemented on a particular platform before compiled programs can run on that platform.
Object Oriented Programming

Since Java is an object oriented programming language it has following features: Reusability of Code Emphasis on data rather than procedure Data is hidden and cannot be accessed by external functions Objects can communicate with each other through functions
8
New data and functions can be easily addedJava has powerful features. The following are some of them:Simple Reusable Portable (Platform Independent) Distributed Robust Secure High Performance Dynamic Threaded Interpreted Object Oriented Programming is a method of implementation in which programs are organized as cooperative collection of objects, each of which represents an instance of a class, and whose classes are all members of a hierarchy of classes united via inheritance relationships. OOP Concepts Four principles of Object Oriented Programming are Abstraction Encapsulation Inheritance Polymorphism Abstraction Abstraction denotes the essential characteristics of an object that distinguish it from all other kinds of objects and thus provide crisply defined conceptual boundaries, relative to the perspective of the viewer. Encapsulation Encapsulation is the process of compartmentalizing the elements of an abstraction that constitute its structure and behavior ; encapsulation serves to separate the contractual interface of an abstraction and its implementation. Encapsulation * Hides the implementation details of a class. * Forces the user to use an interface to access data * Makes the code more maintainable.
9
Inheritance Inheritance is the process by which one object acquires the properties of another object. Polymorphism Polymorphism is the existence of the classes or methods in different forms or single name denoting different implementations.
Java is Distributed
With extensive set of routines to handle TCP/IP protocols like HTTP and FTP java can open and access the objects across net via URLs.
Java is Multithreaded
One of the powerful aspects of the Java language is that it allows multiple threads of execution to run concurrently within the same program A single Java program can have many different threads executing independently and continuously. Multiple Java applets can run on the browser at the same time sharing the CPU time.
Java is Secure
Java was designed to allow secure execution of code across network. To make Java secure many of the features of C and C++ were eliminated. Java does not use Pointers. Java programs cannot access arbitrary addresses in memory.
Garbage collection
Automatic garbage collection is another great feature of Java with which it prevents inadvertent corruption of memory. Similar to C++, Java has a new operator to allocate memory on the heap for a new object. But it does not use delete operator to free the memory as it is done in C++ to free the memory if the object is no longer needed. It is done automatically with garbage collector.
Java Applications
Java has evolved from a simple language providing interactive dynamic content for web pages to a predominant enterprise-enabled programming language suitable for developing significant and critical applications. Today, It is used for many types of applications including Web based applications, Financial applications, Gaming applications, embedded systems, Distributed enterprise applications, mobile applications, Image processors, desktop applications and many more. This site outlines the building blocks of java by stating few java examples along with some java tutorials.
10
Getting Started with Java
Getting Java Basics quickly has become easy with Javabeginner.com. This site is for the java programmers who want to use the Java programming language to create applications using the Java basics. This site is for absolute beginners to advanced java programmers who do not require any prerequisite Java knowledge. For getting started with Java youll have to have some basic understanding of the concepts of programming. After going through all the tutorials in this site, you would have learnt the essential concepts and features of the Java Programming Language which include exceptions, Swing GUI programming, Collections framework etc. A lot of code examples are used through out tutorial to make you understand the language better. All the listings and programs in the website are compiled and run using the JDK 1.5. Download : JDK and JRE 1.5
Java Architecture
The Java environment is composed of a number of system components. You use these components at compile time to create the Java program and at run time to execute the program. Java achieves its independence by creating programs designed to run on the Java Virtual Machine rather than any specific computer system. After you write a Java program, you use a compiler that reads the statements in the program and translates them into a machine independent format called bytecode. Bytecode files, which are very compact, are easily transported through a distributed system like the Internet. The compiled Java code (resulting byte code) will be executed at run time.
Java programs can be written and executed in two ways:

Stand-alone application (A Java Swing Application) Applet which runs on a web browser (Example: Internet Explorer)
Java source code

A Java program is a collection of one or more java classes. A Java source file can contain more than one class definition and has a .java extension. Each class definition in a source file is compiled into a separate class file. The name of this compiled file is comprised of the name of the class with .class as an extension. Before we proceed
11
further in this section, I would recommend you to go through the Basic Language Elements. Below is a java sample code for the traditional Hello World program. Basically, the idea behind this Hello World program is to learn how to create a program, compile and run it. To create your java source code you can use any editor( Text pad/Edit plus are my favorites) or you can use an IDE like Eclipse. public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); }//End of main }//End of HelloWorld Class
Output Hello World ABOUT THE PROGRAM I created a class named HelloWorld containing a simple main function within it. The keyword class specifies that we are defining a class. The name of a public class is spelled exactly as the name of the file (Case Sensitive). All java programs begin execution with the method named main(). main method that gets executed has the following signature : public static void main(String args[]).Declaring this method as public means that it is accessible from outside the class so that the JVM can find it when it looks for the program to start it. It is necessary that the method is declared with return type void (i.e. no arguments are returned from the method). The main method contains a String argument array that can contain the command line arguments. The brackets { and } mark the beginning and ending of the class. The program contains a line System.out.println(Hello World); that tells the computer to print out on one line of text namely Hello World. The semi-colon ; ends the line of code. The double slashes // are used for comments that can be used to describe what a source code is doing. Everything to the right of the slashes on the same line does not get compiled, as they are simply the comments in a program. Java Main method Declarations class MainExample1 {public static void main(String[] args) {}} class MainExample2 {public static void main(String []args) {}} class MainExample3 {public static void main(String args[]) {}} All the 3 valid main methods shown above accepts a single String array argument.
12
Compiling and Running an Application

To compile and run the program you need the JDK distributed by Sun Microsystems. The JDK contains documentation, examples, installation instructions, class libraries and packages, and tools. Download an editor like Textpad/EditPlus to type your code. You must save your source code with a .java extension. The name of the file must be the name of the public class contained in the file. Steps for Saving, compiling and Running a Java Step Step Step Step 1:Save the program With .java Extension. 2:Compile the file from DOS prompt by typing javac <filename>. 3:Successful Compilation, results in creation of .class containing byte code 4:Execute the file by typing java <filename without extension>
Java Development Kit

The Java Developers Kit is distributed by Sun Microsystems. The JDK contains documentation, examples, installation instructions, class libraries and packages, and tools
javadoc
The javadoc tool provided by Sun is used to produce documentation for an application or program,
Jar Files
A jar file is used to group together related class files into a single file for more compact storage, distribution, and transmission.
PATH and CLASSPATH

The following are the general programming errors, which I think every beginning java programmer would come across. Here is a solution on how to solve the problems when running on a Microsoft Windows Machine. 1. javac is not recognized as an internal or external command, operable program or batch file When you get this error, you should conclude that your operating system cannot find the compiler (javac). To solve this error you need to set the PATH variable. How to set the PATH Variable?
13
Firstly the PATH variable is set so that we can compile and execute programs from any directory without having to type the full path of the command. To set the PATH of jdk on your system (Windows XP), add the full path of the jdk<version>\bin directory to the PATH variable. Set the PATH as follows on a Windows machine: a. Click Start > Right Click My Computer and click on Properties b. Click Advanced > Environment Variables. c. Add the location of bin folder of JDK installation for PATH in User Variables and System Variables. A typical value for PATH is: C:\jdk<version>\bin (jdk<version is nothing but the name of the directory where jdk is installed) If there are already some entries in the PATH variable then you must add a semicolon and then add the above value (Version being replaced with the version of JDK). The new path takes effect in each new command prompt window you open after setting the PATH variable. 2. Exception in thread main java.lang.NoClassDefFoundError: HelloWorld If you receive this error, java cannot find your compiled byte code file, HelloWorld.class.If both your class files and source code are in the same working directory and if you try running your program from the current working directory than, your program must get executed without any problems as, java tries to find your .class file is your current directory. If your class files are present in some other directory other than that of the java files we must set the CLASSPATH pointing to the directory that contain your compiled class files.CLASSPATH can be set as follows on a Windows machine: a. Click Start > Right Click My Computer and click on Properties b. Click Advanced > Environment Variables. Add the location of classes folder containing all your java classes in User Variables. If there are already some entries in the CLASSPATH variable then you must add a semicolon and then add the new value . The new class path takes effect in each new command prompt window you open after setting the CLASSPATH variable.
Java 1.5
The Java 1.5 released in September 2004. Goals Less code complexity Better readability
14
More compile-time type safety Some new functionality (generics, scanner) New Features Enhanced for loop Enumerated types Autoboxing & unboxing Generic types Scanner Variable number of arguments (varargs) Static imports Annotations
Basic Language Elements
(Identifiers, keywords, literals, white spaces and comments) This part of the java tutorial teaches you the basic language elements and syntax for the java programming language. Once you get these basic language concepts you can continue with the other object oriented programming language concepts.
Keywords
There are certain words with a specific meaning in java which tell (help) the compiler what the program is supposed to do. These Keywords cannot be used as variable names, class names, or method names. Keywords in java are case sensitive, all characters being lower case. Keywords are reserved words that are predefined in the language; see the table below (Taken from Sun Java Site). All the keywords are in lowercase.
abstract boolean break byte case catch char class
default do double else extends final finally float
if implements import instanceof int interface long native
private protected public return short static strictfp super
this throw throws transient try void volatile while
15
const continue for goto new package switch synchronized
Keywords are marked in yellow as shown in the sample code below /** This class is a Hello World Program used to introduce the Java Language*/ public class HelloWorld { public static void main(String[] args) { System.out.println(Hello World); //Prints output to console } } For more information on different Keywords - Java Keywords Some Tricky Observations: The words virtual, ifdef, typedef, friend, struct and union are all words related to the C programming language. const and goto are Java keywords. The word finalize is the name of a method of the Object class and hence not a keyword. enum and label are not keywords.
Comments
Comments are descriptions that are added to a program to make code easier to understand. The compiler ignores comments and hence its only for documentation of the program. Java supports three comment styles. Block style comments begin with /* and terminate with */ that spans multiple lines. Line style comments begin with // and terminate at the end of the line. (Shown in the above program) Documentation style comments begin with /** and terminate with */ that spans multiple lines. They are generally created using the automatic documentation generation tool, such as javadoc. (Shown in the above program) name of this compiled file is comprised of the name of the class with .class as an extension.
Variable, Identifiers and Data Types

16
Variables are used for data that change during program execution. All variables have a name, a type, and a scope. The programmer assigns the names to variables, known as identifiers. An Identifier must be unique within a scope of the Java program. Variables have a data type, that indicates the kind of value they can store. Variables declared inside of a block or method are called local variables; They are not automatically initialized. The compiler will generate an error as a result of the attempt to access the local variables before a value has been assigned.
public class localVariableEx { public static int a; public static void main(String[] args) { int b; System.out.println("a : "+a); System.out.println("b : "+b); //Compilation error }}
Note in the above example, a compilation error results in where the variable is tried to be accessed and not at the place where its declared without any value. The data type indicates the attributes of the variable, such as the range of values that can be stored and the operators that can be used to manipulate the variable. Java has four main primitive data types built into the language. You can also create your own composite data types. Java has four main primitive data types built into the language. We can also create our own data types. Integer: byte, short, int, and long. Floating Point: float and double Character: char Boolean: variable with a value of true or false. The following chart (Taken from Sun Java Site) summarizes the default values for the java built in data types. Since I thought Mentioning the size was not important as part of learning Java, I have not mentioned it in the below table. The size for each Java type can be obtained by a simple Google search.
Data Type byte short int
Default Value (for fields) 0 0 0
Range -127 to +128 -32768 to +32767
17
long float double char String (object) boolean 0L 0.0f 0.0d \u0000 null false 0 to 65535
When we declare a variable we assign it an identifier and a data type. For Example String message = hello world In the above statement, String is the data type for the identifier message. If you dont specify a value when the variable is declared, it will be assigned the default value for its data type. Identifier Naming Rules Can consist of upper and lower case letters, digits, dollar sign ($) and the underscore ( _ ) character. Must begin with a letter, dollar sign, or an underscore Are case sensitive Keywords cannot be used as identifiers Within a given section of your program or scope, each user defined item must have a unique identifier Can be of any length.
Classes
A class is nothing but a blueprint for creating different objects which defines its properties and behaviors. An object exhibits the properties and behaviors defined by its class. A class can contain fields and methods to describe the behavior of an object. Methods are nothing but members of a class that provide a service for an object or perform some business logic.
Objects
An object is an instance of a class created using a new operator. The new operator returns a reference to a new instance of a class. This reference can be assigned to a reference variable of the class. The process of creating objects from a class is called
18
instantiation. An object reference provides a handle to an object that is created and stored in memory. In Java, objects can only be manipulated via references, which can be stored in variables.
Interface
An Interface is a contract in the form of collection of method and constant declarations. When a class implements an interface, it promises to implement all of the methods declared in that interface.
Instance Members
Each object created will have its own copies of the fields defined in its class called instance variables which represent an objects state. The methods of an object define its behaviour called instance methods. Instance variables and instance methods, which belong to objects, are collectively called instance members. The dot . notation with a object reference is used to access Instance Members.
Static Members
Static members are those that belong to a class as a whole and not to a particular instance (object). A static variable is initialized when the class is loaded. Similarly, a class can have static methods. Static variables and static methods are collectively known as static members, and are declared with a keyword static. Static members in the class can be accessed either by using the class name or by using the object reference, but instance members can only be accessed via object references. Below is a program showing the various parts of the basic language syntax that were discussed above.
/** Comment * Displays "Hello World!" to the standard output. */ public class HelloWorld { String output = ""; static HelloWorld helloObj;
//Line 1
public HelloWorld(){ output = "Hello World"; } public String printMessage(){ return output; }
19
public static void main (String args[]) { helloObj = new HelloWorld(); //Line 2 System.out.println(helloObj.printMessage()); } }
Class Name: HelloWorld Object Reference: helloObj (in Line 1) Object Created: helloObj (In Line 2) Member Function: printMessage Field: output (String) Static Member: helloObj Instance Member : output (String)
Java Operators Tutorial
Java Operators
They are used to manipulate primitive data types. Java operators can be classified as unary, binary, or ternarymeaning taking one, two, or three arguments, respectively. A unary operator may appear before (prefix) its argument or after (postfix) its argument. A binary or ternary operator appears between its arguments. Operators in java fall into 8 different categories: Java operators fall into eight different categories: assignment, arithmetic, relational, logical, bitwise, compound assignment, conditional, and type.
Assignment Operators Arithmetic Operators

++ != --
= > + < * >= / <= % ==
Relational Operators
20
Logical Operators
^ && || & | !
Bit wise Operator

>>>
&
>>
Compound Assignment Operators

/= >>= %= >>>= ?:
+=
-= <<=
*=
Conditional Operator
Java has eight different operator types: assignment, arithmetic, relational, logical, bitwise, compound assignment, conditional, and type.
Assignment operators
The java assignment operator statement has the following syntax:
<variable> = <expression>
If the value already exists in the variable it is overwritten by the assignment operator (=). public class AssignmentOperatorsDemo { public AssignmentOperatorsDemo() { // Assigning Primitive Values int j, k; j = 10; // j gets the value 10. j = 5; // j gets the value 5. Previous value is overwritten. k = j; // k gets the value 5. System.out.println("j is : " + j); System.out.println("k is : " + k); // Assigning References Integer i1 = new Integer("1"); Integer i2 = new Integer("2"); System.out.println("i1 is : " + i1); System.out.println("i2 is : " + i2); i1 = i2; System.out.println("i1 is : " + i1); System.out.println("i2 is : " + i2); // Multiple Assignments k = j = 10; // (k = (j = 10)) System.out.println("j is : " + j); System.out.println("k is : " + k); } public static void main(String args[]) { new AssignmentOperatorsDemo(); } }
Download AssignmentOperatorsDemoSource code
21
Arithmetic operators
Java provides eight Arithmetic operators. They are for addition, subtraction, multiplication, division, modulo (or remainder), increment (or add 1), decrement (or subtract 1), and negation. An example program is shown below that demonstrates the different arithmetic operators in java. The binary operator + is overloaded in the sense that the operation performed is determined by the type of the operands. When one of the operands is a String object, the other operand is implicitly converted to its string representation and string concatenation is performed.
String message = 100 + Messages; //100 Messages
public class ArithmeticOperatorsDemo { public ArithmeticOperatorsDemo() { int x, y = 10, z = 5; x = y + z; System.out.println("+ operator resulted in " + x); x = y - z; System.out.println("- operator resulted in " + x); x = y * z; System.out.println("* operator resulted in " + x); x = y / z; System.out.println("/ operator resulted in " + x); x = y % z; System.out.println("% operator resulted in " + x); x = y++; System.out.println("Postfix ++ operator resulted in " + x); x = ++z; System.out.println("Prefix ++ operator resulted in " + x); x = -y; System.out.println("Unary operator resulted in " + x); // Some examples of special Cases int tooBig = Integer.MAX_VALUE + 1; // -2147483648 which is // Integer.MIN_VALUE. int tooSmall = Integer.MIN_VALUE - 1; // 2147483647 which is // Integer.MAX_VALUE. System.out.println("tooBig becomes " + tooBig); System.out.println("tooSmall becomes " + tooSmall); System.out.println(4.0 / 0.0); // Prints: Infinity System.out.println(-4.0 / 0.0); // Prints: -Infinity System.out.println(0.0 / 0.0); // Prints: NaN double d1 = 12 / 8; // result: 1 by integer division. d1 gets the value // 1.0. double d2 = 12.0F / 8; // result: 1.5 System.out.println("d1 is " + d1); System.out.println("d2 iss " + d2); } public static void main(String args[]) { new ArithmeticOperatorsDemo(); } }
Download ArithmeticOperatorsDemo Source code
22
Relational operators
Relational operators in Java are used to compare 2 or more objects. Java provides six relational operators: greater than (>), less than (<), greater than or equal (>=), less than or equal (<=), equal (==), and not equal (!=). All relational operators are binary operators, and their operands are numeric expressions. Binary numeric promotion is applied to the operands of these operators. The evaluation results in a boolean value. Relational operators have precedence lower than arithmetic operators, but higher than that of the assignment operators. An example program is shown below that demonstrates the different relational operators in java.
public class RelationalOperatorsDemo { public RelationalOperatorsDemo( ) { int x = 10, y = 5; System.out.println("x > y : "+(x > y)); System.out.println("x < y : "+(x < y)); System.out.println("x >= y : "+(x >= y)); System.out.println("x <= y : "+(x <= y)); System.out.println("x == y : "+(x == y)); System.out.println("x != y : "+(x != y)); } public static void main(String args[]){ new RelationalOperatorsDemo(); } }
Download RelationalOperatorsDemo Source code
Logical operators
Logical operators return a true or false value based on the state of the Variables. There are six logical, or boolean, operators. They are AND, conditional AND, OR, conditional OR, exclusive OR, and NOT. Each argument to a logical operator must be a boolean data type, and the result is always a boolean data type. An example program is shown below that demonstrates the different Logical operators in java. public class LogicalOperatorsDemo {
23
public LogicalOperatorsDemo() { boolean x = true; boolean y = false; System.out.println("x & y : " + (x & y)); System.out.println("x && y : " + (x && y)); System.out.println("x | y : " + (x | y)); System.out.println("x || y: " + (x || y)); System.out.println("x ^ y : " + (x ^ y)); System.out.println("!x : " + (!x)); } public static void main(String args[]) { new LogicalOperatorsDemo(); } }
Download LogicalOperatorsDemo Source code
Given that x and y represent boolean expressions, the boolean logical operators are defined in the Table below. x y !x x & y x && y x | y x || y x ^ y
true
true
false
true
true
false
true
false
false
false
true
true
false
true
true
false
true
true
false
false
true
false
false
false
Bitwise operators
Java provides Bit wise operators to manipulate the contents of variables at the bit level. These variables must be of numeric data type ( char, short, int, or long). Java provides seven bitwise operators. They are AND, OR, Exclusive-OR, Complement, Left-shift, Signed Right-shift, and Unsigned Right-shift. An example program is shown below that demonstrates the different Bit wise operators in java.
24
public class BitwiseOperatorsDemo { public BitwiseOperatorsDemo() { int x = 0xFAEF; //1 1 1 1 1 0 1 0 1 1 1 0 1 1 1 1 int y = 0xF8E9; //1 1 1 1 1 0 0 0 1 1 1 0 1 0 0 1 int z; System.out.println("x & y : " + (x & y)); System.out.println("x | y : " + (x | y)); System.out.println("x ^ y : " + (x ^ y)); System.out.println("~x : " + (~x)); System.out.println("x << y : " + (x << y)); System.out.println("x >> y : " + (x >> y)); System.out.println("x >>> y : " + (x >>> y)); //There is no unsigned left shift operator } public static void main(String args[]) { new BitwiseOperatorsDemo(); } }
Download BitwiseOperatorsDemo Source code
The result of applying bitwise operators between two corresponding bits in the operands is shown in the Table below. A B ~A A & B A | B A ^ B
Output 3,0,3 /* * The below program demonstrates bitwise operators keeping in mind operator precedence * Operator Precedence starting with the highest is -> |, ^, & */ public class BitwisePrecedenceEx {
25
public static void main(String[] args) { int a = 1 | 2 ^ 3 & 5; int b = ((1 | 2) ^ 3) & 5; int c = 1 | (2 ^ (3 & 5)); System.out.print(a + "," + b + "," + c); } }
Downloadad BitwiseOperatorsDemo2 Source code
Compound operators
The compound operators perform shortcuts in common programming operations. Java has eleven compound assignment operators. Syntax: argument1 operator = argument2. The above statement is the same as, argument1 = argument1 operator argument2. An example program is shown below that demonstrates the different Compound operators in java. public class CompoundOperatorsDemo { public CompoundOperatorsDemo() { int x = 0, y = 5; x += 3; System.out.println("x : " + x); y *= x; System.out.println("y : " + y); /*Similarly other operators can be applied as shortcuts. Other compound assignment operators include boolean logical , bitwiseand shift operators*/ } public static void main(String args[]) { new CompoundOperatorsDemo(); } }
Download CompoundOperatorsDemo Source code
Conditional operators
The Conditional operator is the only ternary (operator takes three arguments) operator in Java. The operator evaluates the first argument and, if true, evaluates the second argument. If the first argument evaluates to false, then the third argument is evaluated. The conditional operator is the expression equivalent of the if-else statement. The conditional expression can be nested and the conditional operator associates from right to left:(a?b?c?d:e:f:g) evaluates as (a?(b?(c?d:e):f):g)
26
An example program is shown below that demonstrates the Ternary operator in java. public class TernaryOperatorsDemo { public TernaryOperatorsDemo() { int x = 10, y = 12, z = 0; z = x > y ? x : y; System.out.println("z : " + z); } public static void main(String args[]) { new TernaryOperatorsDemo(); } }
Download TernaryOperatorsDemo Source code
/* * The following programs shows that when no explicit parenthesis is used then the conditional operator * evaluation is from right to left */ public class BooleanEx1 { static String m1(boolean b) { return b ? "T" : "F"; } public static void main(String[] args) { boolean t1 = false ? false : true ? false : true ? false : true; boolean t2 = false ? false : (true ? false : (true ? false : true)); boolean t3 = ((false ? false : true) ? false : true) ? false : true; System.out.println(m1(t1) + m1(t2) + m1(t3)); } } Output FFT
Download TernaryOperatorsDemo2 Source code
Type conversion allows a value to be changed from one primitive data type to another. Conversion can occur explicitly, as specified in the program, or implicitly, by Java itself. Java allows both type widening and type narrowing conversions. In java Conversions can occur by the following ways: Using a cast operator (explicit promotion) Using an arithmetic operator is used with arguments of different data types (arithmetic promotion) A value of one type is assigned to a variable of a different type (assignment promotion)
27
Operator Precedence
The order in which operators are applied is known as precedence. Operators with a higher precedence are applied before operators with a lower precedence. The operator precedence order of Java is shown below. Operators at the top of the table are applied before operators lower down in the table. If two operators have the same precedence, they are applied in the order they appear in a statement. That is, from left to right. You can use parentheses to override the default precedence.
postfix unary creation/caste multiplicative additive shift relational equality bitwise AND bitwise exclusive OR bitwise inclusive OR logical AND logical OR ternary assignment
[] . () expr++ expr ++expr expr +expr -expr ! ~ new (type)expr */% +>> >>> < <= > >= instanceof == != & ^ | && || ?: = op=
Example In an operation such as, result = 4 + 5 * 3 First (5 * 3) is evaluated and the result is added to 4 giving the Final Result value as 19. Note that * takes higher precedence than + according to chart shown above. This kind of precedence of one operator over another applies to all the operators.
28
QUIZ 1. How to generate a random number between 1 to x, x being a whole number greater than 1 Ans: double result = x * Math.random();
Java Control Flow Statements
Java Control statements control the order of execution in a java program, based on data values and conditional logic. There are three main categories of control flow statements; Selection statements: if, if-else and switch. Loop statements: while, do-while and for. Transfer statements: break, continue, return, try-catch-finally and assert. We use control statements when we want to change the default sequential order of execution
Selection Statements
The If Statement
The if statement executes a block of code only if the specified expression is true. If the value is false, then the if block is skipped and execution continues with the rest of the program. You can either have a single statement or a block of code within an if statement. Note that the conditional expression must be a Boolean expression. The simple if statement has the following syntax:
if (<conditional expression>) <statement action>
Below is an example that demonstrates conditional execution based on if statement condition. public class IfStatementDemo {
29
public static void main(String[] args) { int a = 10, b = 20; if (a > b) System.out.println("a > b"); if (a < b) System.out.println("b > a"); } } Output b>a
Download IfStatementDemo.java The If-else Statement
The if/else statement is an extension of the if statement. If the statements in the if statement fails, the statements in the else block are executed. You can either have a single statement or a block of code within if-else blocks. Note that the conditional expression must be a Boolean expression. The if-else statement has the following syntax:
if (<conditional expression>) <statement action> else <statement action>
Below is an example that demonstrates conditional execution based on if else statement condition.
public class IfElseStatementDemo { public static void main(String[] args) { int a = 10, b = 20; if (a > b) { System.out.println("a > b"); } else { System.out.println("b > a"); } } } Output b>a
Download IfElseStatementDemo.java
30
Switch Case Statement The switch case statement, also called a case statement is a multi-way branch with several choices. A switch is easier to implement than a series of if/else statements. The switch statement begins with a keyword, followed by an expression that equates to a no long integral value. Following the controlling expression is a code block that contains zero or more labeled cases. Each label must equate to an integer constant and each must be unique. When the switch statement executes, it compares the value of the controlling expression to the values of each case label. The program will select the value of the case label that equals the value of the controlling expression and branch down that path to the end of the code block. If none of the case label values match, then none of the codes within the switch statement code block will be executed. Java includes a default label to use in cases where there are no matches. We can have a nested switch within a case block of an outer switch. Its general form is as follows:
switch (<non-long integral expression>) { case label1: <statement1> case label2: <statement2>
case labeln: <statementn> default: <statement>
} // end switch When executing a switch statement, the program falls through to the next case. Therefore, if you want to exit in the middle of the switch statement code block, you must insert a break statement, which causes the program to continue executing after the current code block.
Below is a java example that demonstrates conditional execution based on nested if else statement condition to find the greatest of 3 numbers.
public class SwitchCaseStatementDemo { public static void main(String[] args) { int a = 10, b = 20, c = 30; int status = -1; if (a > b && a > c) { status = 1; } else if (b > c) { status = 2; } else { status = 3; } switch (status) {
31
case 1: System.out.println("a is the greatest"); break; case 2: System.out.println("b is the greatest"); break; case 3: System.out.println("c is the greatest"); break; default: System.out.println("Cannot be determined"); } } }
Output c is the greatest
Download SwitchCaseStatementDemo.java
~~~~~~~~~~~~ Control statements control the order of execution in a java program, based on data values and conditional logic. There are three main categories of control flow statements; Selection statements: if, if-else and switch. Loop statements: while, do-while and for. Transfer statements: break, continue, return, try-catch-finally and assert. We use control statements when we want to change the default sequential order of execution
Iteration Statements
While Statement The while statement is a looping construct control statement that executes a block of code while a condition is true. You can either have a single statement or a block of code within the while loop. The loop will never be executed if the testing expression evaluates to false. The loop condition must be a boolean expression. The syntax of the while loop is
32
while (<loop condition>) <statements> Below is an example that demonstrates the looping construct namely while loop used to print numbers from 1 to 10.
public class WhileLoopDemo { public static void main(String[] args) { int count = 1; System.out.println("Printing Numbers from 1 to 10"); while (count <= 10) { System.out.println(count++); } } }
Output Printing Numbers from 1 to 10 1 2 3 4 5 6 7 8 9 10 Download WhileLoopDemo.java Do-while Loop Statement The do-while loop is similar to the while loop, except that the test is performed at the end of the loop instead of at the beginning. This ensures that the loop will be executed at least once. A do-while loop begins with the keyword do, followed by the statements that make up the body of the loop. Finally, the keyword while and the test expression completes the do-while loop. When the loop condition becomes false, the loop is terminated and execution continues with the statement immediately following the loop. You can either have a single statement or a block of code within the do-while loop. The syntax of the do-while loop is
33
do <loop body> while (<loop condition>); Below is an example that demonstrates the looping construct namely do-while loop used to print numbers from 1 to 10.
public class DoWhileLoopDemo { public static void main(String[] args) { int count = 1; System.out.println("Printing Numbers from 1 to 10"); do { System.out.println(count++); } while (count <= 10); } }
Output Printing Numbers from 1 to 10 1 2 3 4 5 6 7 8 9 10 Download DoWhileLoopDemo.java Below is an example that creates A Fibonacci sequence controlled by a do-while loop public class Fibonacci { public static void main(String args[]) { System.out.println("Printing Limited set of Fibonacci Sequence"); double fib1 = 0; double fib2 = 1; double temp = 0; System.out.println(fib1); System.out.println(fib2); do { temp = fib1 + fib2; System.out.println(temp); fib1 = fib2; //Replace 2nd with first number fib2 = temp; //Replace temp number with 2nd number
34
} while (fib2 < 5000); } } Output Printing Limited set of Fibonacci Sequence 0.0 1.0 1.0 2.0 3.0 5.0 8.0 13.0 21.0 34.0 55.0 89.0 144.0 233.0 377.0 610.0 987.0 1597.0 2584.0 4181.0 6765.0 Download Fibonacci.java
For Loops
The for loop is a looping construct which can execute a set of instructions a specified number of times. Its a counter controlled loop. The syntax of the loop is as follows: for (<initialization>; <loop condition>; <increment expression>) <loop body> The first part of a for statement is a starting initialization, which executes once before the loop begins. The <initialization> section can also be a comma-separated list of expression statements. The second part of a for statement is a test expression. As long as the expression is true, the loop will continue. If this expression is evaluated as false the first time, the loop will never be executed. The third part of the for statement is the
35
body of the loop. These are the instructions that are repeated each time the program executes the loop. The final part of the for statement is an increment expression that automatically executes after each repetition of the loop body. Typically, this statement changes the value of the counter, which is then tested to see if the loop should continue. All the sections in the for-header are optional. Any one of them can be left empty, but the two semicolons are mandatory. In particular, leaving out the <loop condition> signifies that the loop condition is true. The (;;) form of for loop is commonly used to construct an infinite loop. Below is an example that demonstrates the looping construct namely for loop used to print numbers from 1 to 10. public class ForLoopDemo { public static void main(String[] args) { System.out.println("Printing Numbers from 1 to 10"); for (int count = 1; count <= 10; count++) { System.out.println(count); } } } Output Printing Numbers from 1 to 10 1 2 3 4 5 6 7 8 9 10 Download ForLoopDemo.java ~~~~~~~~~~~~ Control statements control the order of execution in a java program, based on data values and conditional logic. There are three main categories of control flow statements; Selection statements: if, if-else and switch. Loop statements: while, do-while and for. Transfer statements: break, continue, return, try-catch-finally and assert.
36
We use control statements when we want to change the default sequential order of execution
Transfer Statements
Continue Statement A continue statement stops the iteration of a loop (while, do or for) and causes execution to resume at the top of the nearest enclosing loop. You use a continue statement when you do not want to execute the remaining statements in the loop, but you do not want to exit the loop itself. The syntax of the continue statement is continue; // the unlabeled form continue <label>; // the labeled form You can also provide a loop with a label and then use the label in your continue statement. The label name is optional, and is usually only used when you wish to return to the outermost loop in a series of nested loops. Below is a program to demonstrate the use of continue statement to print Odd Numbers between 1 to 10. public class ContinueExample { public static void main(String[] args) { System.out.println("Odd Numbers"); for (int i = 1; i <= 10; ++i) { if (i % 2 == 0) continue; // Rest of loop body skipped when i is even System.out.println(i + "\t"); } } } Output Odd Numbers 1 3 5 7 9 Download ContinueExample.java
37
Break Statement The break statement transfers control out of the enclosing loop ( for, while, do or switch statement). You use a break statement when you want to jump immediately to the statement following the enclosing control structure. You can also provide a loop with a label, and then use the label in your break statement. The label name is optional, and is usually only used when you wish to terminate the outermost loop in a series of nested loops. The Syntax for break statement is as shown below; break; // the unlabeled form break <label>; // the labeled form Below is a program to demonstrate the use of break statement to print numbers Numbers 1 to 10. public class BreakExample { public static void main(String[] args) { System.out.println("Numbers 1 - 10"); for (int i = 1;; ++i) { if (i == 11) break; // Rest of loop body skipped when i is even System.out.println(i + "\t"); } } } Output Numbers 1 - 10 1 2 3 4 5 6 7 8 9 10 Download BreakExample.java
38
Introduction to Java Access Modifiers
Java Access Specifiers

The access to classes, constructors, methods and fields are regulated using access modifiers i.e. a class can control what information or data can be accessible by other classes. To take advantage of encapsulation, you should minimize access whenever possible. Java provides a number of access modifiers to help you set the level of access you want for classes as well as the fields, methods and constructors in your classes. A member has package or default accessibility when no accessibility modifier is specified. Access Modifiers 1. 2. 3. 4. private protected default public
public access modifier Fields, methods and constructors declared public (least restrictive) within a public class are visible to any class in the Java program, whether these classes are in the same package or in another package. private access modifier The private (most restrictive) fields or methods cannot be used for classes and Interfaces. It also cannot be used for fields and methods within an interface. Fields, methods or constructors declared private are strictly controlled, which means they cannot be accesses by anywhere outside the enclosing class. A standard design strategy is to make all fields private and provide public getter methods for them. protected access modifier The protected fields or methods cannot be used for classes and Interfaces. It also cannot be used for fields and methods within an interface. Fields, methods and constructors declared protected in a superclass can be accessed only by subclasses in other packages. Classes in the same package can also access protected fields, methods and constructors as well, even if they are not a subclass of the protected members class. default access modifier Java provides a default specifier which is used when no access modifier is present. Any class, field, method or constructor that has no declared access modifier is accessible only by classes in the same package. The default modifier is not used for fields and methods within an interface. Below is a program to demonstrate the use of public, private, protected and default access modifiers while accessing fields and methods. The output of each of these java files depict the Java access specifiers. The first class is SubclassInSamePackage.java which is present in pckage1 package. This java file contains the
39
Base class and a subclass within the enclosing class that belongs to the same class as shown below.
package pckage1; class BaseClass { public int x = 10; private int y = 10; protected int z = 10; int a = 10; //Implicit Default Access Modifier public int getX() { return x; } public void setX(int x) { this.x = x; } private int getY() { return y; } private void setY(int y) { this.y = y; } protected int getZ() { return z; } protected void setZ(int z) { this.z = z; } int getA() { return a; } void setA(int a) { this.a = a; } } public class SubclassInSamePackage extends BaseClass { public static void main(String args[]) { BaseClass rr = new BaseClass(); rr.z = 0; SubclassInSamePackage subClassObj = new SubclassInSamePackage(); //Access Modifiers - Public System.out.println("Value of x is : " + subClassObj.x); subClassObj.setX(20); System.out.println("Value of x is : " + subClassObj.x); //Access Modifiers - Public // If we remove the comments it would result in a compilaton // error as the fields and methods being accessed are
40
private /* System.out.println("Value of y is : "+subClassObj.y);
subClassObj.setY(20); System.out.println("Value of y is : "+subClassObj.y);*/ //Access Modifiers - Protected System.out.println("Value of z is : " + subClassObj.z); subClassObj.setZ(30); System.out.println("Value of z is : " + subClassObj.z); //Access Modifiers - Default System.out.println("Value of x is : " + subClassObj.a); subClassObj.setA(20); System.out.println("Value of x is : " + subClassObj.a); } }
Output Value Value Value Value Value Value of of of of of of x is : 10 x is : 20 z is : 10 z is : 30 x is : 10 x is : 20
The second class is SubClassInDifferentPackage.java which is present in a different package then the first one. This java class extends First class (SubclassInSamePackage.java). import pckage1.*; public class SubClassInDifferentPackage extends SubclassInSamePackage { public int getZZZ() { return z; } public static void main(String args[]) { SubClassInDifferentPackage subClassDiffObj = new SubClassInDifferentPackage(); SubclassInSamePackage subClassObj = new SubclassInSamePackage(); //Access specifiers - Public System.out.println("Value of x is : " + subClassObj.x); subClassObj.setX(30); System.out.println("Value of x is : " + subClassObj.x); //Access specifiers - Private // if we remove the comments it would result in a compilaton // error as the fields and methods being accessed are private /* System.out.println("Value of y is : "+subClassObj.y); subClassObj.setY(20); System.out.println("Value of y is : "+subClassObj.y);*/ //Access specifiers - Protected // If we remove the comments it would result in a compilaton
41
// /* error as the fields and methods being accessed are protected. System.out.println("Value of z is : "+subClassObj.z);
subClassObj.setZ(30); System.out.println("Value of z is : "+subClassObj.z);*/ System.out.println("Value of z is : " + subClassDiffObj.getZZZ()); //Access Modifiers - Default // If we remove the comments it would result in a compilaton // error as the fields and methods being accessed are default. /* System.out.println("Value of a is : "+subClassObj.a); subClassObj.setA(20); System.out.println("Value of a is : "+subClassObj.a);*/ } } Output Value of x is : 10 Value of x is : 30 Value of z is : 10 The third class is ClassInDifferentPackage.java which is present in a different package then the first one. import pckage1.*; public class ClassInDifferentPackage { public static void main(String args[]) { SubclassInSamePackage subClassObj = new SubclassInSamePackage(); //Access Modifiers - Public System.out.println("Value of x is : " + subClassObj.x); subClassObj.setX(30); System.out.println("Value of x is : " + subClassObj.x); //Access Modifiers - Private // If we remove the comments it would result in a compilaton // error as the fields and methods being accessed are private /* System.out.println("Value of y is : "+subClassObj.y); subClassObj.setY(20); System.out.println("Value of y is : "+subClassObj.y);*/ //Access Modifiers - Protected // If we remove the comments it would result in a compilaton // error as the fields and methods being accessed are protected. /* System.out.println("Value of z is : "+subClassObj.z); subClassObj.setZ(30); System.out.println("Value of z is : "+subClassObj.z);*/ //Access Modifiers - Default // If we remove the comments it would result in a compilaton // error as the fields and methods being accessed are default. /* System.out.println("Value of a is : "+subClassObj.a);
42
subClassObj.setA(20); System.out.println("Value of a is : "+subClassObj.a);*/ } } Output Value of x is : 10 Value of x is : 30
Download all the 3 source files
43
Java Classes and Objects
Introduction to Java Classes A class is nothing but a blueprint or a template for creating different objects which defines its properties and behaviors. Java class objects exhibit the properties and behaviors defined by its class. A class can contain fields and methods to describe the behavior of an object. Methods are nothing but members of a class that provide a service for an object or perform some business logic. Java fields and member functions names are case sensitive. Current states of a classs corresponding object are stored in the objects instance variables. Methods define the operations that can be performed in java programming. A class has the following general syntax:
<class modifiers>class<class name> <extends clause> <implements clause>{ // Dealing with Classes (Class body)
<field declarations (Static and Non-Static)> <method declarations (Static and Non-Static)> <Inner class declarations> <nested interface declarations> <constructor declarations> <Static initializer blocks> } Below is an example showing the Objects and Classes of the Cube class that defines 3 fields namely length, breadth and height. Also the class contains a member function getVolume().
public class Cube { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } }
44
How do you reference a data member/function?
This is accomplished by stating the name of the object reference, followed by a period (dot), followed by the name of the member inside the object. ( objectReference.member ). You call a method for an object by naming the object followed by a period (dot), followed by the name of the method and its argument list, like this: objectName.methodName(arg1, arg2, arg3).
For example:
cubeObject.length = 4; cubeObject.breadth = 4; cubeObject.height = 4; cubeObject.getvolume()
Class Variables Static Fields

We use class variables also know as Static fields when we want to share characteristics across all objects within a class. When you declare a field to be static, only a single instance of the associated variable is created common to all the objects of that class. Hence when one object changes the value of a class variable, it affects all objects of the class. We can access a class variable by using the name of the class, and not necessarily using a reference to an individual object within the class. Static variables can be accessed even though no objects of that class exist. It is declared using static keyword.
Class Methods Static Methods

Class methods, similar to Class variables can be invoked without having an instance of the class. Class methods are often used to provide global functions for Java programs. For example, methods in the java.lang.Math package are class methods. You cannot call non-static methods from inside a static method.
Instance Variables
Instance variables stores the state of the object. Each class would have its own copy of the variable. Every object has a state that is determined by the values stored in the object. An object is said to have changed its state when one or more data values stored in the object have been modified. When an object responds to a message, it will usually perform an action, change its state etc. An object that has the ability to store values is often said to have persistence.
Consider this simple Java program showing the use of static fields and static methods
// Class and Object initialization showing the Object Oriented concepts in Java class Cube { int length = 10;
45
int breadth = 10; int height = 10; public static int numOfCubes = 0; // static variable public static int getNoOfCubes() { //static method return numOfCubes; } public Cube() { numOfCubes++; // } } public class CubeStaticTest { public static void main(String args[]) { System.out.println("Number of Cube objects = " + Cube.numOfCubes); System.out.println("Number of Cube objects = " + Cube.getNoOfCubes()); } }
Download CubeStaticTest.java
Output Number of Cube objects = 0 Number of Cube objects = 0
Final Variable, Methods and Classes

In Java we can mark fields, methods and classes as final. Once marked as final, these items cannot be changed. Variables defined in an interface are implicitly final. You cant change value of a final variable (is a constant). A final class cant be extended i.e., final class may not be subclassed. This is done for security reasons with basic classes like String and Integer. It also allows the compiler to make some optimizations, and makes thread safety a little easier to achieve. A final method cant be overridden when its class is inherited. Any attempt to override or hide a final method will result in a compiler error.
Introduction to Java Objects

The Object Class is the super class for all classes in Java. Some of the object class methods are equals toString() wait() notify() notifyAll()
46
hashcode() clone() An object is an instance of a class created using a new operator. The new operator returns a reference to a new instance of a class. This reference can be assigned to a reference variable of the class. The process of creating objects from a class is called instantiation. An object encapsulates state and behavior. An object reference provides a handle to an object that is created and stored in memory. In Java, objects can only be manipulated via references, which can be stored in variables. Creating variables of your class type is similar to creating variables of primitive data types, such as integer or float. Each time you create an object, a new set of instance variables comes into existence which defines the characteristics of that object. If you want to create an object of the class and have the reference variable associated with this object, you must also allocate memory for the object by using the new operator. This process is called instantiating an object or creating an object instance. When you create a new object, you use the new operator to instantiate the object. The new operator returns the location of the object which you assign o a reference type. Below is an example showing the creation of Cube objects by using the new operator.
public class Cube { int length = 10; int breadth = 10; int height = 10; public int getVolume() { return (length * breadth * height); } public static void main(String[] args) { Cube cubeObj; // Creates a Cube Reference cubeObj = new Cube(); // Creates an Object of Cube System.out.println("Volume of Cube is : " + cubeObj.getVolume()); } }
Download Cube.java
Method Overloading
Method overloading results when two or more methods in the same class have the same name but different parameters. Methods with the same name must differ in their types or number of parameters. This allows the compiler to match parameters and choose the
47
correct method when a number of choices exist. Changing just the return type is not enough to overload a method, and will be a compile-time error. They must have a different signature. When no method matching the input parameters is found, the compiler attempts to convert the input parameters to types of greater precision. A match may then be found without error. At compile time, the right implementation is chosen based on the signature of the method call Below is an example of a class demonstrating Method Overloading
public class MethodOverloadDemo { void sumOfParams() { // First Version System.out.println("No parameters"); } void sumOfParams(int a) { // Second Version System.out.println("One parameter: " + a); } int sumOfParams(int a, int b) { // Third Version System.out.println("Two parameters: " + a + " , " + b); return a + b; } double sumOfParams(double a, double b) { // Fourth Version System.out.println("Two double parameters: " + a + " , " + b); return a + b; } public static void main(String args[]) { MethodOverloadDemo moDemo = new MethodOverloadDemo(); int intResult; double doubleResult; moDemo.sumOfParams(); System.out.println(); moDemo.sumOfParams(2); System.out.println(); intResult = moDemo.sumOfParams(10, 20); System.out.println("Sum is " + intResult); System.out.println(); doubleResult = moDemo.sumOfParams(1.1, 2.2); System.out.println("Sum is " + doubleResult); System.out.println(); } }
Download MethodOverloadDemo.java
Output No parameters
48
One parameter: 2 Two parameters: 10 , 20 Sum is 30 Two double parameters: 1.1 , 2.2 Sum is 3.3000000000000003 Below is a code snippet to shows the interfaces that a Class Implements:
Class cls = java.lang.String.class; Class[] intfs = cls.getInterfaces(); // [java.lang.Comparable, java.lang.CharSequence, java.io.Serializable] // The interfaces for a primitive type is an empty array cls = int.class; intfs = cls.getInterfaces(); // []
Below is a code snippet to show whether a Class Object Represents a Class or Interface:
Class cls = java.lang.String.class; boolean isClass = !cls.isInterface(); // true cls = java.lang.Cloneable.class; isClass = !cls.isInterface(); // false
Java Constructors
A java constructor has the same name as the name of the class to which it belongs. Constructors syntax does not include a return type, since constructors never return a value. Constructors may include parameters of various types. When the constructor is invoked using the new operator, the types must match those that are specified in the constructor definition. Java provides a default constructor which takes no arguments and performs no special actions or initializations, when no explicit constructors are provided. The only action taken by the implicit default constructor is to call the superclass constructor using the super() call. Constructor arguments provide you with a way to provide parameters for the initialization of an object.
49
Below is an example of a cube class containing 2 constructors. (one default and one parameterized constructor). public class Cube1 { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube1() { length = 10; breadth = 10; height = 10; } Cube1(int l, int b, int h) { length = l; breadth = b; height = h; } public static void main(String[] args) { Cube1 cubeObj1, cubeObj2; cubeObj1 = new Cube1(); cubeObj2 = new Cube1(10, 20, 30); System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume()); System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume()); } }
Download Cube1.java
Note: If a class defines an explicit constructor, it no longer has a default constructor to
set the state of the objects. If such a class requires a default constructor, its implementation must be provided. Any attempt to call the default constructor will be a compile time error if an explicit default constructor is not provided in such a case.
Java Overloaded Constructors

Like methods, constructors can also be overloaded. Since the constructors in a class all have the same name as the class, />their signatures are differentiated by their parameter lists. The above example shows that the Cube1 constructor is overloaded one being the default constructor and the other being a parameterized constructor. It is possible to use this() construct, to implement local chaining of constructors in a class. The this() call in a constructorinvokes the an other constructor with the corresponding parameter list within the same class. Calling the default constructor to create a Cube object results in the second and third parameterized constructors being
50
called as well. Java requires that any this() call must occur as the first statement in a constructor. Below is an example of a cube class containing 3 constructors which demostrates the this() method in Constructors context public class Cube2 { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube2() { this(10, 10); System.out.println("Finished with Default Constructor"); } Cube2(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params"); } Cube2(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params"); } public static void main(String[] args) { Cube2 cubeObj1, cubeObj2; cubeObj1 = new Cube2(); cubeObj2 = new Cube2(10, 20, 30); System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume()); System.out.println("Volume of Cube2 is : " + cubeObj2.getVolume()); } } public class Cube2 { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube2() { this(10, 10); System.out.println("Finished with Default Constructor"); } Cube2(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params"); } Cube2(int l, int b, int h) { length = l; breadth = b;
51
height = h; System.out.println("Finished with Parameterized Constructor having 3 params"); } public static void main(String[] args) { Cube2 cubeObj1, cubeObj2; cubeObj1 = new Cube2(); cubeObj2 = new Cube2(10, 20, 30); System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume()); System.out.println("Volume of Cube2 is : " + cubeObj2.getVolume()); } }
Output Finished with Parameterized Constructor having 3 params Finished with Parameterized Constructor having 2 params Finished with Default Constructor Finished with Parameterized Constructor having 3 params Volume of Cube1 is : 1000 Volume of Cube2 is : 6000 Download Cube2.java
Constructor Chaining
Every constructor calls its superclass constructor. An implied super() is therefore included in each constructor which does not include either the this() function or an explicit super() call as its first statement. The super() statement invokes a constructor of the super class. The implicit super() can be replaced by an explicit super(). The super statement must be the first statement of the constructor. The explicit super allows parameter values to be passed to the constructor of its superclass and must have matching parameter types A super() call in the constructor of a subclass will result in the call of the relevant constructor from the superclass, based on the signature of the call. This is called constructor chaining. Below is an example of a class demonstrating constructor chaining using super() method. class Cube { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube() { this(10, 10);
52
System.out.println("Finished with Default Constructor of Cube"); } Cube(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params of Cube"); } Cube(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params of Cube"); } } public class SpecialCube extends Cube { int weight; SpecialCube() { super(); weight = 10; } SpecialCube(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params of SpecialCube"); } SpecialCube(int l, int b, int h) { super(l, b, h); weight = 20; System.out.println("Finished with Parameterized Constructor having 3 params of SpecialCube"); } public static void main(String[] args) { SpecialCube specialObj1 = new SpecialCube(); SpecialCube specialObj2 = new SpecialCube(10, 20); System.out.println("Volume of SpecialCube1 is : " + specialObj1.getVolume()); System.out.println("Weight of SpecialCube1 is : " + specialObj1.weight); System.out.println("Volume of SpecialCube2 is : " + specialObj2.getVolume()); System.out.println("Weight of SpecialCube2 is : " + specialObj2.weight); } } Download SpecialCube.java Output Finished with Parameterized Constructor having 3 params of SpecialCube Finished with Parameterized Constructor having 2 params of SpecialCube
53
Volume of SpecialCube1 is : 1000 Weight of SpecialCube1 is : 10 Volume of SpecialCube2 is : 2000 Weight of SpecialCube2 is : 20 The super() construct as with this() construct: if used, must occur as the first statement in a constructor, and it can only be used in a constructor declaration. This implies that this() and super() calls cannot both occur in the same constructor. Just as the this() construct leads to chaining of constructors in the same class, the super() construct leads to chaining of subclass constructors to superclass constructors. if a constructor has neither a this() nor a super() construct as its first statement, then a super() call to the default constructor in the superclass is inserted.
Note: If a class only defines non-default constructors, then its subclasses will not include
an implicit super() call. This will be flagged as a compile-time error. The subclasses must then explicitly call a superclass constructor, using the super() construct with the right arguments to match the appropriate constructor of the superclass. Below is an example of a class demonstrating constructor chaining using explicit super() call. class Cube { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params of Cube"); } } public class SpecialCube1 extends Cube { int weight; SpecialCube1() { super(10, 20, 30); //Will Give a Compilation Error without this line weight = 10; } public static void main(String[] args) { SpecialCube1 specialObj1 = new SpecialCube1(); System.out.println("Volume of SpecialCube1 is : "+ specialObj1.getVolume()); } } Output
54
Finished with Parameterized Constructor having 3 params of Cube Volume of SpecialCube1 is : 6000 Download SpecialCube1.java
Java Serialization
Introduction to Object Serialization

Java object serialization is used to persist Java objects to a file, database, network, process or any other system. Serialization flattens objects into an ordered, or serialized stream of bytes. The ordered stream of bytes can then be read at a later time, or in another environment, to recreate the original objects. Java serialization does not cannot occur for transient or static fields. Marking the field transient prevents the state from being written to the stream and from being restored during deserialization. Java provides classes to support writing objects to streams and restoring objects from streams. Only objects that support the java.io.Serializableinterface or the java.io.Externalizable interface can be written to streams. public interface Serializable The Serializable interface has no methods or fields. (Marker Interface) Only objects of classes that implement java.io.Serializable interface can be serialized or deserialized
Transient Fields and Java Serialization

The transient keyword is a modifier applied to instance variables in a class. It specifies that the variable is not part of the persistent state of the object and thus never saved during serialization. You can use the transient keyword to describe temporary variables, or variables that contain local information,
such as a process ID or a time lapse.
Input and Output Object Streams

55
ObjectOutputStream is the primary output stream class that implements the ObjectOutput interface for serializing objects. ObjectInputStream is the primary input stream class that implements the ObjectInput interface for deserializing objects. These high-level streams are each chained to a low-level stream, such as FileInputStream or FileOutputStream. The low-level streams handle the bytes of data. The writeObject method saves the state of the class by writing the individual fields to the ObjectOutputStream. The readObject method is used to deserialize the object from the object input stream. Case 1: Below is an example that demonstrates object Serialization into a File
PersonDetails is the bean class that implements the Serializable interface
import java.io.Serializable; public class PersonDetails implements Serializable { private String name; private int age; private String sex; public PersonDetails(String name, int age, String sex) { this.name = name; this.age = age; this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } }
GetPersonDetails is the class that is used to Deserialize object from the File (person.txt).
import import import import import public
java.io.FileInputStream; java.io.IOException; java.io.ObjectInputStream; java.util.ArrayList; java.util.List; class GetPersonDetails {
56
public static void main(String[] args) { String filename = "person.txt"; List pDetails = null; FileInputStream fis = null; ObjectInputStream in = null; try { fis = new FileInputStream(filename); in = new ObjectInputStream(fis); pDetails = (ArrayList) in.readObject(); in.close(); } catch (IOException ex) { ex.printStackTrace(); } catch (ClassNotFoundException ex) { ex.printStackTrace(); } // print out the size System.out.println("Person Details Size: " + pDetails.size()); System.out.println(); } }
PersonPersist is the class that is used to serialize object into the File (person.txt).
public class PersonPersist { public static void main(String[] args) { String filename = "person.txt"; PersonDetails person1 = new PersonDetails("hemanth", 10, "Male"); PersonDetails person2 = new PersonDetails("bob", 12, "Male"); PersonDetails person3 = new PersonDetails("Richa", 10, "Female"); List list = new ArrayList(); list.add(person1); list.add(person2); list.add(person3); FileOutputStream fos = null; ObjectOutputStream out = null; try { fos = new FileOutputStream(filename); out = new ObjectOutputStream(fos); out.writeObject(list); out.close(); System.out.println("Object Persisted"); } catch (IOException ex) { ex.printStackTrace(); } } } Case 2: Below is an example that demonstrates object Serialization into the database
PersonDetails remains the same as shown above GetPersonDetails remains the same as shown above
Create SerialTest Table
57
create table SerialTest( name BLOB, viewname VARCHAR2(30) ); PersonPersist is the class that is used to serialize object into the into the Database Table SerialTest.
import import import import import import import import import import import public
java.io.ByteArrayInputStream; java.io.ByteArrayOutputStream; java.io.IOException; java.io.ObjectInputStream; java.io.ObjectOutputStream; java.sql.Connection; java.sql.DriverManager; java.sql.PreparedStatement; java.sql.ResultSet; java.sql.SQLException; java.sql.Statement; class PersonPersist { static static static static public String userid = "scott", password = "tiger"; String url = "jdbc:odbc:bob"; int count = 0; Connection con = null; static void main(String[] args) { Connection con = getOracleJDBCConnection(); PersonDetails person1 = new PersonDetails("hemanth", 10, "Male"); PersonDetails person2 = new PersonDetails("bob", 12, "Male"); PersonDetails person3 = new PersonDetails("Richa", 10, "Female"); PreparedStatement ps; try { ps = con .prepareStatement("INSERT INTO SerialTest VALUES write(person1, ps); ps.execute(); write(person2, ps); ps.execute(); write(person3, ps); ps.execute(); ps.close(); Statement st = con.createStatement(); ResultSet rs = st.executeQuery("SELECT * FROM SerialTest"); while (rs.next()) { Object obj = read(rs, "Name"); PersonDetails p = (PersonDetails) obj; System.out.println(p.getName() + "\t" + p.getAge() +
(?, ?)");
"\t" + p.getSex()); } rs.close(); st.close(); } catch (Exception e) { } } public static void write(Object obj, PreparedStatement ps) throws SQLException, IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oout = new ObjectOutputStream(baos);
58
oout.writeObject(obj); oout.close(); ps.setBytes(1, baos.toByteArray()); ps.setInt(2, ++count); } public static Object read(ResultSet rs, String column) throws SQLException, IOException, ClassNotFoundException { byte[] buf = rs.getBytes(column); if (buf != null) { ObjectInputStream objectIn = new ObjectInputStream( new ByteArrayInputStream(buf)); return objectIn.readObject(); } return null; } public static Connection getOracleJDBCConnection() { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); } catch (java.lang.ClassNotFoundException e) { System.err.print("ClassNotFoundException: "); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch (SQLException ex) { System.err.println("SQLException: " + ex.getMessage()); } return con; } } Case 3: Below is an example that demonstrates object Serialization into the database using Base 64 Encoder
PersonDetails remains the same as shown above GetPersonDetails remains the same as shown above Create SerialTest Table create table SerialTest( name BLOB, viewname VARCHAR2(30) ); PersonPersist is the class that is used to serialize object into the Database Table SerialTest
import import import import import import import import
java.io.ByteArrayInputStream; java.io.ByteArrayOutputStream; java.io.IOException; java.io.ObjectInputStream; java.io.ObjectOutputStream; java.sql.Connection; java.sql.DriverManager; java.sql.PreparedStatement;
59
import import import public java.sql.ResultSet; java.sql.SQLException; java.sql.Statement; class PersonPersist { static static static static static public String userid = "scott", password = "tiger"; String url = "jdbc:odbc:bob"; int count = 0; Connection con = null; String s; static void main(String[] args) { Connection con = getOracleJDBCConnection(); PersonDetails person1 = new PersonDetails("hemanth", 10, "Male"); PersonDetails person2 = new PersonDetails("bob", 12, "Male"); PersonDetails person3 = new PersonDetails("Richa", 10, "Female"); PreparedStatement ps; try { ps = con .prepareStatement("INSERT INTO SerialTest VALUES write(person1, ps); ps.execute(); write(person2, ps); ps.execute(); write(person3, ps); ps.execute(); ps.close(); Statement st = con.createStatement(); ResultSet rs = st.executeQuery("SELECT * FROM SerialTest"); while (rs.next()) { Object obj = read(rs, "Name"); PersonDetails p = (PersonDetails) obj; System.out.println(p.getName() + "\t" + p.getAge() + "\t" + p.getSex()); } rs.close(); st.close(); } catch (Exception e) { } } public static void write(Object obj, PreparedStatement ps) throws SQLException, IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oout = new ObjectOutputStream(baos); oout.writeObject(obj); oout.close(); byte[] buf = baos.toByteArray(); s = new sun.misc.BASE64Encoder().encode(buf); ps.setString(1, s); // ps.setBytes(1, Base64.byteArrayToBase64(baos.toByteArray())); ps.setBytes(1, baos.toByteArray()); ps.setInt(2, ++count); } public static Object read(ResultSet rs, String column) throws SQLException, IOException, ClassNotFoundException { byte[] buf = new sun.misc.BASE64Decoder().decodeBuffer(s); // byte[] buf = Base64.base64ToByteArray(new // String(rs.getBytes(column))); if (buf != null) { ObjectInputStream objectIn = new ObjectInputStream(
(?, ?)");
60
new ByteArrayInputStream(buf)); Object obj = objectIn.readObject(); // Contains the object PersonDetails p = (PersonDetails) obj; System.out.println(p.getName() + "\t" + p.getAge() + "\t" + p.getSex()); } return null; } public static Connection getOracleJDBCConnection() { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); } catch (java.lang.ClassNotFoundException e) { System.err.print("ClassNotFoundException: "); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch (SQLException ex) { System.err.println("SQLException: " + ex.getMessage()); } return con; } } Below is a program that shows the serialization of a JButton object to a file and a Byte Array Stream. As before theobject to be serialized must implement the Serializable interface. PersonDetails is the bean class that implements the Serializable interface import import import import java.io.ByteArrayOutputStream; java.io.FileOutputStream; java.io.ObjectOutput; java.io.ObjectOutputStream;
public class ObjectSerializationExample { public static void main(String args[]) { try { Object object = new javax.swing.JButton("Submit"); // Serialize to a file namely "filename.dat" ObjectOutput out = new ObjectOutputStream( new FileOutputStream("filename.dat")); out.writeObject(object); out.close(); // Serialize to a byte array ByteArrayOutputStream bos = new ByteArrayOutputStream(); out = new ObjectOutputStream(bos); out.writeObject(object); out.close(); // Get the bytes of the serialized object byte[] buf = bos.toByteArray(); } catch (Exception e) { e.printStackTrace(); } } } Download Object Serialization Source code
61
Java Inheritance
Java Inheritance defines an is-a relationship between a superclass and its subclasses. This means that an object of a subclass can be used wherever an object of the superclass can be used. Class Inheritance in javamechanism is used to build new classes from existing classes. The inheritance relationship is transitive: if class x extends class y, then a class z, which extends class x, will also inherit from class y. For example a car class can inherit some properties from a General vehicle class. Here we find that the base class is the vehicle class and the subclass is the more specific car class. A subclass must use the extends clause to derive from a super class which must be written in the header of the subclass definition. The subclass inherits members of the superclass and hence promotes code reuse. The subclass itself can add its own new behavior and properties. The java.lang.Object class is always at the top of any Class inheritance hierarchy. class Box { double width; double height; double depth; Box() { } Box(double w, double h, double d) { width = w; height = h; depth = d; } void getVolume() { System.out.println("Volume is : " + width * height * depth); } } public class MatchBox extends Box { double weight; MatchBox() { } MatchBox(double w, double h, double d, double m) { super(w, h, d); weight = m; } public static void main(String args[]) { MatchBox mb1 = new MatchBox(10, 10, 10, 10); mb1.getVolume(); System.out.println("width of MatchBox 1 is " + mb1.width); System.out.println("height of MatchBox 1 is " + mb1.height); System.out.println("depth of MatchBox 1 is " + mb1.depth); System.out.println("weight of MatchBox 1 is " + mb1.weight); }
62
} Output Volume is : 1000.0 width of MatchBox 1 is 10.0 height of MatchBox 1 is 10.0 depth of MatchBox 1 is 10.0 weight of MatchBox 1 is 10.0 Download MatchBox.java What is not possible using java class Inheritance? 1. Private members of the superclass are not inherited by the subclass and can only be indirectly accessed. 2. Members that have default accessibility in the superclass are also not inherited by subclasses in other packages, as these members are only accessible by their simple names in subclasses within the same package as the superclass. 3. Since constructors and initializer blocks are not members of a class, they are not inherited by a subclass. 4. A subclass can extend only one superclass class Vehicle { // Instance fields int noOfTyres; // no of tyres private boolean accessories; // check if accessorees present or not protected String brand; // Brand of the car // Static fields private static int counter; // No of Vehicle objects created // Constructor Vehicle() { System.out.println("Constructor of the Super class called"); noOfTyres = 5; accessories = true; brand = "X"; counter++; } // Instance methods public void switchOn() { accessories = true; } public void switchOff() { accessories = false; } public boolean isPresent() { return accessories; } private void getBrand() { System.out.println("Vehicle Brand: " + brand); } // Static methods
63
public static void getNoOfVehicles() { System.out.println("Number of Vehicles: " + counter); } } class Car extends Vehicle { private int carNo = 10; public void printCarInfo() { System.out.println("Car number: " + carNo); System.out.println("No of Tyres: " + noOfTyres); // Inherited. // System.out.println("accessories: " + accessories); // Not Inherited. System.out.println("accessories: " + isPresent()); // Inherited. // System.out.println("Brand: " + getBrand()); // Not Inherited. System.out.println("Brand: " + brand); // Inherited. // System.out.println("Counter: " + counter); // Not Inherited. getNoOfVehicles(); // Inherited. } } public class VehicleDetails { // (3) public static void main(String[] args) { new Car().printCarInfo(); } }
Output Constructor of the Super class called Car number: 10 No of Tyres: 5 accessories: true Brand: X Number of Vehicles: 1 Download VehicleDetails.java
this and super keywords

The two keywords, this and super to help you explicitly name the field or method that you want. Using this and super you have full control on whether to call a method or field present in the same class or to call from the immediate superclass. This keyword is used as a reference to the current object which is an instance of the current class. The keyword super also references the current object, but as an instance of the current classs super class. The this reference to the current object is useful in situations where a local variable hides, or shadows, a field with the same name. If a method needs to pass the current object to another method, it can do so using the this reference. Note that the this
64
reference cannot be used in a static context, as static code is not executed in the context of any object. class Counter { int i = 0; Counter increment() { i++; return this; } void print() { System.out.println("i = " + i); } } public class CounterDemo extends Counter { public static void main(String[] args) { Counter x = new Counter(); x.increment().increment().increment().print(); } } Output Volume is : 1000.0 width of MatchBox 1 is 10.0 height of MatchBox 1 is 10.0 depth of MatchBox 1 is 10.0 weight of MatchBox 1 is 10.0 Download CounterDemo.java
Java Object Typecasting
Object Reference Type Casting

In java object typecasting one object reference can be type cast into another object reference. The cast can be to its own class type or to one of its subclass or superclass types or interfaces. There are compile-time rules and runtime rules for casting in java. How to Typecast Objects with a dynamically loaded Class ? - The casting of object references depends on the relationship of the classes involved in the same hierarchy. Any object reference can be assigned to a reference variable of the type Object, because
65
the Object class is a superclass of every Java class. There can be 2 casting java scenarios
Upcasting Downcasting
When we cast a reference along the class hierarchy in a direction from the root class towards the children or subclasses, it is a downcast. When we cast a reference along the class hierarchy in a direction from the sub classes towards the root, it is an upcast. We need not use a cast operator in this case. The compile-time rules are there to catch attempted casts in cases that are simply not possible. This happens when we try to attempt casts on objects that are totally unrelated (that is not subclass super class relationship or a class-interface relationship) At runtime a ClassCastException is thrown if the object being cast is not compatible with the new type it is being cast to. Below is an example showing when a ClassCastException can occur during object casting //X is a supper class of Y and Z which are sibblings. public class RunTimeCastDemo { public static void main(String args[]) { X x = new X(); Y y = new Y(); Z z = new Z(); X xy = new Y(); // compiles ok (up the hierarchy) X xz = new Z(); // compiles ok (up the hierarchy) // Y yz = new Z(); incompatible type (siblings) // Y y1 = new X(); X is not a Y // Z z1 = new X(); X is not a Z X x1 = y; // compiles ok (y is subclass of X) X x2 = z; // compiles ok (z is subclass of X) Y y1 = (Y) x; // compiles ok but produces runtime error Z z1 = (Z) x; // compiles ok but produces runtime error Y y2 = (Y) x1; // compiles and runs ok (x1 is type Y) Z z2 = (Z) x2; // compiles and runs ok (x2 is type Z) // Y y3 = (Y) z; inconvertible types (siblings) // Z z3 = (Z) y; inconvertible types (siblings) Object o = z; Object o1 = (Y) o; // compiles ok but produces runtime error } } Download ClassCastException example Source Code
Casting Object References: Implicit Casting using a Compiler
66
In general an implicit cast is done when an Object reference is assigned (cast) to: * A reference variable whose type is the same as the class from which the object was instantiated. An Object as Object is a super class of every Class. * A reference variable whose type is a super class of the class from which the object was instantiated. * A reference variable whose type is an interface that is implemented by the class from which the object was instantiated. * A reference variable whose type is an interface that is implemented by a super class of the class from which the object was instantiated. Consider an interface Vehicle, a super class Car and its subclass Ford. The following example shows the automatic conversion of object references handled by the compiler
interface Vehicle { } class Car implements Vehicle { } class Ford extends Car { }
Let c be a variable of type Car class and f be of class Ford and v be an vehicle interface reference. We can assign the Ford reference to the Car variable: I.e. we can do the following Example 1 c = f; //Ok Compiles fine Where c = new Car(); And, f = new Ford(); The compiler automatically handles the conversion (assignment) since the types are compatible (sub class - super class relationship), i.e., the type Car can hold the type Ford since a Ford is a Car. Example 2 v = c; //Ok Compiles fine c = v; // illegal conversion from interface type to class type results in compilation error Where c = new Car(); And v is a Vehicle interface reference (Vehicle v) The compiler automatically handles the conversion (assignment) since the types are compatible (class interface relationship), i.e., the type Car can be cast to Vehicle interface type since Car implements Vehicle Interface. (Car is a Vehicle).
67
Casting Object References: Explicit Casting Sometimes we do an explicit cast in java when implicit casts dont work or are not helpful for a particular scenario. The explicit cast is nothing but the name of the new type inside a pair of matched parentheses. As before, we consider the same Car and Ford Class
class Car { void carMethod(){ } } class Ford extends Car { void fordMethod () { } }
We also have a breakingSystem() function which takes Car reference (Superclass reference) as an input parameter. The method will invoke carMethod() regardless of the type of object (Car or Ford Reference) and if it is a Ford object, it will also invoke fordMethod(). We use the instanceof operator to determine the type of object at run time.
public void breakingSystem (Car obj) { obj.carMethod(); if (obj instanceof Ford) ((Ford)obj).fordMethod (); }
To invoke the fordMethod(), the operation (Ford)obj tells the compiler to treat the Car object referenced by obj as if it is a Ford object. Without the cast, the compiler will give an error message indicating that fordMethod() cannot be found in the Car definition.
The following program shown illustrates the use of the cast operator with references.
Note: Classes Honda and Ford are Siblings in the class Hierarchy. Both these classes
are subclasses of Class Car. Both Car and HeavyVehicle Class extend Object Class. Any class that does not explicitly extend some other class will automatically extends the Object by default. This code instantiates an object of the class Ford and assigns the objects reference to a reference variable of type Car. This assignment is allowed as Car is a superclass of Ford. In order to use a reference of a class type to invoke a method, the method must be defined at or above that class in the class hierarchy. Hence an object of Class Car cannot invoke a method present in Class Ford, since the method fordMethod is not present in Class Car or any of its superclasses. Hence this problem can be colved by a simple downcast by casting the Car object reference to the Ford Class
68
Object reference as done in the program. Also an attempt to cast an object reference to its Sibling Object reference produces a ClassCastException at runtime, although compilation happens without any error.
class Car extends Object { void carMethod() { } } class HeavyVehicle extends Object { } class Ford extends Car { void fordMethod() { System.out.println("I am fordMethod defined in Class Ford"); } } class Honda extends Car { void fordMethod() { System.out.println("I am fordMethod defined in Class Ford"); } } public class ObjectCastingEx { public static void main(String[] args) { Car obj = new Ford(); // Following will result in compilation error // obj.fordMethod(); //As the method fordMethod is undefined for the Car Type // Following will result in compilation error // ((HeavyVehicle)obj).fordMethod(); //fordMethod is undefined in the HeavyVehicle Type // Following will result in compilation error ((Ford) obj).fordMethod(); //Following will compile and run //Honda hondaObj = (Ford)obj; Cannot convert as they are sibblings } }
Download Object Reference Casting Source Code
69
One common casting that is performed when dealing with collections is, you can cast an object reference into a String. import java.util.Vector; public class StringCastDemo { public static void main(String args[]) { String username = "asdf"; String password = "qwer"; Vector v = new Vector(); v.add(username); v.add(password); // String u = v.elementAt(0); Cannot convert from object to String Object u = v.elementAt(0); //Cast not done System.out.println("Username : " + u); String uname = (String) v.elementAt(0); // cast allowed String pass = (String) v.elementAt(1); // cast allowed System.out.println(); System.out.println("Username : " + uname); System.out.println("Password : " + pass); } }
Download Object String Casting Source Code Output

Username : asdf Username : asdf Password : qwer
instanceof Operator
The instanceof operator is called the type comparison operator, lets you determine if an object belongs to a specific class, or implements a specific interface. It returns true if an object is an instance of the class or if the object implements the interface, otherwise it returns false. Below is an example showing the use of instanceof operator class Vehicle { String name; Vehicle() { name = "Vehicle"; } } class HeavyVehicle extends Vehicle {
70
HeavyVehicle() { name = "HeavyVehicle"; } } class Truck extends HeavyVehicle { Truck() { name = "Truck"; } } class LightVehicle extends Vehicle { LightVehicle() { name = "LightVehicle"; } } public class InstanceOfExample { static static static static public boolean result; HeavyVehicle hV = new HeavyVehicle(); Truck T = new Truck(); HeavyVehicle hv2 = null; static void main(String[] args) { result = hV instanceof HeavyVehicle; System.out.print("hV is an HeavyVehicle: " + result + "\n"); result = T instanceof HeavyVehicle; System.out.print("T is an HeavyVehicle: " + result + "\n"); result = hV instanceof Truck; System.out.print("hV is a Truck: " + result + "\n"); result = hv2 instanceof HeavyVehicle; System.out.print("hv2 is an HeavyVehicle: " + result + "\n"); hV = T; //Sucessful Cast form child to parent T = (Truck) hV; //Sucessful Explicit Cast form parent to child
} } Download instanceof operator Source Code Output hV is an HeavyVehicle: true T is an HeavyVehicle: true hV is a Truck: false hv2 is an HeavyVehicle: false
Note: hv2 does not yet reference an HeavyVehicle object, instanceof returns false. Also
we cant use instanceof operator with siblings
71
Java Abstract class and Interface

Abstract Class in java
Java Abstract classes are used to declare common characteristics of subclasses. An abstract class cannot be instantiated. It can only be used as a superclass for other classes that extend the abstract class. Abstract classes are declared with the abstract keyword. Abstract classes are used to provide a template or design for concrete subclasses down the inheritance tree. Like any other class, an abstract class can contain fields that describe the characteristics and methods that describe the actions that a class can perform. An abstract class can include methods that contain no implementation. These are called abstract methods. The abstract method declaration must then end with a semicolon rather than a block. If a class has any abstract methods, whether declared or inherited, the entire class must be declared abstract. Abstract methods are used to provide a template for the classes that inherit the abstract methods. Abstract classes cannot be instantiated; they must be subclassed, and actual implementations must be provided for the abstract methods. Any implementation specified can, of course, be overridden by additional subclasses. An object must have an implementation for all of its methods. You need to create a subclass that provides an implementation for the abstract method. A class abstract Vehicle might be specified as abstract to represent the general abstraction of a vehicle, as creating instances of the class would not be meaningful.
abstract class Vehicle { int numofGears; String color; abstract boolean hasDiskBrake(); abstract int getNoofGears(); }
Example of a shape class as an abstract class
abstract class Shape { public String color; public Shape() { } public void setColor(String c) { color = c;
72
} public String getColor() { return color; } abstract public double area(); }
We can also implement the generic shapes class as an abstract class so that we can draw lines, circles, triangles etc. All shapes have some common fields and methods, but each can, of course, add more fields and methods. The abstract class guarantees that each shape will have the same set of basic properties. We declare this class abstract because there is no such thing as a generic shape. There can only be concrete shapes such as squares, circles, triangles etc. public class Point extends Shape { static int x, y; public Point() { x = 0; y = 0; } public double area() { return 0; } public double perimeter() { return 0; } public static void print() { System.out.println("point: " + x + "," + y); } public static void main(String args[]) { Point p = new Point(); p.print(); } } Output point: 0, 0 Notice that, in order to create a Point object, its class cannot be abstract. This means that all of the abstract methods of the Shape class must be implemented by the Point class. The subclass must define an implementation for every abstract method of the abstract superclass, or the subclass itself will also be abstract. Similarly other shape objects can be created using the generic Shape Abstract class. A big Disadvantage of using abstract classes is not able to use multiple inheritance. In the sense, when a class extends an abstract class, it cant extend any other class.
73
Java Interface
In Java, this multiple inheritance problem is solved with a powerful construct called interfaces. Interface can be used to define a generic template and then one or more abstract classes to define partial implementations of the interface. Interfaces just specify the method declaration (implicitly public and abstract) and can only contain fields (which are implicitly public static final). Interface definition begins with a keyword interface. An interface like that of an abstract class cannot be instantiated. Multiple Inheritance is allowed when extending interfaces i.e. one interface can extend none, one or more interfaces. Java does not support multiple inheritance, but it allows you to extend one class and implement many interfaces. If a class that implements an interface does not define all the methods of the interface, then it must be declared abstract and the method definitions must be provided by the subclass that extends the abstract class. Example 1: Below is an example of a Shape interface
interface Shape { public double area(); public double volume(); }

Below is a Point class that implements the Shape interface.
public class Point implements Shape { static int x, y; public Point() { x = 0; y = 0; } public double area() { return 0; } public double volume() { return 0; } public static void print() { System.out.println("point: " + x + "," + y); } public static void main(String args[]) { Point p = new Point(); p.print(); } }
74
Similarly, other shape objects can be created by interface programming by implementing generic Shape Interface. Example 2: Below is a java interfaces program showing the power of interface programming in java Listing below shows 2 interfaces and 4 classes one being an abstract class. Note: The method toString in class A1 is an overridden version of the method defined in the class named Object. The classes B1 and C1 satisfy the interface contract. But since the class D1 does not define all the methods of the implemented interface I2, the class D1 is declared abstract. Also, i1.methodI2() produces a compilation error as the method is not declared in I1 or any of its super interfaces if present. Hence a downcast of interface reference I1 solves the problem as shown in the program. The same problem applies to i1.methodA1(), which is again resolved by a downcast. When we invoke the toString() method which is a method of an Object, there does not seem to be any problem as every interface or class extends Object and any class can override the default toString() to suit your application needs. ((C1)o1).methodI1() compiles successfully, but produces a ClassCastException at runtime. This is because B1 does not have any relationship with C1 except they are siblings. You cant cast siblings into one another. When a given interface method is invoked on a given reference, the behavior that results will be appropriate to the class from which that particular object was instantiated. This is runtime polymorphism based on interfaces and overridden methods. interface I1 { void methodI1(); // public static by default } interface I2 extends I1 { void methodI2(); // public static by default } class A1 { public String methodA1() { String strA1 = "I am in methodC1 of class A1"; return strA1; } public String toString() { return "toString() method of class A1"; } } class B1 extends A1 implements I2 { public void methodI1() {
75
System.out.println("I am in methodI1 of class B1"); } public void methodI2() { System.out.println("I am in methodI2 of class B1"); } } class C1 implements I2 { public void methodI1() { System.out.println("I am in methodI1 of class C1"); } public void methodI2() { System.out.println("I am in methodI2 of class C1"); } } // Note that the class is declared as abstract as it does not // satisfy the interface contract abstract class D1 implements I2 { public void methodI1() { } // This class does not implement methodI2() hence declared abstract. } public class InterFaceEx {
public static void main(String[] args) { I1 i1 = new B1(); i1.methodI1(); // OK as methodI1 is present in B1 // i1.methodI2(); Compilation error as methodI2 not present in I1 // Casting to convert the type of the reference from type I1 to type I2 ((I2) i1).methodI2(); I2 i2 = new B1(); i2.methodI1(); // OK i2.methodI2(); // OK // Does not Compile as methodA1() not present in interface reference I1 // String var = i1.methodA1(); // Hence I1 requires a cast to invoke methodA1 String var2 = ((A1) i1).methodA1(); System.out.println("var2 : " + var2); String var3 = ((B1) i1).methodA1(); System.out.println("var3 : " + var3); String var4 = i1.toString(); System.out.println("var4 : " + var4); String var5 = i2.toString(); System.out.println("var5 : " + var5); I1 i3 = new C1(); String var6 = i3.toString(); System.out.println("var6 : " + var6); // It prints the Object toString() method Object o1 = new B1(); // o1.methodI1(); does not compile as Object class does not define // methodI1() // To solve the probelm we need to downcast o1 reference. We can do it // in the following 4 ways ((I1) o1).methodI1(); // 1 ((I2) o1).methodI1(); // 2 ((B1) o1).methodI1(); // 3 /*
76
* * B1 does not have any relationship with C1 except they are "siblings". * * Well, you can't cast siblings into one another. * */ // ((C1)o1).methodI1(); Produces a ClassCastException } } Output I am in methodI1 of class B1 I am in methodI2 of class B1 I am in methodI1 of class B1 I am in methodI2 of class B1 var2 : I am in methodC1 of class var3 : I am in methodC1 of class var4 : toString() method of class var5 : toString() method of class var6 : C1@190d11 I am in methodI1 of class B1 I am in methodI1 of class B1 I am in methodI1 of class B1
A1 A1 A1 A1
Download Java Interface Program Example ~~~~~~~~~~~~
Polymorphism
Polymorphism means one name, many forms. There are 3 distinct forms of Java Polymorphism; Method overloading (Compile time polymorphism) Method overriding through inheritance (Run time polymorphism) Method overriding through the Java interface (Run time polymorphism) Polymorphism allows a reference to denote objects of different types at different times during execution. A super type reference exhibits polymorphic behavior, since it can denote objects of its subtypes. interface Shape { public double area(); public double volume(); } class Cube implements Shape {
77
int x = 10; public double area( ) { return (6 * x * x); } public double volume() { return (x * x * x); } } class Circle implements Shape { int radius = 10; public double area() { return (Math.PI * radius * radius); } public double volume() { return 0; } } public class PolymorphismTest { public static void main(String args[]) { Shape[] s = { new Cube(), new Circle() }; for (int i = 0; i < s.length; i++) { System.out.println("The area and volume of " + s[i].getClass() + " is " + s[i].area() + " , " + s[i].volume()); } } } Output The area and volume of class Cube is 600.0 , 1000.0 The area and volume of class Circle is 314.1592653589793 , 0.0 Download Java Polymorphism Program Example The methods area() and volume() are overridden in the implementing classes. The invocation of the both methods area and volume is determined based on run time polymorphism of the current object as shown in the output.
Interface vs Abstract Class

Interface vs Abstract Class Taken from http://interview-questions-java.com/abstract-class-interface.htm 1. Abstract class is a class which contain one or more abstract methods, which has to be implemented by sub classes. An abstract class can contain no abstract methods also i.e. abstract class may contain concrete methods. A Java Interface can contain only method
78
declarations and public static final constants and doesnt contain their implementation. The classes which implement the Interface must provide the method definition for all the methods present. 2. Abstract class definition begins with the keyword abstract keyword followed by Class definition. An Interface definition begins with the keyword interface. 3. Abstract classes are useful in a situation when some general methods should be implemented and specialization behavior should be implemented by subclasses. Interfaces are useful in a situation when all its properties need to be implemented by subclasses 4. All variables in an Interface are by default - public static final while an abstract class can have instance variables. 5. An interface is also used in situations when a class needs to extend an other class apart from the abstract class. In such situations its not possible to have multiple inheritance of classes. An interface on the other hand can be used when it is required to implement one or more interfaces. Abstract class does not support Multiple Inheritance whereas an Interface supports multiple Inheritance. 6. An Interface can only have public members whereas an abstract class can contain private as well as protected members. 7. A class implementing an interface must implement all of the methods defined in the interface, while a class extending an abstract class need not implement any of the methods defined in the abstract class. 8. The problem with an interface is, if you want to add a new feature (method) in its contract, then you MUST implement those method in all of the classes which implement that interface. However, in the case of an abstract class, the method can be simply implemented in the abstract class and the same can be called by its subclass 9. Interfaces are slow as it requires extra indirection to to find corresponding method in in the actual class. Abstract classes are fast 10.Interfaces are often used to describe the peripheral abilities of a class, and not its central identity, E.g. an Automobile class might implement the Recyclable interface, which could apply to many otherwise totally unrelated objects. Note: There is no difference between a fully abstract class (all methods declared as abstract and all fields are public static final) and an interface. Note: If the various objects are all of-a-kind, and share a common state and behavior, then tend towards a common base class. If all they share is a set of method signatures, then tend towards an interface.
79
Similarities: Neither Abstract classes nor Interface can be instantiated.
Java Method Overriding
Method Overriding is achieved when a subclass overrides non-static methods defined in the superclass, following which the new method implementation in the subclass that is executed. The new method definition must have the same method signature (i.e., method name and parameters) and return type. Only parameter types and return type are chosen as criteria for matching method signature. So if a subclass has its method parameters as final it doesnt really matter for method overriding scenarios as it still holds true. The new method definition cannot narrow the accessibility of the method, but it can widen it. The new method definition can only specify all or none, or a subset of the exception classes (including their subclasses) specified in the throws clause of the overridden method in the super class
A program to explain the different concepts of Java Method Overridding

class CustomException extends Exception { } class SuperClassWithDifferentMethods { protected int field1 = 10; protected static int field2 = 20; public void method1() { System.out.println("SuperClassWithDifferentMethods.method1()"); } public final void method2() { System.out.println("SuperClassWithDifferentMethods.method2()"); } private void method3() { System.out.println("SuperClassWithDifferentMethods.method3()"); } private final void method4() { System.out.println("SuperClassWithDifferentMethods.method4()"); } public static void method5() { System.out.println("SuperClassWithDifferentMethods.method5()"); } public void method6() throws Exception { System.out.println("SuperClassWithDifferentMethods.method6()");
80
} private void method7() { System.out.println("SuperClassWithDifferentMethods.method7()"); } private void method8(int x) { System.out.println("SuperClassWithDifferentMethods.method8()"); } public static void method9() { System.out.println("SuperClassWithDifferentMethods.method9()"); } } class OverridingClass extends SuperClassWithDifferentMethods { public int field1 = 30; public static int field2 = 40; public void method1() { System.out.println("OverridingClass.method1()"); } //We can't override a public final method /* public final void method2(){ System.out.println("OverridingClass.method2()"); }*/ private void method3() { System.out.println("OverridingClass.method3()"); } private final void method4() { System.out.println("OverridingClass.method4()"); } public static void method5() { System.out.println("OverridingClass.method5()"); } public void method6() throws CustomException { System.out.println("OverridingClass.method6()"); } public void method7() { System.out.println("OverridingClass.method7()"); } public void method8(final int x) { System.out.println("OverridingClass.method8()"); } //A static method cannot be overridden to be non-static instance method /*public void method9() { System.out.println("OverridingClass.method9()"); }*/ } public class MethodOverridingDemo { public static void main(String[] args) { OverridingClass oc1 = new OverridingClass(); SuperClassWithDifferentMethods sc3 = new OverridingClass(); oc1.method1(); oc1.method2(); // Since its private, the below 2 methods are not visible /* oc1.method3();
81
oc1.method4();*/ oc1.method5(); try { oc1.method6(); } catch (CustomException e) { e.printStackTrace(); } oc1.method7(); oc1.method8(100); System.out.println("oc1.field1 : " + oc1.field1); System.out.println("oc1.field2 : " + oc1.field2); System.out.println("sc3.field1 : " + sc3.field1); System.out.println("sc3.field2 : " + sc3.field2); sc3.method5(); OverridingClass overClass = new OverridingClass(); SuperClassWithDifferentMethods supClass = (SuperClassWithDifferentMethods) overClass; supClass.method5(); supClass.method1(); } }
Output
OverridingClass.method1() SuperClassWithDifferentMethods.method2() OverridingClass.method5() OverridingClass.method6() OverridingClass.method7() OverridingClass.method8() oc1.field1 : 30 oc1.field2 : 40 sc3.field1 : 10 sc3.field2 : 20 SuperClassWithDifferentMethods.method5() SuperClassWithDifferentMethods.method5() OverridingClass.method1() Download MethodOverridingDemo.java The new method definitions in the subclass OverridingClass have the same signature and the same return type as the methods in the superclass SuperClassWithDifferentMethods. The new overridden method6 definition specifies a subset of the exceptions (CustomException). The new overridden method7 definition also widens the accessibility to public from private. The overriding method8 also declares the parameter to be final, which is not a part of the method signature and Method Overriding holds good. A static method cannot be overridden to be non-static instance method as shown in the overridden method declaration of method9. A static method is class-specific and not part of any object, while overriding methods are invoked on behalf of objects of the subclass. There are no such restrictions on the fields, as for fields only the field names matter. A
82
final method cannot be overridden, an attempt to which will result in a compile-time error. A private method is not accessible outside the class in which it is defined; therefore, a subclass cannot override it. A subclass must use the super keyword in order to invoke an overridden method in the superclass. A subclass cannot override fields of the superclass, but it can hide them. Code in the subclass can use the keyword super to access members, including hidden fields. The following distinction between invoking instance methods on an object and accessing fields of an object must be noted. When an instance method is invoked on an object using a reference, it is the class of the current object denoted by the reference, not the type of the reference, that determines which method implementation will be executed. When a field of an object is accessed using a reference, it is the type of the reference, not the class of the current object denoted by the reference, that determines which field will actually be accessed. This is demonstrated in the above program.
Java String Class
Strings in java
Java String Class is immutable, i.e. Strings in java, once created and initialized, cannot be changed on the same reference. A java.lang.String class is final which implies no class and extend it. The java.lang.String class differs from other classes, one difference being that the String objects can be used with the += and + operators for concatenation. Two useful methods for String objects are equals( ) and substring( ). The equals( ) method is used for testing whether two Strings contain the same value. The substring( ) method is used to obtain a selected portion of a String.
Java.lang.String class creation

A simple String can be created using a string literal enclosed inside double quotes as shown; String str1 = My name is bob; Since a string literal is a reference, it can be manipulated like any other String reference. The reference value of a string literal can be assigned to another String reference.
83
If 2 or more Strings have the same set of characters in the same sequence then they share the same reference in memory. Below illustrates this phenomenon. String String String String String String str1 = My name is bob; str2 = My name is bob; str3 = My name + is bob; //Compile time expression name = bob; str4 = My name is + name; str5 = new String(My name is bob);
In the above code all the String references str1, str2 and str3 denote the same String object, initialized with the character string: My name is bob. But the Strings str4 and str5 denote new String objects. Constructing String objects can also be done from arrays of bytes, arrays of characters, or string buffers. A simple way to convert any primitive value to its string representation is by concatenating it with the empty string ("), using the string concatenation operator (+).
public class StringsDemo { public static void main(String[] args) { byte[] bytes = {2, 4, 6, 8}; char[] characters = {'a', 'b', 'C', 'D'}; StringBuffer strBuffer = new StringBuffer("abcde"); // Examples of Creation of Strings String byteStr = new String(bytes); String charStr = new String(characters); String buffStr = new String(strBuffer); System.out.println("byteStr : "+byteStr); System.out.println("charStr : "+charStr); System.out.println("buffStr : "+buffStr); } }
Download StringDemo1.java
84
Output byteStr : charStr : abCD buffStr : abcde ~~~~~~~~~~~~
String Equality
public class StringsDemo2 { public static void main(String[] args) { String str1 = "My name is bob"; String str2 = "My name is bob"; String str3 = "My name " + "is bob"; //Compile time expression String name = "bob"; String str4 = "My name is " + name; String str5 = new String("My name is bob"); System.out.println("str1 == str2 : " + (str1 == str2)); System.out.println("str2 == str3 : " + (str2 == str3)); System.out.println("str3 == str1 : " + (str3 == str1)); System.out.println("str4 == str5 : " + (str4 == str5)); System.out.println("str1 == str4 : " + (str1 == str4)); System.out.println("str1 == str5 : " + (str1 == str5)); System.out.println("str1.equals(str2) : " + str1.equals(str2)); System.out.println("str2.equals(str3) : " + str2.equals(str3)); System.out.println("str3.equals(str1) : " + str3.equals(str1)); System.out.println("str4.equals(str5) : " + str4.equals(str5)); System.out.println("str1.equals(str4) : " + str1.equals(str4)); System.out.println("str1.equals(str5) : " + str1.equals(str5)); } } Download StringDemo2.java Output str1 == str2 : true str2 == str3 : true str3 == str1 : true str4 == str5 : false str1 == str4 : false str1 == str5 : false str1.equals(str2) : true str2.equals(str3) : true str3.equals(str1) : true str4.equals(str5) : true str1.equals(str4) : true str1.equals(str5) : true
Java String Functions

85
The following program explains the usage of the some of the basic String methods like ; 1. compareTo(String anotherString) Compares two strings lexicographically. 2. charAt(int index) Returns the character at the specified index. 3. getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) Copies characters from this string into the destination character array. 4. length() Returns the length of this string. 5. equals(Object anObject) Compares this string to the specified object. 6. equalsIgnoreCase(String anotherString) Compares this String to another String, ignoring case considerations. 7. toUpperCase() Converts all of the characters in this String to upper case using the rules of the default locale. 7. toLowerCase() Converts all of the characters in this String to upper case using the rules of the default locale. 9. concat(String str) Concatenates the specified string to the end of this string. 10. indexOf(int ch) Returns the index within this string of the first occurrence of the specified character. 11. indexOf(int ch, int fromIndex) Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index. 12. indexOf(String str) Returns the index within this string of the first occurrence of the specified substring. 13. indexOf(String str, int fromIndex)
86
Returns the index within this string of the first occurrence of the specified substring, starting at the specified index. 14. lastIndexOf(int ch) Returns the index within this string of the last occurrence of the specified character. 15. lastIndexOf(int ch, int fromIndex) Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index. 16. lastIndexOf(String str) Returns the index within this string of the rightmost occurrence of the specified substring. 17. lastIndexOf(String str, int fromIndex) Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index. 18. substring(int beginIndex) Returns a new string that is a substring of this string. 19. substring(int beginIndex, int endIndex) Returns a new string that is a substring of this string. 20. replace(char oldChar, char newChar) Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar. 21. trim() Returns a copy of the string, with leading and trailing whitespace omitted. 22. toString() This object (which is already a string!) is itself returned. public class StringsDemo3 { public static void main(String[] args) { String str1 = "My name is bob"; char str2[] = new char[str1.length()];
87
String str3 = "bob"; String str4 = "cob"; String str5 = "BoB"; String str6 = "bob"; System.out.println("Length of the String str1 : " + str1.length()); System.out.println("Character at position 3 is : " + str1.charAt(3)); str1.getChars(0, str1.length(), str2, 0); System.out.print("The String str2 is : "); for (int i = 0; i < str2.length; i++) { System.out.print(str2[i]); } System.out.println(); System.out.print("Comparision Test : "); if (str3.compareTo(str4) < 0) { System.out.print(str3 + " < " + str4); } else if (str3.compareTo(str4) > 0) { System.out.print(str3 + " > " + str4); } else { System.out.print(str3 + " equals " + str4); } System.out.println(); System.out.print("Equals Test"); System.out.println("str3.equalsIgnoreCase(5) : " + str3.equalsIgnoreCase(str5)); System.out.println("str3.equals(6) : " + str3.equals(str6)); System.out.println("str1.equals(3) : " + str1.equals(str3)); str5.toUpperCase(); //Strings are immutable System.out.println("str5 : " + str5); String temp = str5.toUpperCase(); System.out.println("str5 Uppercase: " + temp); temp = str1.toLowerCase(); System.out.println("str1 Lowercase: " + str1); System.out.println("str1.concat(str4): " + str1.concat(str4)); String str7temp = " \t\n Now for some Search and Replace Examples String str7 = str7temp.trim(); System.out.println("str7 : " + str7); String newStr = str7.replace('s', 'T'); System.out.println("newStr : " + newStr); System.out.println("indexof Operations on Strings"); System.out.println("Index of p in " + str7 + " : " + str7.indexOf('p')); System.out.println("Index of for in " + str7 + " : " + str7.indexOf("for")); System.out.println("str7.indexOf(for, 30) : " + str7.indexOf("for", 30)); System.out.println("str7.indexOf('p', 30) : " + str7.indexOf('p', 30)); System.out.println("str7.lastIndexOf('p') : " + str7.lastIndexOf('p')); System.out.println("str7.lastIndexOf('p', 4) : " + str7.lastIndexOf('p', 4)); System.out.print("SubString Operations on Strings"); String str8 = "SubString Example"; String sub5 = str8.substring(5); // "ring Example" String sub3_6 = str8.substring(3, 6); // "Str" System.out.println("str8 : " + str8); System.out.println("str8.substring(5) : " + sub5); System.out.println("str8.substring(3,6) : " + sub3_6); } }
";
88
Download StringDemo3.java Output Length of the String str1 : 14 Character at position 3 is : n The String str2 is : My name is bob Comparision Test : bob < cob Equals Teststr3.equalsIgnoreCase(5) : true str3.equals(6) : true str1.equals(3) : false str5 : BoB str5 Uppercase: BOB str1 Lowercase: My name is bob str1.concat(str4): My name is bobcob str7 : Now for some Search and Replace Examples newStr : Now for Tome Search and Replace ExampleT Indexof Operations on Strings Index of p in Now for some Search and Replace Examples : 26 Index of for in Now for some Search and Replace Examples : 4 str7.indexOf(for, 30) : -1 str7.indexOf(p', 30) : 36 str7.lastIndexOf(p') : 36 str7.lastIndexOf(p', 4) : -1 SubString Operations on Stringsstr8 : SubString Example str8.substring(5) : ring Example str8.substring(3,6) : Str Below is a program to check for Alpha Numeric characters in the string.
public class TestAlphaNumericCharacters { private void isAlphaNumeric(final String input) { boolean isCharFlag = false; boolean isNumberFlag = false; final char[] chars = input.toCharArray(); for (int x = 0; x < chars.length; x++) { char c = chars[x]; // lowercase && uppercase alphabet if ((c >= 'a') && (c <= 'z') || (c >= 'A') && (c <= 'Z')) { isCharFlag = true; continue; } if ((c >= '0') && (c <= '9')) { // numeric isNumberFlag = true; continue; }
89
} System.out.println("characters are present:" + isCharFlag); System.out.println("Numbers are present :" + isNumberFlag); } public static void main(String[] args) { TestAlphaNumericCharacters tANC = new TestAlphaNumericCharacters(); tANC.isAlphaNumeric("beginn3ers"); } } Download TestAlphaNumericCharacters.java
Output characters are present:true Numbers are present :true Below is a java program to Reverse a string (Reverse by words / characters) import java.util.*; public class StringReverse { public static void main(String[] args) { String input = "beginner java tutorial"; Stack stack = new Stack(); //A Stack is a Last In First Out Data Structure StringTokenizer stringTokenizer = new StringTokenizer(input); while (stringTokenizer.hasMoreTokens()) { stack.push(stringTokenizer.nextElement()); } System.out.println("Original String: " + input); System.out.print("Reversed String by Words: "); while (!stack.empty()) { System.out.print(stack.pop()); System.out.print(" "); } System.out.println(); System.out.print("Reversed String by characters: "); StringBuffer rev = new StringBuffer(input).reverse(); System.out.print(rev); } } Download StringReverse.java Output Original String: beginner java tutorial Reversed String by Words: tutorial java beginner Reversed String by characters: lairotut avaj rennigeb
90
Java toString Method

Implementing toString method in java is done by overriding the Objects toString method. The java toString() method is used when we need a string representation of an object. It is defined in Object class. This method can be overridden to customize the String representation of the Object. Below is a program showing the use of the Objects Default toString java method. class PointCoordinates { private int x, y; public PointCoordinates(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; } } public class ToStringDemo { public static void main(String args[]) { PointCoordinates point = new PointCoordinates(10, 10); // using the Default Object.toString() Method System.out.println("Object toString() method : " + point); // implicitly call toString() on object as part of string concatenation String s = point + " testing"; System.out.println(s); } }
Download ToStringDemo.java
When you run the
ToStringDemo program, the output is:
Object toString() method : PointCoordinates@119c082
PointCoordinates@119c082 testing In the above example when we try printing PointCoordinates object, it internally calls the Objects toString() method as we have not overridden the java toString() method. Since out example has no toString method, the default one in Object is used. The format of the default toString method of the Object is as shown below.
91
Class Name, @, and the hex version of the objects hashcode concatenated into a string. The default hashCode method in Object is typically implemented by converting the memory address of the object into an integer. Below is an example shown of the same program by Overriding the default Object toString() method. The toString() method must be descriptive and should generally cover all the contents of the object. class PointCoordinates { private int x, y; public PointCoordinates(int x, int y) { this.x = x; this.y = y; } public int getX() { return x; } public int getY() { return y; } // Custom toString() Method. public String toString() { return "X=" + x + " " + "Y=" + y; } } public class ToStringDemo2 { public static void main(String args[]) { PointCoordinates point = new PointCoordinates(10, 10); System.out.println(point); String s = point + " testing"; System.out.println(s); } } Download ToStringDemo2.java When you run the ToStringDemo2 program, the output is:
X=10 Y=10 X=10 Y=10 testing
92
Java String Comparison
Java String compare to determine Equality

java string compare can be done in many ways as shown below. Depending on the type of java string compare you need, each of them is used.
* == Operator * equals method * compareTo method
Comparing using the == Operator The == operator is used when we have to compare the String object references. If two String variables point to the same object in memory, the comparison returns true. Otherwise, the comparison returns false. Note that the == operator does not compare the content of the text present in the String objects. It only compares the references the 2 Strings are pointing to. The following Program would print The strings are unequal In the first case and The strings are equal in the second case.
public class StringComparision1 { public static void main(String[] args) { String name1 = "Bob"; String name2 = new String("Bob"); String name3 = "Bob"; // 1st case if (name1 == name2) { System.out.println("The strings } else { System.out.println("The strings } // 2nd case if (name1 == name3) { System.out.println("The strings } else { System.out.println("The strings } } } Download StringComparision1.java Comparing using the equals Method
are equal."); are unequal.");
93
The equals method is used when we need to compare the content of the text present in the String objects. This method returns true when two String objects hold the same content (i.e. the same values). The following Program would print The strings are unequal In the first case and The strings are equal in the second case. public class StringComparision2 { public static void main(String[] args) { String name1 = "Bob"; String name2 = new String("Bob1"); String name3 = "Bob"; // 1st case if (name1.equals(name2)) { System.out.println("The strings } else { System.out.println("The strings } // 2nd case if (name1.equals(name3)) { System.out.println("The strings } else { System.out.println("The strings } } } Download StringComparision2.java Comparing using the compareTo Method The compareTo method is used when we need to determine the order of Strings lexicographically. It compares char values similar to the equals method. The compareTo method returns a negative integer if the first String object precedes the second string. It returns zero if the 2 strings being compared are equal. It returns a positive integer if the first String object follows the second string. The following Program would print name2 follows name1 In the first case and name1 follows name3 in the second case. public class StringComparision3 { public static void main(String[] args) { String name1 = "bob"; String name2 = new String("cob"); String name3 = "Bob"; // 1st case if (name1.compareTo(name2) == 0) { System.out.println("The strings are equal."); } else if (name1.compareTo(name2) < 0) { System.out.println("name2 follows name1"); } else { System.out.println("name1 follows name2"); } // 2nd case. Comparing Ascii Uppercase will be smaller then Lower Case if (name1.compareTo(name3) == 0) { System.out.println("The strings are equal."); } else if (name1.compareTo(name3) < 0) {
94
System.out.println("name3 follows name1"); } else { System.out.println("name1 follows name3"); } } }
Download StringComparision3.java
Java StringBuffer
StringBuffer Class
StringBuffer class is a mutable class unlike the String class which is immutable. Both the capacity and character string of a StringBuffer Class. StringBuffer can be changed dynamically. String buffers are preferred when heavy modification of character strings is involved (appending, inserting, deleting, modifying etc). Strings can be obtained from string buffers. Since the StringBuffer class does not override the equals() method from the Object class, contents of string buffers should be converted to String objects for string comparison. A StringIndexOutOfBoundsException is thrown if an index is not valid when using wrong index in String Buffer manipulations
Creation of StringBuffers
StringBuffer Constructors
public class StringBufferDemo { public static void main(String[] args) { // Examples of Creation of Strings StringBuffer strBuf1 = new StringBuffer("Bob"); StringBuffer strBuf2 = new StringBuffer(100); //With capacity 100 StringBuffer strBuf3 = new StringBuffer(); //Default Capacity 16 System.out.println("strBuf1 : " + strBuf1); System.out.println("strBuf2 capacity : " + strBuf2.capacity()); System.out.println("strBuf3 capacity : " + strBuf3.capacity()); } }
95
Download StringBufferDemo.java
Output
strBuf1 : Bob strBuf2 capacity : 100 strBuf3 capacity : 16
StringBuffer Functions
The following program explains the usage of the some of the basic StringBuffer methods like ;
1. capacity() Returns the current capacity of the String buffer. 2. length() Returns the length (character count) of this string buffer. 3. charAt(int index) The specified character of the sequence currently represented by the string buffer, as indicated by the index argument, is returned. 4. setCharAt(int index, char ch) The character at the specified index of this string buffer is set to ch 5. toString() Converts to a string representing the data in this string buffer 6. insert(int offset, char c) Inserts the string representation of the char argument into this string buffer. Note that the StringBuffer class has got many overloaded insert methods which can be used based on the application need. 7. delete(int start, int end) Removes the characters in a substring of this StringBuffer 8. replace(int start, int end, String str) Replaces the characters in a substring of this StringBuffer with characters in the specified String. 9. reverse() The character sequence contained in this string buffer is replaced by the reverse of the sequence. 10. append(String str) Appends the string to this string buffer.
96
Note that the StringBuffer class has got many overloaded append methods which can be used based on the application need. 11. setLength(int newLength) Sets the length of this String buffer. public class StringBufferFunctionsDemo { public static void main(String[] args) { // Examples of Creation of Strings StringBuffer strBuf1 = new StringBuffer("Bobby"); StringBuffer strBuf2 = new StringBuffer(100); //With capacity 100 StringBuffer strBuf3 = new StringBuffer(); //Default Capacity 16 System.out.println("strBuf1 : " + strBuf1); System.out.println("strBuf1 capacity : " + strBuf1.capacity()); System.out.println("strBuf2 capacity : " + strBuf2.capacity()); System.out.println("strBuf3 capacity : " + strBuf3.capacity()); System.out.println("strBuf1 length : " + strBuf1.length()); System.out.println("strBuf1 charAt 2 : " + strBuf1.charAt(2)); // A StringIndexOutOfBoundsException is thrown if the index is not valid. strBuf1.setCharAt(1, 't'); System.out.println("strBuf1 after setCharAt 1 to t is : " + strBuf1); System.out.println("strBuf1 toString() is : " + strBuf1.toString()); strBuf3.append("beginner-java-tutorial"); System.out.println("strBuf3 when appended with a String : " + strBuf3.toString()); strBuf3.insert(1, 'c'); System.out.println("strBuf3 when c is inserted at 1 : " + strBuf3.toString()); strBuf3.delete(1, 'c'); System.out.println("strBuf3 when c is deleted at 1 : " + strBuf3.toString()); strBuf3.reverse(); System.out.println("Reversed strBuf3 : " + strBuf3); strBuf2.setLength(5); strBuf2.append("jdbc-tutorial"); System.out.println("strBuf2 : " + strBuf2); // We can clear a StringBuffer using the following line strBuf2.setLength(0); System.out.println("strBuf2 when cleared using setLength(0): " + strBuf2); } }
Download StringBufferFunctionsDemo.java
Output
strBuf1 strBuf1 strBuf2 strBuf3 strBuf1 : Bobby capacity : 21 capacity : 100 capacity : 16 length : 5
97
strBuf1 charAt 2 : b strBuf1 after setCharAt 1 to t is : Btbby strBuf1 toString() is : Btbby strBuf3 when appended with a String : beginner-java-tutorial strBuf3 when c is inserted at 1 : bceginner-java-tutorial strBuf3 when c is deleted at 1 : b Reversed strBuf3 : b strBuf2 :
Understanding Java Exceptions
Exceptions in java are any abnormal, unexpected events or extraordinary conditions that may occur at runtime. They could be file not found exception, unable to get connection exception and so on. On such conditions java throws an exception object. Java Exceptions are basically Java objects. No Project can never escape a java error exception. Java exception handling is used to handle error conditions in a program systematically by taking the necessary action. Exception handlers can be written to catch a specific exception such as Number Format exception, or an entire group of exceptions by using a generic exception handlers. Any exceptions not specifically handled within a Java program are caught by the Java run time environment An exception is a subclass of the Exception/Error class, both of which are subclasses of the Throwable class. Java exceptions are raised with the throw keyword and handled within a catch block. A Program Showing How the JVM throws an Exception at runtime
public class DivideException { public static void main(String[] args) { division(100,4); // Line 1 division(100,0); // Line 2 System.out.println("Exit main()."); }
98
public static void division(int totalSum, int totalNumber) { System.out.println("Computing Division."); int average = totalSum/totalNumber; System.out.println("Average : "+ average); } }
Download DivideException.java An ArithmeticException is thrown at runtime when Line 11 is executed because integer division by 0 is an illegal operation. The Exit main() message is never reached in the main method Output Computing Division. java.lang.ArithmeticException: / by zero Average : 25 Computing Division. at DivideException.division(DivideException.java:11) at DivideException.main(DivideException.java:5) Exception in thread main
Exceptions in Java
Throwable Class The Throwable class provides a String variable that can be set by the subclasses to provide a detail message that provides more information of the exception occurred. All classes of throwables define a one-parameter constructor that takes a string as the detail message. The class Throwable provides getMessage() function to retrieve an exception. It has a printStackTrace() method to print the stack trace to the standard error stream. Lastly It also has a toString() method to print a short description of the exception. For more information on what is printed when the following messages are invoked, please refer the java docs. Syntax String getMessage() void printStackTrace() String toString()
99
Class Exception The class Exception represents exceptions that a program faces due to abnormal or special conditions during execution. Exceptions can be of 2 types: Checked (Compile time Exceptions)/ Unchecked (Run time Exceptions). Class RuntimeException Runtime exceptions represent programming errors that manifest at runtime. For example ArrayIndexOutOfBounds, NullPointerException and so on are all subclasses of the java.lang.RuntimeException class, which is a subclass of the Exception class. These are basically business logic programming errors. Class Error Errors are irrecoverable condtions that can never be caught. Example: Memory leak, LinkageError etc. Errors are direct subclass of Throwable class.
Checked and Unchecked Exceptions

Checked exceptions are subclasss of Exception excluding class RuntimeException and its subclasses. Checked Exceptions forces programmers to deal with the exception that may be thrown. Example: Arithmetic exception. When a checked exception occurs in a method, the method must either catch the exception and take the appropriate action, or pass the exception on to its caller Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its subclasses also are unchecked. Unchecked exceptions , however, the compiler doesnt force the programmers to either catch the exception or declare it in a throws clause. In fact, the programmers may not even know that the exception could be thrown. Example: ArrayIndexOutOfBounds Exception. They are either irrecoverable (Errors) and the program should not attempt to deal with them, or they are logical programming errors. (Runtime Exceptions). Checked exceptions must be caught at compile time. Runtime exceptions do not need to be. Errors often cannot be. Exception Statement Syntax Exceptions are handled using a try-catch-finally construct, which has the Syntax try { <code> } catch (<exception type1> <parameter1>) { // 0 or more <statements> } } finally { // finally block <statements> }
100
try Block
The java code that you think may produce an exception is placed within a try block for a suitable catch block to handle the error. If no exception occurs the execution proceeds with the finally block else it will look for the matching catch block to handle the error. Again if the matching catch handler is not found execution proceeds with the finally block and the default exception handler throws an exception.. If an exception is generated within the try block, the remaining statements in the try block are not executed.
catch Block
Exceptions thrown during execution of the try block can be caught and handled in a catch block. On exit from a catch block, normal execution continues and the finally block is executed (Though the catch block throws an exception).
finally Block
A finally block is always executed, regardless of the cause of exit from the try block, or whether any catch block was executed. Generally finally block is used for freeing resources, cleaning up, closing connections etc. If the finally clock executes a control transfer statement such as a return or a break statement, then this control statement determines how the execution will proceed regardless of any return or control statement present in the try or catch. The following program illustrates the scenario.
try { <code> } catch (<exception type1> <parameter1>) { // 0 or more <statements> } } finally { <statements> }
// finally block
Download DivideException2.java Output Computing Division. Exception : / by zero
101
Finally Block Executes. Exception Occurred result : -1 Below is a program showing the Normal Execution of the Program. Please note that no NullPointerException is generated as was expected by most people
public class DivideException2 { public static void main(String[] args) { int result = division(100,0); // Line 2 System.out.println("result : "+result); } public static int division(int totalSum, int totalNumber) { int quotient = -1; System.out.println("Computing Division."); try{ quotient = totalSum/totalNumber; } catch(Exception e){ System.out.println("Exception : "+ e.getMessage()); } finally{ if(quotient != -1){ System.out.println("Finally Block Executes"); System.out.println("Result : "+ quotient); }else{ System.out.println("Finally Block Executes. Exception Occurred"); return quotient; } } return quotient; } }
Output null (And not NullPointerException)
~~~~~~~~~~~~ Rules for try, catch and finally Blocks

1. For each try block there can be zero or more catch blocks, but only
102
one finally block. 2. The catch blocks and finally block must always appear in conjunction with a try block. 3. A try block must be followed by either at least one catch block or one finally block. 4. The order exception handlers in the catch block must be from the most specific exception
Java exception handling mechanism enables you to catch exceptions in java using try, catch, finally block. be An exception consists of a block of code called a try block, a block of code called a catch block, and the finally block. Lets examine each of these in detail.
public class DivideException1 { public static void main(String[] args) { division(100,0); // Line 2 System.out.println("Main Program Terminating"); } public static void division(int totalSum, int totalNumber) { int quotient = -1; System.out.println("Computing Division."); try{ quotient = totalSum/totalNumber; System.out.println("Result is : "+quotient); } catch(Exception e){ System.out.println("Exception : "+ e.getMessage()); } finally{ if(quotient != -1){ System.out.println("Finally Block Executes"); System.out.println("Result : "+ quotient); }else{ System.out.println("Finally Block Executes. Exception Occurred"); } } } }
Download DivideException1.javaOutput Output
103
Computing Division. Exception : / by zero Finally Block Executes. Exception Occurred Main Program Terminating As shown above when the divide by zero calculation is attempted, an ArithmeticException is thrown. and program execution is transferred to the catch statement. Because the exception is thrown from the try block, the remaining statements of the try block are skipped. The finally block executes. Defining new EXCEPTIONS!! We can have our own custom Exception handler to deal with special exception conditions instead of using existing exception classes. Custom exceptions usually extend the Exception class directly or any subclass of Exception (making it checked). The super() call can be used to set a detail message in the throwable. Below is an example that shows the use of Custom exceptions along with how the throw and throws clause are used.
class BadTemperature extends Exception{ BadTemperature( String reason ){ super ( reason ); } } class TooHot extends BadTemperature{ TooHot(){ super ("Default messaeg : Hot"); } TooHot(String message){ super (message); } } class TooCold extends BadTemperature{ TooCold(){ super ("Default messaeg : Cold"); } TooCold(String message){ super (message); } } class TempertureObject{
104
int temperature; TempertureObject( int temp ) { temperature = temp; } void test() throws TooHot, TooCold { if ( temperature < 70 ) throw new TooCold("Very Cold"); if ( temperature > 80 ) throw new TooHot("Very Hot"); } } public class ExceptionExample1{ private static void temperatureReport( TempertureObject batch ){ try{ batch.test(); System.out.println( "Perfect Temperature" ); } catch ( BadTemperature bt ){ System.out.println( bt.getMessage( ) ); } } public static void main( String[] args ){ temperatureReport( new TempertureObject( 100 ) ); temperatureReport( new TempertureObject( 50 ) ); temperatureReport( new TempertureObject( 75 ) ); } }
Download ExceptionExample.javaOutput Output Very Hot Very Cold Perfect Temperature
throw, throws statement

A program can explicitly throw an exception using the throw statement besides the implicit exception thrown. The general format of the throw statement is as follows: throw <exception reference>; The Exception reference must be of type Throwable class or one of its subclasses. A detail message can be passed to the constructor when the exception object is created.
105
throw new TemperatureException(Too hot); A throws clause can be used in the method prototype. Method() throws <ExceptionType1>,, <ExceptionTypen> { } Each <ExceptionTypei> can be a checked or unchecked or sometimes even a custom Exception. The exception type specified in the throws clause in the method prototype can be a super class type of the actual exceptions thrown. Also an overriding method cannot allow more checked exceptions in its throws clause than the inherited method does. When an exception is thrown, normal execution is suspended. The runtime system proceeds to find a matching catch block that can handle the exception. Any associated finally block of a try block encountered along the search path is executed. If no handler is found, then the exception is dealt with by the default exception handler at the top level. If a handler is found, execution resumes with the code in its catch block. Below is an example to show the use of a throws and a throw statement. public class DivideException3 { public static void main(String[] args) { try{ int result = division(100,10); result = division(100,0); System.out.println("result : "+result); } catch(ArithmeticException e){ System.out.println("Exception : "+ e.getMessage()); } } public static int division(int totalSum, int totalNumber) throws ArithmeticException { int quotient = -1; System.out.println("Computing Division."); try{ if(totalNumber == 0){ throw new ArithmeticException("Division attempt by 0"); } quotient = totalSum/totalNumber; } finally{ if(quotient != -1){ System.out.println("Finally Block Executes"); System.out.println("Result : "+ quotient); }else{ System.out.println("Finally Block Executes. Exception Occurred"); } } return quotient;
106
} }
Download DivideException3.javaOutput Output Computing Division. Finally Block Executes Result : 10 Computing Division. Finally Block Executes. Exception Occurred Exception : Division attempt by 0
Using break and return with Exceptions

This example demonstrates the use of the break, continue and return statements with exceptions. Note that the finally block is executed always except when the return statement is executed. public class ExceptionExample6 { public static void main(String[] args) { int x = 10, y = 2; int counter = 0; boolean flag = true; while (flag) { start: try { if ( y > 1 ) break start; if ( y < 0 ) return; x = x / y; System.out.println ( "x : " + x + " y : "+y ); } catch ( Exception e ) { System.out.println ( e.getMessage() ); } finally { ++counter; System.out.println ( "Counter : " + counter ); } --y; } } } Download ExceptionExample6.javaOutput Output
107
Counter : x : 10 y : Counter : / by zero Counter : Counter : 1 1 2 3 4
Handling Multiple Exceptions

It should be known by now that we can have multiple catch blocks for a particular try block to handle many different kind of exceptions that can be generated. Below is a program to demonstrate the use of multiple catch blocks. import java.io.DataInputStream; import java.io.IOException; import javax.swing.JOptionPane; public class ExceptionExample7{ static int numerator, denominator; public ExceptionExample7( int t, int b ){ numerator = t; denominator = b; } public int divide( ) throws ArithmeticException{ return numerator/denominator; } public static void main( String args[] ){ String num, denom; num = JOptionPane.showInputDialog(null, "Enter the Numerator"); denom = JOptionPane.showInputDialog(null, "Enter the Denominator"); try{ numerator = Integer.parseInt( num ); denominator = Integer.parseInt( denom ); } catch ( NumberFormatException nfe ){ System.out.println( "One of the inputs is not an integer" ); return; } catch ( Exception e ){ System.out.println( "Exception: " + e.getMessage( ) ); return; } ExceptionExample7 d = new ExceptionExample7( numerator, denominator ); try{ double result = d.divide( ); JOptionPane.showMessageDialog(null, "Result : " + result); } catch ( ArithmeticException ae ){ System.out.println( "You can't divide by zero" ); }
108
finally{ System.out.println( "Finally Block is always Executed" ); } } } Download ExceptionExample7.java
Java Singleton Design Pattern

Java has several design patterns Singleton Pattern being the most commonly used. Java Singleton patternbelongs to the family of design patterns, that govern the instantiation process. This design pattern proposes that at any time there can only be one instance of a singleton (object) created by the JVM. The classs default constructor is made private, which prevents the direct instantiation of the object by others (Other Classes). A static modifier is applied to the instance method that returns the object as it then makes this method a class level method that can be accessed without creating an object. One such scenario where it might prove useful is when we develop the help Module in a project. Java Help is an extensible, platform-independent help system that enables authors and developers to incorporate online help into applications. Singletons can be used to create a Connection Pool. If programmers create a new connection object in every class that requires it, then its clear waste of resources. In this scenario by using a singleton connection class we can maintain a single connection object which can be used throughout the application.
Implementing Singleton Pattern

To implement this design pattern we need to consider the following 4 steps: Step 1: Provide a default Private constructor public class SingletonObjectDemo { // Note that the constructor is private private SingletonObjectDemo() { // Optional Code } }
109
Step 2: Create a Method for getting the reference to the Singleton Object
public class SingletonObjectDemo { private static SingletonObject singletonObject; // Note that the constructor is private private SingletonObjectDemo() { // Optional Code } public static SingletonObjectDemo getSingletonObject() { if (singletonObject == null) { singletonObject = new SingletonObjectDemo(); } return singletonObject; } } We write a public static getter or access method to get the instance of the Singleton Object at runtime. First time the object is created inside this method as it is null. Subsequent calls to this method returns the same object created as the object is globally declared (private) and the hence the same referenced object is returned.
Step 3: Make the Access method Synchronized to prevent Thread Problems.
public static synchronized SingletonObjectDemo getSingletonObject() It could happen that the access method may be called twice from 2 different classes at the same time and hence more than one object being created. This could violate the design patter principle. In order to prevent the simultaneous invocation of the getter method by 2 threads or classes simultaneously we add the synchronized keyword to the method declaration
Step 4: Override the Object clone method to prevent cloning
We can still be able to create a copy of the Object by cloning it using the Objects clone method. This can be done as shown below SingletonObjectDemo clonedObject = (SingletonObjectDemo) obj.clone(); This again violates the Singleton Design Patterns objective. So to deal with this we need to override the Objects clone method which throws a CloneNotSupportedException exception. public Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException(); } The below program shows the final Implementation of Singleton Design Pattern in java, by using all the 4 steps mentioned above.
110
class SingletonClass { private static SingletonClass singletonObject; /** A private Constructor prevents any other class from instantiating. */ private SingletonClass() { // Optional Code } public static synchronized SingletonClass getSingletonObject() { if (singletonObject == null) { singletonObject = new SingletonClass(); } return singletonObject; } public Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException(); } } public class SingletonObjectDemo { public static void main(String args[]) { // SingletonClass obj = new SingletonClass(); //Compilation error not allowed SingletonClass obj = SingletonClass.getSingletonObject(); // Your Business Logic System.out.println("Singleton object obtained"); } }
Download SingletonObjectDemo.java Another approach We dont need to do a lazy initialization of the instance object or to check for null in the get method. We can also make the singleton class final to avoid sub classing that may cause other problems. public class SingletonClass { private static SingletonClass ourInstance = new SingletonClass(); public static SingletonClass getInstance() { return singletonObj; } private SingletonClass() { } } In Summary, the job of the Singleton class is to enforce the existence of a maximum of one object of the same type at any given time. Depending on your implementation, your class and all of its data might be garbage collected. Hence we must ensure that at any point there must be a live reference to the class when the application is running.
111
Java Threads Tutorial
Introduction to Threads
Multithreading refers to two or more tasks executing concurrently within a single program. A thread is an independent path of execution within a program. Many threads can run concurrently within a program. Every thread in Java is created and controlled by the java.lang.Thread class. A Java program can have many threads, and these threads can run concurrently, either asynchronously or synchronously.
Multithreading has several advantages over Multiprocessing such as;
Threads are lightweight compared to processes Threads share the same address space and therefore can share both data and code Context switching between threads is usually less expensive than between processes Cost of thread intercommunication is relatively low that that of process intercommunication Threads allow different tasks to be performed concurrently.
The following figure shows the methods that are members of the Object and Thread Class.
Thread Creation
There are two ways to create thread in java; Implement the Runnable interface (java.lang.Runnable) By Extending the Thread class (java.lang.Thread)
112
Implementing the Runnable Interface

The Runnable Interface Signature public interface Runnable { void run(); } One way to create a thread in java is to implement the Runnable Interface and then instantiate an object of the class. We need to override the run() method into our class which is the only method that needs to be implemented. The run() method contains the logic of the thread. The procedure for creating threads based on the Runnable interface is as follows: 1. A class implements the Runnable interface, providing the run() method that will be executed by the thread. An object of this class is a Runnable object. 2. An object of Thread class is created by passing a Runnable object as argument to the Thread constructor. The Thread object now has a Runnable object that implements the run() method. 3. The start() method is invoked on the Thread object created in the previous step. The start() method returns immediately after a thread has been spawned. 4. The thread ends when the run() method ends, either by normal completion or by throwing an uncaught exception. Below is a program that illustrates instantiation and running of threads using the runnable interface instead of extending the Thread class. To start the thread you need to invoke the start() method on your object. class RunnableThread implements Runnable { Thread runner; public RunnableThread() { } public RunnableThread(String threadName) { runner = new Thread(this, threadName); // (1) Create a new thread. System.out.println(runner.getName()); runner.start(); // (2) Start the thread. } public void run() { //Display info about this particular thread System.out.println(Thread.currentThread()); } } public class RunnableExample { public static void main(String[] args) { Thread thread1 = new Thread(new RunnableThread(), "thread1");
113
Thread thread2 = new Thread(new RunnableThread(), "thread2"); RunnableThread thread3 = new RunnableThread("thread3"); //Start the threads thread1.start(); thread2.start(); try { //delay for one second Thread.currentThread().sleep(1000); } catch (InterruptedException e) { } //Display info about the main thread System.out.println(Thread.currentThread()); } } Output thread3 Thread[thread1,5,main] Thread[thread2,5,main] Thread[thread3,5,main] Thread[main,5,main]private
Download Runnable Thread Program Example
This approach of creating a thread by implementing the Runnable Interface must be used whenever the class being used to instantiate the thread object is required to extend some other class.
Extending Thread Class

The procedure for creating threads based on extending the Thread is as follows: 1. A class extending the Thread class overrides the run() method from the Thread class to define the code executed by the thread. 2. This subclass may call a Thread constructor explicitly in its constructors to initialize the thread, using the super() call. 3. The start() method inherited from the Thread class is invoked on the object of the class to make the thread eligible for running. Below is a program that illustrates instantiation and running of threads by extending the Thread class instead of implementing the Runnable interface. To start the thread you need to invoke the start() method on your object. class XThread extends Thread { XThread() { } XThread(String threadName) { super(threadName); // Initialize thread. System.out.println(this); start(); }
114
public void run() { //Display info about this particular thread System.out.println(Thread.currentThread().getName()); } } public class ThreadExample { public static void main(String[] args) { Thread thread1 = new Thread(new XThread(), "thread1"); Thread thread2 = new Thread(new XThread(), "thread2"); // The below 2 threads are assigned default names Thread thread3 = new XThread(); Thread thread4 = new XThread(); Thread thread5 = new XThread("thread5"); //Start the threads thread1.start(); thread2.start(); thread3.start(); thread4.start(); try { //The sleep() method is invoked on the main thread to cause a one second delay. Thread.currentThread().sleep(1000); } catch (InterruptedException e) { } //Display info about the main thread System.out.println(Thread.currentThread()); } } Output Thread[thread5,5,main] thread1 thread5 thread2 Thread-3 Thread-2 Thread[main,5,main]
Download Java Thread Program Example
When creating threads, there are two reasons why implementing the Runnable interface may be preferable to extending the Thread class: Extending the Thread class means that the subclass cannot extend any other class, whereas a class implementing the Runnable interface has this option. A class might only be interested in being runnable, and therefore, inheriting the full overhead of the Thread class would be excessive.
An example of an anonymous class below shows how to create a thread and start it: ( new Thread() { public void run() {
115
for(;;) System.out.println(Stop the world!); } } ).start(); ~~~~~~~~~~~~
Thread Synchronization
With respect to multithreading, Synchronization is a process of controlling the access of shared resources by the multiple threads in such a manner that only one thread can access a particular resource at a time. In non synchronized multithreaded application, it is possible for one thread to modify a shared object while another thread is in the process of using or updating the objects value. Synchronization prevents such type of data corruption which may otherwise lead to dirty reads and significant errors. Generally critical sections of the code are usually marked with synchronized keyword. Examples of using Thread Synchronization is in The Producer/Consumer Model. Locks are used to synchronize access to a shared resource. A lock can be associated with a shared resource. Threads gain access to a shared resource by first acquiring the lock associated with the object/block of code. At any given time, at most only one thread can hold the lock and thereby have access to the shared resource. A lock thus implements mutual exclusion. The object lock mechanism enforces the following rules of synchronization: A thread must acquire the object lock associated with a shared resource, before it can enter the shared resource. The runtime system ensures that no other thread can enter a shared resource if another thread already holds the object lock associated with the shared resource. If a thread cannot immediately acquire the object lock, it is blocked, that is, it must wait for the lock to become available. When a thread exits a shared resource, the runtime system ensures that the object lock is also relinquished. If another thread is waiting for this object lock, it can proceed to acquire the lock in order to gain access to the shared resource. Classes also have a class-specific lock that is analogous to the object lock. Such a lock is actually a lock on the java.lang.Class object associated with the class. Given a class A, the reference A.class denotes this unique Class object. The class lock can be used in much the same way as
116
an object lock to implement mutual exclusion. There can be 2 ways through which synchronized can be implemented in Java: synchronized methods synchronized blocks
Synchronized statements are same as synchronized methods. A synchronized statement can only be executed after a thread has acquired the lock on the object/class referenced in the synchronized statement.
Synchronized Methods
Synchronized methods are methods that are used to control access to an object. A thread only executes a synchronized method after it has acquired the lock for the methods object or class. .If the lock is already held by another thread, the calling thread waits. A thread relinquishes the lock simply by returning from the synchronized method, allowing the next thread waiting for this lock to proceed. Synchronized methods are useful in situations where methods can manipulate the state of an object in ways that can corrupt the state if executed concurrently. This is called a race condition. It occurs when two or more threads simultaneously update the same value, and as a consequence, leave the value in an undefined or inconsistent state. While a thread is inside a synchronized method of an object, all other threads that wish to execute this synchronized method or any other synchronized method of the object will have to wait until it gets the lock. This restriction does not apply to the thread that already has the lock and is executing a synchronized method of the object. Such a method can invoke other synchronized methods of the object without being blocked. The non-synchronized methods of the object can of course be called at any time by any thread.
Below is an example shows how synchronized methods and object locks are used to coordinate access to a common object by multiple threads. If the synchronized keyword is removed, the message is displayed in random fashion.
public class SyncMethodsExample extends Thread { static String[] msg = { "Beginner", "java", "tutorial,", ".,", "com", "is", "the", "best" }; public SyncMethodsExample(String id) { super(id); } public static void main(String[] args) { SyncMethodsExample thread1 = new SyncMethodsExample("thread1: "); SyncMethodsExample thread2 = new SyncMethodsExample("thread2: "); thread1.start(); thread2.start(); boolean t1IsAlive = true; boolean t2IsAlive = true; do { if (t1IsAlive && !thread1.isAlive()) { t1IsAlive = false; System.out.println("t1 is dead."); } if (t2IsAlive && !thread2.isAlive()) { t2IsAlive = false;
117
System.out.println("t2 is dead."); } } while (t1IsAlive || t2IsAlive); } void randomWait() { try { Thread.currentThread().sleep((long) (3000 * Math.random())); } catch (InterruptedException e) { System.out.println("Interrupted!"); } } public synchronized void run() { SynchronizedOutput.displayList(getName(), msg); } } class SynchronizedOutput { // if the 'synchronized' keyword is removed, the message // is displayed in random fashion public static synchronized void displayList(String name, String list[]) { for (int i = 0; i < list.length; i++) { SyncMethodsExample t = (SyncMethodsExample) Thread .currentThread(); t.randomWait(); System.out.println(name + list[i]); } } } Output thread1: Beginner thread1: java thread1: tutorial, thread1: ., thread1: com thread1: is thread1: the thread1: best t1 is dead. thread2: Beginner thread2: java thread2: tutorial, thread2: ., thread2: com thread2: is thread2: the thread2: best t2 is dead. Download Synchronized Methods Thread Program Example Class Locks
Synchronized Blocks
118
Static methods synchronize on the class lock. Acquiring and relinquishing a class lock by a thread in order to execute a static synchronized method, proceeds analogous to that of an object lock for a synchronized instance method. A thread acquires the class lock before it can proceed with the execution of any static synchronized method in the class, blocking other threads wishing to execute any such methods in the same class. This, of course, does not apply to static, non-synchronized methods, which can be invoked at any time. Synchronization of static methods in a class is independent from the synchronization of instance methods on objects of the class. A subclass decides whether the new definition of an inherited synchronized method will remain synchronized in the subclass.The synchronized block allows execution of arbitrary code to be synchronized on the lock of an arbitrary object. The general form of the synchronized block is as follows: synchronized (<object reference expression>) { <code block> } A compile-time error occurs if the expression produces a value of any primitive type. If execution of the block completes normally, then the lock is released. If execution of the block completes abruptly, then the lock is released. A thread can hold more than one lock at a time. Synchronized statements can be nested. Synchronized statements with identical expressions can be nested. The expression must evaluate to a non-null reference value, otherwise, a NullPointerException is thrown. The code block is usually related to the object on which the synchronization is being done. This is the case with synchronized methods, where the execution of the method is synchronized on the lock of the current object: public Object method() { synchronized (this) { // Synchronized block on current object // method block } } Once a thread has entered the code block after acquiring the lock on the specified object, no other thread will be able to execute the code block, or any other code requiring the same object lock, until the lock is relinquished. This happens when the execution of the code block completes normally or an uncaught exception is thrown. Object specification in the synchronized statement is mandatory. A class can choose to synchronize the execution of a part of a method, by using the this reference and putting the relevant part of the method in the synchronized block. The braces of the block cannot be left out, even if the code block has just one statement. class SmartClient { BankAccount account; // public void updateTransaction() { synchronized (account) { // (1) synchronized block account.update(); // (2) } } } In the previous example, the code at (2) in the synchronized block at (1) is synchronized on the BankAccount object. If several threads were to concurrently execute the method
119
updateTransaction() on an object of SmartClient, the statement at (2) would be executed by one thread at a time, only after synchronizing on the BankAccount object associated with this particular instance of SmartClient. Inner classes can access data in their enclosing context. An inner object might need to synchronize on its associated outer object, in order to ensure integrity of data in the latter. This is illustrated in the following code where the synchronized block at (5) uses the special form of the this reference to synchronize on the outer object associated with an object of the inner class. This setup ensures that a thread executing the method setPi() in an inner object can only access the private double field myPi at (2) in the synchronized block at (5), by first acquiring the lock on the associated outer object. If another thread has the lock of the associated outer object, the thread in the inner object has to wait for the lock to be relinquished before it can proceed with the execution of the synchronized block at (5). However, synchronizing on an inner object and on its associated outer object are independent of each other, unless enforced explicitly, as in the following code: class Outer { // (1) Top-level Class private double myPi; // (2) protected class Inner { // (3) Non-static member Class public void setPi() { // (4) synchronized(Outer.this) { // (5) Synchronized block on outer object myPi = Math.PI; // (6) } } } } Below example shows how synchronized block and object locks are used to coordinate access to shared objects by multiple threads. public class SyncBlockExample extends Thread { static String[] msg = { "Beginner", "java", "tutorial,", ".,", "com", "is", "the", "best" }; public SyncBlockExample(String id) { super(id); } public static void main(String[] args) { SyncBlockExample thread1 = new SyncBlockExample("thread1: "); SyncBlockExample thread2 = new SyncBlockExample("thread2: "); thread1.start(); thread2.start(); boolean t1IsAlive = true; boolean t2IsAlive = true; do { if (t1IsAlive && !thread1.isAlive()) { t1IsAlive = false; System.out.println("t1 is dead."); } if (t2IsAlive && !thread2.isAlive()) { t2IsAlive = false; System.out.println("t2 is dead."); } } while (t1IsAlive || t2IsAlive); } void randomWait() { try {
120
Thread.currentThread().sleep((long) (3000 * Math.random())); } catch (InterruptedException e) { System.out.println("Interrupted!"); } } public void run() { synchronized (System.out) { for (int i = 0; i < msg.length; i++) { randomWait(); System.out.println(getName() + msg[i]); } } } } Output thread1: Beginner thread1: java thread1: tutorial, thread1: ., thread1: com thread1: is thread1: the thread1: best t1 is dead. thread2: Beginner thread2: java thread2: tutorial, thread2: ., thread2: com thread2: is thread2: the thread2: best t2 is dead. Synchronized blocks can also be specified on a class lock: synchronized (<class name>.class) { <code block> } The block synchronizes on the lock of the object denoted by the reference <class name>.class. A static synchronized method classAction() in class A is equivalent to the following declaration: static void classAction() { synchronized (A.class) { // Synchronized block on class A // } } In summary, a thread can hold a lock on an object
121
by executing a synchronized instance method of the object by executing the body of a synchronized block that synchronizes on the object by executing a synchronized static method of a class ~~~~~~~~~~~~
Thread States
A Java thread is always in one of several states which could be running, sleeping, dead, etc. A thread can be in any of the following states: New Thread state (Ready-to-run state) Runnable state (Running state) Not Runnable state Dead state
New Thread
A thread is in this state when the instantiation of a Thread object creates a new thread but does not start it running. A thread starts life in the Ready-to-run state. You can call only the start() or stop() methods when the thread is in this state. Calling any method besides start() or stop() causes an IllegalThreadStateException.
Runnable
When the start() method is invoked on a New Thread() it gets to the runnable state or running state by calling the run() method. A Runnable thread may actually be running, or may be awaiting its turn to run.
Not Runnable
A thread becomes Not Runnable when one of the following four events occurs: When sleep() method is invoked and it sleeps for a specified amount of time When suspend() method is invoked When the wait() method is invoked and the thread waits for notification of a free resource or waits for the completion of another thread or waits to acquire a lock of an object. The thread is blocking on I/O and waits for its completion
Example: Thread.currentThread().sleep(1000); Note: Thread.currentThread() may return an output like Thread[threadA,5,main] The output shown in bold describes
122
the name of the thread, the priority of the thread, and the name of the group to which it belongs.
Here, the run() method put itself to sleep for one second and becomes Not Runnable during that period. A thread can be awakened abruptly by invoking the interrupt() method on the sleeping thread object or at the end of the period of time for sleep is over. Whether or not it will actually start running depends on its priority and the availability of the CPU. Hence I hereby list the scenarios below to describe how a thread switches form a non runnable to a runnable state: If a thread has been put to sleep, then the specified number of milliseconds must elapse (or it must be interrupted). If a thread has been suspended, then its resume() method must be invoked If a thread is waiting on a condition variable, whatever object owns the variable must relinquish it by calling either notify() or notifyAll(). If a thread is blocked on I/O, then the I/O must complete.
Dead State
A thread enters this state when the run() method has finished executing or when the stop() method is invoked. Once in this state, the thread cannot ever run again. ~~~~~~~~~~~~
Thread Priority
In Java we can specify the priority of each thread relative to other threads. Those threads having higher priority get greater access to available resources then lower priority threads. A Java thread inherits its priority from the thread that created it. Heavy reliance on thread priorities for the behavior of a program can make the program non portable across platforms, as thread scheduling is host platform dependent. You can modify a threads priority at any time after its creation using the setPriority() method and retrieve the thread priority value using getPriority() method. The following static final integer constants are defined in the Thread class: MIN_PRIORITY (0) Lowest Priority NORM_PRIORITY (5) Default Priority MAX_PRIORITY (10) Highest Priority
The priority of an individual thread can be set to any integer value between and including the above defined constants.
123
When two or more threads are ready to be executed and system resource becomes available to execute a thread, the runtime system (the thread scheduler) chooses the Runnable thread with the highest priority for execution. If two threads of the same priority are waiting for the CPU, the thread scheduler chooses one of them to run in a > round-robin fashion. The chosen thread will run until one of the following conditions is true: a higher priority thread becomes Runnable. (Pre-emptive scheduling) it yields, or its run() method exits on systems that support time-slicing, its time allotment has expired
Thread Scheduler
Schedulers in JVM implementations usually employ one of the two following strategies:
Preemptive scheduling
If a thread with a higher priority than all other Runnable threads becomes Runnable, the scheduler will preempt the running thread (is moved to the runnable state) and choose the new higher priority thread for execution.
Time-Slicing or Round-Robin scheduling
A running thread is allowed to execute for a fixed length of time (a time slot its assigned to), after which it moves to the Ready-to-run state (runnable) to await its turn to run again. A thread scheduler is implementation and platform-dependent; therefore, how threads will be scheduled is unpredictable across different platforms.
Yielding
A call to the static method yield(), defined in the Thread class, will cause the current thread in the Running state to move to the Runnable state, thus relinquishing the CPU. The thread is then at the mercy of the thread scheduler as to when it will run again. If there are no threads waiting in the Ready-to-run state, this thread continues execution. If there are other threads in the Ready-to-run state, their priorities determine which thread gets to execute. The yield() method gives other threads of the same priority a chance to run. If there are no equal priority threads in the Runnable state, then the yield is ignored.
Sleeping and Waking Up

The thread class contains a static method named sleep() that causes the currently running thread to pause its execution and transit to the Sleeping state. The method does not relinquish any lock that the thread might have. The thread will sleep for at least the time specified in its argument, before entering the runnable state where it takes its turn to run again. If a thread is interrupted while sleeping, it will throw an InterruptedException when it awakes and gets to execute. The Thread class has several overloaded versions of the sleep() method.
124
Waiting and Notifying

Waiting and notifying provide means of thread inter-communication that synchronizes on the same object. The threads execute wait() and notify() (or notifyAll()) methods on the shared object for this purpose. The notifyAll(), notify() and wait() are methods of the Object class. These methods can be invoked only from within a synchronized context (synchronized method or synchronized block), otherwise, the call will result in an IllegalMonitorStateException. The notifyAll() method wakes up all the threads waiting on the resource. In this situation, the awakened threads compete for the resource. One thread gets the resource and the others go back to waiting. wait() method signatures final void wait(long timeout) throws InterruptedException final void wait(long timeout, int nanos) throws InterruptedException final void wait() throws InterruptedException The wait() call can specify the time the thread should wait before being timed out. An another thread can invoke an interrupt() method on a waiting thread resulting in an InterruptedException. This is a checked exception and hence the code with the wait() method must be enclosed within a try catch block. notify() method signatures final void notify() final void notifyAll() A thread usually calls the wait() method on the object whose lock it holds because a condition for its continued execution was not met. The thread leaves the Running state and transits to the Waiting-for-notification state. There it waits for this condition to occur. The thread relinquishes ownership of the object lock. The releasing of the lock of the shared object by the thread allows other threads to run and execute synchronized code on the same object after acquiring its lock. The wait() method causes the current thread to wait until another thread notifies it of a condition change. A thread in the Waiting-for-notification state can be awakened by the occurrence of any one of these three incidents: 1. Another thread invokes the notify() method on the object of the waiting thread, and the waiting thread is selected as the thread to be awakened. 2. The waiting thread times out. 3. Another thread interrupts the waiting thread. Notify Invoking the notify() method on an object wakes up a single thread that is waiting on the lock of this object. A call to the notify() method has no consequences if there are no threads in the wait set of the object. The notifyAll() method wakes up all threads in the wait set of the shared object. Below program shows three threads, manipulating the same stack. Two of them are pushing elements on the stack, while the third one is popping elements off the stack.
125
This example illustrates how a thread waiting as a result of calling the wait() method on an object, is notified by another thread calling the notify() method on the same object class StackClass { private Object[] stackArray; private volatile int topOfStack; StackClass(int capacity) { stackArray = new Object[capacity]; topOfStack = -1; } public synchronized Object pop() { System.out.println(Thread.currentThread() + ": popping"); while (isEmpty()) { try { System.out.println(Thread.currentThread() + ": waiting to pop"); wait(); } catch (InterruptedException e) { e.printStackTrace(); } } Object obj = stackArray[topOfStack]; stackArray[topOfStack--] = null; System.out.println(Thread.currentThread() + ": notifying after pop"); notify(); return obj; } public synchronized void push(Object element) { System.out.println(Thread.currentThread() + ": pushing"); while (isFull()) { try { System.out.println(Thread.currentThread() + ": waiting to push"); wait(); } catch (InterruptedException e) { e.printStackTrace(); } } stackArray[++topOfStack] = element; System.out.println(Thread.currentThread() + ": notifying after push"); notify(); } public boolean isFull() { return topOfStack >= stackArray.length - 1; } public boolean isEmpty() { return topOfStack < 0; } } abstract class StackUser extends Thread { protected StackClass stack; StackUser(String threadName, StackClass stack) { super(threadName); this.stack = stack; System.out.println(this);
126
setDaemon(true); start(); } } class StackPopper extends StackUser { // Stack Popper StackPopper(String threadName, StackClass stack) { super(threadName, stack); } public void run() { while (true) { stack.pop(); } } } class StackPusher extends StackUser { // Stack Pusher StackPusher(String threadName, StackClass stack) { super(threadName, stack); } public void run() { while (true) { stack.push(new Integer(1)); } } } public class WaitAndNotifyExample { public static void main(String[] args) { StackClass stack = new StackClass(5); new StackPusher("One", stack); new StackPusher("Two", stack); new StackPopper("Three", stack); System.out.println("Main Thread sleeping."); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Exit from Main Thread."); } } Download Wait Notify methods Thread Program Example The field topOfStack in class StackClass is declared volatile, so that read and write operations on this variable will access the master value of this variable, and not any copies, during runtime. Since the threads manipulate the same stack object and the push() and pop() methods in the class StackClassare synchronized, it means that the threads synchronize on the same object. How the program uses wait() and notify() for inter thread communication. (1) The synchronized pop() method - When a thread executing this method on the StackClass object finds that the stack is empty, it invokes the wait() method in order to
127
wait for some other thread to fill the stack by using the synchronized push. Once an other thread makes a push, it invokes the notify method. (2)The synchronized push() method - When a thread executing this method on the StackClass object finds that the stack is full, i t invokes the wait() method to await some other thread to remove an element to provide space for the newly to be pushed element. Once an other thread makes a pop, it invokes the notify method. ~~~~~~~~~~~~
Joining
A thread invokes the join() method on another thread in order to wait for the other thread to complete its execution. Consider a thread t1 invokes the method join() on a thread t2. The join() call has no effect if thread t2 has already completed. If thread t2 is still alive, then thread t1 transits to the Blocked-for-join-completion state. Below is a program showing how threads invoke the overloaded thread join method. public class ThreadJoinDemo { public static void main(String[] args) { Thread t1 = new Thread("T1"); Thread t2 = new Thread("T2"); try { System.out.println("Wait for the child threads to finish."); t1.join(); if (!t1.isAlive()) System.out.println("Thread T1 is not alive."); t2.join(); if (!t2.isAlive()) System.out.println("Thread T2 is not alive."); } catch (InterruptedException e) { System.out.println("Main Thread interrupted."); } System.out.println("Exit from Main Thread."); } } Download Java Thread Join Method Program Example Output Wait for the child threads to finish. Thread T1 is not alive. Thread T2 is not alive. Exit from Main Thread.
Deadlock
There are situations when programs become deadlocked when each thread is waiting on a resource that cannot become available. The simplest form of deadlock is when two threads are each waiting on a resource that is locked by the other thread. Since each
128
thread is waiting for the other thread to relinquish a lock, they both remain waiting forever in the Blocked-for-lock-acquisition state. The threads are said to be deadlocked. Thread t1 at tries to synchronize first on string o1 and then on string o2. The thread t2 does the opposite. It synchronizes first on string o2 then on string o1. Hence a deadlock can occur as explained above. Below is a program that illustrates deadlocks in multithreading applications public class DeadLockExample { String o1 = "Lock "; String o2 = "Step "; Thread t1 = (new Thread("Printer1") { public void run() { while (true) { synchronized (o1) { synchronized (o2) { System.out.println(o1 + o2); } } } } }); Thread t2 = (new Thread("Printer2") { public void run() { while (true) { synchronized (o2) { synchronized (o1) { System.out.println(o2 + o1); } } } } }); public static void main(String[] args) { DeadLockExample dLock = new DeadLockExample(); dLock.t1.start(); dLock.t2.start(); } } Download Java Thread deadlock Program Example Note: The following methods namely join, sleep and wait name the InterruptedException in its throws clause and can have a timeout argument as a parameter. The following methods namely wait, notify and notifyAllshould only be called by a thread that holds the lock of the instance on which the method is invoked. The Thread.start method causes a new thread to get ready to run at the discretion of the thread scheduler. The Runnable interface declares the run method. The Thread class implements the Runnable interface. Some implementations of the Thread.yield method will not yield to a thread of lower priority. A program will terminate only when all user threads stop running. A thread inherits its daemon status from the thread that created it.
129
Java Collections Framework
A collection represents a group of objects, known as its elements. This framework is provided in the java.util package. Objects can be stored, retrieved, and manipulated as elements of collections. Collection is a Java Interface. Collections can be used in various scenarios like Storing phone numbers, Employee names database etc. They are basically used to group multiple elements into a single unit. Some collections allow duplicate elements while others do not. Some collections are ordered and others are not. A Collections Framework mainly contains the following 3 parts A Collections Framework is defined by a set of interfaces, concrete class implementations for most of the interfaces and a set of standard utility methods and algorithms. In addition, the framework also provides several abstract implementations, which are designed to make it easier for you to create new and different implementations for handling collections of data.
Core Collection Interfaces

The core interfaces that define common functionality and allow collections to be manipulated independent of their implementation. The 6 core Interfaces used in the Collection framework are: Collection Set List Iterator (Not a part of the Collections Framework) SortedSet Map SortedMap
Note: Collection and Map are the two top-level interfaces.
130
Collection Interface
131
Map Interface
Concrete Classes
The concrete classes that are specific implementations of the core interfaces, providing data structures that a java program can use.
132
Note: Concrete Classes for the Map is shown in the previous section. Standard utility methods and algorithms
Standard utility methods and algorithms

that can be used to perform various operations on collections, such as sorting, searching or creating customized collections.
How are Collections Used

The collections stores object references, rather than objects themselves. Hence primitive values cannot be stored in a collection directly. They need to be encapsulated (using wrapper classes) into an Object prior to storing them into a Collection (such as HashSet, HashMap etc). The references are always stored as type Object. Thus, when you retrieve an element from a collection, you get an Object rather then the actual type of the collection stored in the database. Hence we need to downcast it to the Actual Type while retrieving an element from a collection.
133
One of the capabilities of the Collection Framework is to create a new Collection object and populate it with the contents of an existing Collection object of a same or different actual type.
Below is an example program showing the storing and retrieving of a few Collection Types import java.util.*; public class CollectionsDemo { public static void main(String[] args) { List a1 = new ArrayList(); a1.add("Beginner"); a1.add("Java"); a1.add("tutorial"); System.out.println(" ArrayList Elements"); System.out.print("\t" + a1); List l1 = new LinkedList(); l1.add("Beginner"); l1.add("Java"); l1.add("tutorial"); System.out.println(); System.out.println(" LinkedList Elements"); System.out.print("\t" + l1); Set s1 = new HashSet(); // or new TreeSet() will order the elements; s1.add("Beginner"); s1.add("Java"); s1.add("Java"); s1.add("tutorial"); System.out.println(); System.out.println(" Set Elements"); System.out.print("\t" + s1); Map m1 = new HashMap(); // or new TreeMap() will order based on keys m1.put("Windows", "98"); m1.put("Win", "XP"); m1.put("Beginner", "Java"); m1.put("Tutorial", "Site"); System.out.println(); System.out.println(" Map Elements"); System.out.print("\t" + m1); } } Output ArrayList Elements [Beginner, Java, tutorial] LinkedList Elements [Beginner, Java, tutorial] Set Elements [tutorial, Beginner, Java] Map Elements {Tutorial=Site, Windows=98, Win=XP, Beginner=Java}
134
Download CollectionsDemo.java
Java Collections Source Code Examples

On the following pages in this tutorial I have described how elements can be manipulated by different collections namely; Java Java Java Java Java Java Java ArrayList LinkedList TreeSet HashMap Vector HashTable HashSet
Java ArrayList
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable Resizable-array implementation of the List interface. A java ArrayList is used to store an ordered group of elements where duplicates are allowed. Implements all optional list operations, and permits all elements, including null. This class is similar to Vector, except that it is unsynchronized. The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. ArrayLists give great performance on get() and set() methods, but do not perform well on add() and remove() methods when compared to a LinkedList. An ArrayList capacity is the size of the array used to store the elements in the list. As elements are added to an ArrayList, its capacity grows automatically. It is an Array based implementation where elements of the List can be accessed directly through get() method.
To prevent unsynchronized access to the list: List list = Collections.synchronizedList(new ArrayList()); Below is an ArrayList Example showing how collections are manipulated using an ArrayList import import import import import java.util.List; java.util.ArrayList; java.util.Iterator; java.util.ListIterator; java.util.Collections;
import java.util.Random;
135
public class ArrayListExample { public static void main(String[] args) { // ArrayList Creation List arraylistA = new ArrayList(); List arraylistB = new ArrayList(); // Adding elements to the ArrayList for (int i = 0; i < 5; i++) { arraylistA.add(new Integer(i)); } arraylistB.add("beginner"); arraylistB.add("java"); arraylistB.add("tutorial"); arraylistB.add("."); arraylistB.add("com"); arraylistB.add("java"); arraylistB.add("site"); // Iterating through the ArrayList to display the Contents. Iterator i1 = arraylistA.iterator(); System.out.print("ArrayList arraylistA --> "); while (i1.hasNext()) { System.out.print(i1.next() + " , "); } System.out.println(); System.out.print("ArrayList arraylistA --> "); for (int j = 0; j < arraylistA.size(); j++) { System.out.print(arraylistA.get(j) + " , "); } System.out.println(); Iterator i2 = arraylistB.iterator(); System.out.println("ArrayList arraylistB --> "); while (i2.hasNext()) { System.out.print(i2.next() + " , "); } System.out.println(); System.out.println(); System.out.println("Using ListIterator to retrieve ArrayList Elements"); System.out.println(); ListIterator li1 = arraylistA.listIterator(); //next(), hasPrevious(), hasNext(), hasNext() nextIndex() can be used with a // ListIterator interface implementation System.out.println("ArrayList arraylistA --> "); while (li1.hasNext()) { System.out.print(li1.next() + " , "); } System.out.println(); // Searching for an element in the ArrayList int index = arraylistB.indexOf("java"); System.out.println("'java' was found at : " + index); int lastIndex = arraylistB.lastIndexOf("java"); System.out.println("'java' was found at : " + lastIndex + " from the last"); System.out.println(); // Getting the subList from the original List List subList = arraylistA.subList(3, arraylistA.size()); System.out.println("New Sub-List(arraylistA) from index 3 to " + arraylistA.size() + ": " + subList); System.out.println(); // Sort an ArrayList System.out.print("Sorted ArrayList arraylistA --> "); Collections.sort(arraylistA);
136
System.out.print(arraylistA); System.out.println(); // Reversing an ArrayList System.out.print("Reversed ArrayList arraylistA --> "); Collections.reverse(arraylistA); System.out.println(arraylistA); System.out.println(); // Checking emptyness of an ArrayList System.out.println("Is arraylistA empty? " + arraylistA.isEmpty()); System.out.println(); // Checking for Equality of ArrayLists ArrayList arraylistC = new ArrayList(arraylistA); System.out.println("arraylistA.equals(arraylistC)? " + arraylistA.equals(arraylistC)); System.out.println(); // Shuffling the elements of an ArrayList in Random Order Collections.shuffle(arraylistA, new Random()); System.out.print("ArrayList arraylistA after shuffling its elements--> "); i1 = arraylistA.iterator(); while (i1.hasNext()) { System.out.print(i1.next() + " , "); } System.out.println(); System.out.println(); // Converting an ArrayList to an Array Object[] array = arraylistA.toArray(); for (int i = 0; i < array.length; i++) { System.out.println("Array Element [" + i + "] = " + array[i]); } System.out.println(); // Clearing ArrayList Elements arraylistA.clear(); System.out.println("arraylistA after clearing : " + arraylistA); System.out.println(); } }
Output ArrayList arraylistA > 0 , 1 , 2 , 3 , 4 , ArrayList arraylistA > 0 , 1 , 2 , 3 , 4 , ArrayList arraylistB > beginner , java , tutorial , . , com , java , site , Using ListIterator to retrieve ArrayList Elements ArrayList arraylistA > 0,1,2,3,4, java was found at : 1 java was found at : 5 from the last New Sub-List(arraylistA) from index 3 to 5: [3, 4]
137
Sorted ArrayList arraylistA > [0, 1, 2, 3, 4] Reversed ArrayList arraylistA > [4, 3, 2, 1, 0] Is arraylistA empty? false arraylistA.equals(arraylistC)? true ArrayList arraylistA after shuffling its elements> 3 , 2 , 1 , 0 , 4 , Array Array Array Array Array Element Element Element Element Element [0] [1] [2] [3] [4] = = = = = 3 2 1 0 4
arraylistA after clearing : []

Download ArrayListExample.java
JavaLinked List
A LinkedList is used to store an ordered group of elements where duplicates are allowed. A LinkedList is based on a double linked list where elements of the List are typically accessed through add() and remove() methods. Below is an LinkedList Example showing how collections are manipulated using an LinkedList
import import import import import import
java.util.List; java.util.LinkedList; java.util.Iterator; java.util.ListIterator; java.util.Collections; java.util.Random;
public class LinkedListExample { public static void main(String[] args) { // LinkedList Creation List linkedListA = new LinkedList(); List linkedListB = new LinkedList(); // Adding elements to the LinkedList for (int i = 0; i < 5; i++) { linkedListA.add(new Integer(i)); } linkedListB.add("beginner"); linkedListB.add("java");
138
linkedListB.add("tutorial"); linkedListB.add("."); linkedListB.add("com"); linkedListB.add("java"); linkedListB.add("site"); // Iterating through the LinkedList Iterator i1 = linkedListA.iterator(); System.out.print("LinkedList linkedListA while (i1.hasNext()) { System.out.print(i1.next() + " , } System.out.println(); System.out.print("LinkedList linkedListA
to display the Contents. --> "); ");
--> ");
for (int j = 0; j < linkedListA.size(); j++) { System.out.print(linkedListA.get(j) + " , "); } System.out.println(); Iterator i2 = linkedListB.iterator(); System.out.println("LinkedList linkedListB --> "); while (i2.hasNext()) { System.out.print(i2.next() + " , "); } System.out.println(); System.out.println(); System.out.println("Using ListIterator to retrieve LinkedList Elements"); System.out.println(); ListIterator li1 = linkedListA.listIterator(); //next(), hasPrevious(), hasNext(), hasNext() nextIndex() can be used with a // ListIterator interface implementation System.out.println("LinkedList linkedListA --> "); while (li1.hasNext()) { System.out.print(li1.next() + " , "); } System.out.println(); // Searching for an element in the LinkedList int index = linkedListB.indexOf("java"); System.out.println("'java' was found at : " + index); int lastIndex = linkedListB.lastIndexOf("java"); System.out.println("'java' was found at : " + lastIndex + " from the last"); System.out.println(); // Getting the subList from the original List List subList = linkedListA.subList(3, linkedListA.size()); System.out.println("New Sub-List(linkedListA) from index 3 to " + linkedListA.size() + ": " + subList); System.out.println(); // Sort an LinkedList System.out.print("Sorted LinkedList linkedListA --> "); Collections.sort(linkedListA); System.out.print(linkedListA); System.out.println(); // Reversing an LinkedList System.out.print("Reversed LinkedList linkedListA --> "); Collections.reverse(linkedListA); System.out.println(linkedListA); System.out.println(); // Checking emptyness of an LinkedList System.out.println("Is linkedListA empty? " + linkedListA.isEmpty()); System.out.println();
139
// Checking for Equality of LinkedLists LinkedList LinkedListC = new LinkedList(linkedListA); System.out.println("linkedListA.equals(LinkedListC)? " + linkedListA.equals(LinkedListC)); System.out.println(); // Shuffling the elements of an LinkedList in Random Order Collections.shuffle(linkedListA, new Random()); System.out.print("LinkedList linkedListA after shuffling its elements--> "); i1 = linkedListA.iterator(); while (i1.hasNext()) { System.out.print(i1.next() + " , "); } System.out.println(); System.out.println(); // Converting an LinkedList to an Array Object[] array = linkedListA.toArray(); for (int i = 0; i < array.length; i++) { System.out.println("Array Element [" + i + "] = " + array[i]); } System.out.println(); // Clearing LinkedList Elements linkedListA.clear(); System.out.println("linkedListA after clearing : " + linkedListA); System.out.println(); } } Output LinkedList linkedListA > 0 , 1 , 2 , 3 , 4 , LinkedList linkedListA > 0 , 1 , 2 , 3 , 4 , LinkedList linkedListB > beginner , java , tutorial , . , com , java , site , Using ListIterator to retrieve LinkedList Elements LinkedList linkedListA > 0,1,2,3,4, java was found at : 1 java was found at : 5 from the last New Sub-List(linkedListA) from index 3 to 5: [3, 4] Sorted LinkedList linkedListA > [0, 1, 2, 3, 4] Reversed LinkedList linkedListA > [4, 3, 2, 1, 0] Is linkedListA empty? false linkedListA.equals(LinkedListC)? true LinkedList linkedListA after shuffling its elements> 3 , 2 , 4 , 0 , 1 ,
140
Array Array Array Array Array Element Element Element Element Element [0] [1] [2] [3] [4] = = = = = 3 2 4 0 1
linkedListA after clearing : []

Download LinkedListExample.java
Java TreeSet
public class TreeSet<E> extends AbstractSet<E> implements SortedSet<E>, Cloneable, Serializable This class implements the Set interface and guarantees that the sorted set will be in ascending element order, sorted according to the natural order of the elements or by the comparator provided at set creation time, depending on which constructor is used. This implementation not synchronized provides guaranteed log(n) time cost for the basic operations (add, remove and contains). To prevent unsynchronized access to the Set.: SortedSet s = Collections.synchronizedSortedSet(new TreeSet(..));
Below is a TreeSet Example showing how collections are manipulated using a TreeSet
import java.util.Set; import java.util.TreeSet; import java.util.Iterator; public class TreeSetExample { public static void doTreeSetExample() { } public static void main(String[] args) { Set treeSet = new TreeSet(); // the treeset stores Integer objects into the TreeSet for (int i = 0; i < 5; i++) { treeSet.add(new Integer(i)); } // Since its a Integer Object Set adding any other elements in the Same // set will produce a // ClassCastException exception at runtime. // treeSet.add("a string"); System.out.print("The elements of the TreeSet are : ");
141
Iterator i = treeSet.iterator(); while (i.hasNext()) { System.out.print(i.next() + "\t"); } } } Output The elements of the TreeSet are : 0 1 2 3 4
Download TreeSetExample.java
Java HashMap
The java HashMap class does not guarantee that the order will remain constant over time. This implementation provides constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets. The HashMap implementation is not synchronized. If multiple threads access this map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally.
To prevent unsynchronized access to the Map: Map m = Collections.synchronizedMap(new HashMap()); Below is a HashMap Example used to store the number of words that begin with a given letter /* * Using a HashMap to store the number of words that begin with a given letter. */ import java.util.HashMap; public class HashMapExample { static String[] names = { "heman", "bob", "hhh", "shawn", "scot","shan", "keeth" }; private static HashMap counter = new HashMap(); private static Integer cnt = null; public static void main(String args[]) { for (int i = 0; i < names.length; i++) { cnt = (Integer) (counter.get(new Character(names[i].charAt(0)))); if (cnt == null) { counter.put(new Character(names[i].charAt(0)),new Integer("1")); } else { counter.put(new Character(names[i].charAt(0)), new Integer(cnt.intValue() + 1));
142
} } System.out.println("\nnumber of words beginning with each letter is shown below "); System.out.println(counter.toString()); } } Output number of words beginning with each letter is shown below {s=3, b=1, k=1, h=2}
Download HashMapExample.java
Java Vector
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable The Vector class implements a growable array of objects where the size of the vector can grow or shrink as needed dynamically. Like an array, it contains components that can be accessed using an integer index. An application can increase the capacity of a vector before inserting a large number of components; this reduces the amount of incremental reallocation.
Below is a Vector Example showing how collections are manipulated using a Vector import import import import import import import import import import import import import import java.awt.Container; java.awt.FlowLayout; java.awt.event.ActionEvent; java.awt.event.ActionListener; java.awt.event.WindowAdapter; java.awt.event.WindowEvent; java.util.Enumeration; java.util.NoSuchElementException; java.util.Vector; javax.swing.JButton; javax.swing.JFrame; javax.swing.JLabel; javax.swing.JOptionPane; javax.swing.JTextField;
public class VectorDemo extends JFrame { private JLabel jlbString = new JLabel("Enter a string"); public VectorDemo() { super("Vector class demo"); // Made final as it can be accessed by inner classes
143
final JLabel jlbStatus = new JLabel(); Container contentPane = getContentPane(); final Vector vector = new Vector(1); contentPane.setLayout(new FlowLayout()); contentPane.add(jlbString); final JTextField jtfInput = new JTextField(10); contentPane.add(jtfInput); JButton jbnAdd = new JButton("Add"); jbnAdd.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { vector.addElement(jtfInput.getText().trim()); jlbStatus.setText("Appended to end: " + jtfInput.getText().trim()); jtfInput.setText(""); } }); contentPane.add(jbnAdd); JButton jbnRemove = new JButton("Remove"); jbnRemove.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // Returns true if element in vector if (vector.removeElement(jtfInput.getText().trim())) jlbStatus.setText("Removed: " + jtfInput.getText()); else jlbStatus.setText(jtfInput.getText().trim() + " not in vector"); } }); contentPane.add(jbnRemove); JButton jbnFirst = new JButton("First"); jbnFirst.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { try { jlbStatus.setText("First element: " + vector.firstElement()); } catch (NoSuchElementException exception) { jlbStatus.setText(exception.toString()); } } }); contentPane.add(jbnFirst); JButton jbnLast = new JButton("Last"); jbnLast.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { try { jlbStatus.setText("Last element: " + vector.lastElement()); } catch (NoSuchElementException exception) { jlbStatus.setText(exception.toString()); } } }); contentPane.add(jbnLast); JButton jbnEmpty = new JButton("Is Empty?"); jbnEmpty.addActionListener(new ActionListener() {
144
public void actionPerformed(ActionEvent e) { jlbStatus.setText(vector.isEmpty() ? "Vector is empty" : "Vector is not empty"); } }); contentPane.add(jbnEmpty); JButton jbnContains = new JButton("Contains"); jbnContains.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { String searchKey = jtfInput.getText().trim(); if (vector.contains(searchKey)) { jlbStatus.setText("Vector contains " + searchKey); } else { jlbStatus.setText("Vector does not contain " + searchKey); } } }); contentPane.add(jbnContains); JButton jbnFindElement = new JButton("Find"); jbnFindElement.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { jlbStatus.setText("Element found at location " + vector.indexOf(jtfInput.getText().trim())); } }); contentPane.add(jbnFindElement); JButton jbnTrim = new JButton("Trim"); jbnTrim.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { vector.trimToSize(); jlbStatus.setText("Vector trimmed to size"); } }); contentPane.add(jbnTrim); JButton jbnSize = new JButton("Size/Capacity"); jbnSize.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { jlbStatus.setText("Size = " + vector.size() + "; Capacity = " + vector.capacity()); } }); contentPane.add(jbnSize); JButton jbnDisplay = new JButton("Display"); jbnDisplay.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { Enumeration enum1 = vector.elements(); StringBuffer buf = new StringBuffer(); while (enum1.hasMoreElements()) buf.append(enum1.nextElement()).append(" "); JOptionPane.showMessageDialog(null, buf.toString(), "Contents of Vector", JOptionPane.PLAIN_MESSAGE); } }); contentPane.add(jbnDisplay);
145
contentPane.add(jlbStatus); setSize(300, 200); setVisible(true); } public static void main(String args[]) { VectorDemo vectorDemo = new VectorDemo(); vectorDemo.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); } } Output
Java HashTable
HashTable is synchronized. Iterator in the HashMap is fail-safe while the enumerator for the Hashtable isnt. Hashtable doesnt allow nulls
Below is a HashTable Example showing how collections are manipulated using a HashTable Please Note that It must be Compiled in Java 1.4. // Demonstrates the Hashtable class of the java.util package. public class HashTableDemo extends JFrame { public HashTableDemo() { super(" Hashtable Sourcecode Example"); final JLabel jlbStatus = new JLabel(); final Hashtable hashTable = new Hashtable(); final JTextArea display = new JTextArea(4, 20); display.setEditable(false);
146
JPanel jplNorth = new JPanel(); jplNorth.setLayout(new BorderLayout()); JPanel jplNorthSub = new JPanel(); jplNorthSub.add(new JLabel("Name (Key)")); final JTextField jtfFirstName = new JTextField(8); jplNorthSub.add(jtfFirstName); jplNorthSub.add(new JLabel("Phone No")); final JTextField jtfPhone = new JTextField(8); jplNorthSub.add(jtfPhone); jplNorth.add(jplNorthSub, BorderLayout.NORTH); jplNorth.add(jlbStatus, BorderLayout.SOUTH); JPanel jplSouth = new JPanel(); jplSouth.setLayout(new GridLayout(2, 5)); JButton jbnAdd = new JButton("Add"); jbnAdd.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { String strNum = jtfPhone.getText().trim(); String strName = jtfFirstName.getText().trim(); if ((strNum != null && strNum.equals("")) || (strName != null && strName.equals(""))) { JOptionPane.showMessageDialog(HashTableDemo.this, "Please enter both Name and Phone No"); return; } int num = 0; try { num = Integer.parseInt(strNum); } catch (NumberFormatException ne) { ne.printStackTrace(); } EmployeeDetails emp = new EmployeeDetails(strName, num); Object val = hashTable.put(strName, emp); if (val == null) jlbStatus.setText("Added: " + emp.toString()); else jlbStatus.setText("Added: " + emp.toString() + "; Replaced: " + val.toString()); } }); jplSouth.add(jbnAdd); JButton jbnGet = new JButton("Get"); jbnGet.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { Object val = hashTable.get(jtfFirstName.getText().trim()); if (val != null) jlbStatus.setText("Get: " + val.toString()); else jlbStatus.setText("Get: " + jtfFirstName.getText()+ " not in table"); } }); jplSouth.add(jbnGet); JButton jbnRemove = new JButton("Remove Name"); jbnRemove.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { Object val = hashTable.remove(jtfFirstName.getText() .trim());
147
if (val != null) jlbStatus.setText("Remove: " + val.toString()); else jlbStatus.setText("Remove: " + jtfFirstName.getText()+ " not in table"); } }); jplSouth.add(jbnRemove); JButton jbnIsEmpty = new JButton("Empty ?"); jbnIsEmpty.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { jlbStatus.setText("Empty: " + hashTable.isEmpty()); } }); jplSouth.add(jbnIsEmpty); JButton jbnContains = new JButton("Contains key"); jbnContains.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { jlbStatus.setText("Contains key: "+ hashTable.containsKey(jtfFirstName.getText().trim())); } }); jplSouth.add(jbnContains); JButton jbnClear = new JButton("Clear table"); jbnClear.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { hashTable.clear(); jlbStatus.setText("HashTable Emptied"); } }); jplSouth.add(jbnClear); JButton jbnDisplay = new JButton("List objects"); jbnDisplay.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { StringBuffer buf = new StringBuffer(); for (Enumeration enum = hashTable.elements(); enum.hasMoreElements();) buf.append(enum.nextElement()).append('\n'); display.setText(buf.toString()); } }); jplSouth.add(jbnDisplay); JButton jbnKeys = new JButton("List keys"); jbnKeys.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { StringBuffer buf = new StringBuffer(); for (Enumeration enum = hashTable.keys(); enum.hasMoreElements();) buf.append(enum.nextElement()).append('\n'); JOptionPane.showMessageDialog(null, buf.toString(), "Display Keys of HashTable ",JOptionPane.PLAIN_MESSAGE); } }); jplSouth.add(jbnKeys); Container c = getContentPane();
148
c.add(jplNorth, BorderLayout.NORTH); c.add(new JScrollPane(display), BorderLayout.CENTER); c.add(jplSouth, BorderLayout.SOUTH); setSize(540, 300); setVisible(true); } public static void main(String args[]) { HashTableDemo hashTableDemo = new HashTableDemo(); hashTableDemo.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); } } class EmployeeDetails { private String name; private int phoneNp; public EmployeeDetails(String fName, int phNo) { name = fName; phoneNp = phNo; } public String toString() { return name + " " + phoneNp; } } Output
149
Java HashSet
The HashSet class implements the Set interface. It makes no guarantee that the order of elements will remain constant over time. This class is not synchronized and permits a null element. This class offers constant time performance for the basic operations (add, remove, contains and size), assuming the hash function disperses the elements properly among the buckets. To prevent unsynchronized access to the Set: Set s = Collections.synchronizedSet(new HashSet());
Below is a HashSet Example showing how collections are manipulated using a HashSet import java.util.*; public class HashSetExample { private static String names[] = { "bob", "hemanth", "hhh", "hero", "shawn", "bob", "mike", "Rick", "rock", "hemanth", "mike", "undertaker" }; public static void main(String args[]) { ArrayList aList; aList = new ArrayList(Arrays.asList(names)); System.out.println("The names elements " + aList); HashSet ref = new HashSet(aList); // create a HashSet Iterator i = ref.iterator(); System.out.println(); System.out.print("Unique names are: "); while (i.hasNext()) System.out.print(i.next() + " "); System.out.println(); } } Output The names elements [bob, hemanth, hhh, hero, shawn, bob, mike, Rick, rock, hemanth, mike, undertaker]
150
Java Date Utility
Java Date API

java.util. Class Date java.lang.Object extended by java.util.Date All Implemented Interfaces: Cloneable, Comparable, Serializable Direct Known Subclasses: Date, Time, Timestamp public class Date extends Object implements Serializable, Cloneable, Comparable The class Date represents a specific instant in time, with millisecond precision.
Java Date Source Code

import import import import import java.text.DateFormat; java.text.ParseException; java.text.SimpleDateFormat; java.util.Calendar; java.util.Date;
public class DateUtility { /* Add Day/Month/Year to a Date add() is used to add values to a Calendar object. You specify which Calendar field is to be affected by the operation (Calendar.YEAR, Calendar.MONTH, Calendar.DATE). */ public static final String DATE_FORMAT = "dd-MM-yyyy"; //See Java DOCS for different date formats // public static final String DATE_FORMAT = "yyyy-MM-dd"; public static void addToDate() { System.out.println("1. Add to a Date Operation\n"); SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT); //Gets a calendar using the default time zone and locale. Calendar c1 = Calendar.getInstance(); Date d1 = new Date(); //System.out.println("Todays date in Calendar Format : "+c1);
151
System.out.println("c1.getTime() : " + c1.getTime()); System.out.println("c1.get(Calendar.YEAR): "+ c1.get(Calendar.YEAR)); System.out.println("Todays date in Date Format : " + d1); c1.set(1999, 0, 20); //(year,month,date) System.out.println("c1.set(1999,0 ,20) : " + c1.getTime()); c1.add(Calendar.DATE, 20); System.out.println("Date + 20 days is : "+ sdf.format(c1.getTime())); System.out.println(); System.out.println("-------------------------------------"); } /*Substract Day/Month/Year to a Date roll() is used to substract values to a Calendar object. You specify which Calendar field is to be affected by the operation (Calendar.YEAR, Calendar.MONTH, Calendar.DATE). Note: To substract, simply use a negative argument. roll() does the same thing except you specify if you want to roll up (add 1) or roll down (substract 1) to the specified Calendar field. The operation only affects the specified field while add() adjusts other Calendar fields. See the following example, roll() makes january rolls to december in the same year while add() substract the YEAR field for the correct result. Hence add() is preferred even for subtraction by using a negative element. */ public static void subToDate() { System.out.println("2. Subtract to a date Operation\n"); SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT); Calendar c1 = Calendar.getInstance(); c1.set(1999, 0, 20); System.out.println("Date is : " + sdf.format(c1.getTime())); // roll down, substract 1 month c1.roll(Calendar.MONTH, false); System.out.println("Date roll down 1 month : "+ sdf.format(c1.getTime())); c1.set(1999, 0, 20); System.out.println("Date is : " + sdf.format(c1.getTime())); c1.add(Calendar.MONTH, -1); // substract 1 month System.out.println("Date minus 1 month : "+ sdf.format(c1.getTime())); System.out.println(); System.out.println("-------------------------------------"); } public static void daysBetween2Dates() { System.out.println("3. No of Days between 2 dates\n"); Calendar c1 = Calendar.getInstance(); //new GregorianCalendar(); Calendar c2 = Calendar.getInstance(); //new GregorianCalendar(); c1.set(1999, 0, 20); c2.set(1999, 0, 22); System.out.println("Days Between " + c1.getTime() + " and " + c2.getTime() + " is"); System.out.println((c2.getTime().getTime() - c1.getTime() .getTime()) / (24 * 3600 * 1000)); System.out.println(); System.out.println("-------------------------------------"); }
152
public static void daysInMonth() { System.out.println("4. No of Days in a month for a given date\n"); Calendar c1 = Calendar.getInstance(); // new GregorianCalendar(); c1.set(1999, 6, 20); int year = c1.get(Calendar.YEAR); int month = c1.get(Calendar.MONTH); // int days = c1.get(Calendar.DATE); int[] daysInMonths = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31 }; daysInMonths[1] += DateUtility.isLeapYear(year) ? 1 : 0; System.out.println("Days in " + month + "th month for year" + year + "is " + daysInMonths[c1.get(Calendar.MONTH)]); System.out.println(); System.out.println("-------------------------------------"); } public static void validateAGivenDate() { System.out.println("5. Validate a given date\n"); String dt = "20011223"; String invalidDt = "20031315"; String dateformat = "yyyyMMdd"; Date dt1 = null, dt2 = null; try { SimpleDateFormat sdf = new SimpleDateFormat(dateformat); sdf.setLenient(false); dt1 = sdf.parse(dt); dt2 = sdf.parse(invalidDt); System.out.println("Date is ok = " + dt1 + "(" + dt + ")"); } catch (ParseException e) { System.out.println(e.getMessage()); } catch (IllegalArgumentException e) { System.out.println("Invalid date"); } System.out.println(); System.out.println("-------------------------------------"); } public static void compare2Dates() { System.out.println("6. Comparision of 2 dates\n"); SimpleDateFormat fm = new SimpleDateFormat("dd-MM-yyyy"); Calendar c1 = Calendar.getInstance(); Calendar c2 = Calendar.getInstance(); c1.set(2000, 02, 15); c2.set(2001, 02, 15); System.out.print(fm.format(c1.getTime()) + " is "); if (c1.before(c2)) { System.out.println("less than " + fm.format(c2.getTime())); } else if (c1.after(c2)) { System.out.println("greater than " + fm.format(c2.getTime())); } else if (c1.equals(c2)) { System.out.println("is equal to " + fm.format(c2.getTime())); } System.out.println(); System.out.println("-------------------------------------"); }
153
public static void getDayofTheDate() { System.out.println("7. Get the day for a given date\n"); Date d1 = new Date(); String day = null; DateFormat f = new SimpleDateFormat("EEEE"); try { day = f.format(d1); } catch (Exception e) { e.printStackTrace(); } System.out.println("The day for " + d1 + " is " + day); System.out.println(); System.out.println("-------------------------------------"); } //Utility Method to find whether an Year is a Leap year or Not public static boolean isLeapYear(int year) { if ((year % 100 != 0) || (year % 400 == 0)) { return true; } return false; } public static void main(String args[]) { addToDate(); //Add day, month or year to a date field. subToDate(); //Subtract day, month or year to a date field. daysBetween2Dates(); //The "right" way would be to compute the Julian day number of //both dates and then do the subtraction. daysInMonth();//Find the number of days in a month for a date validateAGivenDate();//Check whether the date format is proper compare2Dates(); //Compare 2 dates getDayofTheDate(); } } Output 1. Add to a Date Operation c1.getTime() : Sat Mar 31 10:47:54 IST 2007 c1.get(Calendar.YEAR): 2007 Todays date in Date Format : Sat Mar 31 10:47:54 IST 2007 c1.set(1999,0 ,20) : Wed Jan 20 10:47:54 IST 1999 Date + 20 days is : 09-02-1999 2. Subtract to a date Operation Date is : 20-01-1999 Date roll down 1 month : 20-12-1999 Date is : 20-01-1999 Date minus 1 month : 20-12-1998
154
3. No of Days between 2 dates Days Between Wed Jan 20 10:47:54 IST 1999 and Fri Jan 22 10:47:54 IST 1999 is 2 4. No of Days in a month for a given date Days in 6th month for year 1999 is 31 5. Validate a given date Unparseable date: 20031315 6. Comparision of 2 dates 15-03-2000 is less than 15-03-2001 7. Get the day for a given date The day for Sat Mar 31 10:47:54 IST 2007 is Saturday Download Date Utility Source Code
What is the GregorianCalendar class? The GregorianCalendar provides support for traditional Western calendars. What is the SimpleTimeZone class? The SimpleTimeZone class provides support for a Gregorian calendar.
155
Java Swing Tutorial

This site contains brief tutorials for java swing programming along with java swing examples and source code.
Java Swings Tutorial

What is Swings in java ? A part of The JFC Swing Java consists of Look and feel Accessibility Java 2D Drag and Drop, etc Compiling & running programs javac <program.java> && java <program> Or JCreator / IDE if you do not explicitly add a GUI component to a container, the GUI component will not be displayed when the container appears on the screen. Swing, which is an extension library to the AWT, includes new and improved components that enhance the look and functionality of GUIs. Swing can be used to build Standalone swing gui Apps as well as Servlets and Applets. It employs a model/view design architecture. Swing is more portable and more flexible than AWT. Swing Model/view design: The view part of the MV design is implemented with a component object and the UI object. The model part of the MV design is implemented by a model object and a change listener object. Swing is built on top of AWT and is entirely written in Java, using AWTs lightweight component support. In particular, unlike AWT, t he architecture of Swing components makes it easy to customize both their appearance and behavior. Components from AWT and Swing can be mixed, allowing you to add Swing support to existing AWT-based programs. For example, swing components such as JSlider, JButton and JCheckbox could be used in the same program with standard AWT labels, textfields and scrollbars. You could subclass the existing Swing UI, model, or change listener classes without having to reinvent the entire implementation. Swing also has the ability to replace these objects on-the-fly.
100% Java implementation of components Pluggable Look & Feel
156

Lightweight components Uses MVC Architecture Model represents the data View as a visual representation of the data Controller takes input and translates it to changes in data Three parts Component set (subclasses of JComponent) Support classes Interfaces
In Swing, classes that represent GUI components have names beginning with the letter J. Some examples are JButton, JLabel, and JSlider. Altogether there are more than 250 new classes and 75 interfaces in Swing twice as many as in AWT. Java Swing class hierarchy The class JComponent, descended directly from Container, is the root class for most of Swings user interface components.
Swing contains components that youll use to build a GUI. I am listing you some of the commonly used Swing components. To learn and understand these swing programs, AWT Programming knowledge is not required.
Java Swing Examples

Below is a java swing code for the traditional Hello World program.
157
Basically, the idea behind this Hello World program is to learn how to create a java program, compile and run it. To create your java source code you can use any editor( Text pad/Edit plus are my favorites) or you can use an IDE like Eclipse. import javax.swing.JFrame; import javax.swing.JLabel; //import statements //Check if window closes automatically. Otherwise add suitable code public class HelloWorldFrame extends JFrame { public static void main(String args[]) { new HelloWorldFrame(); } HelloWorldFrame() { JLabel jlbHelloWorld = new JLabel("Hello World"); add(jlbHelloWorld); this.setSize(100, 100); // pack(); setVisible(true); } } Output
Note: Below are some links to java swing tutorials that forms a helping
hand to get started with java programming swing.
JPanel is Swings version of the AWT class Panel and uses the same default
layout, FlowLayout. JPanel is descended directly from JComponent.
JFrame is Swings version of Frame and is descended directly from that

class. The components added to the frame are referred to as its contents; these are managed by the contentPane. To add a component to a JFrame, we must use its contentPane instead.
JInternalFrame is confined to a visible area of a container it is

placed in. It can be iconified , maximized and layered.
JWindow
is Swings version of Window and is descended directly from
that class. Like Window, it uses BorderLayout by default. JDialog is Swings version of Dialog and is descended directly from that class. Like Dialog, it uses BorderLayout by default. Like JFrame and JWindow, JDialog contains a rootPane hierarchy including a contentPane, and it allows layered and glass panes. All dialogs are modal, which means the current thread is blocked until user interaction with it has been completed. JDialog class
158
is intended as the basis for creating custom dialogs; however, some of the most common dialogs are provided through static methods in the class JOptionPane.
JLabel, descended from JComponent, is used to create text labels.

The abstract class AbstractButton extends class JComponent and provides a foundation for a family of button classes, including
JButton. JTextField allows editing of a single line of text. New features include
the ability to justify the text left, right, or center, and to set the texts font.
JPasswordField (a direct subclass of JTextField) you can

suppress the display of input. Each character entered can be replaced by an echo character. This allows confidential input for passwords, for example. By default, the echo character is the asterisk, *.
JTextArea
underlying
allows editing of multiple lines of text. JTextArea can be
used in conjunction with class JScrollPane to achieve scrolling. The
JScrollPane can be forced to always or never have either
the vertical or horizontal scrollbar; JButton is a component the user clicks to trigger a specific action.
JRadioButton is similar to JCheckbox, except for the default icon

for each class. A set of radio buttons can be associated as a group in which only one button at a time can be selected.
JCheckBox
is not a member of a checkbox group. A checkbox can be
selected and deselected, and it also displays its current state.
JComboBox
is like a drop down box. You can click a drop-down
arrow and select an option from a list. For example, when the component has focus, pressing a key that corresponds to the first character in some entrys name selects that entry. A vertical scrollbar is used for longer lists.
JList
provides a scrollable set of items from which one or more may be
selected. JList can be populated from an Array or Vector. JList does not support scrolling directly, instead, the list must be associated with a scrollpane. The view port used by the scroll pane can also have a user-defined border. JList actions are handled using ListSelectionListener.
JTabbedPane contains a tab that can have a tool tip and a

mnemonic, and it can display both text and an image.
JToolbar contains a number of components whose type is usually some

kind of button which can also include separators to group related components within the toolbar.
159
FlowLayout when used arranges swing components from left to

right until theres no more space available. Then it begins a new row below it and moves from left to right again. Each component in a FlowLayout gets as much space as it needs and no more.
BorderLayout
between the areas.
places swing components in the North, South,
East, West and center of a container. You can add horizontal and vertical gaps
GridLayout is a layout manager that lays out a containers

components in a rectangular grid. The container is divided into equal-sized rectangles, and one component is placed in each rectangle.
GridBagLayout is a layout manager that lays out a containers

components in a grid of cells with each component occupying one or more cells, called its display area. The display area aligns components vertically and horizontally, without requiring that the components be of the same size.
JMenubar
can contain several JMenus. Each of the JMenus can
contain a series of JMenuItem s that you can select. Swing provides support for pull-down and popup menus.
Scrollable JPopupMenu is a scrollable popup menu

that can be used whenever we have so many items in a popup menu that exceeds the screen visible height.
Java Swing Projects
Java Swing Calculator
developed using Java Swing. It
is a basic four-function calculator java program source code.
Java Swing Address Book demonstrates how to create a

simple free address book program using java swing and jdbc. Also you will learn to use the following swing components like Jbuttons, JFrames, JTextFields and Layout Manager (GridBagLayout).
160
Java JFrame class example

JFrame
Java Swing Tutorial Explaining the JFrame class. The components added to the frame are referred to as its contents; these are managed by the contentPane. To add a component to a JFrame, we must use its contentPane instead.JFrame is a Window with border, title and buttons. When JFrame is set visible, an event dispatching thread is started. JFrame objects store several objects including a Container object known as the content pane. To add a component to a JFrame, add it to the content pane.
JFrame Features
Its a window with title, border, (optional) menu bar and user-specified components. It can be moved, resized, iconified. It is not a subclass of JComponent. Delegates responsibility of managing user-specified components to a content pane, an instance of JPanel.
Centering JFrames
By default, a Jframe is displayed in the upper-left corner of the screen. To display a frame at a specified location, you can use the setLocation(x, y) method in the JFrame class. This method places the upper-left corner of a frame at location (x, y). The Swing API keeps improving with abstractions such as the setDefaultCloseOperation method for the JFrame
Crating a JFrame Window

Step 1: Construct an object of the JFrame class. Step 2: Set the size of the Jframe. Step 3: Set the title of the Jframe to appear in the title bar (title bar will be blank if no title is set). Step 4: Set the default close operation. When the user clicks the close button, the program stops running. Step 5: Make the Jframe visible.
161
How to position JFrame on Screen?
frame.setLocationRelativeTo( null );
JFrame Source Code

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JFrameDemo { public static void main(String s[]) { JFrame frame = new JFrame("JFrame Source Demo"); // Add a window listner for close button frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); // This is an empty content area in the frame JLabel jlbempty = new JLabel(""); jlbempty.setPreferredSize(new Dimension(175, 100)); frame.getContentPane().add(jlbempty, BorderLayout.CENTER); frame.pack(); frame.setVisible(true); } } Output
Download jFrame Source Code
Java JFrame Hierarchy

javax.swing
Class JFrame
java.lang.Object java.awt.Component java.awt.Container java.awt.Window java.awt.Frame javax.swing.JFrame
162
All Implemented Interfaces: Accessible, ImageObserver, MenuContainer, RootPaneContainer, Serializable, WindowConstants
JFrame Constructor
JFrame()
Constructs a new frame that is initially invisible.

JFrame(GraphicsConfiguration gc)
Creates a Frame in the specified GraphicsConfiguration of a screen device and a blank title.
JFrame(String title)
Creates a new, initially invisible Frame with the specified title.

JFrame(String title, GraphicsConfiguration gc)
Creates a JFrame with the specified title and the specified GraphicsConfiguration of a screen device.
Java JInternalFrame class example
JInternalFrame
Java Swing Tutorial Explaining the JInternalFrame class. A JInternalFrame is confined to a visible area of a container it is placed in. JInternalFrame a top level swing component that has a contentpane. It can be iconified in this case the icon remains in the main application container. It can be maximized Frame consumes the main application It can be closed using standard popup window controls It can be layered
JInternalFrame Source Code

import import import import import javax.swing.JInternalFrame; javax.swing.JDesktopPane; javax.swing.JMenu; javax.swing.JMenuItem; javax.swing.JMenuBar;
163
import javax.swing.JFrame; import java.awt.event.*; import java.awt.*; public class JInternalFrameDemo extends JFrame { JDesktopPane jdpDesktop; static int openFrameCount = 0; public JInternalFrameDemo() { super("JInternalFrame Usage Demo"); // Make the main window positioned as 50 pixels from each edge of the // screen. int inset = 50; Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); setBounds(inset, inset, screenSize.width - inset * 2, screenSize.height - inset * 2); // Add a Window Exit Listener addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) { System.exit(0); } }); // Create and Set up the GUI. jdpDesktop = new JDesktopPane(); // A specialized layered pane to be used with JInternalFrames createFrame(); // Create first window setContentPane(jdpDesktop); setJMenuBar(createMenuBar()); // Make dragging faster by setting drag mode to Outline jdpDesktop.putClientProperty("JDesktopPane.dragMode", "outline"); } protected JMenuBar createMenuBar() { JMenuBar menuBar = new JMenuBar(); JMenu menu = new JMenu("Frame"); menu.setMnemonic(KeyEvent.VK_N); JMenuItem menuItem = new JMenuItem("New IFrame"); menuItem.setMnemonic(KeyEvent.VK_N); menuItem.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { createFrame(); } }); menu.add(menuItem); menuBar.add(menu); return menuBar; } protected void createFrame() { MyInternalFrame frame = new MyInternalFrame(); frame.setVisible(true); // Every JInternalFrame must be added to content pane using JDesktopPane jdpDesktop.add(frame); try { frame.setSelected(true); } catch (java.beans.PropertyVetoException e) { } } public static void main(String[] args) { JInternalFrameDemo frame = new JInternalFrameDemo();
164
frame.setVisible(true); } class MyInternalFrame extends JInternalFrame { static final int xPosition = 30, yPosition = 30; public MyInternalFrame() { super("IFrame #" + (++openFrameCount), true, // resizable true, // closable true, // maximizable true);// iconifiable setSize(300, 300); // Set the window's location. setLocation(xPosition * openFrameCount, yPosition * openFrameCount); } } } Output
Download JInternalFrame Source Code
Java JInternalFrame Hierarchy

javax.swing
Class JInternalFrame
java.lang.Object
165
| +java.awt.Component | +java.awt.Container | +javax.swing.JComponent | +javax.swing.JInternalFrame All Implemented Interfaces: Accessible, ImageObserver, MenuContainer, RootPaneContainer, Serializable, WindowConstants
JInternalFrame Constructor
JInternalFrame()
Creates a non-resizable, non-closable, non-maximizable, non-iconifiable JInternalFrame with no title.

JInternalFrame(String title)
Creates a non-resizable, non-closable, non-maximizable, non-iconifiable JInternalFrame with the specified title.
JInternalFrame(String title, boolean resizable)
Creates a non-closable, non-maximizable, non-iconifiable JInternalFrame with the specified title and resizability.
JInternalFrame(String title, boolean resizable, boolean closable)
Creates a non-maximizable, non-iconifiable JInternalFrame with the specified title, resizability, and closability.
JInternalFrame(String title, boolean resizable, boolean closable, boolean maximizable)
Creates a non-iconifiable JInternalFrame with the specified title, resizability, closability, and maximizability.
JInternalFrame(String title, boolean resizable, boolean closable, boolean maximizable, boolean iconifiable)
Creates a JInternalFrame with the specified title, resizability, closability, maximizability
166
Java JWindow class example
JWindow
Java Swing Tutorial Explaining the JWindow Component. JWindow is Swings version of Window and is descended directly from that class. Like Window, it uses BorderLayout by default. Almost all Swing components are lightweight except JApplet, JFrame, JDialog, and JWindow.
JWindow Source Code

public class JWindowDemo extends JWindow { private int X = 0; private int Y = 0; public JWindowDemo() { setBounds(60, 60, 100, 100); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); // An Exit Listener } }); // Print (X,Y) coordinates on Mouse Click addMouseListener(new MouseAdapter() { public void mousePressed(MouseEvent e) { X = e.getX(); Y = e.getY(); System.out.println("The (X,Y) coordinate of window is (" + X + "," + Y + ")"); } }); addMouseMotionListener(new MouseMotionAdapter() { public void mouseDragged(MouseEvent e) { setLocation(getLocation().x + (e.getX() - X), getLocation().y + (e.getY() - Y)); } }); setVisible(true); } public static void main(String[] args) { new JWindowDemo(); } } Output
167
Download JWindow Source Code
Java JWindow Hierarchy

javax.swing
Class JWindow
java.lang.Object java.awt.Component java.awt.Container java.awt.Window All Implemented Interfaces: Accessible, ImageObserver, MenuContainer, Serializable Direct Known Subclasses: BasicToolBarUI.DragWindow, Dialog, Frame, JWindow
JWindow Constructor
Window(Frame owner)
Constructs a new invisible window with the specified Frame as its owner.
Window(Window owner)
Constructs a new invisible window with the specified Window as its owner.
Window(Window owner, GraphicsConfiguration gc)
Constructs a new invisible window with the specified window as its owner and a GraphicsConfiguration of a screen device.
168
Java JLabel class example
JLabels
Java Swing Tutorial Explaining the JLabel Component. JLabel, descended from JComponent, is used to create text labels. A JLabel object provides text instructions or information on a GUI display a single line of read-only text, an image or both text and image. We use a Swing JLabel when we need a user interface component that displays a message or an image. JLabels Provide text instructions on a GUI lRead-only text lPrograms rarely change a labels contents lClass JLabel (subclass of JComponent)
JLabel Source Code

import import import import import import import java.awt.GridLayout; java.awt.event.WindowAdapter; java.awt.event.WindowEvent; javax.swing.JLabel; javax.swing.JPanel; javax.swing.JFrame; javax.swing.ImageIcon;
public class JlabelDemo extends JPanel { JLabel jlbLabel1, jlbLabel2, jlbLabel3; public JlabelDemo() { ImageIcon icon = new ImageIcon("java-swing-tutorial.JPG", "My Website"); // Creating an Icon setLayout(new GridLayout(3, 1)); // 3 rows, 1 column Panel having Grid Layout jlbLabel1 = new JLabel("Image with Text", icon, JLabel.CENTER); // We can position of the text, relative to the icon: jlbLabel1.setVerticalTextPosition(JLabel.BOTTOM); jlbLabel1.setHorizontalTextPosition(JLabel.CENTER); jlbLabel2 = new JLabel("Text Only Label"); jlbLabel3 = new JLabel(icon); // Label of Icon Only // Add labels to the Panel add(jlbLabel1); add(jlbLabel2); add(jlbLabel3); } public static void main(String[] args) { JFrame frame = new JFrame("jLabel Usage Demo");
169
frame.addWindowListener(new WindowAdapter() { // Shows code to Add Window Listener public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.setContentPane(new JlabelDemo()); frame.pack(); frame.setVisible(true); } } Output
Download jLabel Source Code
Java JLabel Hierarchy

javax.swing Class JLabel java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.JLabel All Implemented Interfaces: Accessible, ImageObserver, MenuContainer, Serializable, SwingConstants Direct Known Subclasses: BasicComboBoxRenderer, DefaultListCellRenderer, DefaultTableCellRenderer, DefaultTreeCellRenderer
JLabel Constructor
JLabel() Creates a JLabel instance with no image and with an empty string for the title.
170
JLabel(Icon image) Creates a JLabel instance with the specified image. JLabel(Icon image, int horizontalAlignment) Creates a JLabel instance with the specified image and horizontal alignment. JLabel(String text) Creates a JLabel instance with the specified text. JLabel(String text, Icon icon, int horizontalAlignment) Creates a JLabel instance with the specified text, image, and horizontal alignment. JLabel(String text, int horizontalAlignment) Creates a JLabel instance with the specified text and horizontal alignment.
Java JTextField class example
JTextField
Java Swing Tutorial Explaining the JTextField Component. JTextField allows editing/displaying of a single line of text. New features include the ability to justify the text left, right, or center, and to set the texts font. When the user types data into them and presses the Enter key, an action event occurs. If the program registers an event listener, the listener processes the event and can use the data in the text field at the time of the event in the program. JTextField is an input area where the user can type in characters. If you want to let the user enter multiple lines of text, you cannot use Jtextfields unless you create several of them. The solution is to useJTextArea, which enables the user to enter multiple lines of text.
JTextField Source Code

// A program to demonstrate the use of JTextFields's //Import Statements import javax.swing.*; import java.awt.*; import java.awt.event.*; public class JTextFieldDemo extends JFrame { //Class Declarations JTextField jtfText1, jtfUneditableText; String disp = ""; TextHandler handler = null; //Constructor public JTextFieldDemo() {
171
super("TextField Test Demo"); Container container = getContentPane(); container.setLayout(new FlowLayout()); jtfText1 = new JTextField(10); jtfUneditableText = new JTextField("Uneditable text field", 20); jtfUneditableText.setEditable(false); container.add(jtfText1); container.add(jtfUneditableText); handler = new TextHandler(); jtfText1.addActionListener(handler); jtfUneditableText.addActionListener(handler); setSize(325, 100); setVisible(true); } //Inner Class TextHandler private class TextHandler implements ActionListener { public void actionPerformed(ActionEvent e) { if (e.getSource() == jtfText1) { disp = "text1 : " + e.getActionCommand(); } else if (e.getSource() == jtfUneditableText) { disp = "text3 : " + e.getActionCommand(); } JOptionPane.showMessageDialog(null, disp); } } //Main Program that starts Execution public static void main(String args[]) { JTextFieldDemo test = new JTextFieldDemo(); test.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }// End of class TextFieldTest Output
Download
jTextField Source Code
Another Example: JTextField Source Code

public class JTextFieldDemo2 extends JFrame implements ActionListener { JTextField jtfInput; JTextArea jtAreaOutput; String newline = "\n"; public JTextFieldDemo2() { createGui(); } public void createGui() { jtfInput = new JTextField(20);
172
jtfInput.addActionListener(this); jtAreaOutput = new JTextArea(5, 20); jtAreaOutput.setEditable(false); JScrollPane scrollPane = new JScrollPane(jtAreaOutput, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); GridBagLayout gridBag = new GridBagLayout(); Container contentPane = getContentPane(); contentPane.setLayout(gridBag); GridBagConstraints gridCons1 = new GridBagConstraints(); gridCons1.gridwidth = GridBagConstraints.REMAINDER; gridCons1.fill = GridBagConstraints.HORIZONTAL; contentPane.add(jtfInput, gridCons1); GridBagConstraints gridCons2 = new GridBagConstraints(); gridCons2.weightx = 1.0; gridCons2.weighty = 1.0; contentPane.add(scrollPane, gridCons2); } public void actionPerformed(ActionEvent evt) { String text = jtfInput.getText(); jtAreaOutput.append(text + newline); jtfInput.selectAll(); } public static void main(String[] args) { JTextFieldDemo2 jtfTfDemo = new JTextFieldDemo2(); jtfTfDemo.pack(); jtfTfDemo.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); jtfTfDemo.setVisible(true); } } Output
Download jTextField Source Code
Java JTextField Hierarchy

javax.swing java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent
173
javax.swing.text.JTextComponent javax.swing.JTextField All Implemented Interfaces: Accessible, ImageObserver, MenuContainer, Scrollable, Serializable, SwingConstants Direct Known Subclasses: DefaultTreeCellEditor.DefaultTextField, JFormattedTextField, JPasswordField
JTextField Constructor
JTextField()
Constructs a new TextField.

JTextField(Document doc, String text, int columns)
Constructs a new JTextField that uses the given text storage model and the given number of columns.
JTextField(int columns)
Constructs a new empty TextField with the specified n umber of columns.

JTextField(String text)
Constructs a new TextField initialized with the specified text.

JTextField(String text, int columns)
Constructs a new TextField initialized with the specified text and columns.
Java JPasswordField class example
JPasswordField
Java Swing Tutorial Explaining the JPasswordField Component. JPasswordField (a direct subclass of JTextField) you can suppress the display of input. Each character entered can be replaced by an echo character. This allows confidential input for passwords, for example. By default, the echo character is the asterisk, *. When the user types data into them and presses the Enter key, an action event occurs. If the program registers an event listener, the listener processes the event and can use the data in the text field at the time of the event in the program. If you need to provide an editable text field that doesnt show the characters the user types use the JPasswordField class.
JPasswordField Source Code

174
public class JPasswordFieldDemo { public static void main(String[] argv) { final JFrame frame = new JFrame("JPassword Usage Demo"); JLabel jlbPassword = new JLabel("Enter the password: "); JPasswordField jpwName = new JPasswordField(10); jpwName.setEchoChar('*'); jpwName.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JPasswordField input = (JPasswordField) e.getSource(); char[] password = input.getPassword(); if (isPasswordCorrect(password)) { JOptionPane.showMessageDialog(frame, "Correct password."); } else { JOptionPane.showMessageDialog(frame, "Sorry. Try again.", "Error Message", JOptionPane.ERROR_MESSAGE); } } }); JPanel jplContentPane = new JPanel(new BorderLayout()); jplContentPane.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); jplContentPane.add(jlbPassword, BorderLayout.WEST); jplContentPane.add(jpwName, BorderLayout.CENTER); frame.setContentPane(jplContentPane); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.pack(); frame.setVisible(true); } private static boolean isPasswordCorrect(char[] inputPassword) { char[] actualPassword = { 'h', 'e', 'm', 'a', 'n', 't', 'h' }; if (inputPassword.length != actualPassword.length) return false; // Return false if lengths are unequal for (int i = 0; i < inputPassword.length; i++) if (inputPassword[i] != actualPassword[i]) return false; return true; } } Output
Download JPasswordField Source Code
175
Java JPasswordField Hierarchy
javax.swing Class JPasswordField java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.text.JTextComponent javax.swing.JTextField javax.swing.JPasswordField All Implemented Interfaces: ImageObserver, MenuContainer, Serializable, Accessible, Scrollable, SwingConstants
JPasswordField Constructor
JPasswordField()
Constructs a new JPasswordField, with a default document, null starting text string, and 0 column width.
JPasswordField(Document doc, String txt, int columns)
Constructs a new JPasswordField that uses the given text storage model and the given number of columns.
JPasswordField(int columns)
Constructs a new empty JPasswordField with the specified number of columns.

JPasswordField(String text)
Constructs a new JPasswordField initialized with the specified text.

JPasswordField(String text, int columns)
Constructs a new JPasswordField initialized with the specified text and columns.
Java JTextArea class example

JTextArea
Java Swing Tutorial Explaining the JTextArea Component. JTextArea allows editing of multiple lines of text. JTextArea can be used in conjunction with class JScrollPane to achieve scrolling. The underlying JScrollPane can be forced to always or never have either the vertical or horizontal scrollbar.
JTextArea Source Code

176
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JTextAreaDemo extends JFrame implements ActionListener { JTextField jtfInput; JTextArea jtAreaOutput; String newline = "\n"; public JTextAreaDemo() { createGui(); } public void createGui() { jtfInput = new JTextField(20); jtfInput.addActionListener(this); jtAreaOutput = new JTextArea(5, 20); jtAreaOutput.setCaretPosition(jtAreaOutput.getDocument() .getLength()); jtAreaOutput.setEditable(false); JScrollPane scrollPane = new JScrollPane(jtAreaOutput, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS); GridBagLayout gridBag = new GridBagLayout(); Container contentPane = getContentPane(); contentPane.setLayout(gridBag); GridBagConstraints gridCons1 = new GridBagConstraints(); gridCons1.gridwidth = GridBagConstraints.REMAINDER; gridCons1.fill = GridBagConstraints.HORIZONTAL; contentPane.add(jtfInput, gridCons1); GridBagConstraints gridCons2 = new GridBagConstraints(); gridCons2.weightx = 1.0; gridCons2.weighty = 1.0; contentPane.add(scrollPane, gridCons2); } public void actionPerformed(ActionEvent evt) { String text = jtfInput.getText(); jtAreaOutput.append(text + newline); jtfInput.selectAll(); } public static void main(String[] args) { JTextAreaDemo jtfTfDemo = new JTextAreaDemo(); jtfTfDemo.pack(); jtfTfDemo.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); jtfTfDemo.setVisible(true); } } Output
177
Download JTextArea Source Code
Java JTextArea Hierarchy

javax.swing Class JTextArea java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.text.JTextComponent javax.swing.JTextField All Implemented Interfaces: Accessible, ImageObserver, MenuContainer, Scrollable, Serializable, SwingConstants Direct Known Subclasses: DefaultTreeCellEditor.DefaultTextField, JFormattedTextField, JPasswordField
JTextArea Constructor
JTextArea()
Constructs a new TextArea.

JTextArea(Document doc)
Constructs a new JTextArea with the given document model, and defaults for all of the other arguments (null, 0, 0).
JTextArea(Document doc, String text, int rows, int columns)
Constructs a new JTextArea with the specified number of rows and columns, and the given model. JTextArea(int rows, int columns) Constructs a new empty TextArea with the specified number of rows and columns. JTextArea(String text) Constructs a new TextArea with the specified text displayed. JTextArea(String text, int rows, int columns) Constructs a new TextArea with the specified text and number of rows and columns.
178
Java JButton class example
JButton
Java Swing Tutorial Explaining the JButton Component. The abstract class AbstractButton extends class JComponent and provides a foundation for a family of button classes, including JButton. A button is a component the user clicks to trigger a specific action. There are several types of buttons in Java, all are subclasses of AbstractButton. command buttons: is created with class JButton. It generates ActionEvent. toggle buttons: have on/off or true/false values. check boxes: a group of buttons. It generates ItemEvent. radio buttons: a group of buttons in which only one can be selected. It generates ItemEvent.
JButton Source Code

import import import import import import import import import java.awt.event.ActionEvent; java.awt.event.ActionListener; java.awt.event.KeyEvent; java.net.URL; javax.swing.AbstractButton; javax.swing.ImageIcon; javax.swing.JButton; javax.swing.JFrame; javax.swing.JPanel;
public class JButtonDemo extends JPanel implements ActionListener { protected static JButton jbnLeft, jbnMiddle, jbnRight; public JButtonDemo() { // Create Icons that can be used with the jButtons ImageIcon leftButtonIcon = createImageIcon("rightarrow.JPG"); ImageIcon middleButtonIcon = createImageIcon("java-swing-tutorial.JPG"); ImageIcon rightButtonIcon = createImageIcon("leftarrow.JPG"); jbnLeft = new JButton("Disable centre button", leftButtonIcon); jbnLeft.setVerticalTextPosition(AbstractButton.CENTER); jbnLeft.setHorizontalTextPosition(AbstractButton.LEADING); jbnLeft.setMnemonic(KeyEvent.VK_D); // Alt-D clicks the button jbnLeft.setActionCommand("disable"); jbnLeft.setToolTipText("disable the Centre button."); // Adding Tool // tips jbnMiddle = new JButton("Centre button", middleButtonIcon); jbnMiddle.setVerticalTextPosition(AbstractButton.BOTTOM); jbnMiddle.setHorizontalTextPosition(AbstractButton.CENTER); jbnMiddle.setMnemonic(KeyEvent.VK_M); // Alt-M clicks the button jbnMiddle.setToolTipText("Centre button");
179
jbnRight = new JButton("Enable centre button", rightButtonIcon); // Use the default text position of CENTER, TRAILING (RIGHT). jbnRight.setMnemonic(KeyEvent.VK_E); // Alt-E clicks the button jbnRight.setActionCommand("enable"); jbnRight.setEnabled(false); // Disable the Button at creation time // Listen for actions on Left and Roght Buttons jbnLeft.addActionListener(this); jbnRight.addActionListener(this); jbnRight.setToolTipText("Enable the Centre button."); // Add Components to the frame, using the default FlowLayout. add(jbnLeft); add(jbnMiddle); add(jbnRight); } public void actionPerformed(ActionEvent e) { if ("disable".equals(e.getActionCommand())) { jbnMiddle.setEnabled(false); jbnLeft.setEnabled(false); jbnRight.setEnabled(true); } else { jbnMiddle.setEnabled(true); jbnLeft.setEnabled(true); jbnRight.setEnabled(false); } } // Returns an ImageIcon, or null if the path was invalid. protected static ImageIcon createImageIcon(String path) { URL imgURL = JButtonDemo.class.getResource(path); if (imgURL != null) { return new ImageIcon(imgURL); } else { System.err.println("Couldn't find image in system: " + path); return null; } } // Create the GUI and show it. private static void createGUI() { JFrame.setDefaultLookAndFeelDecorated(true); // Create and set up the frame. JFrame frame = new JFrame("jButton usage demo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Create and set up the content pane. JButtonDemo buttonContentPane = new JButtonDemo(); buttonContentPane.setOpaque(true); // content panes must be opaque frame.getRootPane().setDefaultButton(jbnLeft); frame.setContentPane(buttonContentPane); // Display the window. frame.pack(); frame.setVisible(true); } public static void main(String[] args) { javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createGUI(); } }); } }
180
Output
Download jButton Source Code
Another Example: JButton Source Code

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JButtonDemo2 { JFrame jtfMainFrame; JButton jbnButton1, jbnButton2; JTextField jtfInput; JPanel jplPanel; public JButtonDemo2() { jtfMainFrame = new JFrame("Which Button Demo"); jtfMainFrame.setSize(50, 50); jbnButton1 = new JButton("Button 1"); jbnButton2 = new JButton("Button 2"); jtfInput = new JTextField(20); jplPanel = new JPanel(); jbnButton1.setMnemonic(KeyEvent.VK_I); //Set ShortCut Keys jbnButton1.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { jtfInput.setText("Button 1!"); } }); jbnButton2.setMnemonic(KeyEvent.VK_I); jbnButton2.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { jtfInput.setText("Button 2!"); } }); jplPanel.setLayout(new FlowLayout()); jplPanel.add(jtfInput); jplPanel.add(jbnButton1); jplPanel.add(jbnButton2); jtfMainFrame.getContentPane().add(jplPanel, BorderLayout.CENTER); jtfMainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); jtfMainFrame.pack(); jtfMainFrame.setVisible(true); } public static void main(String[] args) {
181
// Set the look and feel to Java Swing Look try { UIManager.setLookAndFeel(UIManager .getCrossPlatformLookAndFeelClassName()); } catch (Exception e) { } JButtonDemo2 application = new JButtonDemo2(); } } Output
Download jButton Source Code
Java JButton Hierarchy

javax.swing Class JButton java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.AbstractButton javax.swing.JButton All Implemented Interfaces: Accessible, ImageObserver, ItemSelectable, MenuContainer, Serializable, SwingConstants Direct Known Subclasses: BasicArrowButton, MetalComboBoxButton
JButton Constructor
JButton()
Creates a button with no set text or icon.

JButton(Action a)
Creates a button where properties are taken from the Action supplied.
JButton(Icon icon)
Creates a button with an icon.

JButton(String text)
Creates a button with text.
182
JButton(String text, Icon icon)
Creates a button with initial text and an icon.
Java JCheckBox class example

JCheckBox
Java Swing Tutorial Explaining the JCheckBox Component. JCheckBox is not a member of a checkbox group. A checkbox can be selected and deselected, and it also displays its current state.
JCheckBox Source Code

Note: Help for getting the below source code is taken from Java Sun Website
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JCheckBoxDemo extends JPanel { //Four accessory choices provide for 16 different combinations JCheckBox jcbChin; JCheckBox jcbGlasses; JCheckBox jcbHair; JCheckBox jcbTeeth; /* The image for each combination is contained in a separate image file whose name indicates the accessories. The filenames are "geek-XXXX.gif" where XXXX can be one * of the following 16 choices. */ StringBuffer choices; JLabel jlbPicture; CheckBoxListener myListener = null; public JCheckBoxDemo() { // Add an item listener for each of the check boxes. // This is the listener class which contains business logic myListener = new CheckBoxListener(); // Create check boxes with default selection true
jcbChin = new JCheckBox("Chin"); jcbChin.setMnemonic(KeyEvent.VK_C); //Alt+C Checks/Unchecks the check Box jcbChin.setSelected(true); jcbChin.addItemListener(myListener);
183
jcbGlasses = new JCheckBox("Glasses"); jcbGlasses.setMnemonic(KeyEvent.VK_G); //Alt+G Checks/Unchecks the check Box jcbGlasses.setSelected(true); jcbGlasses.addItemListener(myListener); jcbHair = new JCheckBox("Hair"); jcbHair.setMnemonic(KeyEvent.VK_H); //Alt+H Checks/Unchecks the check Box jcbHair.setSelected(true); jcbHair.addItemListener(myListener); jcbTeeth = new JCheckBox("Teeth"); jcbTeeth.setMnemonic(KeyEvent.VK_T); //Alt+T Checks/Unchecks the check Box jcbTeeth.setSelected(true); jcbTeeth.addItemListener(myListener); // Indicates what's on the geek. choices = new StringBuffer("cght");//Default Image has all the parts. // Set up the picture label jlbPicture = new JLabel(new ImageIcon("geek-" + choices.toString().trim() + ".gif")); jlbPicture.setToolTipText(choices.toString().trim()); // Put the check boxes in a column in a panel JPanel jplCheckBox = new JPanel(); jplCheckBox.setLayout(new GridLayout(0, 1)); //0 rows, 1 Column jplCheckBox.add(jcbChin); jplCheckBox.add(jcbGlasses); jplCheckBox.add(jcbHair); jplCheckBox.add(jcbTeeth); setLayout(new BorderLayout()); add(jplCheckBox, BorderLayout.WEST); add(jlbPicture, BorderLayout.CENTER); setBorder(BorderFactory.createEmptyBorder(20,20,20,20)); } //Listens to the check boxes events class CheckBoxListener implements ItemListener { public void itemStateChanged(ItemEvent e) { int index = 0; char c = '-'; Object source = e.getSource(); if (source == jcbChin) { index = 0; c = 'c'; } else if (source == jcbGlasses) { index = 1; c = 'g'; } else if (source == jcbHair) { index = 2; c = 'h'; } else if (source == jcbTeeth) { index = 3; c = 't'; } if (e.getStateChange() == ItemEvent.DESELECTED)
184
c = '-'; choices.setCharAt(index, c); jlbPicture.setIcon(new ImageIcon("geek-" + choices.toString().trim() + ".gif")); jlbPicture.setToolTipText(choices.toString()); } } public static void main(String s[]) { JFrame frame = new JFrame("JCheckBox Usage Demo"); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.setContentPane(new JCheckBoxDemo()); frame.pack(); frame.setVisible(true); } } Output
Download jCheckBox Source Code
Java JComboBox class example
JComboBox
Java Swing Tutorial Explaining the JComboBox Component. JComboBox is like a drop down box you can click a drop-down arrow and select an option from a list. It generates ItemEvent. For example, when the component has focus, pressing a key that
185
corresponds to the first character in some entrys name selects that entry. A vertical scrollbar is used for longer lists.
JComboBox Source Code

import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JComboBoxDemo extends JPanel { JLabel jlbPicture; public JComboBoxDemo() { String[] comboTypes = { "Numbers", "Alphabets", "Symbols" }; // Create the combo box, and set 2nd item as Default JComboBox comboTypesList = new JComboBox(comboTypes); comboTypesList.setSelectedIndex(2); comboTypesList.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { JComboBox jcmbType = (JComboBox) e.getSource(); String cmbType = (String) jcmbType.getSelectedItem(); jlbPicture.setIcon(new ImageIcon("" + cmbType.trim().toLowerCase() + ".jpg")); }
}); // Set up the picture jlbPicture = new JLabel(new ImageIcon("" + comboTypes[comboTypesList.getSelectedIndex()] + ".jpg") jlbPicture.setBorder(BorderFactory.createEmptyBorder(10, 0, 0, 0)); jlbPicture.setPreferredSize(new Dimension(177, 122 + 10)); // Layout the demo setLayout(new BorderLayout()); add(comboTypesList, BorderLayout.NORTH); add(jlbPicture, BorderLayout.SOUTH); setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); } public static void main(String s[]) { JFrame frame = new JFrame("JComboBox Usage Demo"); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.setContentPane(new JComboBoxDemo()); frame.pack(); frame.setVisible(true); } } Output
186
Download JComboBox Source Code
Another Example: JComboBox Source Code

import import import import import import java.awt.*; java.awt.event.*; javax.swing.*; javax.swing.border.*; java.util.*; java.text.*;
public class DateComboBoxDemo extends JPanel { static JLabel String public JFrame frame; jlbResult; datePattern_Current; DateComboBoxDemo() { String[] datePatterns = { "dd MMMMM yyyy", "dd.MM.yy", "MM/dd/yy", "yyyy.MM.dd G 'at' hh:mm:ss z", "EEE, MMM d, ''yy", "h:mm a", "H:mm:ss:SSS", "K:mm a,z", "yyyy.MMMMM.dd GGG hh:mm aaa" }; datePattern_Current = datePatterns[0]; // Set up the UI for selecting a pattern. JLabel jlbHeading = new JLabel( "Enter Date pattern /Select from list:"); JComboBox patternList = new JComboBox(datePatterns); patternList.setEditable(true); patternList.setAlignmentX(Component.LEFT_ALIGNMENT); patternList.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { JComboBox jcmbDates = (JComboBox) e.getSource(); String seletedDate = (String) jcmbDates.getSelectedItem(); datePattern_Current = seletedDate; showDateinLabel(); } }); // Create the UI for displaying result JLabel jlbResultHeading = new JLabel("Current Date/Time", JLabel.LEFT); jlbResult = new JLabel(" "); jlbResult.setForeground(Color.black);
187
jlbResult.setBorder(BorderFactory.createCompoundBorder( BorderFactory.createLineBorder(Color.black), BorderFactory .createEmptyBorder(5, 5, 5, 5))); // Lay out everything JPanel jpnDate = new JPanel(); jpnDate.setLayout(new BoxLayout(jpnDate, BoxLayout.Y_AXIS)); jpnDate.add(jlbHeading); jpnDate.add(patternList); JPanel jpnResults = new JPanel(); jpnResults.setLayout(new GridLayout(0, 1)); jpnResults.add(jlbResultHeading); jpnResults.add(jlbResult); setLayout(new BoxLayout(this, BoxLayout.Y_AXIS)); jpnDate.setAlignmentX(Component.LEFT_ALIGNMENT); jpnResults.setAlignmentX(Component.LEFT_ALIGNMENT); add(jpnDate); add(Box.createRigidArea(new Dimension(0, 10))); add(jpnResults); setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); showDateinLabel(); } // constructor /** Formats and displays today's date. */ public void showDateinLabel() { Date today = new Date(); SimpleDateFormat formatter = new SimpleDateFormat( datePattern_Current); try { String dateString = formatter.format(today); jlbResult.setForeground(Color.black); jlbResult.setText(dateString); } catch (IllegalArgumentException e) { jlbResult.setForeground(Color.red); jlbResult.setText("Error: " + e.getMessage()); } } public static void main(String s[]) { frame = new JFrame("JComboBox Usage Demo"); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.setContentPane(new DateComboBoxDemo()); frame.pack(); frame.setVisible(true); } } Output
Download JComboBox Source Code
Java JComboBox Hierarchy

javax.swing
Class JComboBox
java.lang.Object
188
java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.JComboBox All Implemented Interfaces: Accessible, ActionListener, EventListener, ImageObserver, ItemSelectable, ListDataListener, MenuContainer, Serializable
JComboBox Constructor
JComboBox() Creates a JComboBox with a default data model. JComboBox(ComboBoxModel aModel) Creates a JComboBox that takes its items from an existing ComboBoxModel. JComboBox(Object[] items) Creates a JComboBox that contains the elements in the specified array. JComboBox(Vector items) Creates a JComboBox that contains the elements in the specified Vector. ~~~~~~~~~~~~
Editable JComboBox
Java Swing Tutorial Explaining the Editable JComboBox Component. JComboBox is like a drop down box you can click a drop-down arrow and select an option from a list. It generates ItemEvent. For example, when the component has focus, pressing a key that corresponds to the first character in some entrys name selects that entry. A vertical scrollbar is used for longer lists.
Editable JComboBox Source Code

Oct 30, 2006 by Hemanth JComboBoxs getSelectedItem() is used to get what is entered into the control. However when a user types something into the JCombBox rather than selecting an item from the list and does not hit enter after entering the text, the getSelectedItem() does not return what is currently entered in the field (it instead gets the last selected item). The users often do not know to hit enter when they change the value in the JComboBox so they just click an OK button on the panel (signifying a save) and the value in the JComboBox is not properly saved. But the below program overcomes this probelm by
189
simulating an enter key in the JComboBox or get the value that has been manually entered when the user does not hot enter in the JComboBox. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JComboBoxEditable extends JFrame { JComboBox jcmbNames; public JComboBoxEditable() { String[] names = { "hemanth", "Shawn", "Hunter", "Undertaker", "Big Show" }; jcmbNames = new JComboBox( names ); jcmbNames.setEditable( true ); getContentPane().add(jcmbNames, BorderLayout.NORTH); JButton jbnOk = new JButton("Ok"); getContentPane().add(jbnOk, BorderLayout.SOUTH); // Print Name of the Selected Combo Box Item to Console when OK button is pressed jbnOk.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println( jcmbNames.getSelectedItem() ); } }); // is pressed Print Name of the Selected Combo Box Item to Console when Enter
jcmbNames.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println( jcmbNames.getSelectedItem() ); } }); } public static void main(String[] args) { JComboBoxEditable frame = new JComboBoxEditable(); frame.setDefaultCloseOperation( EXIT_ON_CLOSE ); frame.pack(); frame.setLocationRelativeTo( null ); frame.setVisible( true ); } } Output
190
Download Editable JComboBox Source Code
Java JList class example
JList
Java Swing Tutorial Explaining the JList Component. JList provides a scrollable set of items from which one or more may be selected. JList can be populated from an Array or Vector. JList does not support scrolling directlyinstead, the list must be associated with a scrollpane. The view port used by the scrollpane can also have a user-defined border. JList actions are handled using ListSelectionListener.
JList Source Code

import import import import import javax.swing.*; javax.swing.event.ListSelectionEvent; javax.swing.event.ListSelectionListener; java.awt.*; java.awt.event.*;
public class JListDemo extends JFrame { JList list; String[] listColorNames = { "black", "blue", "green", "yellow", "white" }; Color[] listColorValues = { Color.BLACK, Color.BLUE, Color.GREEN, Color.YELLOW, Color.WHITE }; Container contentpane; public JListDemo() { super("List Source Demo"); contentpane = getContentPane(); contentpane.setLayout(new FlowLayout()); list = new JList(listColorNames); list.setSelectedIndex(0); list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); contentpane.add(new JScrollPane(list)); list.addListSelectionListener(new ListSelectionListener() { public void valueChanged(ListSelectionEvent e) { contentpane.setBackground(listColorValues[list .getSelectedIndex()]); } });
191
setSize(200, 200); setVisible(true); } public static void main(String[] args) { JListDemo test = new JListDemo(); test.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } Output
Download JList Source Code
Java JList Class

javax.swing Class Class JList
java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.JList

All Implemented Interfaces:
Accessible, ImageObserver, MenuContainer, Scrollable, Serializable
JList Constructor
JList()
Constructs a JList with an empty model.

JList(ListModel dataModel)
Constructs a JList that displays the elements in the specified, non-null model.
JList(Object[] listData)
Constructs a JList that displays the elements in the specified array.

JList(Vector listData)
Constructs a JList that displays the elements in the specified Vector.
192
Java JTabbedPane class example
JTabbedPane
Java Swing Tutorial Explaining the JTabbedPane Component. A JTabbedPane contains a tab that can have a tool tip and a mnemonic, and it can display both text and an image. The shape of a tab and the way in which the selected tab is displayed varies by Look and Feel.
JTabbedPane Source Code

import import import import import import import javax.swing.JTabbedPane; javax.swing.ImageIcon; javax.swing.JLabel; javax.swing.JPanel; javax.swing.JFrame; java.awt.*; java.awt.event.*;
public class JTabbedPaneDemo extends JPanel { public JTabbedPaneDemo() { ImageIcon icon = new ImageIcon("java-swing-tutorial.JPG"); JTabbedPane jtbExample = new JTabbedPane(); JPanel jplInnerPanel1 = createInnerPanel("Tab 1 Contains Tooltip and Icon"); jtbExample.addTab("One", icon, jplInnerPanel1, "Tab 1"); jtbExample.setSelectedIndex(0); JPanel jplInnerPanel2 = createInnerPanel("Tab 2 Contains Icon only"); jtbExample.addTab("Two", icon, jplInnerPanel2); JPanel jplInnerPanel3 = createInnerPanel("Tab 3 Contains Tooltip and Icon"); jtbExample.addTab("Three", icon, jplInnerPanel3, "Tab 3"); JPanel jplInnerPanel4 = createInnerPanel("Tab 4 Contains Text only"); jtbExample.addTab("Four", jplInnerPanel4); // Add the tabbed pane to this panel. setLayout(new GridLayout(1, 1)); add(jtbExample); } protected JPanel createInnerPanel(String text) { JPanel jplPanel = new JPanel(); JLabel jlbDisplay = new JLabel(text); jlbDisplay.setHorizontalAlignment(JLabel.CENTER); jplPanel.setLayout(new GridLayout(1, 1)); jplPanel.add(jlbDisplay); return jplPanel; } public static void main(String[] args) { JFrame frame = new JFrame("TabbedPane Source Demo"); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {
193
System.exit(0); } }); frame.getContentPane().add(new JTabbedPaneDemo(), BorderLayout.CENTER); frame.setSize(400, 125); frame.setVisible(true); } } Output
Download JTabbedPane Source Code
JTabbedPane question When I use a JTabbedPane and want to listen to which tab is being clicked, which listerner should I use?
Answer: ChangeListener
Java JTabbedPane Hierarchy

javax.swing
Class JTabbedPane
java.lang.Object java.awt.Component java.awt.Container javax.swing.JComponent javax.swing.JTabbedPane

Accessible, ImageObserver, MenuContainer, Serializable, SwingConstants
JTabbedPane Constructor
JTabbedPane()
Creates an empty TabbedPane with a default tab placement of JTabbedPane.TOP.

JTabbedPane(int tabPlacement)
Creates an empty TabbedPane with the specified tab placement of either: JTabbedPane.TOP, JTabbedPane.BOTTOM, JTabbedPane.LEFT, or JTabbedPane.RIGHT.
194
JTabbedPane(int tabPlacement, int tabLayoutPolicy)
Creates an empty TabbedPane with the specified tab placement and tab layout policy.
Java JToolBar class example
JToolbar
Java Swing Tutorial Explaining the JToolBar Component. A JToolbar contains a number of components whose type is usually some kind of button which can also include separators to group related components within the toolbar. The toolbar can be docked against any of the four edges of a container (panel or a frame). A toolbar can also be made to float. Toolbars uses BoxLayout, which arranges components in one horizontal row/ vertical column. This layout manager does not force each component to have the same height or width; instead, it uses their preferred height or width, and attempts to align them. You can adjust the resulting alignment by calling class Components methods setAlignmentX() and/or setAlignmentY() on each component.
JToolbar Source Code

import import import import import import import import import import javax.swing.JToolBar; javax.swing.JButton; javax.swing.ImageIcon; javax.swing.JFrame; javax.swing.JTextArea; javax.swing.JScrollPane; javax.swing.JPanel; javax.swing.JTextField; java.awt.*; java.awt.event.*;
public class JToolBarDemo extends JFrame { protected JTextArea textArea; protected String newline = "\n"; public JToolBarDemo() { super("ToolBarDemo"); // Create the toolbar. JToolBar jtbMainToolbar = new JToolBar(); // setFloatable(false) to make the toolbar non movable addButtons(jtbMainToolbar); // Create the text area textArea = new JTextArea(5, 30); JScrollPane jsPane = new JScrollPane(textArea); // Lay out the content pane. JPanel jplContentPane = new JPanel(); jplContentPane.setLayout(new BorderLayout()); jplContentPane.setPreferredSize(new Dimension(400, 100));
195
jplContentPane.add(jtbMainToolbar, BorderLayout.NORTH); jplContentPane.add(jsPane, BorderLayout.CENTER); setContentPane(jplContentPane); } public void addButtons(JToolBar jtbToolBar) { JButton jbnToolbarButtons = null; // first button jbnToolbarButtons = new JButton(new ImageIcon("left.gif")); jbnToolbarButtons.setToolTipText("left"); jbnToolbarButtons.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { displayInTextArea("This is Left Toolbar Button Reporting"); } }); jtbToolBar.add(jbnToolbarButtons); // 2nd button jbnToolbarButtons = new JButton(new ImageIcon("right.gif")); jbnToolbarButtons.setToolTipText("right"); jbnToolbarButtons.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { displayInTextArea("This is right Toolbar Button Reporting"); } }); jtbToolBar.add(jbnToolbarButtons); jtbToolBar.addSeparator(); // 3rd button jbnToolbarButtons = new JButton(new ImageIcon("open.gif")); jbnToolbarButtons.setToolTipText("open"); jbnToolbarButtons.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { displayInTextArea("This is open Toolbar Button Reporting"); } }); jtbToolBar.add(jbnToolbarButtons); // 4th button jbnToolbarButtons = new JButton(new ImageIcon("save.gif")); jbnToolbarButtons.setToolTipText("save"); jbnToolbarButtons.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { displayInTextArea("This is save Toolbar Button Reporting"); } }); jtbToolBar.add(jbnToolbarButtons); // We can add separators to group similar components jtbToolBar.addSeparator(); // fourth button jbnToolbarButtons = new JButton("Text button"); jbnToolbarButtons.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { displayInTextArea("Text button"); } }); jtbToolBar.add(jbnToolbarButtons); // fifth component is NOT a button! JTextField jtfButton = new JTextField("Text field"); jtfButton.setEditable(false);
196
jtfButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { displayInTextArea("TextField component can also be placed"); } }); jtbToolBar.add(jtfButton); } protected void displayInTextArea(String actionDescription) { textArea.append(actionDescription + newline); } public static void main(String[] args) { JToolBarDemo jtfToolbar = new JToolBarDemo(); // Extends Frame. jtfToolbar.pack(); jtfToolbar.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); jtfToolbar.setVisible(true); } } Output
Download JToolbar Source Code
Java JToolBar Hierarchy

javax.swing
Class JToolBar
java.lang.Object java.awt.BorderLayout
LayoutManager, LayoutManager2, Serializable
JToolBar Constructor
JToolBar()
Creates a new tool bar; orientation defaults to HORIZONTAL.

JToolBar(int orientation)
Creates a new tool bar with the specified orientation.
197
JToolBar(String name)
Creates a new tool bar with the specified name.

JToolBar(String name, int orientation)
Creates a new tool bar with a specified name and orientation.
Java FlowLayout class example
FlowLayout
Java Swing Tutorial Explaining the FlowLayout. FlowLayout when used arranges swing components from left to right until theres no more space available. Then it begins a new row below it and moves from left to right again. Each component in a FlowLayout gets as much space as it needs and no more.
FlowLayout Source Code

import import import import import import import import import java.awt.ComponentOrientation; java.awt.Container; java.awt.Dimension; java.awt.FlowLayout; javax.swing.JButton; javax.swing.JCheckBox; javax.swing.JFrame; javax.swing.JLabel; javax.swing.JTextField;
public class FlowLayoutDemo { public static boolean RIGHT_TO_LEFT = false; public static void addComponents(Container contentPane) { if (RIGHT_TO_LEFT) { contentPane.setComponentOrientation( ComponentOrientation.RIGHT_TO_LEFT); } contentPane.setLayout(new FlowLayout()); contentPane.add(new contentPane.add(new contentPane.add(new contentPane.add(new contentPane.add(new } private static void createAndShowGUI() { JFrame.setDefaultLookAndFeelDecorated(true); JFrame frame = new JFrame("FlowLayout Source Demo") { JLabel("JLabel 1")); JButton("JButton 2")); JCheckBox("JCheckBox 3")); JTextField("Long-Named JTextField 4")); JButton("JButton 5"));
198
public Dimension getMinimumSize() { Dimension prefSize = getPreferredSize(); return new Dimension(100, prefSize.height); } }; frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane and components in FlowLayout addComponents(frame.getContentPane()); frame.pack(); frame.setVisible(true); } public static void main(String[] args) { javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createAndShowGUI(); } }); } } Output
Download FlowLayout Source Code
Java BorderLayout class example
BorderLayout
Java Swing Tutorial Explaining the BorderLayout . BorderLayout places swing components in the North, South, East, West and center of a container. All extra space is placed in the center area. You can add horizontal and vertical gaps between the areas. Every content pane is initialized to use a BorderLayout. Components are added to a BorderLayout by using the add method. JFrames content pane default layout manager: BorderLayout. In BorderLayout, a components position is specified by a second argument to add.
199
BorderLayout Source Code

/* * BorderLayoutDemo.java is a 1.4 application that requires no other files. */ import import import import import import java.awt.BorderLayout; java.awt.Container; java.awt.Dimension; javax.swing.JButton; javax.swing.JFrame; javax.swing.JLabel;
public class BorderLayoutDemo { public static boolean RIGHT_TO_LEFT = false; public static void addComponentsToPane(Container contentPane) { Use BorderLayout. Default empty constructor with no horizontal and vertical gaps contentPane.setLayout(new BorderLayout(5,5)); if (!(contentPane.getLayout() instanceof BorderLayout)) { contentPane.add(new JLabel("Container doesn't use BorderLayout!")); return; } if (RIGHT_TO_LEFT) { contentPane.setComponentOrientation( java.awt.ComponentOrientation.RIGHT_TO_LEFT); } JButton jbnSampleButtons = new JButton("Button 1 (PAGE_START)"); contentPane.add(jbnSampleButtons, BorderLayout.PAGE_START); jbnSampleButtons = new JButton("Button 2 (CENTER)"); jbnSampleButtons.setPreferredSize(new Dimension(200, 100)); contentPane.add(jbnSampleButtons, BorderLayout.CENTER); jbnSampleButtons = new JButton("Button 3 (LINE_START)"); contentPane.add(jbnSampleButtons, BorderLayout.LINE_START); jbnSampleButtons = new JButton("Long-Named Button 4 (PAGE_END)"); contentPane.add(jbnSampleButtons, BorderLayout.PAGE_END); jbnSampleButtons = new JButton("5 (LINE_END)"); contentPane.add(jbnSampleButtons, BorderLayout.LINE_END); } private static void createAndShowGUI() { JFrame.setDefaultLookAndFeelDecorated(true); JFrame frame = new JFrame("BorderLayout Source Demo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane and add swing components to it addComponentsToPane(frame.getContentPane()); frame.pack(); frame.setVisible(true);
// //
200
} public static void main(String[] args) { javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createAndShowGUI(); } }); } } output
Download BorderLayout Source Code
Java GridLayout class example
GridLayout
Java Swing Tutorial Explaining the GridLayout. GridLayout is a layout manager that lays out a containers components in a rectangular grid. The container is divided into equalsized rectangles, and one component is placed in each rectangle.
GridLayout Source Code

import java.awt.*; import javax.swing.*; public class GridLayoutDemo { public final static boolean RIGHT_TO_LEFT = false; public static void addComponentsToPane(Container contentPane) { if (RIGHT_TO_LEFT) { contentPane.setComponentOrientation(
201
ComponentOrientation.RIGHT_TO_LEFT); } // Any number of rows and 2 columns contentPane.setLayout(new GridLayout(0,2)); contentPane.add(new contentPane.add(new contentPane.add(new contentPane.add(new contentPane.add(new } private static void createAndShowGUI() { JFrame.setDefaultLookAndFeelDecorated(true); JFrame frame = new JFrame("GridLayout Source Demo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane and components in GridLayout addComponentsToPane(frame.getContentPane()); JLabel("JLabel 1")); JButton("JButton 2")); JCheckBox("JCheckBox 3")); JTextField("Long-Named JTextField 4")); JButton("JButton 5"));
frame.pack(); frame.setVisible(true); } public static void main(String[] args) { javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createAndShowGUI(); } }); } } Output
Download GridLayout Source Code
Java GridLayout Hierarchy

javax.swing
Class GridLayout java.lang.Object java.awt.GridLayout All Implemented Interfaces: LayoutManager, Serializable
202
GridLayout Constructor
GridLayout()
Creates a grid layout with a default of one column per component, in a single row.
GridLayout(int rows, int cols)
Creates a grid layout with the spe cified number of rows and columns.
GridLayout(int rows, int cols, int hgap, int vgap)
Creates a grid layout with the specified number of rows and columns.
Java GridBagLayout class example
GridBagLayout
Java Swing Tutorial Explaining the GridBagLayout. GridBagLayout is a layout manager that lays out a containers components in a grid of cells with each component occupying one or more cells, called its display area. The display area aligns components vertically and horizontally, without requiring that the components be of the same size.
GridBagLayout Source Code

import import import import import java.awt.*; javax.swing.JButton; javax.swing.JComboBox; javax.swing.JFrame; javax.swing.JTextField;
public class GridBagLayoutDemo { public static void addComponentsToPane(Container pane) { JButton jbnButton; pane.setLayout(new GridBagLayout()); GridBagConstraints gBC = new GridBagConstraints(); gBC.fill = GridBagConstraints.HORIZONTAL; jbnButton = new JButton("Button 1"); gBC.weightx = 0.5; gBC.gridx = 0; gBC.gridy = 0; pane.add(jbnButton, gBC);
203
JTextField jtf = new JTextField("TextField 1"); gBC.gridx = 2; gBC.gridy = 0; jtf.setEditable(false); pane.add(jtf, gBC); jbnButton = new JButton("Button 3"); gBC.gridx = 2; gBC.gridy = 0; pane.add(jbnButton, gBC); jbnButton = new JButton("Button 4"); gBC.ipady = 40; //This component has more breadth compared to other buttons gBC.weightx = 0.0; gBC.gridwidth = 3; gBC.gridx = 0; gBC.gridy = 1; pane.add(jbnButton, gBC); JComboBox jcmbSample = new JComboBox(new String[]{"ComboBox 1", "hi", "hello"}); gBC.ipady = 0; gBC.weighty = 1.0; gBC.anchor = GridBagConstraints.PAGE_END; gBC.insets = new Insets(10,0,0,0); //Padding gBC.gridx = 1; gBC.gridwidth = 2; gBC.gridy = 2; pane.add(jcmbSample, gBC); } private static void createAndShowGUI() { JFrame.setDefaultLookAndFeelDecorated(true); JFrame frame = new JFrame("GridBagLayout Source Demo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Set up the content pane. addComponentsToPane(frame.getContentPane()); frame.pack(); frame.setVisible(true); } public static void main(String[] args) { javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createAndShowGUI(); } }); } } Output
204
After Expanding the Frame
Download GridBagLayout Source Code
GridBagLayout Class
javax.swing
Class GridBagLayout
java.lang.Object java.awt.GridBagLayout
LayoutManager, LayoutManager2, Serializable
GridBagLayout Constructor
GridBagLayout()
Creates a grid bag layout manager..
205
Java JMenu class example
JMenu
Java Swing Tutorial Explaining the JMenuBar Component. Swing provides support for pull-down and popup menus. A JMenubar can contain several JMenu s. Each of the JMenu s can contain a series of JMenuItem s that you can select.
How Menus Are Created?
1. First, A JMenubar is created 2. Then, we attach all of the menus to this JMenubar. 3. Then we add JMenuItem s to the JMenu s. 4. The JMenubar is then added to the frame. By default, each JMenuItem added to a JMenu is enabledthat is, it can be selected. In certain situations, we may need to disable a JMenuItem. This is done by calling setEnabled(). The setEnabled() method also allows components to be enabled.
JMenu Source Code

import import import import import import import import import import import import import import java.awt.*; java.awt.event.*; javax.swing.JMenu; javax.swing.JMenuItem; javax.swing.JCheckBoxMenuItem; javax.swing.JRadioButtonMenuItem; javax.swing.ButtonGroup; javax.swing.JMenuBar; javax.swing.KeyStroke; javax.swing.ImageIcon; javax.swing.JPanel; javax.swing.JTextArea; javax.swing.JScrollPane; javax.swing.JFrame;
//Used Action Listner for JMenuItem & JRadioButtonMenuItem //Used Item Listner for JCheckBoxMenuItem public class JMenuDemo implements ActionListener, ItemListener { JTextArea jtAreaOutput; JScrollPane jspPane; public JMenuBar createJMenuBar() { JMenuBar mainMenuBar; JMenu menu1, menu2, submenu; JMenuItem plainTextMenuItem, textIconMenuItem, iconMenuItem, subMenuItem; JRadioButtonMenuItem rbMenuItem; JCheckBoxMenuItem cbMenuItem; ImageIcon icon = createImageIcon("jmenu.jpg"); mainMenuBar = new JMenuBar(); menu1 = new JMenu("Menu 1");
206
menu1.setMnemonic(KeyEvent.VK_M); mainMenuBar.add(menu1); // Creating the MenuItems plainTextMenuItem = new JMenuItem("Menu item with Plain Text", KeyEvent.VK_T); // can be done either way for assigning shortcuts // menuItem.setMnemonic(KeyEvent.VK_T); // Accelerators, offer keyboard shortcuts to bypass navigating the menu // hierarchy. plainTextMenuItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_1, ActionEvent.ALT_MASK)); plainTextMenuItem.addActionListener(this); menu1.add(plainTextMenuItem); textIconMenuItem = new JMenuItem("Menu Item with Text & Image", icon); textIconMenuItem.setMnemonic(KeyEvent.VK_B); textIconMenuItem.addActionListener(this); menu1.add(textIconMenuItem); // Menu Item with just an Image iconMenuItem = new JMenuItem(icon); iconMenuItem.setMnemonic(KeyEvent.VK_D); iconMenuItem.addActionListener(this); menu1.add(iconMenuItem); menu1.addSeparator(); // Radio Button Menu items follow a seperator ButtonGroup itemGroup = new ButtonGroup(); rbMenuItem = new JRadioButtonMenuItem( "Menu Item with Radio Button"); rbMenuItem.setSelected(true); rbMenuItem.setMnemonic(KeyEvent.VK_R); itemGroup.add(rbMenuItem); rbMenuItem.addActionListener(this); menu1.add(rbMenuItem); rbMenuItem = new JRadioButtonMenuItem( "Menu Item 2 with Radio Button"); itemGroup.add(rbMenuItem); rbMenuItem.addActionListener(this); menu1.add(rbMenuItem); menu1.addSeparator(); // Radio Button Menu items follow a seperator cbMenuItem = new JCheckBoxMenuItem("Menu Item with check box"); cbMenuItem.setMnemonic(KeyEvent.VK_C); cbMenuItem.addItemListener(this); menu1.add(cbMenuItem); cbMenuItem = new JCheckBoxMenuItem("Menu Item 2 with check box"); cbMenuItem.addItemListener(this); menu1.add(cbMenuItem); menu1.addSeparator(); // Sub Menu follows a seperator submenu = new JMenu("Sub Menu"); submenu.setMnemonic(KeyEvent.VK_S); subMenuItem = new JMenuItem("Sub MenuItem 1"); subMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_2, ActionEvent.CTRL_MASK)); subMenuItem.addActionListener(this); submenu.add(subMenuItem); subMenuItem = new JMenuItem("Sub MenuItem 2"); submenu.add(subMenuItem); subMenuItem.addActionListener(this); menu1.add(submenu); // Build second menu in the menu bar.
207
menu2 = new JMenu("Menu 2"); menu2.setMnemonic(KeyEvent.VK_N); mainMenuBar.add(menu2); return mainMenuBar; } public Container createContentPane() { // Create the content-pane-to-be. JPanel jplContentPane = new JPanel(new BorderLayout()); jplContentPane.setLayout(new BorderLayout());// Can do it either way // to set layout jplContentPane.setOpaque(true); // Create a scrolled text area. jtAreaOutput = new JTextArea(5, 30); jtAreaOutput.setEditable(false); jspPane = new JScrollPane(jtAreaOutput); // Add the text area to the content pane. jplContentPane.add(jspPane, BorderLayout.CENTER); return jplContentPane; } /** Returns an ImageIcon, or null if the path was invalid. */ protected static ImageIcon createImageIcon(String path) { java.net.URL imgURL = JMenuDemo.class.getResource(path); if (imgURL != null) { return new ImageIcon(imgURL); } else { System.err.println("Couldn't find image file: " + path); return null; } } private static void createGUI() { JFrame.setDefaultLookAndFeelDecorated(true); // Create and set up the window. JFrame frame = new JFrame("JMenu Usage Demo"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JMenuDemo app = new JMenuDemo(); frame.setJMenuBar(app.createJMenuBar()); frame.setContentPane(app.createContentPane()); frame.setSize(500, 300); frame.setVisible(true); } public void actionPerformed(ActionEvent e) { JMenuItem source = (JMenuItem) (e.getSource()); String s = "Menu Item source: " + source.getText() + " (an instance of " + getClassName(source) + ")"; jtAreaOutput.append(s + "\n"); jtAreaOutput.setCaretPosition(jtAreaOutput.getDocument() .getLength()); } public void itemStateChanged(ItemEvent e) { JMenuItem source = (JMenuItem) (e.getSource()); String s = "Menu Item source: " + source.getText() + " (an instance of " + getClassName(source) + ")" + "\n" + " State of check Box: " + ((e.getStateChange() == ItemEvent.SELECTED) ? "selected" : "unselected"); jtAreaOutput.append(s + "\n"); jtAreaOutput.setCaretPosition(jtAreaOutput.getDocument()
208
.getLength()); } // Returns the class name, no package info protected String getClassName(Object o) { String classString = o.getClass().getName(); int dotIndex = classString.lastIndexOf("."); return classString.substring(dotIndex + 1); // Returns only Class name } public static void main(String[] args) { javax.swing.SwingUtilities.invokeLater(new Runnable() { public void run() { createGUI(); } }); } } Output
Download JMenuBar Source Code
Java Scrollable Popup Menu
Scrollable JPopupMenu
Java Swing Tutorial Explaining the Scrollable Popup Menu Component. Scrollable JPopupMenu can be used in any of the Java Applications. I developed this as the popup menu can have so many menuitems that, they exceed the screen visible area
209
and would not be visible. I needed a way to scroll through the menu items of the pop up menu to avoid this visibility problem.
Scrollable PopupMenu Source Code

Custom JButtons are placed on a JPanel. This JPanel is placed on JScrollPane which has a scrollbar. These custom JButtons are nothing but menuitems. These menuitems can be checked and unchecked similar to JCheckBoxMenuItems. My scrollable jpopupmenu source code contains 5 files. 1. JFramePopupMenu.java (Mainframe containing the button to invoke Scrollable popup menu) 2. XCheckedButton.java (Custom JButton which acts like a JCheckBoxMenuItem for the pop up menu. This class provides a JCheckBoxMenuItrem Functionality, optionally working like a JMenuItem, primarily used with XJPopupMenu. Rationale for development of this component was the inability of a JMenuItem to work in a Scrollable Popup menu as in XJPopupMenu) 3. XJPopupMenu.java (This is the heart of Scrollable JPopupMenu code) 4. XConstant.java (Interface containing commonly used constants) 5. check.gif 6. menu_spacer.gif
Here is a source code showing, how to create a java swing JPopupMenu with a vertical scrollbar:
1. JFramePopupMenu.java
import java.awt.Component; import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent;
210
import java.awt.event.MouseListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JTextField; import javax.swing.SwingUtilities; public class JFramePopupMenu extends JFrame private JPanel jContentPane = null; private JButton jbnPopup = null; private JTextField jtfNumOfMenus = null; private JLabel lblNumElem = null; private XJPopupMenu scrollablePopupMenu = new XJPopupMenu(this); private JButton getBtnPopup() { if (jbnPopup == null) { jbnPopup = new JButton(); jbnPopup.setText("View Scrollable popup menu "); int n = Integer.parseInt(getTxtNumElem().getText()); for (int i=0;i<n;i++){ XCheckedButton xx = new XCheckedButton(" JMenuItem xx.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) { System.out.println( e ); scrollablePopupMenu.hidemenu(); } }); // Add Custom JSeperator after 2nd and 7th MenuItem. if(i == 2 || i == 7){ scrollablePopupMenu.addSeparator(); } scrollablePopupMenu.add(xx); " + (i+1)); {
211
} jbnPopup.addMouseListener(new MouseAdapter() { public void mousePressed(MouseEvent e) { Component source = (Component) e.getSource(); scrollablePopupMenu.show(source, e.getX(), e.getY()); } }); } return jbnPopup; } private JTextField getTxtNumElem() { if (jtfNumOfMenus == null) { jtfNumOfMenus = new JTextField(); jtfNumOfMenus.setColumns(3); jtfNumOfMenus.setText("60"); } return jtfNumOfMenus; } public static void main(String[] args) { SwingUtilities.invokeLater(new Runnable() { public void run() { JFramePopupMenu thisClass = new JFramePopupMenu(); thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); thisClass.setVisible(true); } }); } public JFramePopupMenu() { super(); initialize();
212
} private void initialize() { this.setSize(274, 109); this.setContentPane(getJContentPane()); this.setTitle(" Scrollable JPopupMenu "); } private JPanel getJContentPane() { if (jContentPane == null) { lblNumElem = new JLabel(); FlowLayout flowLayout = new FlowLayout(); flowLayout.setHgap(8); flowLayout.setVgap(8); jContentPane = new JPanel(); jContentPane.setLayout(flowLayout); jContentPane.add(getBtnPopup(), null); jContentPane.add(lblNumElem, null); jContentPane.add(getTxtNumElem(), null); } return jContentPane; } }
2. XCheckedButton.java
import java.awt.Color; import java.awt.event.ItemEvent; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import javax.swing.Action; import javax.swing.BorderFactory; import javax.swing.ButtonGroup; import javax.swing.Icon;
213
import javax.swing.ImageIcon; import javax.swing.JButton; import javax.swing.JToggleButton; import javax.swing.SwingConstants; import javax.swing.UIManager; import javax.swing.plaf.ComponentUI; import javax.swing.plaf.basic.BasicButtonUI; /** * @author balajihe * */ public class XCheckedButton extends JButton { // Icon to be used to for the Checked Icon of the Button checkedIcon;
private static ImageIcon /**
* These colors are required in order to simulate the JMenuItem's L&F */ public static final Color MENU_HIGHLIGHT_BG_COLOR = UIManager.getColor ("MenuItem.selectionBackground"); public static final Color MENU_HIGHLIGHT_FG_COLOR = UIManager.getColor ("MenuItem.selectionForeground"); public static final Color MENUITEM_BG_COLOR = UIManager.getColor ("MenuItem.background"); public static final Color MENUITEM_FG_COLOR = UIManager.getColor ("MenuItem.foreground"); // This property if set to false, will result in the checked Icon not being
displayed // when the button is selected private boolean displayCheck public XCheckedButton() { super(); = true;
214
init(); } public XCheckedButton(Action a) { super(a); init(); } public XCheckedButton(Icon icon) { super(icon); init(); } public XCheckedButton(String text, Icon icon) { super(text, icon); init(); } public XCheckedButton(String text) { super(text); init(); } /** * Initialize component LAF and add Listeners */ private void init() { MouseAdapter mouseAdapter = getMouseAdapter(); // Basically JGoodies LAF UI for JButton does not allow Background color to be set. // So we need to set the default UI, ComponentUI ui = BasicButtonUI.createUI(this); this.setUI(ui); setBorder(BorderFactory.createEmptyBorder(3, 0, 3, 2)); setMenuItemDefaultColors(); // setContentAreaFilled(false);
215
setHorizontalTextPosition(SwingConstants.RIGHT); setHorizontalAlignment(SwingConstants.LEFT); // setModel(new JToggleButton.ToggleButtonModel());
setModel(new XCheckedButtonModel()); setSelected(false); this.addMouseListener(mouseAdapter); } private void setMenuItemDefaultColors() { XCheckedButton.this.setBackground(MENUITEM_BG_COLOR); XCheckedButton.this.setForeground(MENUITEM_FG_COLOR); } /** * @return */ private MouseAdapter getMouseAdapter() { return new MouseAdapter() { // For static menuitems, the background color remains the highlighted color, if this is overridden public void mousePressed(MouseEvent e) { setMenuItemDefaultColors(); } public void mouseEntered(MouseEvent e) {
XCheckedButton.this.setBackground(MENU_HIGHLIGHT_BG_COLOR
XCheckedButton.this.setForeground(MENU_HIGHLIGHT_FG_COLOR } public void mouseExited(MouseEvent e) { setMenuItemDefaultColors(); } }; } /**
216
* @param checkedFlag */ public void displayIcon(boolean checkedFlag) { if (checkedFlag && isDisplayCheck()) { if (checkedIcon == null) { checkedIcon = new ImageIcon("check.gif"); } this.setIcon(checkedIcon); } else { this.setIcon(XConstant.EMPTY_IMAGE_ICON); } this.repaint(); } private class XCheckedButtonModel extends JToggleButton.ToggleButtonModel { /* * Need to Override keeping the super code, else the check mark won't come */ public void setSelected(boolean b) { ButtonGroup group = getGroup(); if (group != null) { // use the group model instead group.setSelected(this, b); b = group.isSelected(this); } if (isSelected() == b) { return; } if (b) { stateMask |= SELECTED; } else { stateMask &= ~SELECTED;
217
} // fireStateChanged(); // Send ItemEvent fireItemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_ CHANGED, this, this.isSelected() ? ItemEvent.SELECTED : ItemEvent.DESELECTED)); XCheckedButton.this.displayIcon(b); } } // Returns true if Button will display Checked Icon on Click. // Default Behaviour is to display a Checked Icon Send ChangeEvent
public boolean isDisplayCheck() { return displayCheck; } /** * Sets the property which determines whether a checked Icon should be displayed or not * Setting to false, makes this button display like a normal button * @param displayCheck */ public void setDisplayCheck(boolean displayCheck) { this.displayCheck = displayCheck; } }
218
3. XJPopupMenu.java
this.getToolkit().getScreenSize().height - this.getToolkit().getScreenInsets(jframe.getGraphicsConfiguration()).top - this.getToolkit().getScreenInsets(jframe.getGraphicsConfiguration()).bottom - 4)); super.add(scroll, BorderLayout.CENTER); // } public void show(Component invoker, int x, int y) { init(jframe); // this.pack(); super.add(scroll);
panelMenus.validate(); int maxsize = scroll.getMaximumSize().height; int realsize = panelMenus.getPreferredSize().height; int sizescroll = 0; if (maxsize < realsize) { sizescroll = scroll.getVerticalScrollBar().getPreferredSize().width; } Scroll.setPreferredSize(new Dimension(scroll.getPreferredSize().width + sizescroll + 20, scroll.getPreferredSize().height)); this.pack(); this.setInvoker(invoker); if (sizescroll != 0) { //Set popup size only if scrollbar is visible this.setPopupSize(new Dimension(scroll.getPreferredSize().width + 20, scroll.getMaximumSize().height - 20)); } // this.setMaximumSize(scroll.getMaximumSize());
Point invokerOrigin = invoker.getLocationOnScreen(); this.setLocation((int) invokerOrigin.getX() + x, (int) invokerOrigin.getY() + y);
219
this.setVisible(true); } public void hidemenu() { if (this.isVisible()) { this.setVisible(false); } } public void add(AbstractButton menuItem) { // menuItem.setMargin(new Insets(0, 20, 0 , 0));
if (menuItem == null) { return; } panelMenus.add(menuItem); menuItem.removeActionListener(this); menuItem.addActionListener(this); if (menuItem.getIcon() == null) { menuItem.setIcon(EMPTY_IMAGE_ICON); } if (!(menuItem instanceof XCheckedButton)) { System.out.println(menuItem.getName()); } } public void addSeparator() { panelMenus.add(new XSeperator()); } public void actionPerformed(ActionEvent e) { this.hidemenu(); } public Component[] getComponents() { return panelMenus.getComponents();
220
} private static class XSeperator extends JSeparator { XSeperator() { ComponentUI ui = XBasicSeparatorUI.createUI(this); XSeperator.this.setUI(ui); } private static class XBasicSeparatorUI extends BasicSeparatorUI { public static ComponentUI createUI(JComponent c) { return new XBasicSeparatorUI(); } public void paint(Graphics g, JComponent c) { Dimension s = c.getSize(); if (((JSeparator) c).getOrientation() == JSeparator.VERTICAL) { g.setColor(c.getForeground()); g.drawLine(0, 0, 0, s.height); g.setColor(c.getBackground()); g.drawLine(1, 0, 1, s.height); } else // HORIZONTAL { g.setColor(c.getForeground()); g.drawLine(0, 7, s.width, 7); g.setColor(c.getBackground()); g.drawLine(0, 8, s.width, 8); } } } } }
221
4. XConstant.java
import javax.swing.Icon; import javax.swing.ImageIcon; public interface XConstant { public static final Icon EMPTY_IMAGE_ICON = new ImageIcon("menu_spacer.gif"); }
Note: Please use the 2 jgoodies jars present in the zip file for the jgoodies look and feel Download Scrollable JPopupMenu Source Code
Java Swing Calculator

This is a free Java calculator tutorial developed using Java Swing. Below you will find the java code for calculator along with the screenshot. It is a basic four-function calculator java program source code. The calculator that we build will look like:
Java simple calculator 1. A four-function calculator with the following functions: * Addition - adds two numbers: n1 + n2. * Subtraction - subtracts number two from number one: n1 - n2. * Multiplication - Multiplies two numbers: n1 * n2. * Division - divides number two into number one: n1 / n2. 2. Used JButton for the numbers and functions.
222
3. Used Jmenu for File and help. 4. Created a class to respond to the events caused by numbers, functions, exit, help and about functionality. 5. Used BorderLayout to layout various components in the Calculator Frame. A BorderLayout lays out a container, arranging and resizing its components to fit in five regions: north, south, east, west, and center.
Java Calculator Source Code

Oct 15, 2006 by Hemanth
/* Name: Hemanth. B Website: wwww.java-swing-tutorial.html Topic: A basic Java Swing Calculator Conventions Used in Source code ---------------------------------
1. All JLabel components start with jlb* 2. All JPanel components start with jpl* 3. All JMenu components start with jmenu* 4. All JMenuItem components start with jmenuItem* 5. All JDialog components start with jdlg* 6. All JButton components start with jbn* */ import import import import import import import import import import import import import import import import import import import import import import
java.awt.BorderLayout; java.awt.Color; java.awt.Container; java.awt.FlowLayout; java.awt.Font; java.awt.GridLayout; java.awt.Window; java.awt.event.ActionEvent; java.awt.event.ActionListener; java.awt.event.KeyEvent; java.awt.event.WindowAdapter; java.awt.event.WindowEvent; javax.swing.JButton; javax.swing.JDialog; javax.swing.JFrame; javax.swing.JLabel; javax.swing.JMenu; javax.swing.JMenuBar; javax.swing.JMenuItem; javax.swing.JPanel; javax.swing.JTextArea; javax.swing.KeyStroke;
223
public class Calculator extends JFrame implements ActionListener { // Variables final int MAX_INPUT_LENGTH = 20; final int INPUT_MODE = 0; final int RESULT_MODE = 1; final int ERROR_MODE = 2; int displayMode; boolean clearOnNextDigit, percent; double lastNumber; String lastOperator; private JMenu jmenuFile, jmenuHelp; private JMenuItem jmenuitemExit, jmenuitemAbout; private JLabel jlbOutput; private JButton jbnButtons[]; private JPanel jplMaster, jplBackSpace, jplControl; /* * Font(String name, int style, int size) Creates a new Font from the specified name, style and point size. */ Font f12 = new Font("Times New Roman", 0, 12); Font f121 = new Font("Times New Roman", 1, 12); // Constructor public Calculator() { /* Set Up the JMenuBar. * Have Provided All JMenu's with Mnemonics * Have Provided some JMenuItem components with Keyboard Accelerators */ jmenuFile = new JMenu("File"); jmenuFile.setFont(f121); jmenuFile.setMnemonic(KeyEvent.VK_F); jmenuitemExit = new JMenuItem("Exit"); jmenuitemExit.setFont(f12); jmenuitemExit.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, ActionEvent.CTRL_MASK)); jmenuFile.add(jmenuitemExit); jmenuHelp = new JMenu("Help"); jmenuHelp.setFont(f121); jmenuHelp.setMnemonic(KeyEvent.VK_H); jmenuitemAbout = new JMenuItem("About Calculator"); jmenuitemAbout.setFont(f12); jmenuHelp.add(jmenuitemAbout); JMenuBar mb = new JMenuBar(); mb.add(jmenuFile); mb.add(jmenuHelp); setJMenuBar(mb); //Set frame layout manager setBackground(Color.gray); jplMaster = new JPanel(); jlbOutput = new JLabel("0"); jlbOutput.setHorizontalTextPosition(JLabel.RIGHT); jlbOutput.setBackground(Color.WHITE); jlbOutput.setOpaque(true); // Add components to frame getContentPane().add(jlbOutput, BorderLayout.NORTH);
224
jbnButtons = new JButton[23]; // GridLayout(int rows, int cols, int hgap, int vgap) JPanel jplButtons = new JPanel(); // container for Jbuttons // Create numeric Jbuttons for (int i = 0; i <= 9; i++) { // set each Jbutton label to the value of index jbnButtons[i] = new JButton(String.valueOf(i)); } // Create operator Jbuttons jbnButtons[10] = new JButton("+/-"); jbnButtons[11] = new JButton("."); jbnButtons[12] = new JButton("="); jbnButtons[13] = new JButton("/"); jbnButtons[14] = new JButton("*"); jbnButtons[15] = new JButton("-"); jbnButtons[16] = new JButton("+"); jbnButtons[17] = new JButton("sqrt"); jbnButtons[18] = new JButton("1/x"); jbnButtons[19] = new JButton("%"); jplBackSpace = new JPanel(); jplBackSpace.setLayout(new GridLayout(1, 1, 2, 2)); jbnButtons[20] = new JButton("Backspace"); jplBackSpace.add(jbnButtons[20]); jplControl = new JPanel(); jplControl.setLayout(new GridLayout(1, 2, 2, 2)); jbnButtons[21] = new JButton(" CE "); jbnButtons[22] = new JButton("C"); jplControl.add(jbnButtons[21]); jplControl.add(jbnButtons[22]); // Setting all Numbered JButton's to Blue. The rest to Red for (int i = 0; i < jbnButtons.length; i++) { jbnButtons[i].setFont(f12); if (i < 10) jbnButtons[i].setForeground(Color.blue); else jbnButtons[i].setForeground(Color.red); } // Set panel layout manager for a 4 by 5 grid jplButtons.setLayout(new GridLayout(4, 5, 2, 2)); //Add buttons to keypad panel starting at top left // First row for (int i = 7; i <= 9; i++) { jplButtons.add(jbnButtons[i]); } // add button / and sqrt jplButtons.add(jbnButtons[13]); jplButtons.add(jbnButtons[17]); // Second row for (int i = 4; i <= 6; i++) { jplButtons.add(jbnButtons[i]); } // add button * and x^2 jplButtons.add(jbnButtons[14]); jplButtons.add(jbnButtons[18]); // Third row for (int i = 1; i <= 3; i++) { jplButtons.add(jbnButtons[i]); } //adds button - and % jplButtons.add(jbnButtons[15]); jplButtons.add(jbnButtons[19]);
225
//Fourth Row // add 0, +/-, ., +, and = jplButtons.add(jbnButtons[0]); jplButtons.add(jbnButtons[10]); jplButtons.add(jbnButtons[11]); jplButtons.add(jbnButtons[16]); jplButtons.add(jbnButtons[12]); jplMaster.setLayout(new BorderLayout()); jplMaster.add(jplBackSpace, BorderLayout.WEST); jplMaster.add(jplControl, BorderLayout.EAST); jplMaster.add(jplButtons, BorderLayout.SOUTH); // Add components to frame getContentPane().add(jplMaster, BorderLayout.SOUTH); requestFocus(); //activate ActionListener for (int i = 0; i < jbnButtons.length; i++) { jbnButtons[i].addActionListener(this); } jmenuitemAbout.addActionListener(this); jmenuitemExit.addActionListener(this); clearAll(); //add WindowListener for closing frame and ending program addWindowListener(new WindowAdapter() { public void windowClosed(WindowEvent e) { System.exit(0); } }); } //End of Contructor Calculator // Perform action public void actionPerformed(ActionEvent e){ double result = 0; if(e.getSource() == jmenuitemAbout){ JDialog dlgAbout = new CustomABOUTDialog(this, "About Java Swing Calculator", true); dlgAbout.setVisible(true); }else if(e.getSource() == jmenuitemExit){ System.exit(0); } // Search for the button pressed until end of array or key found for (int i=0; i< 1) setDisplayString("0"); } break; case 21: // CE
clearExisting();
226
break; case 22: // C
clearAll(); break; } } } } void setDisplayString(String s) { jlbOutput.setText(s);
} String getDisplayString() { return jlbOutput.getText(); } void addDigitToDisplay(int digit) { if (clearOnNextDigit) setDisplayString(""); String inputString = getDisplayString(); if (inputString.indexOf("0") == 0) { inputString = inputString.substring(1); } if ((!inputString.equals("0") || digit > 0) && inputString.length() < MAX_INPUT_LENGTH) { setDisplayString(inputString + digit); } displayMode = INPUT_MODE; clearOnNextDigit = false; } void addDecimalPoint() { displayMode = INPUT_MODE; if (clearOnNextDigit) setDisplayString(""); String inputString = getDisplayString(); // If the input string already contains a decimal point, don't // do anything to it. if (inputString.indexOf(".") < 0) setDisplayString(new String(inputString + ".")); } void processSignChange() { if (displayMode == INPUT_MODE) { String input = getDisplayString(); if (input.length() > 0 && !input.equals("0")) { if (input.indexOf("-") == 0) setDisplayString(input.substring(1)); else setDisplayString("-" + input); } } else if (displayMode == RESULT_MODE) { double numberInDisplay = getNumberInDisplay(); if (numberInDisplay != 0) displayResult(-numberInDisplay); } } void clearAll() {
227
setDisplayString("0"); lastOperator = "0"; lastNumber = 0; displayMode = INPUT_MODE; clearOnNextDigit = true; } void clearExisting() { setDisplayString("0"); clearOnNextDigit = true; displayMode = INPUT_MODE; } double getNumberInDisplay() { String input = jlbOutput.getText(); return Double.parseDouble(input); } void processOperator(String op) { if (displayMode != ERROR_MODE) { double numberInDisplay = getNumberInDisplay(); if (!lastOperator.equals("0")) { try { double result = processLastOperator(); displayResult(result); lastNumber = result; } catch (DivideByZeroException e) { } } else { lastNumber = numberInDisplay; } clearOnNextDigit = true; lastOperator = op; } } void processEquals() { double result = 0; if (displayMode != ERROR_MODE) { try { result = processLastOperator(); displayResult(result); } catch (DivideByZeroException e) { displayError("Cannot divide by zero!"); } lastOperator = "0"; } } double processLastOperator() throws DivideByZeroException { double result = 0; double numberInDisplay = getNumberInDisplay(); if (lastOperator.equals("/")) { if (numberInDisplay == 0) throw (new DivideByZeroException()); result = lastNumber / numberInDisplay; } if (lastOperator.equals("*")) result = lastNumber * numberInDisplay; if (lastOperator.equals("-")) result = lastNumber - numberInDisplay; if (lastOperator.equals("+")) result = lastNumber + numberInDisplay; return result; } void displayResult(double result) {
228
setDisplayString(Double.toString(result)); lastNumber = result; displayMode = RESULT_MODE; clearOnNextDigit = true; } void displayError(String errorMessage) { setDisplayString(errorMessage); lastNumber = 0; displayMode = ERROR_MODE; clearOnNextDigit = true; } public static void main(String args[]) { Calculator calci = new Calculator(); Container contentPane = calci.getContentPane(); // contentPane.setLayout(new BorderLayout()); calci.setTitle("Java Swing Calculator"); calci.setSize(241, 217); calci.pack(); calci.setLocation(400, 250); calci.setVisible(true); calci.setResizable(false); } } //End of Swing Calculator Class. class DivideByZeroException extends Exception { public DivideByZeroException() { super(); } public DivideByZeroException(String s) { super(s); } } class CustomABOUTDialog extends JDialog implements ActionListener { JButton jbnOk; CustomABOUTDialog(JFrame parent, String title, boolean modal) { super(parent, title, modal); setBackground(Color.black); JPanel p1 = new JPanel(new FlowLayout(FlowLayout.CENTER)); StringBuffer text = new StringBuffer(); text.append("Calculator Information\n\n"); text.append("Developer: Hemanth\n"); text.append("Version: 1.0"); JTextArea jtAreaAbout = new JTextArea(5, 21); jtAreaAbout.setText(text.toString()); jtAreaAbout.setFont(new Font("Times New Roman", 1, 13)); jtAreaAbout.setEditable(false); p1.add(jtAreaAbout); p1.setBackground(Color.red); getContentPane().add(p1, BorderLayout.CENTER); JPanel p2 = new JPanel(new FlowLayout(FlowLayout.CENTER)); jbnOk = new JButton(" OK "); jbnOk.addActionListener(this); p2.add(jbnOk); getContentPane().add(p2, BorderLayout.SOUTH); setLocation(408, 270); setResizable(false); addWindowListener(new WindowAdapter() {
229
public void windowClosing(WindowEvent e) { Window aboutDialog = e.getWindow(); aboutDialog.dispose(); } }); pack(); } public void actionPerformed(ActionEvent e) { if (e.getSource() == jbnOk) { this.dispose(); } } }
Download Java Calculator Source Code
Java Swing Address Book

This java swing project code demonstrates how to create a simple free address book program using java swing and jdbc. Also you will learn to use the following swing components like Jbuttons, JFrames, JTextFields and Layout Manager (GridBagLayout). In short, this is a Simple Address Book that keeps Names, email, Address and Phone Numbers of friends or people. It makes use of the JDBC driver and SQL statements for connecting and manipulating with the database.
230
Java Address Book Source Code

Oct 22, 2006 by Hemanth This Project Source code consists of 3 files: 1. 2. 3. 4. AddressBookDemo.java PersonDao.java PersonInfo.java An sql Table (Person Table)
AddressBookDemo.java
/* Name: Hemanth. B Website: java-swing-tutorial.html Topic: A basic Java Address Book Conventions Used in Source code --------------------------------1. All JLabel components start with jlb* 2. All JPanel components start with jpl* 3. All JMenu components start with jmenu* 4. All JMenuItem components start with jmenuItem* 5. All JDialog components start with jdlg* 6. All JButton components start with jbn* */ import java.awt.Container; import import import import import import import import import import import java.awt.GridBagConstraints; java.awt.GridBagLayout; java.awt.Insets; java.awt.event.ActionEvent; java.awt.event.ActionListener; java.util.ArrayList; javax.swing.JButton; javax.swing.JFrame; javax.swing.JLabel; javax.swing.JOptionPane; javax.swing.JTextField;
public class AddressBookDemo implements ActionListener { ArrayList personsList; PersonDAO pDAO; JFrame appFrame; JLabel jlbName, jlbAddress, jlbPhone, jlbEmail; JTextField jtfName, jtfAddress, jtfPhone, jtfEmail; JButton jbbSave, jbnDelete, jbnClear, jbnUpdate, jbnSearch, jbnForward, jbnBack, jbnExit; String name, address, email; int phone;
231
int recordNumber; // used to naviagate using >> and buttons Container cPane; public static void main(String args[]) { new AddressBookDemo(); } public AddressBookDemo() { name = ""; address = ""; email = ""; phone = -1; //Stores 0 to indicate no Phone Number recordNumber = -1; createGUI(); personsList = new ArrayList(); // creating PersonDAO object pDAO = new PersonDAO(); } public void createGUI(){ /*Create a frame, get its contentpane and set layout*/ appFrame = new JFrame("Address Book"); cPane = appFrame.getContentPane(); cPane.setLayout(new GridBagLayout()); //Arrange components on contentPane and set Action Listeners to each JButton arrangeComponents(); appFrame.setSize(240,300); appFrame.setResizable(false); appFrame.setVisible(true); } public void arrangeComponents() { jlbName = new JLabel("Name"); jlbAddress = new JLabel("Address"); jlbPhone = new JLabel("Phone"); jlbEmail = new JLabel("Email"); jtfName = new JTextField(20); jtfAddress = new JTextField(20); jtfPhone = new JTextField(20); jtfEmail = new JTextField(20); jbbSave = new JButton("Save"); jbnDelete = new JButton("Delete"); jbnClear = new JButton("Clear"); jbnUpdate = new JButton("Update"); jbnSearch = new JButton("Search"); jbnForward = new JButton(">>"); jbnBack = new JButton(""); jbnExit = new JButton("Exit"); /*add all initialized components to the container*/ GridBagConstraints gridBagConstraintsx01 = new GridBagConstraints(); gridBagConstraintsx01.gridx = 0; gridBagConstraintsx01.gridy = 0; gridBagConstraintsx01.insets = new Insets(5, 5, 5, 5); cPane.add(jlbName, gridBagConstraintsx01); GridBagConstraints gridBagConstraintsx02 = new GridBagConstraints(); gridBagConstraintsx02.gridx = 1; gridBagConstraintsx02.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx02.gridy = 0; gridBagConstraintsx02.gridwidth = 2; gridBagConstraintsx02.fill = GridBagConstraints.BOTH; cPane.add(jtfName, gridBagConstraintsx02); GridBagConstraints gridBagConstraintsx03 = new GridBagConstraints();
232
gridBagConstraintsx03.gridx = 0; gridBagConstraintsx03.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx03.gridy = 1; cPane.add(jlbAddress, gridBagConstraintsx03); GridBagConstraints gridBagConstraintsx04 = new GridBagConstraints(); gridBagConstraintsx04.gridx = 1; gridBagConstraintsx04.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx04.gridy = 1; gridBagConstraintsx04.gridwidth = 2; gridBagConstraintsx04.fill = GridBagConstraints.BOTH; cPane.add(jtfAddress, gridBagConstraintsx04); GridBagConstraints gridBagConstraintsx05 = new GridBagConstraints(); gridBagConstraintsx05.gridx = 0; gridBagConstraintsx05.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx05.gridy = 2; cPane.add(jlbPhone, gridBagConstraintsx05); GridBagConstraints gridBagConstraintsx06 = new GridBagConstraints(); gridBagConstraintsx06.gridx = 1; gridBagConstraintsx06.gridy = 2; gridBagConstraintsx06.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx06.gridwidth = 2; gridBagConstraintsx06.fill = GridBagConstraints.BOTH; cPane.add(jtfPhone, gridBagConstraintsx06); GridBagConstraints gridBagConstraintsx07 = new GridBagConstraints(); gridBagConstraintsx07.gridx = 0; gridBagConstraintsx07.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx07.gridy = 3; cPane.add(jlbEmail, gridBagConstraintsx07); GridBagConstraints gridBagConstraintsx08 = new GridBagConstraints(); gridBagConstraintsx08.gridx = 1; gridBagConstraintsx08.gridy = 3; gridBagConstraintsx08.gridwidth = 2; gridBagConstraintsx08.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx08.fill = GridBagConstraints.BOTH; cPane.add(jtfEmail, gridBagConstraintsx08); GridBagConstraints gridBagConstraintsx09 = new GridBagConstraints(); gridBagConstraintsx09.gridx = 0; gridBagConstraintsx09.gridy = 4; gridBagConstraintsx09.insets = new Insets(5, 5, 5, 5); cPane.add(jbbSave, gridBagConstraintsx09); GridBagConstraints gridBagConstraintsx10 = new GridBagConstraints(); gridBagConstraintsx10.gridx = 1; gridBagConstraintsx10.gridy = 4; gridBagConstraintsx10.insets = new Insets(5, 5, 5, 5); cPane.add(jbnDelete, gridBagConstraintsx10); GridBagConstraints gridBagConstraintsx11 = new GridBagConstraints(); gridBagConstraintsx11.gridx = 2; gridBagConstraintsx11.gridy = 4; gridBagConstraintsx11.insets = new Insets(5, 5, 5, 5); cPane.add(jbnUpdate, gridBagConstraintsx11); GridBagConstraints gridBagConstraintsx12 = new GridBagConstraints(); gridBagConstraintsx12.gridx = 0; gridBagConstraintsx12.gridy = 5; gridBagConstraintsx12.insets = new Insets(5, 5, 5, 5); cPane.add(jbnBack, gridBagConstraintsx12); GridBagConstraints gridBagConstraintsx13 = new GridBagConstraints(); gridBagConstraintsx13.gridx = 1; gridBagConstraintsx13.gridy = 5; gridBagConstraintsx13.insets = new Insets(5, 5, 5, 5); cPane.add(jbnSearch, gridBagConstraintsx13); GridBagConstraints gridBagConstraintsx14 = new GridBagConstraints();
233
gridBagConstraintsx14.gridx = 2; gridBagConstraintsx14.gridy = 5; gridBagConstraintsx14.insets = new Insets(5, 5, 5, 5); cPane.add(jbnForward, gridBagConstraintsx14); GridBagConstraints gridBagConstraintsx15 = new GridBagConstraints(); gridBagConstraintsx15.gridx = 1; gridBagConstraintsx15.insets = new Insets(5, 5, 5, 5); gridBagConstraintsx15.gridy = 6; cPane.add(jbnClear, gridBagConstraintsx15); GridBagConstraints gridBagConstraintsx16 = new GridBagConstraints(); gridBagConstraintsx16.gridx = 2; gridBagConstraintsx16.gridy = 6; gridBagConstraintsx16.insets = new Insets(5, 5, 5, 5); cPane.add(jbnExit, gridBagConstraintsx16); jbbSave.addActionListener(this); jbnDelete.addActionListener(this); jbnClear.addActionListener(this); jbnUpdate.addActionListener(this); jbnSearch.addActionListener(this); jbnForward.addActionListener(this); jbnBack.addActionListener(this); jbnExit.addActionListener(this); } public void actionPerformed(ActionEvent e) { if (e.getSource() == jbbSave) { savePerson(); clear(); } else if (e.getSource() == jbnDelete) { deletePerson(); clear(); } else if (e.getSource() == jbnUpdate) { updatePerson(); clear(); } else if (e.getSource() == jbnSearch) { searchPerson(); } else if (e.getSource() == jbnForward) { displayNextRecord(); } else if (e.getSource() == jbnBack) { displayPreviousRecord(); } else if (e.getSource() == jbnClear) { clear(); } else if (e.getSource() == jbnExit) { System.exit(0); } } // Save the Person into the Address Book public void savePerson() { name = jtfName.getText(); name = name.toUpperCase(); //Save all names in Uppercase address = jtfAddress.getText(); try { phone = Integer.parseInt("" + jtfPhone.getText()); } catch (Exception e) { /*System.out.print("Input is a string"); JOptionPane.showMessageDialog(null, "Please enter Phone Number");*/ } email = jtfEmail.getText(); if (name.equals("")) { JOptionPane.showMessageDialog(null, "Please enter person name.");
234
} else { //create a PersonInfo object and pass it to PersonDAO to save it PersonInfo person = new PersonInfo(name, address, phone, email); pDAO.savePerson(person); JOptionPane.showMessageDialog(null, "Person Saved"); } } public void deletePerson() { name = jtfName.getText(); name = name.toUpperCase(); if (name.equals("")) { JOptionPane.showMessageDialog(null, "Please enter person name to delete."); } else { //remove Person of the given name from the Address Book database int numberOfDeleted = pDAO.removePerson(name); JOptionPane.showMessageDialog(null, numberOfDeleted + " Record(s) deleted."); } } public void updatePerson() { if (recordNumber >= 0 && recordNumber < personsList.size()) { PersonInfo person = (PersonInfo) personsList.get(recordNumber); int id = person.getId(); /*get values from text fields*/ name = jtfName.getText(); address = jtfAddress.getText(); phone = Integer.parseInt(jtfPhone.getText()); email = jtfEmail.getText(); /*update data of the given person name*/ person = new PersonInfo(id, name, address, phone, email); pDAO.updatePerson(person); JOptionPane.showMessageDialog(null, "Person info record updated successfully."); } else { JOptionPane.showMessageDialog(null, "No record to Update"); } } //Perform a Case-Insensitive Search to find the Person public void searchPerson() { name = jtfName.getText(); name = name.toUpperCase(); /*clear contents of arraylist if there are any from previous search*/ personsList.clear(); recordNumber = 0; if (name.equals("")) { JOptionPane.showMessageDialog(null, "Please enter person name to search."); } else { /*get an array list of searched persons using PersonDAO*/ personsList = pDAO.searchPerson(name); if (personsList.size() == 0) { JOptionPane.showMessageDialog(null, "No records found."); //Perform a clear if no records are found. clear(); } else { /*downcast the object from array list to PersonInfo*/ PersonInfo person = (PersonInfo) personsList .get(recordNumber); // displaying search record in text fields jtfName.setText(person.getName());
235
jtfAddress.setText(person.getAddress()); jtfPhone.setText("" + person.getPhone()); jtfEmail.setText(person.getEmail()); } } } public void displayNextRecord() { // inc in recordNumber to display next person info, already stored in // personsList during search recordNumber++; if (recordNumber >= personsList.size()) { JOptionPane.showMessageDialog(null, "You have reached end of " + "search results"); /*if user has reached the end of results, disable forward button*/ jbnForward.setEnabled(false); jbnBack.setEnabled(true); // dec by one to counter last inc recordNumber--; } else { jbnBack.setEnabled(true); PersonInfo person = (PersonInfo) personsList.get(recordNumber); // displaying search record in text fields jtfName.setText(person.getName()); jtfAddress.setText(person.getAddress()); jtfPhone.setText("" + person.getPhone()); jtfEmail.setText(person.getEmail()); } } public void displayPreviousRecord() { // dec in recordNumber to display previous person info, already //stored in personsList during search recordNumber--; if (recordNumber < 0) { JOptionPane.showMessageDialog(null, "You have reached begining " + "of search results"); /*if user has reached the begining of results, disable back button*/ jbnForward.setEnabled(true); jbnBack.setEnabled(false); // inc by one to counter last dec recordNumber++; } else { jbnForward.setEnabled(true); PersonInfo person = (PersonInfo) personsList.get(recordNumber); // displaying search record in text fields jtfName.setText(person.getName()); jtfAddress.setText(person.getAddress()); jtfPhone.setText("" + person.getPhone()); jtfEmail.setText(person.getEmail()); } } public void clear() { jtfName.setText(""); jtfAddress.setText(""); jtfPhone.setText(""); jtfEmail.setText(""); /*clear contents of arraylist*/ recordNumber = -1; personsList.clear(); jbnForward.setEnabled(true); jbnBack.setEnabled(true); }
236
}
PersonInfo.java
/* Name: Hemanth. B Website: java-swing-tutorial.html Topic: A basic Java Address Book Conventions Used in Source code --------------------------------1. All JLabel components start with jlb* 2. All JPanel components start with jpl* 3. All JMenu components start with jmenu* 4. All JMenuItem components start with jmenuItem* 5. All JDialog components start with jdlg* 6. All JButton components start with jbn* */ import java.util.*; import java.sql.*; public class PersonDAO { /* Person Table needs to be created in the Oracle Database. * create table Person ( id Integer, name Varchar(30), address Varchar(30), phone Integer, email Varchar(50) );*/ private ArrayList personsList; private String userid = "scott"; private String password = "tiger"; static String url = "jdbc:odbc:bob"; private Connection con; // constructor public PersonDAO() { personsList = new ArrayList(); getConnection(); //Create Connection to the Oracle Database } public Connection getConnection() { try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); } catch (java.lang.ClassNotFoundException e) { System.err.print("ClassNotFoundException: "); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch (SQLException ex) {
237
System.err.println("SQLException: " + ex.getMessage()); } return con; } public ArrayList searchPerson(String name) { try { String sql = "SELECT * FROM Person WHERE name like '%" + name + "%'"; // Create a prepared statement Statement s = con.createStatement(); ResultSet rs = s.executeQuery(sql); String pname = ""; String address = ""; String email = ""; int id, phone; while (rs.next()) { id = rs.getInt("id"); pname = rs.getString("name"); address = rs.getString("address"); phone = rs.getInt("phone"); email = rs.getString("email"); //Create a PersonInfo object PersonInfo person = new PersonInfo(id, pname, address, phone, email); //Add the person object to array list personsList.add(person); } } catch (Exception e) { System.out.println(e); } return personsList; } public void savePerson(PersonInfo person) { try { String sql = "INSERT INTO Person(name, address, " + "phone, email) VALUES (?,?,?,?) "; // Create a Preparedstatement PreparedStatement ps = con.prepareStatement(sql); ps.setString(1, person.getName()); ps.setString(2, person.getAddress()); ps.setInt(3, person.getPhone()); ps.setString(4, person.getEmail()); ps.executeUpdate(); } catch (Exception e) { System.out.println(e); } } public void updatePerson(PersonInfo person) { try { String sql = "UPDATE Person SET name = ?, address=? , " + "phone=? , email=? where id=?"; // Create a Prepared statement PreparedStatement ps = con.prepareStatement(sql); ps.setString(1, person.getName()); ps.setString(2, person.getAddress()); ps.setInt(3, person.getPhone()); ps.setString(4, person.getEmail()); ps.setInt(5, person.getId()); ps.executeUpdate(); } catch (Exception e) { System.out.println(e);
238
} } public int removePerson(String name) { int no = 0; try { String sql = "DELETE FROM Person WHERE name = ?"; // Create a Prepared statement PreparedStatement ps = con.prepareStatement(sql); ps.setString(1, name); no = ps.executeUpdate(); } catch (Exception e) { System.out.println(e); } return no; } }// end class PersonDAO
SQL Table
create table Person ( id Integer, name Varchar(30), address Varchar(30), phone Integer, email Varchar(50)
Download Java Address Book Source Code
239
Java JDBC Tutorial JDBC-Table of Contents

JDBC Tutorial Homepage
JDBC Introduction JDBC Architecture Java Database Connectivity Steps Test JDBC Driver Installation & Connection
JDBC ResultSets
ResultSet and Cursors Types of Result Sets Result Set Methods
Types of JDBC Drivers

Type Type Type Type 1: 2: 3: 4: JDBC-ODBC Bridge driver Native-API/partly Java driver All Java/Net-protocol driver Native-protocol/all-Java driver
Create Table
Create SQL Table
Insert Records
Inserting Data into SQL Tables
Select Records
Retrieving Data from SQL Tables
Update Table
Update SQL Tables
Using Prepared Statements

Using Prepared Statements
240
JDBC Tutorial Homepage
JDBC Introduction
The JDBC ( Java Database Connectivity) API defines interfaces and classes for writing database applications in Java by making database connections. Using JDBC you can send SQL, PL/SQL statements to almost any relational database. JDBC is a Java API for executing SQL statements and supports basic SQL functionality. It provides RDBMS access by allowing you to embed SQL inside Java code. Because Java can run on a thin client, applets embedded in Web pages can contain downloadable JDBC code to enable remote database access. You will learn how to create a table, insert values into it, query the table, retrieve results, and update the table with the help of a JDBC Program example. Although JDBC was designed specifically to provide a Java interface to relational databases, you may find that you need to write Java code to access non-relational databases as well.
JDBC Architecture
Java application calls the JDBC library. JDBC loads a driver which talks to the database. We can change database engines without changing database code.
JDBC Basics - Java Database Connectivity Steps

Before you can create a java jdbc connection to the database, you must first import the java.sql package. import java.sql.*; The star ( * ) indicates that all of the classes in the package java.sql are to be imported.
1. Loading a database driver,

In this step of the jdbc connection process, we load the driver class by calling Class.forName() with the Driver class name as an argument. Once loaded, the Driver class creates an instance of itself. A client can connect to Database Server through JDBC Driver. Since most of the Database servers support ODBC driver therefore JDBC-ODBC Bridge driver is commonly used. The return type of the Class.forName (String ClassName) method is Class. Class is a class in java.lang package.
241
try { Class.forName(sun.jdbc.odbc.JdbcOdbcDriver); //Or any other driver } catch(Exception x){ System.out.println( Unable to load the driver class! ); }
2. Creating a oracle jdbc Connection
The JDBC DriverManager class defines objects which can connect Java applications to a JDBC driver. DriverManager is considered the backbone of JDBC architecture. DriverManager class manages the JDBC drivers that are installed on the system. Its getConnection() method is used to establish a connection to a database. It uses a username, password, and a jdbc url to establish a connection to the database and returns a connection object. A jdbc Connection represents a session/connection with a specific database. Within the context of a Connection, SQL, PL/SQL statements are executed and results are returned. An application can have one or more connections with a single database, or it can have many connections with different databases. A Connection object provides metadata i.e. information about the database, tables, and fields. It also contains methods to deal with transactions.
JDBC URL Syntax::
jdbc: <subprotocol>: <subname>
JDBC URL Example:: jdbc: <subprotocol>: <subname>Each driver has its own subprotocol Each subprotocol has its own syntax for the source. Were using the jdbc odbc subprotocol, so the DriverManager knows to use the sun.jdbc.odbc.JdbcOdbcDriver.
try{ Connection dbConnection=DriverManager.getConnection(url,loginName,Pass word) } catch( SQLException x ){ System.out.println( Couldnt get connection! ); }
3. Creating a jdbc Statement object,
Once a connection is obtained we can interact with the database. Connection interface defines methods for interacting with the database via the established connection. To execute SQL statements, you need to instantiate a Statement object from your connection object by using the createStatement() method. Statement statement = dbConnection.createStatement(); A statement object is used to send and execute SQL statements to a database.
Three kinds of Statements
242
Statement: Execute simple sql queries without parameters. Statement createStatement() Creates an SQL Statement object. Prepared Statement: Execute precompiled sql queries with or without parameters. PreparedStatement prepareStatement(String sql) returns a new PreparedStatement object. PreparedStatement objects are precompiled SQL statements. Callable Statement: Execute a call to a database stored procedure. CallableStatement prepareCall(String sql) returns a new CallableStatement object. CallableStatement objects are SQL stored procedure call statements.
4. Executing a SQL statement with the Statement object, and returning a jdbc resultSet.
Statement interface defines methods that are used to interact with database via the execution of SQL statements. The Statement class has three methods for executing statements: executeQuery(), executeUpdate(), and execute(). For a SELECT statement, the method to use is executeQuery . For statements that create or modify tables, the method to use is executeUpdate. Note: Statements that create a table, alter a table, or drop a table are all examples of DDL statements and are executed with the method executeUpdate. execute() executes an SQL statement that is written as String object. ResultSet provides access to a table of data generated by executing a Statement. The table rows are retrieved in sequence. A ResultSet maintains a cursor pointing to its current row of data. The next() method is used to successively step through the rows of the tabular results. ResultSetMetaData Interface holds information on the types and properties of the columns in a ResultSet. It is constructed from the Connection object.
Test JDBC Driver Installation
import javax.swing.JOptionPane; public class TestJDBCDriverInstallation_Oracle { public static void main(String[] args) { StringBuffer output = new StringBuffer(); output.append(Testing oracle driver installation \n); try { String className = sun.jdbc.odbc.JdbcOdbcDriver; Class driverObject = Class.forName(className); output.append(Driver : +driverObject+\n);
243
output.append(Driver Installation Successful); JOptionPane.showMessageDialog(null, output); } catch (Exception e) { output = new StringBuffer(); output.append(Driver Installation FAILED\n); JOptionPane.showMessageDialog(null, output); System.out.println(Failed: Driver Error: + e.getMessage()); } } }
Download JDBC Sample Code
Java JDBC Connection Example, JDBC Driver Example

import import import import java.sql.Connection; java.sql.DatabaseMetaData; java.sql.DriverManager; java.sql.SQLException;
public class JDBCDriverInformation { static String userid=scott, password = tiger; static String url = jdbc:odbc:bob; static Connection con = null; public static void main(String[] args) throws Exception { Connection con = getOracleJDBCConnection(); if(con!= null){ System.out.println(Got Connection.); DatabaseMetaData meta = con.getMetaData(); System.out.println(Driver Name : +meta.getDriverName()); System.out.println(Driver Version : +meta.getDriverVersion()); }else{ System.out.println(Could not Get Connection); } } public static Connection getOracleJDBCConnection(){ try { Class.forName(sun.jdbc.odbc.JdbcOdbcDriver);
244
} catch(java.lang.ClassNotFoundException e) { System.err.print(ClassNotFoundException: ); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } return con; } }
JDBC Result Sets ResultSet and Cursors

The rows that satisfy a particular query are called the result set. The number of rows returned in a result set can be zero or more. A user can access the data in a result set using a cursor one row at a time from top to bottom. A cursor can be thought of as a pointer to the rows of the result set that has the ability to keep track of which row is currently being accessed. The JDBC API supports a cursor to move both forward and backward and also allowing it to move to a specified row or to a row whose position is relative to another row. The JDBC Resultset example is shown in the next sections to follow.
Types of Result Sets

The ResultSet interface provides methods for retrieving and manipulating the results of executed queries, and ResultSet objects can have different functionality and characteristics. These characteristics are result set type, result set concurrency, and cursor holdability. The type of a ResultSet object determines the level of its functionality in two areas: the ways in which the cursor can be manipulated, and how concurrent changes made to the underlying data source are reflected by the ResultSet object. The sensitivity of the ResultSet object is determined by one of three different ResultSet types:
245
TYPE_FORWARD_ONLY the result set is not scrollable i.e. the cursor moves only forward, from before the first row to after the last row. TYPE_SCROLL_INSENSITIVE the result set is scrollable; its cursor can move both forward and backward relative to the current position, and it can move to an absolute position. TYPE_SCROLL_SENSITIVE the result set is scrollable; its cursor can move both forward and backward relative to the current position, and it can move to an absolute position. Before you can take advantage of these features, however, you need to create a scrollable ResultSet object. The following line of code illustrates one way to create a scrollable ResultSet object: Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY); ResultSet srs = stmt.executeQuery(..); The first argument is one of three constants added to the ResultSet API to indicate the type of a ResultSet object: TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, and TYPE_SCROLL_SENSITIVE. The second argument is one of two ResultSet constants for specifying whether a result set is read-only or updatable: CONCUR_READ_ONLY and CONCUR_UPDATABLE. If you do not specify any constants for the type and updatability of a ResultSet object, you will automatically get one that is TYPE_FORWARD_ONLY and CONCUR_READ_ONLY.
Result Set Methods

When a ResultSet object is first created, the cursor is positioned before the first row. To move the cursor, you can use the following methods: next() - moves the cursor forward one row. Returns true if the cursor is now positioned on a row and false if the cursor is positioned after the last row. previous() - moves the cursor backwards one row. Returns true if the cursor is now positioned on a row and false if the cursor is positioned before the first row. first() - moves the cursor to the first row in the ResultSet object. Returns true if the cursor is now positioned on the first row and false if the ResultSet object does not contain any rows. last() - moves the cursor to the last row in the ResultSet object. Returns true if the cursor is now positioned on the last row and false if the ResultSet object does not contain any rows. beforeFirst() - positions the cursor at the start of the ResultSet object, before the first row. If the ResultSet object does not contain any rows, this method has no effect. afterLast() - positions the cursor at the end of the ResultSet object, after the last row. If the ResultSet object does not contain any rows, this method has no effect. relative(int rows) - moves the cursor relative to its current position. absolute(int n) - positions the cursor on the n-th row of the ResultSet object.
246
JDBC Driver Types JDBC Driver Types

JDBC drivers are divided into four types or levels. The different types of jdbc drivers are: Type Type Type Type 1: 2: 3: 4: JDBC-ODBC Bridge driver (Bridge) Native-API/partly Java driver (Native) AllJava/Net-protocol driver (Middleware) All Java/Native-protocol driver (Pure)
4 types of jdbc drivers are elaborated in detail as shown below:
Type 1 JDBC Driver

JDBC-ODBC Bridge driver The Type 1 driver translates all JDBC calls into ODBC calls and sends them to the ODBC driver. ODBC is a generic API. The JDBC-ODBC Bridge driver is recommended only for experimental use or when no other alternative is available.
Type 1: JDBC-ODBC Bridge Advantage The JDBC-ODBC Bridge allows access to almost any database, since the databases ODBC drivers are already available.
247
Disadvantages 1. Since the Bridge driver is not written fully in Java, Type 1 drivers are not portable. 2. A performance issue is seen as a JDBC call goes through the bridge to the ODBC driver, then to the database, and this applies even in the reverse process. They are the slowest of all driver types. 3. The client system requires the ODBC Installation to use the driver. 4. Not good for the Web.
Type 2 JDBC Driver

Native-API/partly Java driver The distinctive characteristic of type 2 jdbc drivers are that Type 2 drivers convert JDBC calls into database-specific calls i.e. this driver is specific to a particular database. Some distinctive characteristic of type 2 jdbc drivers are shown below. Example: Oracle will have oracle native api.
Type 2: Native api/ Partly Java Driver Advantage The distinctive characteristic of type 2 jdbc drivers are that they are typically offer better performance than the JDBC-ODBC Bridge as the layers of communication (tiers) are less than that of Type 1 and also it uses Native api which is Database specific. Disadvantage 1. Native API must be installed in the Client System and hence type 2 drivers cannot be used for the Internet. 2. Like Type 1 drivers, its not written in Java Language which forms a portability issue. 3. If we change the Database we have to change the native api as it is specific to a database 4. Mostly obsolete now 5. Usually not thread safe.
248
Type 3 JDBC Driver

All Java/Net-protocol driver Type 3 database requests are passed through the network to the middle-tier server. The middle-tier then translates the request to the database. If the middle-tier server can in turn use Type1, Type 2 or Type 4 drivers.
Type 3: All Java/ Net-Protocol Driver Advantage 1. This driver is server-based, so there is no need for any vendor database library to be present on client machines. 2. This driver is fully written in Java and hence Portable. It is suitable for the web. 3. There are many opportunities to optimize portability, performance, and scalability. 4. The net protocol can be designed to make the client JDBC driver very small and fast to load. 5. The type 3 driver typically provides support for features such as caching (connections, query results, and so on), load balancing, and advanced system administration such as logging and auditing. 6. This driver is very flexible allows access to multiple databases using one driver. 7. They are the most efficient amongst all driver types. Disadvantage It requires another server application to install and maintain. Traversing the recordset may take longer, since the data comes through the backend server.
249
Type 4 JDBC Driver

Native-protocol/all-Java driver The Type 4 uses java networking libraries to communicate directly with the database server.
Type 4: Native-protocol/all-Java driver Advantage 1. The major benefit of using a type 4 jdbc drivers are that they are completely written in Java to achieve platform independence and eliminate deployment administration issues. It is most suitable for the web. 2. Number of translation layers is very less i.e. type 4 JDBC drivers dont have to translate database requests to ODBC or a native connectivity interface or to pass the request on to another server, performance is typically quite good. 3. You dont need to install special software on the client or server. Further, these drivers can be downloaded dynamically. Disadvantage With type 4 drivers, the user needs a different driver for each database.
JDBC Create Table

Create SQL Table
Tables are composed of rows and columns. Each row represents a record in the database. Columns are also known as fields, or attributes. You can relate one database table to another by causing a given column in the table to derive its value from the value of a column in another table. If the tables had no columns in common, then there would
250
be no way to relate them to one another. Because you can link tables together you can easily extract data from multiple tables with a single query, if your query mechanism supports this type of query. In order to integrate your tables into a single database, youll need to ensure that each table has a column that contains a value unique to that table. Such a column is called a key. Below is a JDBC Program showing the use of executeUpdate() to create a table jdbc programming. For my website I am creating the following 2 tables (Employee, Orders) Employee_ID is the primary key which forms a relation between the 2 tables. CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) ); Employees:
Employee_ID 6323 5768 1234 5678

Orders:
Name Hemanth Bob Shawn Michaels
CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER );
Prod_ID 543 432 876
Product Name Belt Bottle Ring
Employee_ID 6323 1234 5678
import javax.swing.JOptionPane; import java.sql.*; public class JDBCProgram{ static String userid=scott, password = tiger; static String url = jdbc:odbc:bob; // String url = jdbc:mySubprotocol:myDataSource; ? static Statement stmt; static Connection con; public static void main(String args[]){ JOptionPane.showMessageDialog (null,JDBC Programming showing Creation of Tables); int choice = -1;
251
do{ choice = getChoice(); if (choice != 0){ getSelected(choice); } } while ( choice != 0); System.exit(0); } public static int getChoice() { String choice; int ch; choice = JOptionPane.showInputDialog(null, 1. Create Employees Table\n+ 2. Create Products Table\n+ 0. Exit\n\n+ Enter your choice); ch = Integer.parseInt(choice); return ch; } public static void getSelected(int choice){ if(choice==1){ createEmployees(); } if(choice==2){ createOrders(); } } public static Connection getConnection() { try { Class.forName (sun.jdbc.odbc.JdbcOdbcDriver); //Class.forName(myDriver.ClassName); ? } catch(java.lang.ClassNotFoundException e) { System.err.print(ClassNotFoundException: ); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } return con; } /*CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30)
252
);*/ public static void createEmployees() { Connection con = getConnection(); String createString; createString = create table Employees ( + Employee_ID INTEGER, + Name VARCHAR(30)); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Employees Table Created); } /*CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER );*/ public static void createOrders() { Connection con = getConnection(); String createString; createString = create table Orders ( + Prod_ID INTEGER, + ProductName VARCHAR(20), + Employee_ID INTEGER ); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Orders Table Created); } }//End of class
253
Download JDBC small
JDBC Tutorial Insert Inserting Data into SQL Tables

We will insert data into the tables Employees and Orders as created in the previous tutorial, one row at a time, supplying the information to be stored in each column of that row using a jdbc insert query statement. The values to be inserted into the columns are listed in the same order that the columns were declared when the table was created. Below is a JDBC Program showing the use of executeUpdate() to create a table and insert row into using java jdbc insert data statement. For my website I am creating the following 2 tables (Employee, Orders) as a part of the JDBC tutorial for insert in jdbc insert query. Employee_ID is the primary key which forms a relation between the 2 tables. CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) ); Employees:
Employee_ID 6323 5768 1234 5678

Orders:
CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER ); Prod_ID 543 432 876 Product Name Belt Bottle Ring Employee_ID 6323 1234 5678
254
insert using JDBC Insert Statement
import javax.swing.JOptionPane; import java.sql.*; public class JDBCProgram{ //JDBC Insert Example static String userid=scott, password = tiger; static String url = jdbc:odbc:bob; // String url = jdbc:mySubprotocol:myDataSource; ? static Statement stmt; static Connection con; public static void main(String args[]){ JOptionPane.showMessageDialog (null,JDBC Programming showing Insertion of Table Data); int choice = -1; do{ choice = getChoice(); if (choice != 0){ getSelected(choice); } } while ( choice != 0); System.exit(0); } public static int getChoice() { String choice; int ch; choice = JOptionPane.showInputDialog(null, 1. Create Employees Table\n+ 2. Create Products Table\n+ 3. Insert data into Employees Table\n+ 4. Insert data into Products Table\n+ 0. Exit\n\n+ Enter your choice); ch = Integer.parseInt(choice); return ch; } public static void getSelected(int choice){ if(choice==1){ createEmployees(); }
255
if(choice==2){ createOrders(); } if(choice==3){ insertEmployees(); } if(choice==4){ insertOrders(); } } public static Connection getConnection() { try { Class.forName (sun.jdbc.odbc.JdbcOdbcDriver); //Class.forName(myDriver.ClassName); ? } catch(java.lang.ClassNotFoundException e) { System.err.print(ClassNotFoundException: ); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } return con; } /*CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) );*/ public static void createEmployees() { Connection con = getConnection(); String createString; createString = create table Employees ( + Employee_ID INTEGER, +
256
Name VARCHAR(30)); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Employees Table Created); } /*CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER );*/ public static void createOrders() { Connection con = getConnection(); String createString; createString = create table Orders ( + Prod_ID INTEGER, + ProductName VARCHAR(20), + Employee_ID INTEGER ); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Orders Table Created); } /*Employee_ID Name
257
6323 Hemanth 5768 Bob 1234 Shawn 5678 Michaels */ public static void insertEmployees() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Employees values(6323, Hemanth); insertString2 = insert into Employees values(5768, Bob); insertString3 = insert into Employees values(1234, Shawn); insertString4 = insert into Employees values(5678, Michaels); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.executeUpdate(insertString4); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Employees Table); } /* Prod_ID 543 432 876 ProductName Belt Bottle Ring Employee_ID 6323 1234 5678
*/ public static void insertOrders() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Orders values(543, Belt, 6323); insertString2 = insert into Orders
258
values(432, Bottle, 1234); insertString3 = insert into Orders values(876, Ring, 5678); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Orders Table); } }//End of class
JDBC Select Statement Example

Retrieving Data using JDBC Select Query
We can use Java JDBC Select statement in a java program to retrieve the data and display it for the respective Tables. JDBC returns results in a ResultSet object, so we need to declare an instance of the class ResultSet to hold our results. Select is the SQL keyword that performs a query. We invoke the jdbc select query (executequery) method, using the jdbc select data statement as the parameter. The tabular results of the query are captured in the ResultSet object, results. Note that executeQuery() always returns a ResultSet although it need not have any rows in it. The return value for an executeQuery is a ResultSet object containing the results of the query sent to the DBMS, To process each row in the ResultSet, we use the next() method. This method moves the pointer through the rows of data. The ResultSet maintains a cursor pointing to the current row. Because this cursor is initially positioned before the first row, we must call next() before we can see any rows at all. Below is a JDBC Program showing the use of executeQuery() to retrieve values from ResultSets using jdbc programming. For my website I am creating the following 2 tables (Employee, Orders) as a part of the JDBC tutorial. Employee_ID is the primary key which forms a relation between the 2 tables.
259
CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) ); Employees Table:
Employee_ID 6323 5768 1234 5678

Orders Table:
Prod_ID 543 432 876
Product Name Belt Bottle Ring
Employee_ID 6323 1234 5678
JDBC SQL Select Example

import javax.swing.JOptionPane; import java.sql.*; public class JDBCProgram{ static String userid=scott, password = tiger; static String url = jdbc:odbc:bob; // String url = jdbc:mySubprotocol:myDataSource; ? static Statement stmt; static Connection con; public static void main(String args[]){ JOptionPane.showMessageDialog(null,JDBC Programming showi ng Retrieval of Table Data); int choice = -1; do{ choice = getChoice(); if (choice != 0){ getSelected(choice); }
260
} while ( choice != 0); System.exit(0); } public static int getChoice() { String choice; int ch; choice = JOptionPane.showInputDialog(null, 1. Create Employees Table\n+ 2. Create Products Table\n+ 3. Insert data into Employees Table\n+ 4. Insert data into Orders Table\n+ 5. Retrieve data for Employees Table\n+ 6. Retrieve data for Orders Table\n+ 0. Exit\n\n+ Enter your choice); ch = Integer.parseInt(choice); return ch; } public static void getSelected(int choice){ if(choice==1){ createEmployees(); } if(choice==2){ createOrders(); } if(choice==3){ insertEmployees(); } if(choice==4){ insertOrders(); } if(choice==5){ retrieveEmployees(); } if(choice==6){ retrieveOrders(); } } public static Connection getConnection() { try { Class.forName(sun.jdbc.odbc.JdbcOdbcDriver); //Class.forName(myDriver.ClassName); ?
261
} catch(java.lang.ClassNotFoundException e) { System.err.print(ClassNotFoundException: ); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } return con; } /*CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) );*/ public static void createEmployees() { Connection con = getConnection(); String createString; createString = create table Employees ( + Employee_ID INTEGER, + Name VARCHAR(30)); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Employees Table Created); } /*CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER );*/
262
public static void createOrders() { Connection con = getConnection(); String createString; createString = create table Orders ( + Prod_ID INTEGER, + ProductName VARCHAR(20), + Employee_ID INTEGER ); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Orders Table Created); } /*Employee_ID Name 6323 Hemanth 5768 Bob 1234 Shawn 5678 Michaels */ public static void insertEmployees() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Employees values(6323, Hemanth); insertString2 = insert into Employees values(5768, Bob); insertString3 = insert into Employees values(1234, Shawn); insertString4 = insert into Employees values(5678, Michaels); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2);
263
stmt.executeUpdate(insertString3); stmt.executeUpdate(insertString4); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Employees Table); } /* Prod_ID 543 432 876 ProductName Belt Bottle Ring Employee_ID 6323 1234 5678
*/ public static void insertOrders() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Orders values(543, Belt, 6323); insertString2 = insert into Orders values(432, Bottle, 1234); insertString3 = insert into Orders values(876, Ring, 5678); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Orders Table); } public static void retrieveEmployees(){ Connection con = getConnection();
264
String result = null; String selectString; selectString = select * from Employees; result =Employee_ID\t\tName\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { int id = rs.getInt(Employee_ID); String name = rs.getString(Name); result+=id+\t\t+ name+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); } public static void retrieveOrders(){ Connection con = getConnection(); String result = null; String selectString; selectString = select * from Orders; result =Prod_ID\t\tProductName\t\tEmployee_ID\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { int pr_id = rs.getInt(Prod_ID); String prodName = rs.getString(ProductName); int id = rs.getInt(Employee_ID); result +=pr_id+\t\t+ prodName+\t\t+id+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); }
265
}//End of class
Java JDBC Update JDBC Update Table Example

We can use java jdbc update statements in a java program to update the data for a Table. Below is a program showing the use of jdbc executeupdate (uses jdbc update query) to update a table. The return value for a jdbc sql update is an int that indicates how many rows of a table were updated.
For instance in a statement like int n = stmt.executeUpdate(); For my website I am creating the following 2 tables (Employee, Orders) as a part of the JDBC update table statement. Employee_ID is the primary key which forms a relation between the 2 tables. CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) ); Employees:
Employee_ID 6323 5768 1234 5678

Orders:
Prod_ID
Product Name
Employee_ID
266
543 432 876 Belt Bottle Ring 6323 1234 5678
Below is a jdbc update example
import javax.swing.JOptionPane; import java.sql.*; public class JDBCProgram{ static String userid=scott, password = tiger; static String url = jdbc:odbc:bob; // String url = jdbc:mySubprotocol:myDataSource; ? static Statement stmt; static Connection con; public static void main(String args[]){ JOptionPane.showMessageDialog (null,JDBC Programming showing Updation of Table Data); int choice = -1; do{ choice = getChoice(); if (choice != 0){ getSelected(choice); } } while ( choice != 0); System.exit(0); } public static int getChoice() { String choice; int ch; choice = JOptionPane.showInputDialog(null, 1. Create Employees Table\n+ 2. Create Products Table\n+ 3. Insert data into Employees Table\n+ 4. Insert data into Orders Table\n+ 5. Retrieve data for Employees Table\n+ 6. Retrieve data for Orders Table\n+ 7. Update Employees Table\n+ 0. Exit\n\n+ Enter your choice); ch = Integer.parseInt(choice); return ch;
267
} public static void getSelected(int choice){ if(choice==1){ createEmployees(); } if(choice==2){ createOrders(); } if(choice==3){ insertEmployees(); } if(choice==4){ insertOrders(); } if(choice==5){ retrieveEmployees(); } if(choice==6){ retrieveOrders(); } if(choice==7){ updateEmployees(); //Uses JDBC Update Statement } } public static Connection getConnection() { try { Class.forName(sun.jdbc.odbc.JdbcOdbcDriver); //Class.forName(myDriver.ClassName); ? } catch(java.lang.ClassNotFoundException e) { System.err.print(ClassNotFoundException: ); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); }
268
return con; } /*CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) );*/ public static void createEmployees() { Connection con = getConnection(); String createString; createString = create table Employees ( + Employee_ID INTEGER, + Name VARCHAR(30)); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Employees Table Created); } /*CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER );*/ public static void createOrders() { Connection con = getConnection(); String createString; createString = create table Orders ( + Prod_ID INTEGER, + ProductName VARCHAR(20), + Employee_ID INTEGER );
269
try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Orders Table Created); } /*Employee_ID Name 6323 Hemanth 5768 Bob 1234 Shawn 5678 Michaels */ public static void insertEmployees() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Employees values(6323, Hemanth); insertString2 = insert into Employees values(5768, Bob); insertString3 = insert into Employees values(1234, Shawn); insertString4 = insert into Employees values(5678, Michaels); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.executeUpdate(insertString4); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Employees Table);
270
} /* Prod_ID 543 432 876 ProductName Belt Bottle Ring Employee_ID 6323 1234 5678
*/ public static void insertOrders() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Orders values(543, Belt, 6323); insertString2 = insert into Orders values(432, Bottle, 1234); insertString3 = insert into Orders values(876, Ring, 5678); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Orders Table); } public static void retrieveEmployees(){ Connection con = getConnection(); String result = null; String selectString; selectString = select * from Employees; result =Employee_ID\t\tName\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { int id = rs.getInt(Employee_ID); String name = rs.getString(Name);
271
result+=id+\t\t+ name+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); } public static void retrieveOrders(){ Connection con = getConnection(); String result = null; String selectString; selectString = select * from Orders; result =Prod_ID\t\tProductName\t\tEmployee_ID\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { int pr_id = rs.getInt(Prod_ID); String prodName = rs.getString(ProductName); int id = rs.getInt(Employee_ID); result +=pr_id+\t\t+ prodName+\t\t+id+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); } public static void updateEmployees(){ Connection con = getConnection(); String updateString1; updateString1 = update Employees set name = hemanthbalaji where Employee_id = 6323; try {
272
stmt = con.createStatement(); stmt.executeUpdate(updateString1); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Updated into Employees Table); } }//End of class
Prepared Statements Tutorial

Java Prepared Statements
Java JDBC Prepared statements are pre-compiled SQL statements. Precompiled SQL is useful if the same SQL is to be executed repeatedly, for example, in a loop. Prepared statements in java only save you time if you expect to execute the same SQL over again. Every java sql prepared statement is compiled at some point. To use a java preparedstatements, you must first create a object by calling the Connection.prepareStatement() method. JDBC PreparedStatements are useful especially in situations where you can use a for loop or while loop to set a parameter to a succession of values. If you want to execute a Statement object many times, it normally reduces execution time to use a PreparedStatement object instead. The syntax is straightforward: just insert question marks for any parameters that youll be substituting before you send the SQL to the database. As with CallableStatements, you need to call close() to make sure database resources are freed as soon as possible. Below is a JDBC Program showing the use of jdbc prepared statements to insert data into tables using jdbc programming. You need to supply values to be used in place of the question mark placeholders (if there are any) before you can execute a PreparedStatement object. You do this by calling one of the setXXX methods defined in the PreparedStatement class. There is a setXXX method for each primitive type declared in the Java programming language. An example of a PreparedStatement object is PreparedStatement pstmt = con.prepareStatement(update Orders set pname = ? where Prod_Id = ?); pstmt.setInt(2, 100); pstmt.setString(1, Bob); pstmt.executeUpdate();
273
An important feature of a PreparedStatement object is that, unlike a Statement object, it is given an SQL statement when it is created. This SQL statement is sent to the DBMS right away, where it is compiled. As a result, the PreparedStatement object contains not just an SQL statement, but an SQL statement that has been precompiled. This means that when the PreparedStatement is executed, the DBMS can just run the PreparedStatement SQL statement without having to compile it first. Using Prepared Statements in jdbc, objects can be used for SQL statements with no parameters, you probably use them most often for SQL statements that take parameters. The advantage of using SQL statements that take parameters is that you can use the same statement and supply it with different values each time you execute it. For my website I am creating the following 2 tables (Employee, Orders) as a part of the JDBC tutorial. Employee_ID is the primary key which forms a relation between the 2 tables CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) ); Employees:
Employee_ID 6323 5768 1234 5678

Orders:
CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER ); Prod_ID 543 432 876 Product Name Belt Bottle Ring Employee_ID 6323 1234 5678
Java JDBC Prepared Statement Example

import javax.swing.JOptionPane; import java.sql.*; public class JDBCProgram{
274
static String userid=scott, password = tiger; static String url = jdbc:odbc:bob // String url = jdbc:mySubprotocol:myDataSource; static static static public Statement stmt; PreparedStatement pstmt; Connection con; static void main(String args[]){
; ?
JOptionPane.showMessageDial og(null,JDBC Programming showing Updation of Table Data); int choice = -1; do{ choice = getChoice(); if (choice != 0){ getSelected(choice); } } while ( choice != 0); System.exit(0); } public static int getChoice() { String choice; int ch; choice = JOptionPane.showInputDialog(null, 1. Create Employees Table\n+ 2. Create Products Table\n+ 3. Insert data into Employees Table\n+ 4. Insert data into Orders Table\n+ 5. Retrieve data for Employees Table\n+ 6. Retrieve data for Orders Table\n+ 7. Update Employees Table\n+ 8. Update Employees Table Using a Prepared Statement\n+ 9. Update many records of Orders Table Using a Prepared Statement\n+ 10. List the name of employees who bought CDsn+ 0. Exit\n\n+ Enter your choice); ch = Integer.parseInt(choice); return ch; } public static void getSelected(int choice){ if(choice==1){ createEmployees();
275
} if(choice==2){ createOrders(); } if(choice==3){ insertEmployees(); } if(choice==4){ insertOrders(); } if(choice==5){ retrieveEmployees(); } if(choice==6){ retrieveOrders(); } if(choice==7){ updateEmployees(); } if(choice==8){ updateEmployeesPrepared(); } if(choice==9){ updateOrdersPrepared(); } if(choice==10){ dynamicQuery(); } } public static Connection getConnection() { try { Class.forName(sun.jdbc.odbc.JdbcOdbcDriver); //Class.forName(myDriver.ClassName); ? } catch(java.lang.ClassNotFoundException e) { System.err.print(ClassNotFoundException: ); System.err.println(e.getMessage()); } try { con = DriverManager.getConnection(url, userid, password); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage());
276
} return con; } /*CREATE TABLE Employees ( Employee_ID INTEGER, Name VARCHAR(30) );*/ public static void createEmployees() { Connection con = getConnection(); String createString; createString = create table Employees ( + Employee_ID INTEGER, + Name VARCHAR(30)); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Employees Table Created); } /*CREATE TABLE Orders ( Prod_ID INTEGER, ProductName VARCHAR(20), Employee_ID INTEGER );*/ public static void createOrders() { Connection con = getConnection(); String createString; createString = create table Orders ( + Prod_ID INTEGER, + ProductName VARCHAR(20), + Employee_ID
277
INTEGER ); try { stmt = con.createStatement(); stmt.executeUpdate(createString); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Orders Table Created); } /*Employee_ID Name 6323 Hemanth 5768 Bob 1234 Shawn 5678 Michaels */ public static void insertEmployees() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Employees values(6323, Hemanth); insertString2 = insert into Employees values(5768, Bob); insertString3 = insert into Employees values(1234, Shawn); insertString4 = insert into Employees values(5678, Michaels); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.executeUpdate(insertString4); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); }
278
JOptionPane.showMessageDialog(null,Data Inserted into Employees Table); } /* Prod_ID 543 432 876 ProductName Belt Bottle Ring Employee_ID 6323 1234 5678
*/ public static void insertOrders() { Connection con = getConnection(); String insertString1, insertString2, insertString3, insertString4; insertString1 = insert into Orders values(543, Belt, 6323); insertString2 = insert into Orders values(432, Bottle, 1234); insertString3 = insert into Orders values(876, Ring, 5678); try { stmt = con.createStatement(); stmt.executeUpdate(insertString1); stmt.executeUpdate(insertString2); stmt.executeUpdate(insertString3); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Inserted into Orders Table); } public static void retrieveEmployees(){ Connection con = getConnection(); String result = null; String selectString; selectString = select * from Employees; result =Employee_ID\t\tName\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { int id = rs.getInt(Employee_ID);
279
String name = rs.getString(Name); result+=id+\t\t+ name+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); } public static void retrieveOrders(){ Connection con = getConnection(); String result = null; String selectString; selectString = select * from Orders; result =Prod_ID\t\tProductName\t\tEmployee_ID\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { int pr_id = rs.getInt(Prod_ID); String prodName = rs.getString(ProductName); int id = rs.getInt(Employee_ID); result +=pr_id+\t\t+ prodName+\t\t+id+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); } public static void updateEmployees(){ Connection con = getConnection(); String updateString1; updateString1 = update Employees set name = hemanthbalaji where Employee_id = 6323;
280
try { stmt = con.createStatement(); stmt.executeUpdate(updateString1); stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Updated into Employees Table); } public static void updateEmployeesPrepared(){ Connection con = getConnection(); // create prepared statement try { pstmt = con.prepareStatement (update Employees set name = ? where Employee_Id = ?); pstmt.setString(1, hemanthbob); //Note index starts with 1 pstmt.setInt(2, 6323); pstmt.executeUpdate(); pstmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Updated into Employees Table); } public static void updateOrdersPrepared(){ int [] productIds = {543, 432, 876}; String [] productNames = {cds, dvds, Espresso}; int len = productNames.length; Connection con = getConnection(); try { pstmt = con.prepareStatement (update Orders set productname = ? where Prod_Id
= ?);
281
for(int i = 0; i < len; i++) { pstmt.setInt(2, productIds[i]); pstmt.setString(1, productNames[i]); pstmt.executeUpdate(); } pstmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null,Data Updated into Orders Table); } public static void dynamicQuery(){ Connection con = getConnection(); String result = null; String selectString; selectString = select Employees.name from Employees, Orders where productname = cds + and Employees.employee_id = Orders.employee_id ; result =Name\n; try { stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectString); while (rs.next()) { String name = rs.getString(Name); result+=name+\n; } stmt.close(); con.close(); } catch(SQLException ex) { System.err.println(SQLException: + ex.getMessage()); } JOptionPane.showMessageDialog(null, result); } }//End of class

Java Powerful Fundamental

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java Powerful Fundamental

Uploaded by

Copyright:

Available Formats

1

Created By: Jignesh S. Prajapati

Getting Started with Java

Basic Language Elements

Created By: Jignesh S. Prajapati

Java Control Statements

Java Access Modifiers

Classes and Objects

Java Class Inheritance

Created By: Jignesh S. Prajapati

Java Object Casting

Abstract class and Interface

Java Method Overriding Java String Class

Java toString() Method

Java String Comparison

Java Exception Handling

Created By: Jignesh S. Prajapati

Java Singleton Design Pattern

Java Threads Tutorial

Java Collections Framework

Java Date Util

Created By: Jignesh S. Prajapati

Java Swing Tutorial

Created By: Jignesh S. Prajapati

Introduction to Java Programming

Java Virtual Machine

Object Oriented Programming

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Getting Started with Java

Java programs can be written and executed in two ways:

Java source code

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Compiling and Running an Application

Java Development Kit

PATH and CLASSPATH

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Basic Language Elements

abstract boolean break byte case catch char class

default do double else extends final finally float

if implements import instanceof int interface long native

private protected public return short static strictfp super

this throw throws transient try void volatile while

Created By: Jignesh S. Prajapati

Variable, Identifiers and Data Types

Data Type byte short int

Default Value (for fields) 0 0 0

Range -127 to +128 -32768 to +32767

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Java Operators Tutorial

Assignment Operators Arithmetic Operators

= > + < * >= / <= % ==

Created By: Jignesh S. Prajapati

Bit wise Operator

Compound Assignment Operators

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati

Created By: Jignesh S. Prajapati