Pages

▼

Tuesday, 8 September 2015

Java Programs for MCA

1.  A) Write a JAVA Program to demonstrate Constructor Overloading and Method overloading.

class  box
{
     double  width,height,depth,length,breadth;

     box()
     {     }
  
     box(double   w,double  h,double  d)
     {
           width = w;   height  = h;   depth = d;
     }
   
     box(double  len)
     {
          width = height = depth = len;
     }
       
     void  rect(double  x,double y)
     {
           length = x;   breadth = y;
      }

     void rect(double  x)
     {
          length = breadth = x;
      }

     double  volume()
     {
         return(width * height * depth);
     }

     double   area()
     {  
          return(length * breadth);                
     }
}

class   lab01a
{
     public  static  void  main(String  args[])
     {
          box  mybox1 = new  box(10,20,15);
          box  mybox2 = new  box(5);
        
          box  rect1     = new  box();
          box  rect2     = new  box();
        
          rect1.rect(10,20);
          rect2.rect(8);
        
          double   areaR, vol;

          vol = mybox1.volume();
          System.out.println("Volume of mybox1 = " +vol);

          vol = mybox2.volume();
          System.out.println("Volume of mybox2 = " +vol);

          areaR = rect1.area();
          System.out.println("Area of rect1= " +areaR);

          areaR = rect2.area();
          System.out.println("Area of rect1 = " +areaR);
     }
}

Output:

C:\New Folder>java lab01a
Volume of mybox1 = 3000.0
Volume of mybox2 = 125.0
Area of rect1= 200.0
Area of rect1 = 64.0

            Two or more methods within the same class that share the same name, as long as their parameter declarations are different are called method overloading. box () is a constructor is called three times with different parameters and rect() is a method, which is called two times with different parameters.

1 B) Write a JAVA Program to implement Inner class and demonstrate its Access Protections.

 class  outer
{
     int  outdata = 10;
    
     void  display()
     {
          inner  inobj = new  inner();
          System.out.println("Accessing from outer class");
          System.out.println("The value of outdata is " +outdata);
          System.out.println("The value of indata is "   +inobj.indata);
     }
   
     class  inner
      {
          int  indata = 20;
          void  inmethod()
          {
               System.out.println("Accessing from inner class");
               System.out.println("The sum of indata & outdata is " +(outdata + indata));
          }
     }
}

class  lab01b
{
     public  static  void  main(String  args[])
     {
          outer  outobj  = new  outer();
          outobj.display();
          outer.inner  inobj1 = outobj.new  inner();
          inobj1.inmethod();
     }
}

Output:

C:\New Folder>java lab01b
Accessing from outer class
The value of outdata is 10
The value of indata is 20

Accessing from inner class
The sum of indata & outdata is 30

        An inner class is a non-static nested class. It has access to all of the variables and methods of its outer class. An instance of Inner can be created only within the scope of class Outer. The Java compiler generates an error message if any code outside of class Outer attempts to instantiate class Inner.

2 A) Write a JAVA Program to implement Inheritance.
class  A
{
     int  i = 10;
     protected  int  j = 20;

     void  showij()
     {
          System.out.println("i = " +i);
          System.out.println("j = " +j);
     }
}
class   B  extends  A
{
     int  k = 30;

     void showk()
     {
          System.out.println("k = " +k);
     }
     void  sum()
     {
          System.out.println("i + j + k = " +(i+j+k));
     }
}

class  lab02a
{
     public  static  void  main(String  args[])
     {
          B  subobj = new  B();
        
          System.out.println("Contents of Super class accessed using sub class object");       
          subobj.showij();
        
          System.out.println("Contents of Supter class accessed using sub class object");       
          subobj.showk();
        
          System.out.println("Sum of i, j, & k accessed using sub class object");       
          subobj.sum();
     }
}

Output:

C:\New Folder>java lab02a
Contents of Super class accessed using sub class object
i = 10
j = 20
Contents of Super class accessed using sub class object
k = 30
Sum of i, j, & k accessed using sub class object
i + j + k = 60

            The subclass B includes all of the members of its superclass, A. This is why subOb can access i and j and call showij( ). Also, inside sum( ), i and j can be referred to directly, as if they were part of B. Even though A is a superclass for B, it is also a completely independent, stand-alone class. Being a superclass for a subclass does not mean that the superclass cannot be used by itself.

2 B) Write a JAVA Program to implement Exception Handling (Using Nested try catch and finally).

