Trying to understand Java Sockets

Question

First, I have been able to find enough examples to get off ground zero and now I need a little help understanding what I have found.
Secondly, I have a problem that i need a little help on.
First - as I understand it the // indicates a comment and then I found a snippet that helped me get what I wanted but I can't understand this
     } catch(IOException e) {
     e.printStackTrace();
     // System.exit(3);
return;
in this is example is the //System.exit(3) doing anything or is it just intended as a comment? What does the return do? Where does it return to?
Secondly - the problem. In setting up the socket, I am trying to trap for a few common errors such as parameter not entered on the command line, invalid host, invalid port, or port not listening, etc. Some of these I have been able to figure out because people have examples that help me figure out how to use it but others don't. Here is my code snippet so far. I am trying to explore the PortUnreachableEception class and haven't had any success at all. Where would it go and what would be the right way to use it in this scenario?
Thanks
George Mizzell
import java.io.*;
import java.net.*;
public class GetBoth3{
public static final int GetDayTimePort = 13;
public static final int GetQuotePort = 17;
public static void main(String[] args){
     if (args.length != 1) {
     System.err.println("Oops, no address to find");
     // System.exit(1);
     return;
     InetAddress address = null;
     try {
     address = InetAddress.getByName(args[0]);
     } catch(UnknownHostException e) {
     e.printStackTrace();
     // System.exit(2);
return;
     Socket getDateTime = null;
     try {
     getDateTime = new Socket(address, GetDayTimePort);
     } catch(IOException e) {
     e.printStackTrace();
     // System.exit(3);
return;
     InputStream in = null;
     try {
     in = getDateTime.getInputStream();
     } catch(IOException e) {
     e.printStackTrace();
     // System.exit(5);
return;
     BufferedReader reader = new BufferedReader(new InputStreamReader(in));
     String line = null;
     try {
     line = reader.readLine();
     } catch(IOException e) {
     e.printStackTrace();
     // System.exit(6);
return;
     System.out.println("The current date and time on " + address + " is " + line);
     // System.exit(0);
return;
} // GetBoth3

Answer 1

Starting with your first question:
} catch(IOException e) {
e.printStackTrace();
// System.exit(3);
return;
System.exit(3) is commented out there, it is not doing anything. At first it seems confusing because... why write a line of code, then comment it out? Does it tell us anything? What's going on? The reason that it's commented out is either because the original programmer put System.exit(3) there and decided to use return instead, but didn't want to forget what the original line of code was, or, he wanted to suggest to the reader that perhaps System.exit(3) may be more appropriate than return. Sometimes, when I am debugging an application I wrote, I comment out lines of code without deleting them, so that I won't forget what they were. Or, I comment out my debugging code so that I can easily use it again later without it being compiled into release versions.
So, to answer your question. The //System.exit(3) does nothing, it is just intended as a comment. Return causes the flow of execution to jump out of the method that it is currently in and return to the calling method. For example:
    public static void main (String[] args) {
        System.out.println("Calling poo(true):");
        poo(true);
        System.out.println("Calling poo(false):");
        poo(false);
        System.out.println("Sorry, no more poo.");
    public static void poo (boolean do_return) {
        System.out.println("First line.");
        if (do_return) return;
        System.out.println("Second line.");
    };The output should be:
    Calling poo(true):
    First line.
    Calling poo(false):
    First line.
    Second line.
    Sorry, no more poo.I don't know if any of that works, I just typed it here. But, you should be able to see what I'm getting at. If do_return is true in poo, then the return statement causes poo to RETURN to main (which is the function that poo was called from) before printing "Second line.".
By contrast, if I would have put System.exit(3) in poo() instead of return, then after calling poo(true) and printing "First line.", the program would have exited back to the system, and "Calling poo(false):" would never have been printed.
So, in the code that you typed, in GetBoth3.main:
if (args.length != 1) {
System.err.println("Oops, no address to find");
// System.exit(1);
return;
Putting a commented out //System.exit(1) does nothing in your program, it's just a comment. When ever you use "return" from main, since nothing called main, returning from main just exits the program and returns to the system.
So:
1) Use return in a method to stop executing the rest of the code in the method, and exit the method.
2) Use return in main() to end the program. This is the same as typing System.exit(0) in main.
3) Use System.exit(code) anywhere in your program to end the program at any given time.
Note that the following code:
    public myMethod () {
        // Do some things...
        if (some_expression == true) return;
        // Do some more things....
    };is functionally equivalent to:
    public myMethod () {
        // Do some things...
        if (some_expression != true) {
            // Do some more things...
    };But the first one is a bit easier to read, esp. when your code gets more complex.
Here is my code snippet so far. I am trying to explore the
PortUnreachableEception class and haven't had any success at all.
Where would it go and what would be the right way to use it in this
scenario?
If you look at the class derivation tree at the top of the javadoc page for PortUnreachableException, you see that one of the classes it is derived from is IOException. Whenever you use a try...catch block, not only does "catch" catch whatever type of exception you specify, but it also catches all exception classes DERIVED from the one that you specified. So, by catching an IOException, you are, in fact, also catching PortUnreachableExceptions. The problem is, in this code...
    try {
        getDateTime = new Socket(address, GetDayTimePort);
    } catch (IOException iox) {
        System.out.println("Error: " + iox);
        System.exit(0);
    };...although you are catching an IOException (and PortUnreachableException's) as well, you have no clean way of differentiating between PortUnreachableException and any other IOException in your code (except by using instanceof, which I can explain later if you want, but it's not really the preferred way to do it in this case).
You could try the following exception handler instead:
    try {
        getDateTime = new Socket(address, GetDayTimePort);
    } catch (PortUnreachableException px) {
        // Stuff
    };But then you will get an uncaught exception compiler error, because the Socket constructor throws an IOException, and you are only catching a subset of exceptions derived from IOException, so any other exceptions besides PortUnreachableException (and the exceptions derived from PortUnreachableException) will remain uncaught by your exception handler.
The solution is to catch both, like so:
    try {
        getDateTime = new Socket(address, GetDayTimePort);
    } catch (PortUnreachableException px) {
        System.out.println("Invalid port specified!");
        System.exit(some_exit_code);
    } catch (IOException iox) {
        System.out.println("Error creating socket: " + iox);
        System.exit(some_exit_code);
    };Note that the order in which your catch statements appear is important. If an exception is thrown in the try block, the program will go to each catch block in order, and execute the first one that applies. So, since PortUnreachableException is derived from IOException, and can therefore be caught by IOException catch blocks, the following code will not do what you want:
    try {
        getDateTime = new Socket(address, GetDayTimePort);
    } catch (IOException iox) {
        System.out.println("Error creating socket: " + iox);
        System.exit(some_exit_code);
    } catch (PortUnreachableException px) {
        System.out.println("Invalid port specified!");
        System.exit(some_exit_code);
    };Since the IOException catch block appears first, and since PortUnreachableExceptions can be caught be IOException catch blocks, then the IOException catch block code will execute, not the PortUnreachableException catch block code.
Also, you may be confused about a few other things I threw in my code:
First of all, "some_exit_code" is whatever exit code you want. The exit code you use does not directly affect your application in any way. Exit codes are useful if you say, spawn your application from another process, and then you want the spawning process to be able to know some information about how your application exited. I can explain that better too, if you want.
Secondly, I used System.exit() instead of return in the main() exception handlers just so that I could control the exit code of the application. If you have no use for exit codes, just use return from main. Also, keep in mind, if you use System.exit() in ANOTHER method (not main) instead of return, then you will exit the program rather than returning from the method.
Also, System.out.println("Error: " + iox) will print a good amount of detail about the IOException iox. Although it won't be as useful as printStackTrace() to you, the developer, it will be more readable than printStackTrace() to the common user.
As an aside, relating to System.out.println, if you define the following method in one of your classes:
    public String toString () {
        return "A string representation of this class.";
    };Then you can use System.out.println(MyClass), or String i = "Description: " + MyClass to print readable information about MyClass. I didn't explain that well so here is an example:
    // OddEven.java
    public class OddEven {
        protected int i;
        public OddEven (int i) {
            this.i = i;
        public String toString () {
            if ((i % 2) == 0) return "even number";
            else return "odd number";
    // Whatever.java
    public class Whatever {
        public static void main (String[] args) {
            OddEven o = new OddEven(31);
            OddEven e = new OddEven(100);
            System.out.println("OddEven o: " + o);
            System.out.println("OddEven e: " + e);
    };That should work, haven't tested it though. But basically, any time an Object gets converted to a String (for example, by passing an Object to a function expecting a String, or by use '+' to concatenate an Object to a String), the toString() method of that Object is called, and the return value is used as the String.
That example should give you another idea about what return does, too.
If you want me to explain instanceof, exit codes, or class derivation and inheritance, lemme know.
Hope any of this helps.
Jason Cipriani
[email protected]
[email protected]