Java Manual

JAVA LAB MANUAL

BHARAT INSTITUTE OF ENGINEERING & TECHNOLOGY

JAVA LAB MANUAL BIET

2

TABLE OF CONTENTS

1. Lab Plan

2. Introduction to Java

3. Unit – I (Basic Java) a. Introduction to main concepts used in Unit – 1

b. Experiment – 1 (Quadratic Equation Roots) c. Experiment – 2 (Fibonacci Series)

d. Experiment – 3 (Prime Numbers) e. Experiment – 4 (Matrix Multiply)

f. Experiment – 5 (Tokenize Integers and get SUM)

g. Experiment – 6 (Palindrome) h. Experiment – 7 (Names Sorting)

4. Unit – II (Streams API & Data Structures) a. Experiment – 8 (File Properties)

b. Experiment – 9 (Display File) c. Experiment – 10 (Word Count & Character Count)

5. Unit – III (User Interface & Event Handling)

a. Experiment – 11 (Message in Applet) b. Experiment – 12 (Interest Applet)

c. Experiment – 13 (Mouse Events)

d. Experiment – 14 (Draw Lines)

6. Unit – IV (Threads, Client Server, Reflection API)

a. Experiment – 15 (Multiple Threads) b. Experiment – 16 (Producer Consumer)

c. Experiment – 17 (Polymorphism implementation)


3

Introduction to JAVA Java Programming Language:

Java is a very popular and widely used programming language and it was not be an exaggeration to say it is the most widely used programming language in industry now.

The reason for its wide popularity was probably the well thought of goals of the programming language. Among other attractive features, the following stand out in

ensuring it gets wide acceptability.

1. Ease of use

2. Object Oriented 3. Very strong API

4. Focus on removing hard to use and error-prone constructs 5. Platform Independence

6. Open Source encouraging collaborative development.

7. Security (Sandbox)

When people refer to the term JAVA, they are actually referring to any one or all three of the following.

The JAVA Programming Language

The Java Virtual Machine

The JAVA Application Programming Interface

All three together along with the numerous tools that provide for a strong programming

environment, making programming easy and encouraging rapid application development has made Java one of the most popular programming languages.

The JAVA Virtual Machine:

Contrary to other popular languages, JAVA follows a half-compiled, half-interpreted approach to achieve the famed platform independence. Java inventors also defined a

platform independent java machine language called Byte-Code into which java Compiler

compiles all Java Programs. This byte code is the machine language of the Java Virtual Machine and is platform independent. Java Virtual Machine is a software interpreter

which interprets byte code (.class files) and executes them on the target machine on which the byte code in running. Java inventors provided reference implementations of

Java Virtual machine on some of the most popular machine architectures and


4

encouraged vendors in developing the same for almost all machine architectures by

providing the reference implementation.

Since the byte code is machine independent, JAVA programs can be compiled once (into byte code) and executed on any machine architecture provided there is a JVM

implementation on that architecture.

Java Application Programming Interface: Java comes with a pretty exhaustive application programming interface which covers a

wide ranging set of tasks which programmers need. By providing a easy to use application programming interface, JAVA makes the task of the programmer some what

easy, allowing him to focus on the solution to his problem not having to worry about

implementing simple data structures, working on lower level file interaction, etc. Java API has classes that provide support for large number of GUI widgets, Input & Output

Streams, Database interaction, Socket communication libraries, utility data structures, simple data types, reflection API among other things. The API also is designed with

extensibility and provides scope for alternate implementations by a thoughtful separation of Interfaces and implementations.

Installation: The latest version of JAVA (1.6 at the time of writing this revision of manual) is freely

downloadable from www.java.sun.com. All machines in our Java lab have JAVA 1.5 or higher installed at C:\Program Files\Java.

On the Linux/Solaris side, the students should run the command “which javac” on their shell to figure out the path of Java installation.

Java Compiler: Java Compiler is the utility that compiles Java programs to their corresponding Byte

Code(.class files). Javac is platform independent, for the simple reason that both source(input) and output of the javac program are platform independent. Java Compiler

or “javac” as it is commonly called would be available in C:\Program

Files\Java\jdk1.5.0_01\bin.

Java Interpreter: Java interpreter or the Java Virtual Machine (It is called so because interpreter is a

machine emulator executing each instruction in byte-code, line by line) is the software which executes Byte-Code. The interpreter is machine dependent because it interprets

machine independent byte-code on a given machine architecture. The Java interpreter

or “java” as it is commonly called would be available in C:\Program Files\Java\jdk1.5.0_01\bin

Environment Variables:

PATH: This should have the path of “javac” and other utilities, so they can be invoked directly without having to give the full absolute path.

http://www.java.sun.com/


5

CLASS PATH:

This environment variable is used to hold all paths in which Java Byte code of all c lasses which one hopes to use in his or her program. For example, classpath environment

variable should have the path till lib directly in Java installation if we plan to use the Java API classes which we most certainly will. CLASSPATH should also have path of all

user defined packages that would be used.

Packages:

Packages are actually groups of related classes and also serve the purpose of avoiding namespace cluttering. You can define your own packages and put your classes in that

package.

Example:

Let us say I want to create 2 classes called Stack and Queue. I would create a package called edu.biet.cse.generic and put these classes in that package. To do so, I have to do

the following: 1. Create a directory structure edu/biet/cse/generic is some folder x.

2. Put my Stack and Queue classes in that directory with the first line of these .java files indicating that they belong to package edu.biet.cse.generic.

3. Compile all files in the package by going into the generic directory and saying

“javac *.java” 4. If I want to use these classes, I put the path “x” in CLASSPATH environment

variable. 5. In the java file where I want to use the classes in this package, I would put an

import edu.biet.cse.generic.* statement before going ahead and using the class.

JAVA API Packages:

JAVA API groups all interfaces and classes into a set of packages depending on the functionality they are addressing and supporting.

Java.lang package offers the basic data types and basic classes and is automatically

imported without any explicit import from programmers. All other packages have to be

explicitly imported by the programmers depending on the need. Importing classes means that the classes would be loaded by the Java Loader into JVM and takes time. So, it is

advisable to only import those packages and classes which would be used.

Other commonly used packages in JAVA API are java.io, java.util, java.sql, java.awt, javax.swing, java.net, etc.

JAVA API Documentation:

What does it contain? API documentation contains the list of all packages, classes, interfaces and a description

of all methods and their signatures among other things. The documentation is the most definitive source of API available and how to use for the programmers and is actually

generated directly from source code using the JAVA doc utility. In fact, it is


6

recommended that we use JAVA Doc to generate similar documentation for all JAVA

classes we write as a matter of practice.

Where is it available? JAVA API documentation is a must for all JAVA programmers and can be downloaded

from Java.sun.com. Without documentation handy, it is highly unlikely you would be using the API support in JAVA to a good extent. Java API is available on all our machines

in C:\Program Files\Java\jdk1.5.0_01\docs.

How to use?

Clicking on C:\program files\Java\jdk1.5.0_01\docs\index.html will lead you to a page where there will be a link to API specification. Click on the framed version. From the

