Plz help me on this java Application

Transfer a file from client to server location 1) File -> new -> Java Project, give a name as TestLab2, then next and finish

. 2) In the Package Explorer, select src -> new -> class, give a name CapitalizeServer and finish

3) Copy and paste the CapitalizeServer.java code.

4) In the Package Explorer, select src -> new -> class, give a name CapitalizeClient and finish 5)

Copy and paste the CapitalizeClient.java code.

6) Compile the CapitalizeServer.java.

7) Run the CapitalizeClient.java. In the Enter IP Address window, enter the IPv4 Address

--CapitalizeClient--

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

/**

* A simple Swing-based client for the capitalization server.

* It has a main frame window with a text field for entering

* strings and a textarea to see the results of capitalizing

* them.

*/

public class CapitalizeClient {

private BufferedReader in;

private PrintWriter out;

private JFrame frame = new JFrame("Capitalize Client");

private JTextField dataField = new JTextField(40);

private JTextArea messageArea = new JTextArea(8, 60);

/**

* Constructs the client by laying out the GUI and registering a

* listener with the textfield so that pressing Enter in the

* listener sends the textfield contents to the server.

*/

public CapitalizeClient() {

// Layout GUI

messageArea.setEditable(false);

frame.getContentPane().add(dataField, "North");

frame.getContentPane().add(new JScrollPane(messageArea), "Center");

// Add Listeners

dataField.addActionListener(new ActionListener() {

/**

* Responds to pressing the enter key in the textfield

* by sending the contents of the text field to the

* server and displaying the response from the server

* in the text area. If the response is "." we exit

* the whole application, which closes all sockets,

* streams and windows.

*/

public void actionPerformed(ActionEvent e) {

out.println(dataField.getText());

String response;

try {

response = in.readLine();

if (response == null || response.equals("")) {

System.exit(0);

}

} catch (IOException ex) {

response = "Error: " + ex;

}

messageArea.append(response + " ");

dataField.selectAll();

}

});

}

/**

* Implements the connection logic by prompting the end user for

* the server's IP address, connecting, setting up streams, and

* consuming the welcome messages from the server. The Capitalizer

* protocol says that the server sends three lines of text to the

* client immediately after establishing a connection.

*/

public void connectToServer() throws IOException {

BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));

// Get the server address from a dialog box.

/*

String serverAddress = JOptionPane.showInputDialog(

frame,

"Enter IP Address of the Server:",

"Welcome to the Capitalization Program",

JOptionPane.QUESTION_MESSAGE);

*/

System.out.println("Enter Server IP Address");

String serverAddress = inFromUser.readLine();

// Make connection and initialize streams

Socket socket = new Socket(serverAddress, 9898);

in = new BufferedReader(

new InputStreamReader(socket.getInputStream()));

out = new PrintWriter(socket.getOutputStream(), true);

// Consume the initial welcoming messages from the server

for (int i = 0; i < 3; i++) {

//messageArea.append(in.readLine() + " ");

System.out.println(in.readLine() + " ");

}

while(true){

System.out.println("Enter line to capitalize");

String line = inFromUser.readLine();

if(line.equals("."))

{

System.out.println("Bye Bye!!!");

out.println(line);

break;

}

out.println(line);

System.out.println(in.readLine() + " ");

}

}

/**

* Runs the client application.

*/

public static void main(String[] args) throws Exception {

CapitalizeClient client = new CapitalizeClient();

//client.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//client.frame.pack();

//client.frame.setVisible(true);

client.connectToServer();

}

}

---CapitalizeServer--

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

/**

* A server program which accepts requests from clients to

* capitalize strings. When clients connect, a new thread is

* started to handle an interactive dialog in which the client

* sends in a string and the server thread sends back the

* capitalized version of the string.

*

* The program is runs in an infinite loop, so shutdown in platform

* dependent. If you ran it from a console window with the "java"

* interpreter, Ctrl+C generally will shut it down.

*/

public class CapitalizeServer {

/**

* Application method to run the server runs in an infinite loop

* listening on port 9898. When a connection is requested, it

* spawns a new thread to do the servicing and immediately returns

* to listening. The server keeps a unique client number for each

* client that connects just to show interesting logging

* messages. It is certainly not necessary to do this.

*/

public static void main(String[] args) throws Exception {

System.out.println("The capitalization server is running.");

int clientNumber = 0;

ServerSocket listener = new ServerSocket(9898);

try {

while (true) {

new Capitalizer(listener.accept(), clientNumber++).start();

}

} finally {

listener.close();

}

}

/**

* A private thread to handle capitalization requests on a particular

* socket. The client terminates the dialogue by sending a single line

* containing only a period.

*/

private static class Capitalizer extends Thread {

private Socket socket;

private int clientNumber;

public Capitalizer(Socket socket, int clientNumber) {

this.socket = socket;

this.clientNumber = clientNumber;

log("New connection with client# " + clientNumber + " at " + socket);

}

/**

* Services this thread's client by first sending the

* client a welcome message then repeatedly reading strings

* and sending back the capitalized version of the string.

*/

public void run() {

try {

// Decorate the streams so we can send characters

// and not just bytes. Ensure output is flushed

// after every newline.

BufferedReader in = new BufferedReader(

new InputStreamReader(socket.getInputStream()));

PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

// Send a welcome message to the client.

out.println("Hello, you are client #" + clientNumber + ".");

out.println("Enter a line with only a period to quit ");

// Get messages from the client, line by line; return them

// capitalized

while (true) {

//System.out.println("Recieving String");

String input = in.readLine();

System.out.println("Recieved from client: "+input);

if (input == null || input.equals(".")) {

break;

}

//System.out.println("Tesst");

out.println(input.toUpperCase());

}

} catch (IOException e) {

log("Error handling client# " + clientNumber + ": " + e);

} finally {

try {

socket.close();

} catch (IOException e) {

log("Couldn't close a socket, what's going on?");

}

log("Connection with client# " + clientNumber + " closed");

}

}

/**

* Logs a simple message. In this case we just write the

* message to the server applications standard output.

*/

private void log(String message) {

System.out.println(message);

}

}

}