Одинаковый код и лишь один работает.

System.out.println("Amigo is very smart");
System.out.println("Amigo is very smart");

System.out.print("Amigo is very smart" + System.lineSeparator());
System.out.print("Amigo is very smart" + System.lineSeparator());

package com.javarush.task.task30.task3008;

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

public class ConsoleHelper {

    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));


    public static void writeMessage(String message) {
        System.out.println(message);
    }

    public static String readString() {
        String str;
        while (true) {
            try {
                str = reader.readLine();
                break;
            }
            catch (IOException e) {
                System.out.println("Произошла ошибка при попытке ввода текста. Попробуйте еще раз.");
            }
        }
        return str;
    }

    public static int readInt() {
        int number;
        while (true) {
            try {
                number = Integer.parseInt(readString());
                break;
            }
            catch (NumberFormatException e) {
                System.out.println("Произошла ошибка при попытке ввода текста. Попробуйте еще раз.");
            }
        }
        return number;
    }

}

package com.javarush.task.task30.task3008;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Server {
    private static Map<String, Connection> connectionMap = new ConcurrentHashMap<>();

    public static void main(String[] args) throws IOException {
        int port = ConsoleHelper.readInt();

        try (ServerSocket serverSocket = new ServerSocket(port)){
            System.out.println("Server started");
            while (true) {
                Handler handler = new Handler(serverSocket.accept());
                handler.start();
            }
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    }

    public static void sendBroadcastMessage(Message message) {
        for (Map.Entry<String, Connection> pair : connectionMap.entrySet()) {
            try {
                pair.getValue().send(message);
            } catch (IOException e) {
                System.out.println("Message not sended. Error: " + e.getMessage());
            }
        }
    }

private static class Handler extends Thread {
        private Socket socket;

        public Handler (Socket socket) {
            this.socket = socket;
        }

        public void run() {
            ConsoleHelper.writeMessage(String.valueOf(socket.getRemoteSocketAddress()));
            String name = null;
            try (Connection connection = new Connection(socket)) {

                name = serverHandshake(connection);
                sendBroadcastMessage(new Message(MessageType.USER_ADDED, name));
                notifyUsers(connection, name);
                serverMainLoop(connection, name);
            }
            catch (IOException | ClassNotFoundException e) {
                ConsoleHelper.writeMessage("Произошла ошибка при обмене данными с удаленным адресом.");
            }
            if(name != null) {
                connectionMap.remove(name);
                sendBroadcastMessage(new Message(MessageType.USER_REMOVED, name));
            }
            ConsoleHelper.writeMessage("Connection is cosed!");
        }

        private String serverHandshake(Connection connection) throws IOException, ClassNotFoundException {
            Message nameRequest = new Message(MessageType.NAME_REQUEST, "Введите, пожалуйста, ваше имя!");
            Message query;
            do {
                connection.send(nameRequest);
                query = connection.receive();
            }
            while (query.getType() != MessageType.USER_NAME
                    || query.getData().isEmpty()
                    || connectionMap.containsKey(query.getData()));

            connectionMap.put(query.getData(), connection);
            connection.send(new Message(MessageType.NAME_ACCEPTED, "Name accepted"));

            return query.getData();
        }

private void notifyUsers(Connection connection, String userName) throws IOException {
            for (Map.Entry<String, Connection> pair : connectionMap.entrySet()) {
                Message request = new Message(MessageType.USER_ADDED, pair.getKey());
                if (!pair.getKey().equals(userName))
                    connection.send(request);
            }
        }

        private void serverMainLoop(Connection connection, String userName) throws IOException, ClassNotFoundException {
            while (true) {
                Message clientMessage = connection.receive();
                if (clientMessage.getType() == MessageType.TEXT)
                    sendBroadcastMessage(new Message(MessageType.TEXT, userName + ": " + clientMessage.getData()));
                else
                    ConsoleHelper.writeMessage("Error!");
            }
        }
    }
}

package com.javarush.task.task30.task3008;

import java.io.Serializable;

public class Message implements Serializable {
    private final MessageType type;
    private final String data;

    public Message(MessageType type) {
        this.type = type;
        data = null;
    }

    public Message(MessageType type, String data) {
        this.type = type;
        this.data = data;
    }

    public MessageType getType() {
        return type;
    }

    public String getData() {
        return data;
    }
}

package com.javarush.task.task30.task3008;

import java.io.Closeable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.SocketAddress;

public class Connection implements Closeable {
    private final Socket socket;
    private final ObjectOutputStream out;
    private final ObjectInputStream in;


    public Connection(Socket socket) throws IOException {
        this.socket = socket;
        out = new ObjectOutputStream (socket.getOutputStream()) ;
        in = new ObjectInputStream (socket.getInputStream());
    }

    public  void send(Message message) throws IOException {
        synchronized (out) {
            out.writeObject(message);
        }
    }

    public  Message receive() throws IOException, ClassNotFoundException {
        synchronized (in) {
            return (Message) in.readObject();
        }
    }

    public SocketAddress getRemoteSocketAddress() {
        return socket.getRemoteSocketAddress();
    }

    @Override
    public void close() throws IOException {
        in.close();
        out.close();
        socket.close();
    }
}

package com.javarush.task.task30.task3008.client;

import com.javarush.task.task30.task3008.Connection;
import com.javarush.task.task30.task3008.ConsoleHelper;
import com.javarush.task.task30.task3008.Message;
import com.javarush.task.task30.task3008.MessageType;

import java.io.IOException;
import java.net.Socket;
import java.net.SocketAddress;

public class Client {
    protected Connection connection;
    private  volatile boolean clientConnected;

    protected  String getServerAddress() {
        return ConsoleHelper.readString();
    }

    protected int getServerPort() {
        return ConsoleHelper.readInt();
    }

    protected String getUserName() {
        return ConsoleHelper.readString();
    }

    protected boolean shouldSendTextFromConsole() {
        return  true;
    }

    protected SocketThread getSocketThread() {
        return  new SocketThread();
    }

    protected void sendTextMessage(String text) {
        try {
            Message message = new Message(MessageType.TEXT, text);
            connection.send(message);
        }
        catch (IOException e) {
            clientConnected = false;
            ConsoleHelper.writeMessage("Произошла ошибка при отправке сообщения");
        }
    }

public void run() {
    SocketThread socketThread = getSocketThread();
    socketThread.setDaemon(true);
    socketThread.start();
    try {
        synchronized (this) {
            this.wait();
            if(clientConnected) {
                ConsoleHelper.writeMessage("Соединение установлено. Для выхода наберите команду 'exit'.");
                String str = "";
                while(clientConnected) {
                        str = ConsoleHelper.readString();
                        if(str.equals("exit")) {
                            break;
                        }
                        if (shouldSendTextFromConsole()) {
                            sendTextMessage(str);
                        }
                }
            }
            else {
                ConsoleHelper.writeMessage("Произошла ошибка во время работы клиента.");
                return;
            }
        }
    }
    catch (Exception e) {
        ConsoleHelper.writeMessage("Error!");
        return;
    }
}



public static void main(String[] args) {
    Client client = new Client();
    client.run();
}


public class SocketThread extends  Thread {

    protected void processIncomingMessage(String message) {
        ConsoleHelper.writeMessage(message);
    }

    protected void informAboutAddingNewUser(String userName) {
        ConsoleHelper.writeMessage("Участник с именем " + userName + " присоединился к чату.");
    }

protected void informAboutDeletingNewUser(String userName) {
    ConsoleHelper.writeMessage("Участник с именем " + userName + " покинул чат.");
}

protected void notifyConnectionStatusChanged(boolean clientConnected) {
    Client.this.clientConnected = clientConnected;
    synchronized (Client.this) {
        Client.this.notify();
    }
}

@Override
public void run() {
    String serverAddress = getServerAddress();
    int serverPort = getServerPort();
    try {
        Socket socket = new Socket(serverAddress, serverPort);
        Client.this.connection = new Connection(socket);
        clientHandshake();
        clientMainLoop();
    }
    catch (IOException | ClassNotFoundException e) {
        notifyConnectionStatusChanged(false);
    }
}

protected  void clientHandshake() throws IOException, ClassNotFoundException {
            while (true) {
                Message message = Client.this.connection.receive();
                if(message.getType() == MessageType.NAME_REQUEST) {
                    String userName = getUserName();
                    Client.this.connection.send(new Message(MessageType.USER_NAME, userName));
                }
                else if(message.getType() == MessageType.NAME_ACCEPTED) {
                    notifyConnectionStatusChanged(true);
                    return;
                }
                else {
                    throw new IOException("Unexpected MessageType");
                }
            }
        }

        protected void clientMainLoop() throws IOException, ClassNotFoundException {
            while (true) {
                Message message = Client.this.connection.receive();
                if(message.getType() == MessageType.TEXT) {
                    processIncomingMessage(message.getData());
                }
                else if(message.getType() == MessageType.USER_ADDED) {
                    informAboutAddingNewUser(message.getData());
                }
                else if(message.getType() == MessageType.USER_REMOVED) {
                    informAboutDeletingNewUser(message.getData());
                }
                else {
                    throw new IOException("Unexpected MessageType");
                }
            }
        }

    }
}