resultant page, you can navigate to any package, class, interface and look at its

documentation and go to any related classes following the necessary navigation links.

Starting with a Simple program: Program:

Public class HelloWorld

{

Public static void main(String[] args)

{

System.out.println(“Hello World”);

}

}

Notes: JAVA is a complete object-based language. Everything in JAVA is encapsulated in classes. Main in the class which you give to the interpreter is the entry point to a Java

program. The JAVA interpreter will call the static main directly with command line options without creating an object.

Steps to run a Java Program:

1. Compile Command: To compile, “javac HelloWorld.java”

2. Run Interpreter Command: To interpret, “java HelloWorld”

Note: Compiler will generate HelloWorld.class which is the byte code. The Interpret will

interpret HelloWorld.class by invoking HelloWorld.main().


7

Introduction to Unit - I

This unit covers the basics of Java. In this unit, students work on programs that expose them to basic syntactic structures of Java, arithmetic operations, classes, objects,

access specifiers, core Java API libraries java.lang, java.util, class methods among other things.

Main API Classes Used: 1. java.lang.Float

2. java.lang.Integer 3. java.lang.String

4. java.lang.System 5. java.lang.InputStream

6. java.util.StringTokenizer

Language Concepts Learnt:

I. User Defined Data Types (Classes): One of the fundamental concepts in any object

oriented language (Java is no exception) is the concept of creating user defined data types that encapsulate properties and behavior and selectively exposing public

behavior.

II. Class Methods & Object Methods: For any user defined data type, there will

possibly be properties at an instance (one instance of that data type) level called instance variables or member variables and class variables or class properties which

have the same value across all instances of the class. These properties are

meaningful at the class level and have values irrespective of whether a member of the class has been instantiated or not. These properties can be variables or

methods.

III. Member Variables: Properties of instances of class are called member variables. Mathematically speaking, class is a set and objects are members of a set. Every

element of a set is identified by certain behavior (methods) which is the common

behavior and properties whose values might vary from member of the set to another or stay the same.

IV. Access Specifiers (Private, Public): To allow for data hiding, there are different

specifiers through which access to class members (variables & methods) can be controlled. Public means the member is available for use directly outside the class.

Private means only available for internal methods.


8

V. Arithmetic Operations: The usual plus, minus, multiplication, division, reminder/modulo operators.

VI. Basic Data Types (int, float, Boolean): Though java is object based, a few basic

data types have both a class equivalent and a basic data type. Example: int is a basic data type and Integer is its class equivalent.

VII. Conditional Statement (if), loop statements (for): The conditional and looping

constructs are pretty much the same as C type languages.


9

Experiment 1: Quadratic Equation Roots

1. Problem Statement: Write a Java Program that prints all real solutions to the quadratic equation ax**2+bx+c

= 0. Read in a, b, c and use the quadratic formula. If the discriminant b**2 – 4ac is negative, display a message stating that there are no real solutions.

2. Solution Design:

Design a class named QuadEq which has the constants a, b and c and member variables

and the two roots as member variables. All member variables have to be private. Design 3 public methods, one to computeRoots, the other two methods are getter methods to

give the roots stored in member variables. Write a public method called hasRealRoots() that return Boolean true if the equation has real roots and otherwise returns false.

Class Name: QuadEq

Properties/Member Variables: int a,b,c; double root1, root2;

Constructors: QuadEq(int, int,int) Public Interface: Boolean hasRealRoots(), int computeRoots(), double getRoot1(),

double getRoot2(); Private Methods: None

Java API Classes used: 1. java.lang.System

2. java.lang.Math

3. Unit Testing Code: Write a main method in the same class above or preferably in a different class that does

the following.

1. Creates a QuadEq object with a given value of a, b, c. 2. Calls the method hasRealRoots() on the above object and if true, call

computeRoots() and print the 2 roots by calling getRoot1() and getRoot2(); 3. If hasRealRoots() returns false, print saying the equation does not have real roots.

4. Test Cases:

Test 1:

Input: a = 1, b = 4, c = 4 Expected Output: Root1 = 2, Root2 = 2

Test 2: Input: a = 9, b = 2, c = 5

Expected Output: No real roots


10

5. Reference Implementation:

###########################################################

File name: QuadEq.java

public class QuadEq

{

private int a = 0;

private int b = 0;

private int c = 0;

private double root1 = 0;

private double root2 = 0;

public QuadEq(int arga, int argb, int argc)

{

a = arga;

b = argb;

c = argc;

}

public boolean hasRealRoots()

{

double Det = b*b - 4*a*c;

return (Det >= 0);

}

public void computeRoots()

{

double Det = b*b - 4*a*c;

Det = java.lang.Math.sqrt(Det);

root1 = (-b + Det)/2*a;

root2 = (-b - Det)/2*a;

}


11

public double getRoot1()

{

return root1;

}

public double getRoot2()

{

return root2;

}

}

class QuadEquationTest

{

public static void main(String[] args)

{

int a = 9, b = 2, c = 5;

QuadEq myQuadEq = new QuadEq(a,b,c);

if(myQuadEq.hasRealRoots())

{

myQuadEq.computeRoots();

System.out.println("Root1:" + myQuadEq.getRoot1());

System.out.println("Root2:" + myQuadEq.getRoot2());

}

else

{

System.out.println("The given equation has imaginary roots");

}

}

}

###########################################################

6. Execution:

1. javac QuadEq.java 2. java QuadEquationTest


12

Output:

Experiment 2: Fibonacci Sequence

1. Problem Statement: The Fibonacci sequence is defined by the following rule. The first two values in the

sequence are 1 and 1. Every subsequent value is the sum of the two values preceding it. Write a Java program that uses both recursive and non-recursive functions to print the

nth value in the Fibonacci sequence.

2. Solution Design:

Write a class Fibonacci with 2 static methods. The methods are static because nth Fibonacci number is property of Fibonacci class and there is no concept of object of

Fibonacci series because there is really only one Fibonacci series in the world. The 2 static methods return nth element in Fibonacci series given n and can be names

nthFiboRecursive and nthFiboNonRecursive. Both yield the same result for a given n, but

each follow a different implementation style (one is a recursive algorithm and the other non-recursive) and hence could lead to different performance times for high values of n.

The idea is for the student to appreciate the time-overhead of using recursive algorithms and how it can exponentially increase with n vs. the conceptual simplicity of

a recursive algorithm.

Class Name: Fibonacci

Properties/Member Variables: None Public Interface: static int nthFiboRecursive(int), static int ntheFiboNonRecursive()

Private Methods: None

Java API Classes used:

1. java.lang.System


the following. 1. Take a large value of n (say between 30 to 100)

2. Call nthFiboRecursive with n from step 1.

3. Call nthFiboNonRecursive with n from step 1.

4. Test Cases: Test 1:

Input: n = 30


13

5. Reference Implementation: ####################################################################

File name: Fibonacci.java

public class Fibonacci