class Nesttry
            { public static void main(String args[])
                        { try
                                    { int a = args.length;
                                      int b = 42 / a;
                                  System.out.println("a" + "= " + a);

                        try
                                    { if(a==1) a = a / (a-a);
                                                if(a==2)
                                                {
                                                            int c[] = {1}; c[42] = 99;
                                                }
                                     }
                    catch(ArrayIndexOutOfBoundsException e)
                        {
                                    System.out.println("array out of bounds" + e) ;
                        }
                        finally
                        {
                                    System.out.println("inside first try");
                        }
            }
            catch(ArithmeticException e)
            {
                        System.out.println("Arithmetic Exp" + e);
            }
             finally
            {                      System.out.println("Inside 2nd try");
            }
   }
}




Output:

C:\New Folder>java Nesttry
Arithmetic Expjava.lang.ArithmeticException: / by zero
Inside 2nd try

C:\New Folder>java Nesttry 1 3
a= 2
array out of boundsjava.lang.ArrayIndexOutOfBoundsException: 42
inside first try
Inside 2nd try

            A Java exception is an object that describes an exceptional (that is, error) condition that has occurred in a piece of code. When an exceptional condition arises, an object representing that exception is created and thrown in the method that caused the error. That method may choose to handle the exception itself, or pass it on. Either way, at some point, the exception is caught and processed. Exceptions can be generated by the Java run-time system, or they can be manually generated by your code. This   program will generate Divide by zero and ArrayIndexOutOfBoundsException.

3. I) Write a Java program which has a class called Account that creates account with 500 Rs minimum balance, a deposit () method to deposit amount, a withdraw () method to withdraw amount and also throws LessBalancEexception if an account holder tries withdraw money which makes the balance become less than 500Rs.
   ii) A class called LessBalanceException which returns the statement that says (_Rs) is not valid.
  iii) A class which creates two accounts, both account deposit money and one account tries to withdraw more money which generates a LessBalanceException take appropriate action for the same.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class LessBalanceException extends Exception
{
            double wid;
            LessBalanceException(Double withdraw)
             {
            wid = withdraw;
            }
             public String toString()
            {
            return "Rs. "+wid+" U Cannot with draw, Balance should not less than 500";
             }
}

class Account
{
            double currBal=500;
             void Deposit () throws IOException
            {
                        BufferedReader br= new BufferedReader (new InputStreamReader (System. in));
                        System.out.println ("Enter deposit amount: ");
                        double dep = Double.parseDouble (br.readLine ());
                        if (dep < 100)
                        {
                                    System.out.println (" Deposit Amount should be atleast 100 ");
                                     return;
                         }
                         currBal+=dep;
                         System.out.println ("Amount RS.”+dep+" Deposited... ");
             }

             void CurrBalance()
            {
                         System.out.print("Current Balance : "+currBal);
             }

            void Withdraw() throws LessBalanceException,IOException
            {
                        BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
                        System.out.print("Enter Withdrawal amount : ");
                         double with = Double.parseDouble(br.readLine());          
                         if(with < 100)
                         {
                                    System.out.println(" Withdrawal Amount should b atleast 100 ");
                                     return;
                        }
                        if(currBal - with < 500)    throw new LessBalanceException(with);
                        else
                        {
                                     currBal-=with;
                                    System.out.println("Amount RS. "+with+" withdrawed... ");                                                                                                          
                        }
             }
}
public class Person
{
             public static void main(String args[]) throws IOException,LessBalanceException
            {
                         Account a1 = new Account();
                         Account a2 = new Account();
                         int ch=1,num;

                         while(true)
                        {

                                    BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
                                     System.out.println("Which Account [1,2] And Other num to exit");
                                    num=Integer.parseInt(br.readLine());
 
                                     if(num == 3)
                                     break;
                                     switch(num)
                                    {
                                                case 1: while(true)
                                                {
                                                               System.out.println(" Enter the choice  \n 1: Deposit  \n 2:                                                                 Withdraw  \n 3: Current Balance \n Others: Main menu");
                                                               ch=Integer.parseInt(br.readLine());
                                                                switch(ch)
                                                               {
                                                                         case 1: a1.Deposit();
                                                                                     continue;
                                                          
                                                                         case 2: try
                                                                                    {
                                                                                     a1.Withdraw();
                                                                                    }
                                                                                    catch(LessBalanceException e)
                                                                                    {
                                                                                     System.out.println("Error : "+e+"\n");
                                                                                      }      
                                                                                     continue;
                                                            
                                                                         case 3: System.out.println(" Current Balance :                                                                                               "+a1.currBal+"\n");
                                                                                     continue;                  
                                  
                                                                        default: break;           
                                                               }
                                                               break;
                                                  }
                                                break;
                          
                                  
                                    case 2: while(true)
                                    {
                                                  System.out.println(" Enter the choice  \n 1: Deposit  \n 2:                                                                 Withdraw  \n 3: Current Balance \n Others: Main Menu");
                                                   ch=Integer.parseInt(br.readLine());
                                                   switch(ch)
                                                 {
                                                             case 1: a2.Deposit();
                                                                        continue;
                                                          
                                                             case 2: try
                                                                        {
                                                                                      a1.Withdraw();
                                                                        }
                                                                        catch(LessBalanceException e)
                                                                        {
                                                                                    System.out.println("Error : "+e+"\n");
                                                                          }      
                                                                          continue;
                                                            
                                                             case 3: System.out.println(" Current Balance :                                                                                              "+a2.currBal+"\n");
                                                                          continue;                 
                                  
                                                            default: break;           
                                                 }
                                                break;
                                     }
                                          break;
                                    
                                      default: break;
                        }
                      
             }
}

Output:
C:\New Folder>java Person
Which Account [1,2] And Other num to exit
1
 Enter the choice
 1: Deposit
 2: Withdraw
 3: Current Balance
 Others: Main Menu
1
Enter deposit amount : 1000
Amount RS. 1000.0 Deposited...
 Enter the choice
 1: Deposit
 2: Withdraw
 3: Current Balance
 Others: Main Menu
3
 Current Balance : 1500.0

