Learning Java with Eclipse

Preparing a file

Even getting to the point where you can start typing can be quite daunting, and that’s assuming you’ve got Eclipse to run in the first place (possibly using useful advice from a forum). If Eclipse is loaded, though, follow these instructions:

1. Select File | New | Project… from the main menu
2. Select Java | Java Project from the list
3. Enter the name Inheritance (or anything you want) in the box provided
4. Click Finish

As project creation goes, that probably wasn’t too strenuous, but we aren’t at a stage yet where we can actually type Java code. Continue then:

1. Right click the project you created (which should appear in a list on the left hand side of the screen)
2. Select New | Package
3. Enter the name classes (or anything you want)
4. Click Finish
5. Right click the package you created (which should appear below the project you previously clicked)
6. Select New | Class
7. Enter the name Superclass (it will get confusing if you don’t)
8. Tick the box for public static void main(String[] args) (you don’t want to know what that means yet)
9. Click Finish as all the other default values should be fine

Adding your code

So, that involved a bit of weirdness, but you should find that Eclipse has already generated a 16 line file for you, so those clicks were probably worth it. You should also see the public static void main(String[] args) line in the file, as step 8 selected, and below it the line // TODO Auto-generated method stub. This is obviously a comment, left by Eclipse to tell you what to do next, but rather than come up with some Java yourself just yet, you should paste in these two line:

and remove the comment, because you’ve done what the TODO was refering to.

This is where things get really exciting. You should see that Eclipse has underlined onlyMethod in red, and that’s not because of a spelling mistake, it’s because you are calling a method (or “running a function”, if that phrase is more familiar to you) that hasn’t been written yet. Of course, you could try writing the method yourself, now that Eclipse has been kind enough to tell you what to do, or you could even get me to tell you what to do, but it’s more fun to just get Eclipse to do it for you. Here are the instructions:

1. Put the text cursor somewhere in the text onlyMethod
2. Hold down the Ctrl key and press the 1 key
3. Select the first option Create method onlyMethod() by pressing Return

The more negative of you might complain that now you have even more code that you don’t understand, but that’s much better than having to write a load of code you don’t understand by hand. Fortunately, the only thing left to do for this file is to replace the TODO line with:

but that’s boring to type, so let’s have some more fun with Eclipse:

1. Type sysout where the TODO line was
2. Don’t leave a space afterwards, just hold down the Ctrl key and press the Space bar
3. That should have done half the writing for you, and your text cursor should be between two brackets, so type this.
4. A dropdown list should spring open automatically, so select getClass() from it by pressing the Down arrow key and Return
5. Type . and see another dropdown, from which to select getName() in the same way

Not bad for typing just 6 letters and a couple of dots.

The other file

That’s one file (or “class”, as each file contains just one Java class) out of the way, and we only need one more for this to be a clever little Java application. Repeat the steps above again, then, to create a new class, called Subclass, in the same package, and with an initial empty main method like before. This time we will replace the TODO with some similar code:

and get a similar angry red underlining of onlyMethod, but instead of blindly creating the same code again, we want to tell Eclipse we mean the onlyMethod() defined in the previous class.

Now, finally, we have to understand a bit of Java, but don’t worry, it’s one of the good bits. As you might have guessed from the names, we have created a “superclass” and “subclass” as our two classes (in that order), and this sort of relationship in Java allows “child” subclasses to inherit code from their “parent” super classes. Unfortunately, even the genius of Eclipse isn’t able to work out that we want Subclass to be the subclass of Superclass, and Superclass to be the superclass of Subclass, just from the names. If it could, that would actually be annoying as we’d have to remember that special class names mean special things to Java, and Java isn’t so unpredictable. Instead, we have to explicitly declare the relationship, and it is up to the child to decide, which can be done by changing the line:

to:

You should be saving your work as you go (did I say that Eclipse is notoriously and shamefully crashy?) so do that now, saving the two files individually, but you will notice there is still a problem with the onlyMethod() method. If you hover your mouse over the underlined text, you will see the message The method onlyMethod() from the type Superclass is not visible. Looking back at Superclass (by double-clicking it in the menu on the left, if necessary), you might think onlyMethod() is perfectly visible to you, it’s right there in black and white (and mauve and blue), but being more observant you might worry about the fact it says private next to the method, and you’d be right.

Here again is a good time to think about Java and its idea of inheritance. Just as some things that belong to a parent are private and can’t be seen by the child, so a superclass can have private methods which the child class doesn’t know about. One alternative is to make the method on the superclass public, but just as a parent might not want some family matter public, you may find this exposes too much of your code to other parts of it, which can be confusing. The third option, then, is to protect the privacy of this family matter and mark the method as protected, which is what we’ll do. Typing is so old fashioned, though, and possibly understanding Java is too, as what we can do is put the text cursor on onlyMethod in Subclass and use the Ctrl + 1 trick to select the default option Change visibility of ‘onlyMethod()’ to ‘protected’. Save the file and we’re done.

Run it!

This is only a small, example application so it can only really do two things, but let’s do them:

1. Right click anywhere inside Subclass and select Run As | Java Application
2. See the output classes.Subclass in the console at the bottom of Eclipse
3. Do the same in Superclass
4. See the output classes.Superclass

You may be thinking now “Err, great, but what have I just done exactly?” which isn’t really an Eclipse question. To understand, though, I should probably explain what this onlyMethod actually does, after mentioning it so much. Firstly, System.out.println() is a method for outputing a line of text to the console, and you’ve seen it certainly manages to do that. In particular, the lines it is outputing are the name of the class each time (including their package name), which is precisely what this.getClass().getName() refers to. The intriguing thing about this setup, and the reason I wrote this code originally, is that it shows how the same method, called from two different classes, can produce two different results, even though the method doesn’t take any arguments.

Finally, if you know what I mean by “arguments”, then perhaps it will make sense when I say that public static void main(String[] args) is refering to a public method (which I talked about earlier) called main which has just one argument (called args, but we never use this variable in the main() methods we define). To be precise, the data type of this argument is an array of strings, which is written String[], and the method doesn’t have a return value, so it is void.

But what does static mean? You’ll have to keep learning Java.