{

public static int nthFiboRecursive(int n)

{

if((n == 1) || (n == 2))

{

return 1;

}

else

{

return (Fibonacci.nthFiboRecursive(n - 1) +

Fibonacci.nthFiboRecursive(n - 2));

}

}

public static int nthFiboNonRecursive(int n)

{

if((n == 1) || (n == 2))

{

return 1;

}

else

{

int Lower = 1;

int Higher = 1;

int count = n - 2;

while(count != 0)

{

int temp = Lower + Higher;

Lower = Higher;

Higher = temp;


14

count--;

}

return Higher;

}

}

}

class FibonacciTest

{


{

int n = 30;

System.out.println(Fibonacci.nthFiboRecursive(n));

System.out.println(Fibonacci.nthFiboNonRecursive(n));

}

}

##################################################################################

6. Execution:

1. javac Fibonacci.java 2. java FibonacciTest

OUT PUT:


15

Experiment – 3: Prime Numbers

1. Problem Statement:

Write a Java Program that prompts the user for an integer and then prints out all prime numbers up to that integer.

2. Solution Design:

Write a class called Prime that has two static methods, one (isPrime) which returns true

if a given number is prime and false otherwise and another which takes n and prints all prime numbers less than n by calling the previous method to determine if a number is

prime or not. The reason these methods are static is because these are class methods and there are no

properties that are object specific.

Class Name: PrimeNumbers

Properties/Member Variables: None Public Interface: static boolean isPrime(int), static void allLowerPrimes(int)


JAVA API Classes Used:

1. java.lang.System


the following. 1. Take an input value n.

2. Call the allLowerPrimes(n) method of the Prime class.

4. Test Cases:

Test1: Input: n = 23

Output: All prime numbers less than or equal to 23.


16

5. Reference Implementation: ###########################################################

File name: Prime.java

public class Prime

{

public static boolean isPrime(int n)

{

if((n == 0) || (n == 1))

{

return false;

}

else if(n == 2)

{

return true;

}

else

{

int Median = (n/2) + 1;

boolean isPrime = true;

for(int i=2; i<=Median; i++)

{

if((n % i) == 0)

{

isPrime = false;

break;

}

}

return isPrime;

}

}


17

public static void allLowerPrimes(int n)

{

for(int i = 0;i <=n; i++)

{

if(Prime.isPrime(i))

{

System.out.println(i);

}

}

}

}

class PrimeTest

{


{

int n = 23;

Prime.allLowerPrimes(n);

}

}

###########################################################

6. Execution:

1. javac Prime.java 2. java PrimeTest

OUT PUT:


18

Experiment – 4: Matrix Multiplication


Write a Java program to multiply two given matrices.

2. Solution Design:

Write a class Matrix which encapsulates all properties of a matrix including number of rows, columns, the values of the matrix and whether the matrix is populated with data.

The class should provide access methods to get rows, cols, cell data, whether data is

populated or not. The class should also have public methods to display matrix and multiply this matrix with another matrix. The class should provide a constructor which

takes number of rows and cols only and another which takes number of rows and cols and a String which has blank separated matrix data. For unpopulated Matrix, the class

should provide a method which will allow copying of data from another Matrix. We also want a method which checks whether we can multiply this matrix with another matrix

checking the rows and cols.

Class Name: Matrix

Member Variables: int mNumRows, int mNumCols, int[][] mData, Boolean misDataPopulated.

Public Interface: Boolean isDataPopulated(), int getNumRows(), int getNumCols(), int get CellElement(int, int), Matrix multiply(Matrix), Boolean canMultiply(Matrix), void

CopydataFrom(Matrix), void display();

Constructors: Matrix(int, int); Matrix(int, int, String);

JAVA API Classes Used: 1. java.util.StringTokenizer

2. java.lang.System

3. Unit Testing Code:

Write a main method in the same Matrix class or in another Test class which does the following.

1. Create a Matrix object by supplying data in a String. 2. Create another Matrix object using the same approach.

3. check whether we can multiply the 2 matrices by calling canMultiply()

4. If we can multiply, call multiply method 5. display the result matrix by calling display method.

4. Test Cases:

Test1: Input: Create a 3*2 and a 2*3 matrix and multiply them.

Expected output: Check the result to verify output


19

Test2: Input: Create a 3*2 and a 3*2 matrix and multiply them.

Expected output: Cannot multiply matrices. 5. Reference Implementation:

####################################################################

File: Matrix.java

import java.util.StringTokenizer;

public class Matrix

