When do I construct using "new" or another object?

Great answer by Liam Peters! And a great question. Let's see if we can clear it up a little more.

Case C

InputStream inputStream = new InputStream();
inputStream = connection.getInputStream(); 

The first line creates a new InputStream object and stores it in the inputStream variable.

Line 2 reassigns that variable to a 2nd InputStream object that is created within the getInputStream() method and returned as the result of that method. When the variable is reassigned, the one you created on line 1 is thrown away (and will eventually be collected as garbage).

The reason we wouldn't want to do this is in case InputStream objects take up a lot of memory. It's just twice the memory will be needed for 2 objects. Even though it will eventually be cleaned up automatically, it's inefficient and we want to avoid it.

Case D

The short answer is I probably should have used InputStreamReader instead of Reader to make it more clear. :)

D1: Hopefully we can talk through this in a way that makes sense. Let's revisit this example:

Reader reader = new InputStreamReader(inputStream); // case D

InputStreamReader (the child class) inherits from Reader (the parent class). That means that InputStreamReader is a Reader, just like each of my sons is a Jakuben. Other subclasses are also Readers.

We can assign like this for that reason. InputStreamReader is at least equivalent to Reader, and as you mentioned it does have even more. We only need a Reader later in the code, so any Reader will do.

Now if we try it the other way, we'll have a problem:

InputStreamReader inputStreamReader = new Reader(); // error!

Because InputStreamReader has "more", if we try to use an InputStreamReader method that isn't from the Reader parent, then we will get an exception.

Also, this line would fail because the Reader class is an "abstract" class. Abstract classes are meant to be subclassed, and we always use subclasses of it.

But when is this appropriate?

Because Reader is an abstract class, it defines behaviors that will be consistent among its children. Sometimes we want code that will be accepting of different children. In our blog reader app, perhaps we could read from an InputStreamReader or another subclass, CharArrayReader, which works slightly differently in terms of the "more" things that it does.

We are only calling the read() method from the Reader. So it doesn't matter to our code if read() works on an input stream or an array of chars. Perhaps we would have an if statement earlier in the code that would set the reader variable to either in InputStreamReader or a CharArrayReader based on the choice a user makes.

Let's stop here and pause for understanding and further questions. :)

Ok Jose, this is a really good question.

I'm going to assume that you're comfortable with Case A. - It's the fundamentals of object oriented programming! You create a new object to represent, keep track of, and do work on, some information.

Secondly, Static classes. Case B. This can be confusing until you think of it like this. Static just means that there can only ever be one of these and so using a constructor (new) would be a bit pointless (You don't need to make a new one, because there is only ever one!) Static classes are really useful, because you don't need to pass references to a specific object around your application.

So an example of Case A and Case B working together nicely would be a DVD player and DVD's (Virtual, of course)

An individual DVD would be case A

class DVD{
    //Case A
    private String title;
    private String director;
    private int runtime;

    public DVD(String title, String director, int runtime){
        this.title = title;
        this.director = director;
        this.runtime = runtime;
    }

    public String getDirector(){
        return director;
    }

    public String getTitle(){
        return title;
    }

    public int getRuntime(){
        return runtime;
    }
}

Whereas a DVD player could be static if all it had were methods that do work on a DVD such as

class DVDPlayer{
    // Case B
    public static String DVDtoString(Dvd dvd){
        return dvd.getTitle()+" was directed by " +dvd.getDirector() + " and has a runtime of " + getDurationString(dvd.getRuntime);
    }

    private static String getDurationString(int seconds) {
        int hours = seconds / 3600;
        int minutes = (seconds % 3600) / 60;
        seconds = seconds % 60;
        return twoDigitString(hours) + " : " + twoDigitString(minutes) + " : " + twoDigitString(seconds);
    }

}

Your confusion with Case C is that it's really just a hidden version of Case A. Within connection.getInputStream() there will be a call to instantiate a new Input stream using the new keyword.

Case D is an example of something called Polymorphism. The Java tutorial document on which is actually pretty good.

Hope that isn't all that confusing and I've cleared something up for you!

Is it always case with "get" methods (methods names starting with get) to do the same constructing thing like getInputStream (create automatically new instances)?