Java Socket Sever Client Object Transfer

Client.java

package com.henry.net;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Arrays;

public class Client {
    private Socket socket;
    private ObjectInputStream objectInputStream;
    private ObjectOutputStream objectOutputStream;

    private boolean connected = false;

    public Client() {

    }

    public boolean isConnected() {
        return connected;
    }

    public void connect(String host, int port) {
        try {
            socket = new Socket(host, port);
            connected = true;
            System.out.println("Connected to '" + host + ":" + port + "'.");

            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeUTF(Arrays.toString(socket.getLocalAddress().getAddress()));

            objectInputStream = new ObjectInputStream(socket.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void send(Object obj) {
        try {
            objectOutputStream.writeObject(obj);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Object fetch() {
        try {
            return objectInputStream.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    public void close() {
        try {
            objectOutputStream.close();
            objectInputStream.close();
            socket.close();
            connected = false;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ClientMain.java

package com.henry.net;

public class ClientMain {
    public static void main(String[] args) {
        if (args.length < 5) return;

        int a = Integer.parseInt(args[0]);
        int b = Integer.parseInt(args[1]);
        int clientInterval = Integer.parseInt(args[2]);
        String host = args[3];
        int port = Integer.parseInt(args[4]);

        for (int i = a; i < b; i++) {
            Client client = new Client();
            client.connect(host, port);
            new ClientSendMessage(client, i, clientInterval).start();
        }
    }
}

ClientSendMessage.java

package com.henry.net;

public class ClientSendMessage extends Thread {

    private Client client;
    private int id;
    private int interval;

    ClientSendMessage(Client client, int id, int interval) {
        this.client = client;
        this.id = id;
        this.interval = interval;
    }

    @Override
    public void run() {
        Message[] messages = {
                new Message("[" + id + "] "),
                new Message("Across the Great Wall "),
                new Message("we can reach every corner "),
                new Message("in the world.")
        };

        for (Message message : messages) {
            System.out.println("[" + id + "] Object to be written = " + message);
            client.send(message);
            try {
                Thread.sleep(interval);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        StringBuilder builder = new StringBuilder();

        for (int i = 0; i < messages.length; i++) {
            Message returned = (Message) client.fetch();
            builder.append(returned.getText());
        }

        System.out.println(builder);

        client.close();
    }
}

Message.java

package com.henry.net;

import java.io.Serializable;

public class Message implements Serializable {
    private final String text;

    public Message(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    @Override
    public String toString() {
        return "Message{" + "text='" + text + "'}";
    }
}

Server.java

package com.henry.net;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

class SeverThread extends Thread {
    private static int threadCount = 0;
    private static int id;

    private Socket socket;
    private ObjectInputStream objectInputStream;
    private ObjectOutputStream objectOutputStream;

    private boolean connected = true;

    SeverThread(Socket socket) {
        threadCount++;
        id = threadCount;
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            String clientAddress = objectInputStream.readUTF();
            System.out.println("Established connection from '" + clientAddress + "'.");

            while (connected) {
                Message message = (Message) objectInputStream.readObject();
                System.out.println("[" + id + "] Object received = " + message);
                objectOutputStream.writeObject(new Message(message.getText().toUpperCase()));
            }
        } catch (IOException | ClassNotFoundException e) {
            try {
                objectOutputStream.close();
                objectInputStream.close();
                socket.close();
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
            connected = false;
            e.printStackTrace();
        }
        threadCount--;
        System.out.println("Server thread " + id + " finished.");
    }
}

public class Server extends Thread {
    private ServerSocket serverSocket;

    private boolean listening;

    public Server(int listeningPort) {
        try {
            serverSocket = new ServerSocket(listeningPort);
            System.out.println("Start listening on port " + listeningPort + ".");
            listening = true;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public boolean isListening() {
        return listening;
    }

    public void run() {
        try {
            while (this.isListening()) {
                SeverThread thread = new SeverThread(serverSocket.accept());
                thread.run();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void close() {
        try {
            serverSocket.close();
            listening = false;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        if (args.length < 1) return;
        int port = Integer.parseInt(args[0]);

        Server server = new Server(port);
        server.start();

        Scanner keyboard = new Scanner(System.in);
        while (server.isListening()) {
            String input = keyboard.next();
            if (input.equals("exit")) {
                server.close();
                System.out.println("Sever is going to stop listening.");
            }
        }
    }
}