{

private int mNumRows = 0;

private int mNumCols = 0;

private int [ ][ ] mData;

private boolean mIsDataPopulated = false;

public Matrix(int argRows, int argCols)

{

mNumRows = argRows;

mNumCols = argCols;

mData = new int[mNumRows][mNumCols];

}

public Matrix(int argRows, int argCols, String argIntData)

{

mNumRows = argRows;

mNumCols = argCols;

mData = new int[mNumRows][mNumCols];

StringTokenizer str = new StringTokenizer(argIntData);

int count = str.countTokens();

if(count != (mNumRows * mNumCols))

{

System.out.println("Matrix Cell Items not matching count of rows

and cols");

}


20

else

{

for(int row=0;row<mNumRows;row++)

{

for(int col=0;col<mNumCols;col++)

{

mData[row][col] =

(new Integer(str.nextToken())).intValue();

}

}

}

mIsDataPopulated = true;

}

public boolean isDataPopulated()

{

return mIsDataPopulated;

}

public int getNumRows()

{

return mNumRows;

}

public int getNumCols()

{

return mNumCols;

}

public int getCellElement(int row, int col)

{

return mData[row][col];

}

public boolean copyDataFrom(Matrix anotherMatrix)

{

if(!anotherMatrix.isDataPopulated())

{


21

return false;

}

else if((anotherMatrix.getNumRows() != mNumRows) ||

(anotherMatrix.getNumCols() != mNumCols))

{

return false;

}

else

{

mIsDataPopulated = true;

for(int i = 0;i < mNumRows;i++)

{

for(int j = 0; j < mNumCols;j++)

{

mData[ i ][ j ] = anotherMatrix.getCellElement(i,j);

}

}

return true;

}

}

public boolean canMultiply(Matrix anotherMatrix)

{

if(mNumCols == anotherMatrix.getNumRows())

{

return true;

}

else

{

return false;

}

}

public Matrix multiply(Matrix anotherMatrix)

{

Matrix resultMatrix = null;

if(canMultiply(anotherMatrix))

{

StringBuffer Result = new StringBuffer("");


22

for(int i = 0; i < mNumRows; i++)

{

for(int j = 0; j < anotherMatrix.getNumCols(); j++)

{

int element = 0;

for(int k = 0; k < mNumCols; k++)

{

element+=

getCellElement(i,k)*anotherMatrix.getCellElement(k,j);

}

Result.append((new Integer(element)).toString());

Result.append(" ");

}

}

resultMatrix=new

Matrix(mNumRows,anotherMatrix.getNumCols(),Result.toString());

}

return resultMatrix;

}

public void display()

{

for(int i=0;i < mNumRows; i++)

{

for(int j=0; j < mNumCols; j++)

{

System.out.print(getCellElement(i,j) + " ");

}

System.out.println("");

}

}

}


23

class MatrixMultiplyTest

{


{

int Rows1 = 3;

int Cols1 = 2;

String MatrixStr1 = "1 2 3 4 5 6";

Matrix Matrix1 = new Matrix(3,2,MatrixStr1);

System.out.println("Input Matrix 1");

Matrix1.display();

int Rows2 = 2;

int Cols2 = 3;

String MatrixStr2 = "1 2 3 4 5 6";

Matrix Matrix2 = new Matrix(2,3,MatrixStr2);

System.out.println("Input Matrix 2");

Matrix2.display();

if(Matrix1.canMultiply(Matrix2))

{

Matrix Mul = Matrix1.multiply(Matrix2);

System.out.println("The result of multiplying Matrix1 and Matrix 2

is:");

Mul.display();

}

}

}

####################################################################

6. Execution: 1. javac Matrix.java

2. java MatrixMultiplyTest

OUT PUT:

Experiment – 5: Sum of Integers given as input in one line


24

1. Problem Statement: Write a Java program that read a line of Integers and then displays each integer, and

the sum of all Integers (use StringTokenizer class)

2. Solution Design: Write a class MyIntegerSeries which encapsulates an ArrayList of Integers (to allow for

dynamic growth depending on how many Integers are there in the String) and a public

method called getSUMofSeries() which will give the sum of all Integers. The constructor should take a String and tokenize it to populate the ArrayList of Integers.

Class Name: MyIntegerSeries

Member Variables: ArrayList mIntegerList

Public Interface: int getSUMofSeries() Constructors: MyIntegerSeries(String)

Private Members: None

Java API Classes used: 1. java.lang.String

2. java.lang.System

3. java.util.StringTokenizer


Write a main method in MyIntergerSeries class or a test class which does the following. 1. Create an object of MyInetgerSeries class by giving a String of Integers.

2. Call the getSUMofSeries() method in the above object to get the SUM.

3. Display the SUM.

4. Test Cases: Test1:

Input: String: “1 2 3 4 5 6 7 8 9 10”

Expected Output: 55



25

###########################################################

File: MyIntegerSeries.java

import java.util.StringTokenizer; import java.util.ArrayList;

public class MyIntegerSeries {

private ArrayList<Integer> mIntegerList = null; public MyIntegerSeries(String str) {

StringTokenizer st = new StringTokenizer(str); mIntegerList = new ArrayList<Integer>();

while(st.hasMoreTokens()) { mIntegerList.add(new Integer(st.nextToken()));

} }

public int getSUMofSeries() { int sum = 0;

for(int i = 0; i < mIntegerList.size(); i++) { sum += (mIntegerList.get(i)).intValue();

} return sum;

} } class IntegerSUMTest

{ public static void main(String[] args)

{ String test = "1 2 3 4 5 6 7 8 9 10"; MyIntegerSeries obj = new MyIntegerSeries(test);

System.out.println(obj.getSUMofSeries()); }

} ###########################################################

6. Execution 1. javac MyInetgerSeries.java

2. java IntegerSUMTest

OUTPUT:

Experiment – 6: Palindrome


26

1. Problem Statement: Write a Java program that checks whether a given string is a palindrome or not. Ex:

MADAM is a palindrome.

2. Solution Design: Write a class Palindrome that has a static method (isPalindrome) which takes a String as

argument and returns true if the String is a palindrome, otherwise returns false. The

algorithm just reverses the String after taking the String into a StringBuffer and compares both. If the String and its reverse are same, we can say the given input String

is a Palindrome.

Class Name: Palindrome

Properties/Member Variables: None Public Interface: static Boolean isPalindrome(String);


JAVA API Classes Used: 1. java.lang.StringBuffer

2. java.lang.System


Write a main method in the same class or in another class which does the following. 1. Takes a String as input.

2. Calls the method isPalindrome() with the above String. 3. Check the return value and print the corresponding message.


Input: String = “MALAYALAM” Expected output: The string MALAYALAM is a Palindrome.

Test2: Input: String = “Madam”

Expected output: The string Madam is a Palindrome.

Test3: Input: String = “Hellh”

Expected output: The string Hellh is not a Palindrome.



27

###########################################################

File: Palindrome.java

public class Palindrome

{

public static boolean isPalindrome(String str)

{

StringBuffer buf1 = new StringBuffer(str);

StringBuffer buf2 = new StringBuffer(str);

buf1.reverse();

if((buf1.toString()).equals(buf2.toString()))

{

return true;

}

return false;

}

}

class PalindromeTest

{

public static void main(String[ ] args)

{

String test = "Madam";

if(Palindrome.isPalindrome(test.toLowerCase()))

{

System.out.println("The string:" + test + " is a Palindrome");

}

else

{

System.out.println("The string:" + test + " is not a Palindrome");

}

}

}

###########################################################


28

6. Execution:

1. javac Palindrome.java 2. java PalindromeTest

Out put:

Experiment – 7: Names Sort


29


Write a Java program for sorting a given list of names in ascending order.

2. Solution Design: Write a class NameSort that encapsulates a list (array) of names with a constructor that

takes an array of names and stores them in a private array member variable, and two public methods, one of which sort the list of names in the array member variable and

the other that displays the names in the array.

Class Name: NameSort

Member Variables: String[] mNamesList Constructor: NameSort(String[]);

Public Interface: void sortNames(); void displayNamesList();


JAVA API Classes Used: 1. java.lang.String

2. java.lang.System 3. java.util.Scanner

4. java.util.Arrays


Write a main method either in the class NameSort or in another class which does the following.

1. Read the count of names to be input 2. Read the names.

3. Create an object of NameSort

4. Call displayNamesList 5. Call sortNames

6. Call displayNamesList

4. Test Cases: Test 1:

Input: count = 4; Names = “ABC”, “XYZ”, “HELLO” Expected Output: “ABC”, “HELLO”, “XYZ”

Test2:

Input: count = 6; Names = “gui”, ”bad”, ”design”, ”other”, “hello”, “what”

Expected output: “bad”, “design”, “gui”, “hello”, “other”, “what”



30

###########################################################

File: NameSort.java

import java.lang.*;

import java.util.*;

public class NameSort

{

public NameSort(String[ ] argNames)

{

mNamesList = new String[argNames.length];

System.arraycopy(argNames,0,mNamesList,0,argNames.length);

}

public void sortNames( )

{

Arrays.sort(mNamesList);

}

public void displayNamesList( )

{

System.out.println("The Ordered List now is:");

for(int i=0;i < mNamesList.length; i++)

{

System.out.println(mNamesList[ I ]);

}

}

private String[ ] mNamesList;

}

class NameSortTest

{


31


{

System.out.println("Please enter the number of elements in the

array");

Scanner sc = new Scanner(System.in);

int count = sc.nextInt( );

sc.nextLine( );

String[ ] NamesArray = new String[count];

System.out.println("Enter each name in a line");

for(int i=0;i < count;i++)

{

NamesArray[ i ] = new String(sc.nextLine( ));

}

sc.close( );

NameSort myNameSort = new NameSort(NamesArray);

myNameSort.sortNames( );

myNameSort.displayNamesList( );

}

}

###########################################################

6. Execution:

1. javac NameSort.java

2. java NameSortTest

OUT PUT:

Introduction to Unit - II


32

This unit introduces Streams, which are the JAVA way of providing API for programmers

to read data or write data from and to different data source. The streams API interface is all grouped into java.io package and includes Stream Interfaces, Stream Classes,

Buffered Interfaces, Buffered Classes and other general purpose utility classes related to input/output.

Main JAVA API Classes used:

Java.io.File

Java.io.DataInputStream Java.io.BufferedReader

Java.io.FileInputStream Java.io.FileOutputStream

Java.io.DataOutputStream


1. Programming to Interface: Java API has Interfaces like DataInput and DataOutput which are implemented by various Input and Output Stream classes. This kind of

Interface based API allows the users to program at a high level thereby reducing

the program’s dependency on a specific implementation.

2. Reading data from files: This unit shows you how you can use classes from JAVA API to read from files.

3. Writing data to files: This unit shows you how you can use classes from JAVA API

to write to files.

4. Understanding File related exceptions: This unit exposes you to some of the

exceptions possible while doing IO related operations and what they indicate.

5. Finding out File properties: This unit shows you class that encapsulates file

properties in Java, internally using the local File management system to get the properties.

6. Common Data Structures: Assuming you are already familiar with common data

structures and their operations, this unit gives you a chance to look at JAVA API classes implementing the most common data structures that can be directly used

in your JAVA programs without you having to implement the basic data structures.

Of course, it would be good for students to see the public interface of these data structures and understand how the interface has been designed and understand

core OO principles of data abstraction which are behind the design of JAVA API.

7. IOStream Library Hierarchy: JAVA API library follows a very logical hierarchy of interfaces and implementation classes that allows for extensibility either by

extending interfaces or by changing implementations as the user wants.


33

Understanding the hierarchy and appreciating its design would certainly help

students get the essence of object oriented programming and programming for extensibility.

Experiment – 8: File Properties

1. Problem Statement: Write a Java Program that reads one file name from the user then displays information

about whether the file exists, whether the file is readable, whether the file is writable,

the type of file and the length of the file in bytes.

2. Solution Design: Write a class named MyFile which would have method called displayFileProperties() that

would print all the properties of file like whether the fi le exists, what is the absolute

path of the file, whether the file is readable and writable, whether it is a regular file or a directory and size of file in bytes. The constructor of the class should take a path

(absolute or relative) as argument.

Class Name: MyFile Constructor: public MyFile(String)

Public Interface: void displayFileProperties()

Private Members: File & String Private Methods: None


Write a main method in MyFile or another class which will create a MyFile object with a given File Path String and calls the displayFileProperties() method on the object.

4. Test Cases: Test1: Valid file name with full path

Test2: Valid file name with relative path Test3: invalid file


####################################################################


34

File: MyFile.java

import java.io.*;

public class MyFile

{

private File mFile;

private String mName;

public MyFile(String argFileName)

{

mFile = new File(argFileName);

mName = new String(argFileName);

}

public void displayFileProperties( )

{

if(!mFile.exists( ))

{

System.out.println("The file with path" +\"+ mName +\"+ " does not

exist");

return;

}

System.out.println("The file with path" + \"+ mName +\" + " exists");

System.out.println("The corresponding absolute path is:" +

mFile.getAbsolutePath( ));

if(mFile.canRead( ))

{

System.out.println("The file:" + mName + " is readable");

}

if(mFile.canWrite( ))

{

System.out.println("The file:" + mName + " is writable");

}

if(mFile.isDirectory( ))

{

System.out.println(mName + " is a Directory");

}

else

{

System.out.println(mName + " is a File");


35

System.out.println("The file size is :" + mFile.length( ));

}

}

}

class FilePropertiesTest

{


{

String File = "hi.txt";

MyFile obj = new MyFile(File);

obj.displayFileProperties( );

}

}

####################################################################

6. Execution: 1. javac MyFile.java

2. java FilePropertiesTest

OUTPUT:

Experiment – 9: File Contents



36

Write a Java program that reads a file and displays a file on the screen, and displays the

file on the screen with a line number before each line.

2. Solution Design: Write a class called FileDisplay which checks whether a given file exists, i sReadable, is a

file filetype, reads the file using an InputStream and display the file to command line as is and with line number, one line at a time.

3. Unit Testing Code: Write a main method in DisplayFile or another class which creates an object of

DisplayFile, checks for basic file properties and then calls the displayFile and displayFilewithLineNumber methods to print the contents of the file.

4. Test Cases: Test1: A valid text file in your file system

5. Reference Implementation: ##################################################################################

File: FileDisplay.java

import java.io.*;

public class FileDisplay

{


private File mFileHandle;

public FileDisplay(String str)

{

mName = new String(str);

mFileHandle = new File(mName);

}

public boolean isExistsFile()

{

return (mFileHandle.exists());

}

public boolean isReadableFile()

{

return (mFileHandle.canRead());

}


37

public boolean isRegularFile()

{

return (mFileHandle.isFile());

}

public void displayFileContents()

{

try

{

BufferedReader lBr =

new BufferedReader(new FileReader(mFileHandle));

String lNextLine = lBr.readLine();

while(lNextLine != null)

{

System.out.println(lNextLine);

lNextLine = lBr.readLine();

}

lBr.close();

}

catch(Exception e)

{

e.printStackTrace();

}

}

public void displayFileContentsWithLineNumber()

{

try

{

int lineCount = 0;





{

lineCount++;

System.out.println(lineCount + ":" + lNextLine);


38


}

lBr.close();

}

catch(Exception e)

{


}

}

}

class FileDisplayTest

{


{

String str = "hi.txt";

FileDisplay lDisplay = new FileDisplay(str);

if((lDisplay.isExistsFile()) &&

(lDisplay.isRegularFile()) &&

(lDisplay.isReadableFile()))

{

System.out.println("File Contents of" + str + " are :");

lDisplay.displayFileContents();

System.out.println("File Contents with line number of" + str + " are

:");

lDisplay.displayFileContentsWithLineNumber();

}

}

}

##################################################################################

6. Execution:

1. javac FileDisplay.java 2. java FileDisplayTest


39

out put:

Experiment – 10: Character Count in a File



40

Write a Java program that displays the number of characters, lines and words in a text

file.

2. Solution Design: Write a class FileCharacterCount that has methods to check for basic file properties and

than opens a file using InputStream class and reads one line at a time, tokenizes the line on spaces, gets word count and takes the length of like and adds it to character count

and this comes up with line count, word count and character count of the file.


Write a main method is this class or some other class that creates an object of FileCharacterCount and calls the methods computerCharacterCount() and displayCount

methods to get counts.

4. Test Cases:

Test1: Any valid text file in your file system


File: FileCharacterCount.java

import java.io.*;

import java.util.*;

public class FileCharacterCount

{


private File mFileHandle;

private int mLineCount = 0;

private int mWordCount = 0;

private int mCharacterCount = 0;

public FileCharacterCount(String str)

{

mName = new String(str);

mFileHandle = new File(mName);

}

public boolean isExistsFile()

{

return (mFileHandle.exists());

}


41

public boolean isReadableFile()

{

return (mFileHandle.canRead());

}

public boolean isRegularFile()

{

return (mFileHandle.isFile());

}

public void computeCharacterCount()

{

try

{





{

System.out.println(lNextLine);

mLineCount++;

mCharacterCount = mCharacterCount +

lNextLine.length() + 1;

StringTokenizer st = new StringTokenizer(lNextLine);

while(st.hasMoreTokens())

{

st.nextToken();

mWordCount++;

}


}

lBr.close();

}

catch(Exception e)

{


}

}


42

public void displayCounts()

{

System.out.println("The line count is:" + mLineCount);

System.out.println("The word count is:" + mWordCount);

System.out.println("The character count is:" + mCharacterCount);

}

}

class FileCharacterCountTest

{


{

String str = "hi.txt";

FileCharacterCount lFile = new FileCharacterCount(str);

if((lFile.isExistsFile()) &&

(lFile.isRegularFile()) &&

(lFile.isReadableFile()))

{

lFile.computeCharacterCount();

lFile.displayCounts();

}

}

}

####################################################################

6. Execution: 1. javac FileCharacterCount.java

2. java FileCharacterCount

Introduction to Unit – III

This unit covers the support for rich user interface development in Java. In this unit, students work on programs that expose them to various user interface elements/widgets

provided by Java to help construct rich user interface either in desktop applications or


43

on web using applets which are java objects within HTML. Java supports UI components

starting from the simple ones like button, textbox to complex components like table, tree and components that can contain other components in them like panels, frames,

etc. Java API packages that would be predominately used are java.awt and javax.swing and java.awt.event. JAVA also supports an event model which allows programs to

register callbacks on events of interest on a UI object.

Main API Classes Used:

1. java.awt.Button. 2. java.awt.event.ActionListener

3. java.awt.event.MouseListener 4. java.awt.TextField


1. User Interface Development: Building rich user interface to functionality of software makes it easy for users to use the software there-by enhancing the

utility of the software. Java offers a vast library of widgets that could be used directly to construct your own interfaces.

2. Event driven programming: It is a concept where the software does some action based on an action that user performs on the user interface and otherwise stays

idle waiting for a user action. This kind of programming is pretty common for software which is built for the purpose of users using the services of the software

on an interactive basis as and when they need some functionality supported by the software.

3. Listeners: Any number of listeners might be interested in specific events caused by an explicit action done by the user on a user interface widget and each

listener might do totally different things based on the event being generated. JAVA provides a powerful and elegant mechanism to realize this kind of publish

subscriber model driven by events generated based on actions, with components

acting as publishers publishing information on user action and subscribers registering with publishers to ensure they get all messages from publishers for the

registered event.

4. Applets: Java provides support for embedding objects in HTML allowing users to build rich JAVA powered user interface application accessible from web. Because

applet running on web cannot by default be considered non-malicious, JAVA

implements a sandbox security model which places sufficient restrictions on what an applet can and cannot do to ensure client’s system is not compromised on a

malicious attack.

5. Model View Controller pattern: JAVA user interface library follows MVC pattern that allows multiple views to be attached to a given model and java library


44

automatically ensures all views are updated when the model changes using a

publish-subscribe internal implementation.

Experiment – 11: Message in Applet

1. Problem Statement: Write an applet that displays a simple message.


45

2. Solution Design:

Write a class MyDisplayApplet class which extends JApplet class and implements the init method by adding a JLabel with a message to the content pane of the applet. Set the

size of the applet to some reasonable size.

3. Unit Testing Code: Insert the applet as an object inside html code by using applet tag and giving code,

width and height attributes to the tag.

4. Test Cases:

Test1: go to the AppletTest.html in your favorite browser.


####################################################################

File: MyDisplayApplet.java

import javax.swing.*;

import javax.swing.border.*;

import java.awt.*;

public class MyDisplayApplet extends JApplet

{

public void init()

{

JLabel lLabel = new JLabel("Welcome to Applet World!",

SwingConstants.CENTER);

getContentPane().add(lLabel);

lLabel.setBorder(new javax.swing.border.EmptyBorder(0,0,0,0));

setPreferredSize(new Dimension(400,300));

setVisible(true);

}

}

File: AppletTest.html

<html>

<head>

</head>


46

<body>

<applet code=MyDisplayApplet.class width=600 height=400>

</applet>

</body>

</html>

####################################################################

6. Execution:

1. javac MyDisplayApplet.java 2. goto AppletTest.html in browser.

Experiment – 12: Loan Repayment Applet

1. Problem Statement: Write an applet that computes the payment of a loan based on the amount of the loan,

the interest rate and the number of months. It takes one parameter from the browser: Monthly rate; if true, the interest rate is per month; other wise the interest rate is

annual.

2. Solution Design:

Design a class called InterestApplet extending JApplet and building a UI that has 3 TextFields that allows the user to enter amount, interest rate and number of months

loaned, a button called Compute which when clicked will compute interest and show it

in another TextField labeled Interest. The rate entered is taken as monthly rate or yearly rate based on parameter input coming from Browser.


Write a html file which will invoke this applet using applet tag with code, height and width attributes and another parameter called MonthyRate set to false meaning the rate

entered by ser will be annual interest rate.

4. Test Cases:

Test1: Amount: 100, Months = 12, Interest = 18 Test2: Amount: 1500, Months 29, Interest = 12


####################################################################

File: InterestApplet.java



47


import java.awt.*;

import java.awt.event.*;

public class InterestApplet extends JApplet

{

private JTextField mRepaymentAmountText = null;

private JTextField mLoanText = null;

private JTextField mIntRateText = null;

private JTextField mNumMonthsText = null;

private String mIsMonthlyRate = "";

public void init()

{

mIsMonthlyRate = new String(getParameter("MonthlyRate"));

getContentPane().setLayout(new GridLayout(4,2));

JLabel lLabelAmount = new JLabel("Loan Amount:",

SwingConstants.LEFT);

JLabel lLabelIntRate = new JLabel("Interest Rate:",


JLabel lLabelMonths = new JLabel("Number of Months:",


JButton lButtonRepaymentAmount = new JButton(

"Show Repayment Amount");

mLoanText = new JTextField();

mLoanText.setEnabled(true);

mIntRateText = new JTextField();

mIntRateText.setEnabled(true);

mNumMonthsText = new JTextField();

mNumMonthsText.setEnabled(true);

mRepaymentAmountText = new JTextField();

mRepaymentAmountText.setEnabled(false);


48

getContentPane().add(lLabelAmount);

getContentPane().add(mLoanText);

getContentPane().add(lLabelIntRate);

getContentPane().add(mIntRateText);

getContentPane().add(lLabelMonths);

getContentPane().add(mNumMonthsText);

getContentPane().add(lButtonRepaymentAmount);

getContentPane().add(mRepaymentAmountText);

lButtonRepaymentAmount.addActionListener(

new InterestActionListener());


setVisible(true);

}

public class InterestActionListener implements ActionListener

{

public void actionPerformed(ActionEvent e)

{

float mLoan = (new Float(mLoanText.getText())).floatValue();

float mRate = (new Float(mIntRateText.getText())).floatValue();

float mNumMonths =

(new Integer(mNumMonthsText.getText())).intValue();

if(mIsMonthlyRate.equals("true"))

{

float totalInterest = mLoan*(mRate/100)*mNumMonths;

totalInterest += mLoan;

mRepaymentAmountText.setText(

(new Float(totalInterest)).toString());

}

else

{

float totalInterest = mLoan*(mRate/(12*100))*mNumMonths;

totalInterest += mLoan;


49

mRepaymentAmountText.setText(

(new Float(totalInterest)).toString());

}

}

}

}

File: InterestAppletTest.html

<html>

<head>

</head>

<body>

<applet code=InterestApplet.class width=600 height=100

MonthlyRate=false>

</applet>

</body>

</html>

####################################################################

6. Execution: 1. javac InterestApplet.java

2. go to InterestAppletTest.html in your browser.

Experiment – 13: Handling Mouse Events

1. Problem Statement: Write a Java Program to handle mouse events.

2. Solution Design:


50

Write a class MouseEventsApplet that extends JApplet and implements the

MouseListener interface. The init method will just create a simple UI and all the MouseListener methods are implemented by displaying a corresponding message in the

status section of Applet.

3. Unit Testing Code: Write a simple html and include the MouseEventsApplet object using the Applet tag and

passing code, height and width attributes.

4. Test Cases:

Test1: Test by moving the mouse into and out of the applet and by clicking the mouse in the applet and see the applet status message change.


File: MouseEventsApplet.java



import java.awt.*;


public class MouseEventsApplet extends JApplet implements

MouseListener

{

public void init()

{

JLabel lLabel = new JLabel("Welcome to Applet World!",

SwingConstants.CENTER);

getContentPane().add(lLabel);

lLabel.setBorder(new javax.swing.border.EmptyBorder(0,0,0,0));


setVisible(true);

addMouseListener(this);

}

public void mouseClicked(MouseEvent e)

{

showStatus("Mouse was clicked");

}


51

public void mouseEntered(MouseEvent e)

{

showStatus("Mouse Entered");

}

public void mouseExited(MouseEvent e)

{

showStatus("Mouse Exited");

}

public void mousePressed(MouseEvent e)

{

showStatus("Mouse was Pressed");

}

public void mouseReleased(MouseEvent e)

{

showStatus("Mouse was Released");

}

}

File: MouseEventsAppletTest.html

<html>

<head>

</head>

<body>

<applet code=MouseEventsApplet.class width=600 height=400>

</applet>

</body>

</html>

####################################################################

6. Execution: 1. javac MouseEventsApplet.java

2. go to MouseEventsAppletTest.html in your browser


52

Experiment – 14: Draw Lines


Write a Java Program that allows the user to draw line, rectangles.

2. Solution Design:

Write a class called MyCanvas which encapsulates a Canvas object to which a mouseListener is added. When the mouse is clicked, the point where the click was done

will be added to the ArrayList of points. When the button called DrawLine is clicked, the pointsArray is checked for entries and if there are more than 2 points selected a line is

drawn in the paint method from point1 to point 2.


Main method in MyCanvas class which creates the MyCanvas object and adds it to a frame and displays it.

4. Test Cases:

Test1: Click on more than 2 points in canvas and than click button. A line will be

drawn. Test2: Click on 0 or 1 points in canvas and click draw line button. A message will

be displayed saying line cannot be drawn.


File: MyCanvas.java

import java.awt.*;




import java.util.*;

public class MyCanvas extends JPanel

{

private Canvas mCanvas = null;

private ArrayList<Point> mPointsSelected;

private int mActionSelected = 0;

public MyCanvas()


53

{

setLayout(new BorderLayout());

mCanvas = new Canvas();

mCanvas.addMouseListener(new MyMouseListener());

add(mCanvas, BorderLayout.CENTER);

JPanel lButtonPanel = new JPanel();

lButtonPanel.setLayout(new GridLayout(1,1));

JButton lDrawLineButton = new JButton("Draw Line");

lDrawLineButton.addActionListener(new MyActionListener());

lButtonPanel.add(lDrawLineButton);

add(lButtonPanel, BorderLayout.SOUTH);

mPointsSelected = new ArrayList<Point>();

}

public class MyMouseListener extends MouseAdapter

{

public void mouseClicked(MouseEvent e)

{

mPointsSelected.add(e.getPoint());

}

}

public class MyActionListener implements ActionListener

{

public void actionPerformed(ActionEvent e)

{

if(mPointsSelected.size() >= 2)

{

repaint();

revalidate();

//mPointsSelected.clear();

}

else

{

System.out.println("Not enough points to draw a line");

}

}

}


54

public synchronized void paint(Graphics g)

{

if(mPointsSelected.size() >= 2)

{

Point pnt1 = mPointsSelected.get(0);

Point pnt2 = mPointsSelected.get(1);

int x1 = (int) pnt1.getX();

int y1 = (int) pnt1.getY();

int x2 = (int) pnt2.getX();

int y2 = (int) pnt2.getY();

//g.setColor(new Color(255,0,0));

mCanvas.getGraphics().drawLine(x1,y1,x2,y2);

mPointsSelected.clear();

}

}


{

JFrame lFrame = new JFrame();

lFrame.getContentPane().setLayout(new GridLayout(1,1));

MyCanvas lCanvas = new MyCanvas();

lFrame.getContentPane().add(lCanvas);

lFrame.setSize(400,150);

lFrame.show();

}

}

####################################################################

6. Execution:

1. javac MyCanvas.java 2. java MyCanvas

Introduction to Unit - IV


55

This unit covers JAVA’s features for parallel programming using threads and JAVA’s

support for building client/server application using socket programming. The packages in JAVA API you would be exposed to are java.lang for Thread related classes and java.net

for socket programming related data.

Main API Classes Used:

1. java.lang.Thread

2. java.lang.Runnable 3. java.net.ClientSocket

4. java.net.ServerSocket 5. ObjectInputStream

6. ObjectOutputStream


1. Parallel Programming means we have more than one execution threads running in parallel as far as the user goes as against conventional programs which have

one line of execution

2. Threads is JAVA’s API for providing the users the ability to have multiple lines of

execution in a given program. Threads allow users to start parallel lines of execution, suspend it and share data across multiple threads.

3. Synchronization in JAVA allows users to control parallel access to shared objects

from multiple threads to ensure shared objects do not get into inconsistent

states.

4. Socket Programming allows users to write server programs that are running on a machine tied to a socket and listening for client requests for service and respond

to them. Clients need to know the machine and socket on which the service is

running so it can use the server for a service. It also needs to know the protocol or the message format which the server would understand.

5. Server Socket is distinct from client socket because it is a listening socket only

there to listen to new client connections all the time.

6. Client Socket is used by clients to open a socket on the client side which will connect to the server through server socket and get linked up to a unique socket


56

on the server side for a given connection so message can be exchanged between

client and server till one of the parties closes the connection.

7. Reflection API is JAVA’s support for RTTI (runtime type identification) and allows for objects to be created at runtime, messages to be invoked at runtime with

parameters also constructed at runtime.

Experiment – 15: Multiple Threads


Write a Java Program for creating multiple threads.

2. Solution Design:


57

Write a class MyThread that extends Thread and has a static Counter and a thread

number as members. The run method should call the method called incrementCounter which would be a static method the MyThread class and increments the ourCounter

variable value and prints its value with the Thread id of the Thread object which invokes this method. incrementCounter method should be synchronized so multiple threads do

not try to increment the counter at precisely the same time.

Class: MyThread

Interface: run() Other Methods: static incrementCounter()

Members: int for thread id and a static ourCounter.


A main in the same class or in another test class that creates multiple thread objects with different ids. The threads are started both of them with a certain time-lag.

4. Test Cases:

Test1: create 2 threads with ids 0 & 1 and start them.


####################################################################

File: MyThread.java

public class MyThread extends Thread

{

public static int ourCounter = 0;

private int mId;

public MyThread(int id)

{

mId = id;

}

public void run()

{ while(true)

{

incrementCounter();

try

{

Thread.sleep(300);

}

catch(Exception e)


58

{


}

}

}

synchronized public void incrementCounter()

{

MyThread.ourCounter = MyThread.ourCounter + 1;

System.out.println(mId + ":" + MyThread.ourCounter);

}

}

File: MyThreadTest.java

public class MyThreadTest

{


{

MyThread thread1 = new MyThread(0);

MyThread thread2 = new MyThread(1);

thread1.start();

try

{

Thread.sleep(600);

}

catch(Exception e)

{

}

thread2.start();

}

}

####################################################################

6. Execution:

1. javac MyThread.java 2. javac MyThreadTest.java

3. java MyThreadTest


59

Experiment – 16: Producer – Consumer Problem

1. Problem Statement: Write a Java program that correctly implements producer consumer problem using the

concept of inter thread communication.

2. Solution Design:

Write a class called ProducerThread that extends Thread class and implements the run method by adding in an infinite loop Integer objects into a global stack object. Write a

class called CosumerThread that extends Thread class and implements the run method by popping from a global stack in an infinite loop. Write a class called

ProducerConsumerExample that create the 2 threads, both running infinitely and one

producing for the other to consume at its convenience.

3. Unit Testing Code: Let the producer add a series of elements to the stack and notice that the last item

produced will be the next item consumed if you make the producer and consumer item print what they produce and consume respectively.


Series of Integers 1, 2, 3, 4, …… being produced with a counter.


####################################################################

File: ProducerThread.java

import java.util.*;

public class ProducerThread extends Thread

{

public void run()

{

while(true)

{

Integer lInt = new Integer("30");

ProducerConsumerExample.ourStack.push(lInt);

System.out.println("Produced:");

}

}

}


60

File: ConsumerThread.java

import java.util.*;

public class ConsumerThread extends Thread

{

public void run()

{

while(true)

{

while(ProducerConsumerExample.ourStack.empty())

{

try

{

Thread.sleep(200);

}

catch(Exception e)

{

}

}

System.out.println("The item consumed is: " +

(ProducerConsumerExample.ourStack.pop()).intValue());

}

}

}

File: ProducerConsumerExample.java

import java.util.*;

public class ProducerConsumerExample

{

public static Stack<Integer> ourStack = new Stack<Integer>();


{

Thread prod = new ProducerThread();

prod.start();

Thread consu = new ConsumerThread();


61

consu.start();

}

}

####################################################################

6. Execution: 1. javac ProducerThread.java

2. javac ConsumerThread.java

3. javac ProducerConsumerExample.java

Experiment – 17: Runtime polymorphism Illustration.


Write a Java program that illustrates how run time polymorphism is achieved.

2. Solution Design:

Write a simple class called MyParent which has a default constructor and a public method called displayMessage which display a message indicating the message is coming

from an object of this class. Write another class called MyChild that inherits from

MyParent and overrides displayMessage() method to print a message indicating that the object is of MyChild type. Now write a test class which has a main method in which we

create an ArrayList of MyParent type objects and add to it first an object of MyParent type and then an object of MyChild type. To first see how JAVA’s runtime polymorphism

works, call the displayMessage method on each of the ArrayList objects. Than in another loop use the JAVA Reflection API’s Classes Class, Object, Method to dynamically get the

type of the object in the ArrayList, get a method reference to displayMessage and

invoke the method on the obj in question with an object array with no elements as arguments to this method.

Classes: MyParent, MyChild, RunTimePolymorphismTest

Public Methods: displayMessage() in MyParent and overridden in MyChild, a class that inherits from MyParent.

Member Variables: None


In the main, we are first relying on JAVA’s runtime polymorphism and than doing our own runtime polymorphism and ensuring that the result is the same in both cases.


ArrayList of Base Class Type MyParent populated with at-least 2 objects, one of Base Class Type and the other of Derived Class Type. Java’s internal Runtime

polymorphism and our implementation of polymorphism should yield the same result.


62


File: MyParent.java

public class MyParent

{

public MyParent()

{

}

public void displayMessage()

{

System.out.println("This is an object of parent class");

}

}

File: MyChild.java

public class MyChild extends MyParent

{

public MyChild()

{

super();

}

public void displayMessage()

{

System.out.println("This is an object of child class");

}

}

File: RuntimePolymorphismTest.java

import java.util.*;

import java.lang.reflect.*;

public class RuntimePolymorphismTest

{



63

{

ArrayList<MyParent> lList = new ArrayList<MyParent>();

lList.add(new MyParent());

lList.add(new MyChild());

System.out.println("Let us see a demo of runtime polymorphism

first!");

for(int i=0; i < 2; i++)

{

((MyParent)(lList.get(i))).displayMessage();

}

System.out.println("Manually implemented runtime polymorphism!");

for(int i=0; i < 2; i++)

{

try

{

Object obj = lList.get(i);

// zero orgument method and hence array of 0 elements

Class cls = obj.getClass();

Class[] clsArr = new Class[0];

Object[] objArr = new Object[0];

Method mtd = cls.getMethod("displayMessage",clsArr);

mtd.invoke(obj,objArr);

}

catch(Exception e)

{


}

}

}

}

####################################################################

6. Execution: 1. javac MyParent.java

2. javac MyChild.java


64

3. javac RuntimePolymorphismTest.java

4. java RuntimePolymorphismTest

Java Manual

Documents

java api

java interpreter

java compiler

java programs

java inventors

basic java

term java

path of java installation