 Enter the choice
 1: Deposit
 2: Withdraw
 3: Current Balance
 Others: Main Menu
2
Enter Withdrawal amount : 1200
Error : Rs. 1200.0 U Cannot with draw, Balance should not less than 500

 Enter the choice
 1: Deposit
 2: Withdraw
 3: Current Balance
 Others: Main Menu
3
 Current Balance : 1500.0

 Enter the choice
 1: Deposit
 2: Withdraw
 3: Current Balance
 Others: Main Menu
4
Which Account [1,2] And Other num to exit
3
            We create our own customized exception as per requirements of the application. Though Java provides an extensive set of in-built exceptions, there are cases in which we may need to define our own exceptions in order to handle the various application specific errors that we might encounter.
While defining an user defined exception, we need to take care of the following aspects:
The user defined exception class should extend from Exception class.
The toString () method should be overridden in the user defined exception class in order to display meaningful information about the exception.






4. Write a Java program using Synchronized Threads, Which demonstrates Producer Consumer concepts.
class Q
{
            int n;
            boolean valueSet = false;
            synchronized int get()
            {
                        while(!valueSet)
            try
             {
                        wait();
            }
            catch(InterruptedException e)
            {
                        System.out.println("InterruptedException caught");
            }
                        System.out.println("Got: " + n);
                        valueSet = false;
                        notify();
                        return n;
            }
                        synchronized void put(int n)
            {
                        while(valueSet)
                        try
                        {
                                    wait();
                        }
                        catch (Interrupted Exception e)
                        {
                                    System.out.println("InterruptedException caught");
                        }
                                    this.n = n;
                                    valueSet = true;
                                    System.out.println("Put: " + n);
                                    notify();
                        }
            }
            class Producer implements Runnable
            {
            Q q;
            Producer (Q q)
            {
                        this.q = q;
                        new Thread(this, "Producer").start();
            }
            public void run ()
            {
                        int i = 0;
                        while(true) {
                        q.put(i++);
            }
     }
}
            class Consumer implements Runnable
            {
            Q q;
            Consumer(Q q)
            {
                        this.q = q;
                        new Thread(this, "Consumer").start();
            }
                        public void run()
            {
                        while(true)
                        {
                                    q.get();
                        }
            }
      }
            class PCFixed
            {
            public static void main(String args[])
            {
                        Q q = new Q();
                        new Producer(q);
                        new Consumer(q);
                        System.out.println("Press Control-C to stop.");
            }
      }

Output: Got: 296
Put: 297
Got: 297
Put: 298
Got: 298
Put: 299
Got: 299
Put: 300
Got: 300
Put: 301
Got: 301
Put: 302
Got: 302

5. Write a JAVA program which has
i.  A Interface class for Stack Operations
ii. A Class that implements the Stack Interface and creates a fixed length Stack.
iii. A Class that implements the Stack Interface and creates a Dynamic length Stack.
iv. A Class that uses both the above Stacks through Interface reference and does the Stack operations that demonstrates the runtime binding.

// Define an integer stack interface.
interface IntStack
{
            void push(int item); // store an item
            int pop(); // retrieve an item
}
// An implementation of IntStack that uses fixed storage.
class FixedStack implements IntStack
 {
            private int stck[];
            private int tos;
            // allocate and initialize stack
            FixedStack(int size) {
            stck = new int[size];
            tos = -1;
}
// Push an item onto the stack
public void push(int item)
{
            if(tos==stck.length-1) // use length member
                        System.out.println("Stack is full.");
            else
                        stck[++tos] = item;
}
// Pop an item from the stack
public int pop()
{
            if(tos < 0)
            {
                        System.out.println("Stack underflow.");
            return 0;
          
            }
            else
                        return stck[tos--];
}
}
// Implement a "growable" stack.
class DynStack implements IntStack
{
            private int stck[];
            private int tos;
            // allocate and initialize stack
            DynStack(int size)
            {
                        stck = new int[size];
                        tos = -1;
            }
// Push an item onto the stack
public void push(int item)
{
            // if stack is full, allocate a larger stack
            (tos==stck.length-1)
             {
                        int temp[] = new int[stck.length * 2]; // double size
                        for(int i=0; i<stck.length; i++) temp[i] = stck[i];
                        stck = temp;
                        stck[++tos] = item;
            }
            else
                        stck[++tos] = item;
}
// Pop an item from the stack
public int pop()
{
            if(tos < 0)
            {
                        System.out.println("Stack underflow.");
                        return 0;
            }
            else
            return stck[tos--];
}
}
/* Create an interface variable and access stacks through it. */
class IFTest3
{
public static void main(String args[])
{
            IntStack mystack; // create an interface reference variable
            DynStack ds = new DynStack(5);
            FixedStack fs = new FixedStack(8);
            mystack = ds; // load dynamic stack
            // push some numbers onto the stack
            for(int i=0; i<12; i++)
                        mystack.push(i);
            mystack = fs; // load fixed stack
            for(int i=0; i<8; i++)
                        mystack.push(i);
                        mystack = ds;
            System.out.println("Values in dynamic stack:");
            for(int i=0; i<12; i++)
                        System.out.println(mystack.pop());
                        mystack = fs;
            System.out.println("Values in fixed stack:");
            for(int i=0; i<8; i++)
                        System.out.println(mystack.pop());
   }
}

Output:
C:\New Folder>java IFTest3
Values in dynamic stack:
11
10
9
8
7
6
5
4
3
2
1
0
Values in fixed stack:
7
6
5
4
3
2
1
0

