2. SYLLABUS
1. Develop Rational number class in Java. Use Java Doc comments for
documentation. Your implementation should use efficient representation
for a rational number, i.e. (500 / 1000) should be represented as (½).
2. Develop Date class in Java similar to the one available in java.util
package. Use Java Doc comments.
3. Implement Lisp-like list in Java. Write basic operations such as 'car',
'cdr', and 'cons'. If L is a list [3, 0, 2, 5], L.car () returns 3, while L.cdr()
returns [0,2,5].
4. Design a Java interface for ADT Stack. Develop two different classes
that implement this interface, one using array and the other using linked-
list. Provide necessary exception handling in both the implementations.
5. Design a Vehicle class hierarchy in Java. Write a test program to
demonstrate polymorphism.
6. Design classes for Currency, Rupee, and Dollar. Write a program that
randomly generates Rupee and Dollar objects and write them into a file
using object serialization. Write another program to read that file, convert
to Rupee if it reads a Dollar, and while leave the value as it is if it reads a
Rupee.
7. Design a scientific calculator using event-driven programming paradigm
of Java.
8. Write a multi-threaded Java program to print all numbers below 100,000
that are both prime and Fibonacci number (some examples are 2, 3, 5,
13, etc.). Design a thread that generates prime numbers below 100,000
and writes them into a pipe. Design another thread that generates
Fibonacci numbers and writes them to another pipe. The main thread
should read both the pipes to identify numbers common to both.
9. Develop a simple OPAC system for library using even-driven and
concurrent programming paradigms of Java. Use JDBC to connect to a
back-end database.
10.Develop multi-threaded echo server and a corresponding GUI client in
Java.
11.[Mini-Project] Develop a programmer's editor in Java that supports
syntax-highlighting, compilation support, debugging support, etc.
2
3. 1. IMPLEMENTATION OF RATIONAL NUMBER
Develop Rational number class in Java. Use JavaDoc comments for
documentation. Your implementation should use efficient representation
for a rational number, i.e. (500 / 1000) should be represented as (½).
ALGORITHM:
STEP 1: Get two inputs from the user through command line arguments.
STEP 2: Store the numerator to variable a and denominator to variable b.
STEP 3: If both a and b are either positive or negative, set the flag as 0.
STEP 4: If either a or b is negative, set flag as 1.
STEP 5: Compare the values of a and b and assign the lowest value to c.
STEP 6: Set the for loop for i=2.
STEP 7: If both a and b values are divisible by i, then perform
(i) a=a/i;
(ii) b=b/i;
(ii) i=1;
STEP 8: Repeat the loop if the value of i is less than c. Break the loop if the
condition fails.
STEP 9: If flag is 1, display the result as negative number; else display it as
positive number.
RationalClass.java
import java.util.*;
/**
*@author Sreekandan.K
*/
public class RationalClass
{
/**
The Numerator part of Rational
*/
private int numerator;
3
4. /**
The Denominator part of Rational
*/
private int denominator;
/**
create and initialize a new Rational object
*/
public RationalClass(int numerator,int denominator)
{
if(denominator==0)
{
throw new RuntimeException("Denominator is zero");
}
int g=gcd(numerator,denominator);
if(g==1)
{
System.out.println("No Common Divisor for Numerator and Denominator");
this.numerator=numerator;
this.denominator=denominator;
}
else
{
this.numerator=numerator/g;
this.denominator=denominator/g;
}
}
/**
return string representation
*/
public String display()
{
return numerator+"/"+denominator;
}
/**
@param m
@param n
@return Greatest common divisor for m and n
*/
private static int gcd(int n,int d)
{
4
5. if(d==0)
return n;
else
return gcd(d,n%d);
}
2. IMPLEMENTATION OF DATE SERVER
Develop Date class in Java similar to the one available in java.util package.
Use Java Doc comments.
ALGORITHM:
STEP 1: Create a package which consists of constructors with the following
arguments:
i) Default
ii)Taking 3 arguments year, day and month
iii)Taking 5 arguments year, day, month, hours and minutes
iv)Taking 6 arguments year, day, month, hour, minutes and seconds
STEP 2: Get the year, month, date, hours, minutes, seconds using the
getYear(), getMonth(), getDate(), getHours(), getMinutes(), getSeconds()
methods.
STEP 3: Set all these details using set methods.
STEP 4: After()-the after() method returns true if the current date comes after
the specified date else it returns false
STEP 5: Before()-the before()method returns true if the current date comes
before the specified date else it returns false
STEP 6: Compare()-the compare() method compares the current date with the
specified date and returns 0 if it is equal,if after it returns 1 and if before it
returns -1.
DateFormatDemo.java
import java.text.*;
import java.util.*;
/**
*Class DateFormatDemo formats the date and time by using java.text package
*
*/
public class DateFormatDemo
{
public static void main(String args[])
{
/**
5
6. * @see java.util package
*/
Date date=new Date();
/**
* @see java.text package
*/
DateFormat df;
System.out.println("Current Date and Time - Available in java.util Package:");
System.out.println("-------------------------------------------------------");
System.out.println(date);
System.out.println();
System.out.println("Formatted Date - Using DateFormat Class from java.text
Package:");
System.out.println("---------------------------------------------------------------");
df=DateFormat.getDateInstance(DateFormat.DEFAULT);
System.out.println("Default Date Format:"+df.format(date));
df=DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println("Date In Short Format:"+df.format(date));
df=DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println("Date In Medium Format:"+df.format(date));
df=DateFormat.getDateInstance(DateFormat.LONG);
System.out.println("Date In Long Format:"+df.format(date));
df=DateFormat.getDateInstance(DateFormat.FULL);
System.out.println("Date In Full Format:"+df.format(date));
System.out.println();
System.out.println("Formatted Time - Using DateFormat Class from java.text
Package:");
System.out.println("---------------------------------------------------------------");
df=DateFormat.getTimeInstance(DateFormat.DEFAULT);
System.out.println("Default Time Format:"+df.format(date));
df=DateFormat.getTimeInstance(DateFormat.SHORT);
System.out.println("Time In Short Format:"+df.format(date));
df=DateFormat.getTimeInstance(DateFormat.MEDIUM);
System.out.println("Time In Medium Format:"+df.format(date));
df=DateFormat.getTimeInstance(DateFormat.LONG);
System.out.println("Time In Long Format:"+df.format(date));
df=DateFormat.getTimeInstance(DateFormat.FULL);
System.out.println("Time In Full Format:"+df.format(date));
System.out.println();
System.out.println("Formatted Date and Time - Using SimpleDateFormat Class
from java.text Package:");
System.out.println("------------------------------------------------------------------------------"
);
/**
* @see java.text package
*/
SimpleDateFormat sdf;
sdf=new SimpleDateFormat("dd MMM yyyy hh:mm:sss:S E w D zzz");
6
8. 3. IMPLEMENTATION OF LISP-LIKE LIST
Implement Lisp-like list in Java. Write basic operations such as 'car', 'cdr',
and 'cons'. If L is a list [3, 0, 2, 5], L.car() returns 3, while L.cdr() returns
[0,2,5].
ALGORITHM
STEP 1: Create a node of a list having data part and link part.
STEP 2: Create a menu having the following choices : insert, car, cdr, adjoin
and display.
STEP 3: Read the choice from the user and call the respective m ethods.
STEP 4: Create another class which implements the same interface to
implement the concept of stack through linked list.
INSERT
STEP 1: Create an object of node and append to the list.
CAR
STEP 1: Return the first node data.
CDR
STEP 1: Return all the node (data part) in the list except the first node.
ADJOIN
STEP 1: Check if the node to be inserted is already present in the list, if not
present append to the list.
LispOperation.java
import java.util.*;
/**
*
*/
class Lisp
{
public Vector car(Vector v)
{
Vector elt=new Vector();
elt.addElement(v.elementAt(0));
return elt;
}
public Vector cdr(Vector v)
{
Vector elt=new Vector();
for(int i=1;i<v.size();i++)
elt.addElement(v.elementAt(i));
return elt;
}
public Vector cons(int x, Vector v)
{
v.insertElementAt(x,0);
return v;
}
}
8
9. 4. IMPLEMENTATION OF STACK
Design a Java interface for ADT Stack. Develop two different classes that
implement this interface, one using array and the other using linked-list.
Provide necessary exception handling in both the implementations.
ALGORITHM
STEP 1: Create an interface which consists of three methods namely PUSH,
POP and DISPLAY
STEP 2: Create a class which implements the above interface to implement the
concept of stack through Array
STEP 3: Define all the methods of the interface to push any element, to pop the
top element and to display the elements present in the stack.
STEP 4: Create another class which implements the same interface to
implement the concept of stack through linked list.
STEP 5: Repeat STEP 4 for the above said class also.
STEP 6: In the main class, get the choice from the user to choose whether array
implementation or linked list implementation of the stack.
STEP 7: Call the methods appropriately according to the choices made by the
user in the previous step.
STEP 8: Repeat step 6 and step 7 until the user stops his/her execution
StackADT.java
import java.io.*;
import java.util.*;
interface stackInterface
{
int n=50;
public void pop();
public void push();
public void display();
}
class stack implements stackInterface
{
int arr[]=new int[n];
int top=-1;
Scanner in=new Scanner(System.in);
public void push()
{
try
{
System.out.println("Enter The Element of Stack");
int elt=in.nextInt();
arr[++top]=elt;
}
catch (Exception e)
{
9
10. System.out.println("e");
}
}
public void pop()
{
int pop=arr[top];
top--;
System.out.println("Popped Element Is:"+pop);
}
public void display()
{
if(top<0)
{
System.out.println("Stack Is Empty");
return;
}
else
{
String str=" ";
for(int i=0;i<=top;i++)
str=str+" "+arr[i];
System.out.println("Stack Elements Are:"+str);
}
}
}
/**
*
*/
10
11. 5. IMPLEMENTATION OF VEHICLE CLASS USING POLYMORPHISM
Design a Vehicle class hierarchy in Java. Write a test program to
demonstrate Polymorphism.
ALGORITHM
STEP 1: Create an abstract class named vehicle with abstract method Display
and a concrete method Input.
STEP 2: Define the input method by prompting the user to enter the values for
name, owner, type, number, engine capacity, seating capacity for the vehicle; all
the inputs taken in the form string.
STEP 3: Extend three classes namely Air, Water and Land from the base class.
STEP 4: Define the method display under the class Air by displaying all the
entered values.
STEP 5: Repeat step 4 for the class Water.
STEP 6: Extend the input method for the class Land by taking in the value of
wheeling capacity for the vehicle in the form of string.
STEP 7: In the main method create a reference for the abstract class and create
a switch case to perform operations on the opted class.
STEP 8: Under each class create a switch case to either enter the data or to
display the transport report.
STEP 9: Repeat the main menu on the user's choice.
STEP 10: Create array of objects under each class and call the methods by
assigning the values of the created objects to the reference object, to show
polymorphism.
VehicleDemo.java
import java.io.*;
class Vehicle
{
String regno;
int model;
Vehicle(String r, int m)
{
regno=r;
model=m;
}
void display()
{
System.out.println("Registration Number:"+regno);
System.out.println("Model Number:"+model);
}
}
class Twowheeler extends Vehicle
{
11
12. int wheel;
Twowheeler(String r,int m,int n)
{
super(r,m);
wheel=n;
}
void display()
{
System.out.println("Vehicle : Two Wheeler");
System.out.println("=====================");
super.display();
System.out.println("Number of Wheels:"+wheel+"n");
}
}
class Threewheeler extends Vehicle
{
int leaf;
Threewheeler(String r,int m,int n)
{
super(r,m);
leaf=n;
}
void display()
{
System.out.println("Vehicle : Three Wheeler");
System.out.println("=======================");
super.display();
System.out.println("Number of Leaf:"+leaf+"n");
}
}
class Fourwheeler extends Vehicle
{
int leaf;
Fourwheeler(String r,int m,int n)
{
super(r,m);
leaf=n;
}
void display()
{
System.out.println("Vehicle : Four Wheeler");
System.out.println("======================");
super.display();
System.out.println("Number of Leaf:"+leaf);
}
}
/**
**/
12
13. 6. IMPLEMENTATION OF CURRENCY CONVERTER
Design classes for Currency, Rupee, and Dollar. Write a program that
randomly generates Rupee and Dollar objects and write them into a file
using object serialization. Write another program to read that file, convert
to Rupee if it reads a Dollar, while leave the value as it is if it reads a
Rupee.
ALGORITHM FOR PROGRAM 1:
STEP 1: Create a class named currency that implements the serializable
interface and also it is the base class for rupee and dollar classes.
STEP 2: Create an object for ObjectOutputStream to open a file in write mode
using FileOutputStream.
STEP 3: Read the user choice to enter rupee or dollar amount.
STEP 4: Generate random numbers as the value of rupee or dollar.
STEP 5: If choice is rupee then, append "Rs" to the value generated, else if
choice is dollar append "$" to the value generated.
STEP 6: Display the appended String and also write it into the file opened using
the writeObject() method.
STEP 7: Close the file.
ALGORITHM FOR PROGRAM 2:
STEP 1: Create a class named currency that implements the serializable
interface and also it is the base class for rupee and dollar classes.
STEP 2: Create an object for ObjectInputStream to open the file created in
program1 in read mode using FileInputStream.
STEP 3: If the file does not exist or if it is empty show exceptions.
STEP 4: While the End of file is not reached, do the following...
(i) If the value read is a dollar convert into rupee and print to the user
otherwise
print the rupee as such.
STEP 5: End the program.
writeObj.java
import java.io.*;
import java.util.*;
abstract class Currency implements Serializable
{
protected double money;
public abstract double getValue();
public abstract String printObj();
public Currency(double money)
{
this.money=money;
}
}
class Dollar extends Currency
13
14. {
public Dollar(int money)
{
super(money);
}
public double getValue()
{
return this.money*51;
}
public String printObj()
{
String object="Object Name : DollarnUSD : $"+this.money+"nINR :
Rs"+getValue()+"n";
return object;
}
}
class Rupee extends Currency
{
public Rupee(int amount)
{
super(amount);
}
public double getValue()
{
return this.money;
}
public String printObj()
{
String object="Object Name : Rupee nINR : Rs "+getValue()+"n";
return object;
}
}
/**
*
*/
14
15. 7. IMPLEMENTATION OF CALCULATOR
Develop a scientific calculator using even-driven programming paradigm
of Java.
ALGORITHM:
STEP 1: Create a panel consisting of Buttons for various scientific operations.
STEP 2: Create Button actions.
STEP 3: Place the panel onto a frame.
STEP 4: Associate each Button click with the corresponding actionlistener.
SimpleCalculator.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.*;
/**
*
*/
public class SimpleCalculator
{
public static void main(String[] args)
{
CalcFrame cf=new CalcFrame();
cf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
cf.setVisible(true);
}
}
class CalcFrame extends JFrame
{
public CalcFrame()
{
setTitle("CALCULATOR");
CalcPanel panel=new CalcPanel();
add(panel);
pack();
}
}
class CalcPanel extends JPanel
{
JButton display;
JPanel panel;
double result;
String lastcmd;
boolean start;
public CalcPanel()
{
15
19. 8. IMPLEMENTATION OF FIBONACCI SERIES USING FRAMES
Write a multi-threaded Java program to print all numbers below 100,000
that are both prime and fibonacci number (some examples are 2, 3, 5, 13,
etc.). Design a thread that generates prime numbers below 100,000 and
writes them into a pipe. Design another thread that generates fibonacci
numbers and writes them to another pipe. The main thread should read
both the pipes to identify numbers common to both.
ALGORITHM:
STEP 1: CreateThread1 which generates prime numbers below 100,000 and
store in pipe1.
STEP 2: Create Thread2 which generates Fibonacci numbers below 100,000
and store in pipe 2.
STEP 3: Write a main program which does the following:
(i) Call the two threads created in step1 and step2.
(ii) Read the data from pipe1 and pipe 2 and print the numbers
common to both.
MultiThreadDemo.java
import java.util.*;
import java.io.*;
class Fibonacci extends Thread
{
private PipedWriter out=new PipedWriter();
public PipedWriter getPipedWriter()
{
return out;
}
public void run()
{
Thread t=Thread.currentThread();
t.setName("Fibonacci");
System.out.println(t.getName()+" Thread started...");
int fibo=0,fibo1=0,fibo2=1;
while(true)
{
try
{
fibo=fibo1+fibo2;
if(fibo>100000)
{
out.close();
break;
}
out.write(fibo);
sleep(1000);
19
22. 8. IMPLEMENTATION OF FIBONACCI SERIES USING FRAMES
Develop a simple OPAC system for library using event-driven and
concurrent programming paradigms of Java. Use JDBC to connect to a
back-end database.
ALGORITHM:
STEP 1: Create a Master Database1(Book Details) having the following fields:
BookNo.Book Name, Author, No. of pages, Name of Publisher, Cost.
STEP 2: Create a Master Database2(User Details) having the following fields :
UserID, Department
STEP 3: Create a Transaction Database having the following fields: UserID,
Book No., Date of Renewal / Date of Return, Fine
STEP 4: Create a panel consisting of buttons ADD, UPDATE, DELETE.
Associate these button actions with listeners(with Master Database 1)
STEP 5: Create a panel consisting of buttons ADD, UPDATE, DELETE.
Associate these button actions with listeners(with Master Database 2)
STEP 6: Create another panel consisting of buttons UserID, BookID,
Return/Renewal,Fine.
STEP 7: Associate these buttons with listeners(with Transaction Database).
OpacSystem.java
import java.sql.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
/**
*
*/
public class OpacSystem implements ActionListener
{
JRadioButton author=new JRadioButton("Search By Author");
JRadioButton book=new JRadioButton("Search by Book");
JTextField txt=new JTextField(30);
JLabel label=new JLabel("Enter Search Key");
JButton search=new JButton("SEARCH");
JFrame frame=new JFrame();
JTable table;
DefaultTableModel model;
String query="select*from opacTab";
public OpacSystem()
{
frame.setTitle("OPAC SYSTEM");
frame.setSize(800,500);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(new BorderLayout());
22
24. con.close();
}
catch(Exception e)
{
System.out.println("Exception:"+e);
}
}
public void actionPerformed(ActionEvent ae)
{
if(author.isSelected())
query="select*from opacTab where AUTHOR like '"+txt.getText()+"%'";
if(book.isSelected())
query="select*from opacTab where BOOK like '"+txt.getText()+"%'";
while(model.getRowCount()>0)
model.removeRow(0);
frame.remove(table);
addTable(query);
}
24
25. 10. IMPLEMENTATION OF MULTITHREADED
ECHO SERVER & ECHO CLIENT
Develop multi-threaded echo server and a corresponding GUI client in
Java.
ALGORITHM FOR SERVER:
STEP 1: Establish the connection of socket.
STEP 2: Assign the local Protocol address to the socket.
STEP 3: Move the socket from closed to listener state and provide maximum no.
of Connections.
STEP 4: Create a new socket connection using client address.
STEP 5: Read the data from the socket.
STEP 6: Write the data into socket.
STEP 7: Close the socket.
EchoServer.java
import java.io.*;
import java.net.*;
/**
*
*/
public class EchoServer
{
public static void main(String [] args)
{
System.out.println("Server Started....");
try
{
ServerSocket ss=new ServerSocket(300);
while(true)
{
Socket s= ss.accept();
Thread t = new ThreadedServer(s);
t.start();
}
}
catch(Exception e)
{
System.out.println("Error: " + e);
}
}
}
class ThreadedServer extends Thread
{
Socket soc;
public ThreadedServer(Socket soc)
25
26. {
this.soc=soc;
}
public void run()
{
try
{
BufferedReader in=new BufferedReader(new
InputStreamReader(soc.getInputStream()));
PrintWriter out=new PrintWriter(soc.getOutputStream());
String str=in.readLine();
System.out.println("Message From Client:"+str);
out.flush();
out.println("Message To Client:"+str);
out.flush();
}
catch(Exception e)
{
System.out.println("Exception:"+e);
}
}
}
ALGORITHM FOR CLIENT:
STEP 1: Open the socket.
STEP 2: Get the host name and port number from client.
STEP 3: Write a request to the buffer that contain the request number as a byte
to the
output stream.
STEP 4: Get the message from the user.
STEP 5: Write to the socket.
STEP 6: Set the write operation for success.
STEP 7: Read the contents from the socket / Buffer.
STEP 8: Close the socket.
EchoClient.java
import java.net.*;
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
*
*/
class EchoClient extends JFrame
{
26
29. 11. MINI PROJECT
Develop a programmer's editor in Java that supports syntax high lighting,
compilation support, debugging support, etc.
ALGORITHM:
STEP 1: Create a panel consisting of menu bar containing File, Edit, Compile
and Debug.
STEP 2: Add submenus for each of the menu.
File – New, Open, Save, Quit.
Edit – Cut, Copy, Paste.
Compile – Compile, Link
Debug – Inspect, Call Stack, Watches, BreakPoints.
STEP 3: Associate these event sources with Listeners.
29