            The above program creates a stack, pushes several Integer objects onto it, and then pops them off.




6. Write a JAVA program which has
i.  2 classes which initializes a String in its constructor
ii. A Generic class with 2 type Parameters
iii. Create a Generic Class reference for the above 2 Class and try to print the message inside the constructor (Use to string method).
// A simple generic class with two type  parameters: T and V.
class TwoGen<T, V>
             {
                        T ob1;
                        V ob2;
                        // Pass the constructor a reference to
                        // an object of type T and an object of type V.
                        TwoGen(T o1, V o2)
                        {
                                    ob1 = o1;
                                    ob2 = o2;
                        }

                        // Show types of T and V.
                        void showTypes()
                        {
                                    System.out.println("Type of T is " + ob1.getClass().getName());
                                    System.out.println("Type of V is " + ob2.getClass().getName());
                        }
                        T getob1()
                        {        
                                    return ob1;
                        }

                        V getob2()
                        {
                                    return ob2;
                        }
            }
            // Demonstrate TwoGen.

                        class simpGen
                        {
                                    public static void main(String args[])
                                    {
                                                TwoGen<Integer, String> tgObj = new TwoGen<Integer,                                                               String>(24, "Java");
                                                TwoGen<Integer, String> tgObj1 = new TwoGen<Integer,                                                                         String>(24, "Generics class");
                                                // Show the types.
                                                tgObj.showTypes();
                                                // Obtain and show values.
                                                int  v = tgObj.getob1();
                                                System.out.println("value: " + v);
                                                String str = tgObj.getob2();
                                                System.out.println("value: " + str);

                                                int  x = tgObj1.getob1();
                                                System.out.println("value: " + x);
                                                String str1 = tgObj1.getob2();
                                                System.out.println("value: " + str1);
                                    }
                        }
OutPut:
C:\New Folder>java simpGen
Type of T is java.lang.Integer
Type of V is java.lang.String
value: 24
value: Java
value: 24
value: Generics class
            The term generic means parameterized types. Using generics, it is possible to create a single class, for example, that automatically works with different types of data. A class, interface, or method that operates on a parameterized type is called generic, as in generic class or generic method. When declaring an instance of a generic type, the type argument passed to the type parameter must be a class type. You cannot use a primitive type, such as int or char.

7. Write JAVA programs which demonstrate utilities of Linked List Class.

// Demonstrate Linked List.
import java.util.*;

class LinkedListDemo
{
public static void main (String args[])
            {
            // Create a linked list.
            Linked List<String> ll = new LinkedList<String>();
            // Add elements to the linked list.
            ll.add ("F");
            ll.add ("B");
            ll.add ("D");
            ll.add ("E");
            ll.add ("C");
            ll.addLast ("Z");
            ll.addFirst ("A");
            ll.add (1, "A2");
            System.out.println ("Original contents of ll: " + ll);
            // Remove elements from the linked list.
            ll.remove ("F");
            ll.remove (2);
            System.out.println ("Contents of ll after deletion: "+ ll);
            // Remove first and last elements.
            ll.removeFirst ();
            ll.removeLast ();
            System.out.println ("ll after deleting first and last: "+ ll);
            // Get and set a value. String val = ll.get (2);
            ll.set (2, val + “Changed");
            System.out.println ("ll after change: " + ll);
            }
}

Output :
Original contents of ll: [A, A2, F, B, D, E, C, Z]
Contents of ll after deletion: [A, A2, D, E, C, Z]
ll after deleting first and last: [A2, D, E, C]
ll after change: [A2, D, E Changed, C]




8. Write JAVA programs which uses FileInputStream/FileOutputStream Classes.

A) FileinputStream

/*FileInStreamDemo.java*/
import java.io.*;
public class FileInStreamDemo
{
            public static void main(String[] args)
            {
                        // create file object
                        File file = new File("DevFile.txt");
                        int ch;
                        StringBuffer strContent = new StringBuffer("");
                        FileInputStream fin = null;
                        try
                        {
                                    fin = new FileInputStream(file);
                                    while ((ch = fin.read()) != -1)
                                    strContent.append((char) ch);
                                    fin.close();
                        }
                        catch (FileNotFoundException e)
                        {
                                    System.out.println("File " + file.getAbsolutePath() + " could not be found                                      on filesystem");
                        }
                        catch (IOException ioe)
                        {
                                    System.out.println("Exception while reading the file" + ioe);
                        }
                        System.out.println("File contents :");
                        System.out.println(strContent);
            }
}

Output:
C:\New Folder>java FileInStreamDemo
File contents :
The text shown here will write to a file after run
                        The FileInputStream class is a subclass of InputStream. An InputStream is a reference to source of data (be it a file, network connection etc).The FileInputStream class allows you to read binary data sequentially from a file. The FileInputStream class's constructors allow you to pass either a File object or a path to a file.

B)FileoutputStream

/* Example of FileOutputStream */
import java.io.*;
public class FileOutStreamDemo
{
            public static void main(String[] args)
            {
                        FileOutputStream out; // declare a file output object
                        PrintStream p; // declare a print stream object
                        try
                        {
                                    // Create a new file output stream connected to "DevFile.txt"
                                    out = new FileOutputStream("DevFile.txt");
                                    // Connect print stream to the output stream
                                    p = new PrintStream(out);
                                    p.println("The text shown here will write to a file after run");
                                    System.out.println("The Text is written to DevFile.txt");
                                    p.close();
                        }
                        catch (Exception e)
                         {
                        System.err.println("Error writing to file");
                        }
            }
}

Output:
C:\New Folder>java FileOutStreamDemo
The Text is written to DevFile.txt

9. Write a JAVA Program which writes a object to a file (use transient variable also).
import java.util.Vector;
import java.io.*;
public class SerializationTest
{
            static long start,end;
            OutputStream out = null;
            OutputStream outBuffer = null;
            ObjectOutputStream objectOut = null;
            public Person getObject()
            {
                        Person p = new Person("SID","austin");
                        Vector v = new Vector();
                        for(int i=0;i<7000;i++)
                        {
                                    v.addElement("StringObject:" +i);
                        }
                        p.setData(v);
                        return p;
            }
            public static void main(String[] args)
            {
                        SerializationTest st = new SerializationTest();
                        start = System.currentTimeMillis();
                        st.writeObject();
                        end = System.currentTimeMillis();
                        System.out.println("Time taken for writing :"+ (end-start) + "milli seconds");
            }
            public void writeObject()
            {
            try
            {
                        out = new FileOutputStream("c:/temp/test.txt");
                        outBuffer = new BufferedOutputStream(out);
                        objectOut = new ObjectOutputStream(outBuffer);
                        objectOut.writeObject(getObject());
            }
            catch(Exception e){e.printStackTrace();}
            finally
            {
                        if(objectOut != null)
                        try
                        {
                                    objectOut.close();}catch(IOException e){e.printStackTrace();
                        }
            }
            }
}
class Person implements java.io.Serializable
{
            private String name;
            private transient Vector data;
            private String address;
            public Person(String name,String address)
            {
                        this.name = name;
                        this.address = address;
            }
            public String getAddress()
            {
                        return address;
            }
            public Vector getData()
            {
                        return data;
            }
            public String getName()
            {
                        return name;
            }
            public void setData(Vector data)
            {
                        this.data = data;
            }
}

Serilization is the process of making the object's state persistent. That means the state of the object is converted into stream of bytes and stored in a file. In the same way we can use the de-serilization concept to bring back the object's state from bytes. This is one of the important concept in Java programming because this serilization is mostly used in the networking programming. The object's which are needs to be transmitted through network has to be converted as bytes, for that purpose ever class or interface must implements Serilization interface.
                By default all the variables in the object is converted into the persistent. In some cases, you may want to avoid persisting some variables because you don't have the necesscity to persist those varibale. So, you can declare those variables as transient. if the variable is declared as transient, then it will not be persisted. It is the main purpose of the transient keyword. transient keyword indicates the following :
Ø  The transient keyword is applicable to the member variables of a class.
Ø  The transient keyword is used to indicate that the member variable should not be serialized when the class instance containing that transient variable  is needed to be serialized.

When an instance variable is declared as transient, then its value need not persist when an object is stored. For example:
class T {
transient int a; // will not persist
int b; // will persist
}
The volatile modifier tells the compiler that the variable modified by volatile can be changed unexpectedly by other parts of your program. One of these situations involves multithreaded programs.
volatile variable does not have a copy maintained in the local memory of the thread (on the stack). All changes to the volatile variable (caused by multiple threads) are flushed out to the heap memory (visible from all threads). Hence volatile variable values remain consistent for all threads.
On the other hand, for other instance variables, each java thread maintains a local copy on the stack. Multiple threads may modify this local copy of the instance variable and hence inconsistent values may be visible for multiple threads.             
              

10. Write JAVA programs which uses Datagram Socket for Client Server Communication.

// demonstrate datagrams.
import java.net.*;
class WriteServer
 {
            public static int serverPort = 998;
            public static int clientPort = 999;
            public static int buffer_size = 1024;
                        public static DatagramSocket ds;
            public static byte buffer[] = new byte[buffer_size];
            public static void TheServer() throws Exception
            {
                        int pos=0;
                        while (true)
                        {
                                    int c = System.in.read();
                                    switch (c)
                                    {
                                                case -1:
                                                            System.out.println("Server Quits.");
                                                            return;
                                                case '\r':
                                                            break;
                                                case '\n':
                                                            ds.send(new DatagramPacket(buffer,pos,
                                                            InetAddress.getLocalHost(),clientPort));
                                                            pos=0;
                                                            break;
                                                default:
                                                            buffer[pos++] = (byte) c;
                                    }
            }
            }
            public static void TheClient() throws Exception
             {
                        while(true)
                        {
                                    DatagramPacket p = new DatagramPacket(buffer, buffer.length);
                                    ds.receive(p);
                                    System.out.println(new String(p.getData(), 0, p.getLength()));
                        }
            }
            public static void main(String args[]) throws Exception
             {
                        if(args.length == 1)
                        {
                                    ds = new DatagramSocket(serverPort);
                                    TheServer();
                        }
                        else
                        {
                                    ds = new DatagramSocket(clientPort);
                                    TheClient();
                        }
            }
  }

Output:
            TCP/IP-style networking is appropriate for most networking needs. It provides a serialized,predictable, reliable stream of packet data. This is not without its cost, however. TCP includes many complicated algorithms for dealing with congestion control on crowded networks, as well as pessimistic expectations about packet loss. This leads to a somewhat inefficient way to transport data. Datagrams provide an alternative.
            Datagrams are bundles of information passed between machines. They are somewhat like a hard throw from a well-trained but blindfolded catcher to the third baseman. Once the datagram has been released to its intended target, there is no assurance that it will arrive or even that someone will be there to catch it. Likewise, when the datagram is received, there is no assurance that it hasn’t been damaged in transit or that whoever sent it is still there to receive a response. Java implements datagrams on top of the UDP protocol by using two classes: the DatagramPacket object is the data container, while the DatagramSocket is the mechanism used to send or receive the DatagramPackets.


11. Write  JAVA programs which handles MouseEvent

// Demonstrate the mouse event handlers.
import java.awt.*; import java.awt.event.*;
import java.applet.*;

/*
<applet code="MouseEvents" width=300 height=100>
</applet>
*/
public class MouseEvents extends Applet
implements MouseListener, MouseMotionListener
            {
            String msg = "";
            int mouseX = 0, mouseY = 0; // coordinates of mouse
            public void init() {
            addMouseListener(this);
            addMouseMotionListener(this);
            }
// Handle mouse clicked.
public void mouseClicked(MouseEvent me)
{
            // save coordinates
            mouseX = 0;
            mouseY = 10;
            msg = "Mouse clicked.";
            repaint();
}
// Handle mouse entered.
public void mouseEntered(MouseEvent me)
{
            // save coordinates
            mouseX = 0;
            mouseY = 10;
            msg = "Mouse entered.";
            repaint();
}
// Handle mouse exited.
public void mouseExited(MouseEvent me)
{
            // save coordinates
            mouseX = 0;
            mouseY = 10;
            msg = "Mouse exited.";
            repaint();
}
// Handle button pressed.
public void mousePressed(MouseEvent me)
{
            // save coordinates
            mouseX = me.getX();
            mouseY = me.getY();
            msg = "Down";
            repaint();
}
// Handle button released.
public void mouseReleased(MouseEvent me)
{
            // save coordinates
            mouseX = me.getX();
            mouseY = me.getY();
            msg = "Up";
            repaint();
}
// Handle mouse dragged.
public void mouseDragged(MouseEvent me)
{
            // save coordinates
            mouseX = me.getX();
            mouseY = me.getY();
            msg = "*";
            showStatus("Dragging mouse at " + mouseX + ", " + mouseY);
            repaint();
}
// Handle mouse moved.
public void mouseMoved(MouseEvent me)
{
            // show status
            showStatus("Moving mouse at " + me.getX() + ", " + me.getY());
}
// Display msg in applet window at current X,Y location.
public void paint(Graphics g)
{
            g.drawString(msg, mouseX, mouseY);
 }
}

12. Write JAVA programs which handles keyboardEvent

// Demonstrate the key event handlers.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

/*
<applet code="SimpleKey" width=300 height=100>
</applet>
*/
public class SimpleKey extends Applet implements KeyListener
             {
                        String msg = "";
                        int X = 10, Y = 20; // output coordinates
                        public void init() {
                        addKeyListener(this);
            }
public void keyPressed(KeyEvent ke)
            {
                        showStatus("Key Down");
            }
public void keyReleased(KeyEvent ke)
            {
                        showStatus("Key Up");
            }
public void keyTyped(KeyEvent ke)
            {
                        msg += ke.getKeyChar();
                        repaint();
            }
// Display keystrokes.
public void paint(Graphics g)
            {
                        g.drawString(msg, X, Y);
            }
}

13. Write JAVA programs which implements RMI.

//addserverintf.java

import  java.rmi.*;
public  interface  addserverintf  extends  Remote
{
      double  add(double  d1,double  d2)  throws  RemoteException;
}

//addserverimpl.java

import  java.rmi.*;
import  java.rmi.server.*;
public
class  addserverimpl  extends UnicastRemoteObject  implements addserverintf
{
      public  addserverimpl()  throws  RemoteException
      {
       }
      public  double  add(double  d1,double  d2)  throws  RemoteException
      {
            return  (d1+d2);
      }
}

//addserver.java

import  java.net.*;
import  java.rmi.*;
public  class  addserver
{
      public  static  void main(String  args[])
      {
            try
            {
                  addserverimpl  addsi = new  addserverimpl();
                  Naming.rebind("addserver", addsi);
             }
            catch(Exception  e)
            {
                  System.out.println("Exception  :  " +e);
            }
      }
}

//addclient.java

import  java.rmi.*;
public  class  addclient
{
      public  static  void  main(String  args[])
      {
            try
            {
                  String  addserverURL = "rmi://" +args[0]+ "/addserver";
                  addserverintf  addsi = (addserverintf) Naming.lookup(addserverURL);
                  System.out.println("the first number is " +args[1]);
                  double  d1 = Double.valueOf(args[1]).doubleValue();
                  System.out.println("the second number is " +args[2]);
                  double  d2 = Double.valueOf(args[2]).doubleValue();
                  System.out.println("The  sum  is " +addsi.add(d1,d2));
            }
            catch(Exception  e)
            {
                  System.out.println("Exception  : " +e);
            }
      }
}
            The first file, AddServerIntf.java, defines the remote interface that is provided by the server. It contains one method that accepts two double arguments and returns their sum. All remote interfaces must extend the Remote interface, which is part of java.rmi. Remote defines no members. Its purpose is simply to indicate that an interface uses remote methods. All remote methods can throw a RemoteException.
             The second source file, AddServerImpl.java, implements the remote interface. The implementation of the add( ) method is straightforward. All remote objects must extend UnicastRemoteObject, which provides functionality that is needed to make objects available from remote machines.       
            The third source file, AddServer.java, contains the main program for the server machine.Its primary function is to update the RMI registry on that machine. This is done by using therebind( ) method of the Naming class (found in java.rmi). That method associates a namewith an object reference. The first argument to the rebind( ) method is a string that names the server as “AddServer”. Its second argument is a reference to an instance of AddServerImpl.        The fourth source file, AddClient.java, implements the client side of this distributed application. AddClient.java requires three command-line arguments. The first is the IP address or name of the server machine. The second and third arguments are the two numbers that are to be summed.
            The application begins by forming a string that follows the URL syntax. This URL uses
the rmi protocol. The string includes the IP address or name of the server and the string “AddServer”. The program then invokes the lookup( ) method of the Naming class. This method accepts one argument, the rmi URL, and returns a reference to an object of type AddServerIntf. All remote method invocations can then be directed to this object.
Execution procedure:
1. Compile all the above program.
2. Generate a Stub
            To generate a stub, we use a tool called the RMI compiler, which is invoked from the        command line.
                        rmic AddServerImpl
3. Start the RMI Registry on the Server Machine
                        start rmiregistry
4. Start the Serv
                        java AddServerer
5. Start the Client
            The Add Client software requires three arguments: the name or IP address of the server
machine and the two numbers that are to be summed together. We may invoke it from the command line by using one of the two formats shown here:
                        java Add Client server1 8 9
                        Java Add Client 11.12.13.14 8 9                    
                        java AddClient 127.0.0.1 8 9

Here, the address 127.0.0.1 is the “loop back” address for the local machine. Using this address allows you to exercise the entire RMI mechanism without actually having to install the server on a remote computer.

14. Write a swing Application which uses JTabbedPane
        I.            Each Tab should use JPanel, which includes any one component given below in each Panel
      II.            ComboBox/List/Tree/RadioButton.

// Demonstrate JTabbedPane.

import java.awt.*;
import javax.swing.event.*;
import javax.swing.*;
import javax.swing.tree.*;

/*
<applet code="JTabbedPaneDemo" width=700 height=200>
</applet>
*/

public class JTabbedPaneDemo extends JApplet
            {
              public void init()
             {
                        try
                        {
                                    SwingUtilities.invokeAndWait(new Runnable()
                                    {
                                                public void run()
                                                {
                                                            makeGUI();
                                                }
                                    });

                        }
                        catch (Exception exc)
                        {
                                    System.out.println("Can't create because of " + exc);
                        }
            }
private void makeGUI()
            {
            JTabbedPane jtp = new JTabbedPane();
            jtp.addTab("Cities", new CitiesPanel());
            jtp.addTab("Colors", new ColorsPanel());
            jtp.addTab("Flavors", new FlavorsPanel());
            jtp.addTab("Subjects", new SubjectsPanel());
            jtp.addTab("Movies", new MoviePanel());
            add(jtp);
            }
      }
// Make the panels that will be added to the tabbed pane.
class CitiesPanel extends JPanel
            {
            public CitiesPanel()
            {
                        JButton b1 = new JButton("New York");
                        add(b1);
                        JButton b2 = new JButton("London");
                        add(b2);
                        JButton b3 = new JButton("Hong Kong");
                        add(b3);
                        JButton b4 = new JButton("Tokyo");
                        add(b4);
            }
  }
class ColorsPanel extends JPanel
            {
            public ColorsPanel()
            {
                        JCheckBox cb1 = new JCheckBox("Red");
                        add(cb1);
                        JCheckBox cb2 = new JCheckBox("Green");
                        add(cb2);
                        JCheckBox cb3 = new JCheckBox("Blue");
                        add(cb3);
            }
}
class FlavorsPanel extends JPanel
            {
            public FlavorsPanel()
            {
                        JComboBox jcb = new JComboBox();
                        jcb.addItem("Vanilla");
                        jcb.addItem("Chocolate");
                        jcb.addItem("Strawberry");
                        add(jcb);
            }
}
class SubjectsPanel extends JPanel
            {
                        public SubjectsPanel()
                        {
                                    JTree tree;
                                    JLabel jlab;
                        // Create top node of tree.
                        DefaultMutableTreeNode top = new DefaultMutableTreeNode("Options");
                        // Create subtree of "III Sem".
                        DefaultMutableTreeNode a = new DefaultMutableTreeNode("III Sem");
                        top.add(a);
                        DefaultMutableTreeNode a1 = new DefaultMutableTreeNode("JAva");
                        a.add(a1);
                        DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("SS");
                        a.add(a2);
                        // Create subtree of "B".
                        DefaultMutableTreeNode b = new DefaultMutableTreeNode("IV Sem");
                        top.add(b);
                        DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("J2EE");
                        b.add(b1);
                        DefaultMutableTreeNode b2 = new DefaultMutableTreeNode("ADA");
                        b.add(b2);
                        DefaultMutableTreeNode b3 = new DefaultMutableTreeNode("WP");
                        b.add(b3);
                        // Create the tree.
                        tree = new JTree(top);
                        // Add the tree to a scroll pane.
                        JScrollPane jsp = new JScrollPane(tree);
                        // Add the scroll pane to the content pane.
                        add(jsp);
                        }
            }
class MoviePanel extends JPanel
            {
            public MoviePanel()
            {
                        JList jlst;
                        JLabel jlab;
                        JScrollPane jscrlp;
                        // Create an array of cities.
                        String Cities[] = { "New York", "Chicago", "Houston",
                        "Denver", "Los Angeles", "Seattle",
                        "London", "Paris", "New Delhi",
                        "Hong Kong", "Tokyo", "Sydney"
             };
            // Create a JList.
            jlst = new JList(Cities);
            // Set the list selection mode to single selection.
            jlst.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            add(jlst);
            }

}
at

No comments:

Post a Comment