Java Programming for Kids

To start programming in Java you need to download the Java Development Kit (JDK) from the company called Oracle, which makes releases and updates of Java versions. The full name of the software to download is Java SE Development Kit. We’ll download the Java SE 8, which was the latest version of Java available while writing this book. Just visit Oracle’s Web site. Accept the license agreement and select the proper link depending on the Operational System (OS) installed on your computer.

If you use Windows OS, download the file named jdk-8-windows-i586.exe. Since I work with Apple computers running Mac OS X, the file jdk-8-macosx-x64.dmg is my Java installer. Run your installer program, agree with all default answers (just press the button Next) and you’re almost ready to go.

In Mac OS, Java is installed in the folder /Library/Java/JavaVirtualMachines/jdk1.8.0.jdk (there could other digits after zero, which indicates the update number). On Windows computers it’ll be installed under c:\Program Files\Java\jdk1.8.0, where c: is the name of your hard drive or SSD. If you use Mac OS, your installation is complete.

If you have an idea what to program, typically you’ll need to perform the following three steps:

There are two version of IDEA IDE - Ultimate and Community. The Ultimate version is not free, but it has additional features useful for developing enterprise applications. But this book is about learning the basics of Java programming so using the free Community edition is all we will need.

Open the Web page IntelliJ IDEA and click on the Download Community button. It’ll download the installer program with the name that starts with ideaIC - just run it. On MAC OS the installer doesn’t prompt any questions. Just drag the icon onto the Applications folder.

On Windows, you’ll need to select the folder where IDEA will be install as shown below. Windows installer will also offer to create a desktop icon for IDEA - agree with this.

In several seconds you’ll get the IDEA installed by clicking on the Next button. If you use MAC OS, find it using Spotlight on the top right corner of the screen and click on it. If you use Windows, click on the newly created IDEA icon on your desktop. The first question IDEA asks is if you want to import the settings from the older versions of IDEA. Do not select this. Next comes this Welcome screen:

In IDEA, your Java applications will be located in separate projects. As you’ve probably guessed, you’ll need to select the option Create New Project on the Welcome screen. Then IDEA will ask you about the type of the project you want to create.

Select the option to create a Java project. In IDEA projects consist of modules. By selecting Java we state that our project will have a Java module. Hit the button Next and then again on the following window that will ask about selecting a template that will be used in this project. Now we need to give our project a name and select the JDK to be used with this project.

We don’t want our project to be untitled, so replace this name with hello in the top box. Note how the name of the folder in the Project location box changes accordingly. When you’ll try to do it on your computer, the project location will appear different than mine. Now you need to select the JDK. If you have never worked with Java before, the only JDK you will have is the one installed in Chapter 1 although Java programmers sometimes have more than one JDK installed. For example, they may not be allowed to use the latest JDK 8 for work projects, so they keep the JDK 7 around, but all the fun projects will be created with JDK 8.

We don’t have such restrictions, so JDK 8 is our only choice. Now figure out where to locate it.

Click on the button New, select the menu item JDK, and you’ll see a familiar screen for browsing the folders on your computer. Please refer to the first section of Chapter 1 ( Installing Java on Your Computer) depending on whether you are working with MAC or Windows. I’m using MAC, so I’m choosing Library, Java, JavaVirtualMachines, jdk1.8.0.jdk. Notice the previous window now looks different.

Press the button Finish and your new project is created. Every time you start IDEA it offers you little tips on how to use its cool features. You can opt out from this, but I recommend you read them - you might find some little gems that will make your work with IDEA more fun. The project hello is ready, and you can start writing your Hello World program.

This project consists of the module hello and External Libraries. The source code of your program(s) will be located in the folder src in the hello module. The file hello.iml is where IDEA remembers the settings of the project hello - you don’t need to touch it. Under External Libraries you’ll find a bunch of files that end in .jar. These JAR’s are the libraries of code that came with JDK.

A simple project like our HelloWorld will have just one file with the source code HelloWorld.java. More advanced projects will consist of multiple files. To simplify the application deployment, all these files could be packaged in one or more JARs too. Both JRE and Java SDK include dozens of JARs. Java comes with a jar utility that is used to archive multiple Java classes and other files into a file having the name extension .jar. Internal formats of .jar and .zip files are the same. If your IDEA project will have multiple classes, you can package them into one JAR by using the menu File | Project Structure | Artifacts and then selecting the type JAR.

Java programs consist of classes, and you’ll start getting familiar classes' internals in the section "How Does Hello World Work". Let’s recreate the HelloWorld class from Chapter 1 in IDEA. Select the folder src in your project, and then select the menu File | New | Java Class. You’ll see a little popup window asking for a class name. Enter the name HelloWorld there.

In a second IDEA will generate an empty class HelloWorld as shown below. The white area on the right is a very smart text editor that will allow you to not only enter the text of your program, but will also help you by suggesting what to type next as you type. This editor is really smart!

The text between /** and */ is one of the ways to write comments in your programs. This is an area where you can type any text you want that describes your program in general or any particular code inside the class. We’ll talk about various ways to write comments in the next chapter.

It’s great that you’re following my instructions and the program works. But what exactly is happening in the program HelloWorld? What are all these keywords, braces and parentheses for?

Every Java program has at least one class, and Chapter 3 explains classes in detail. Classes can contain methods, which are the actions that the class can perform. The class HelloWorld has only one method main, which is a special action. It’s a program starter or an entry point of any Java application. You can tell that main is not a Java keyword, but a method, because it has parentheses after the word main. Methods can call (invoke) other methods, for example our method main calls the method println to display Hello World! on the screen.

Each method starts with a declaration line a.k.a. a method signature:

public static void main(String[] args)

This method signature tells us the following:

A Java program can consist of several classes, and each class may include methods. Usually, a Java class has several methods. For example, a class Game can have the methods startGame, stopGame, readScore, and so on. But only one class in the application will have the method main.

The body of our method main has only only one statement:

System.out.println("Hello World!");

Every statement or a method call must end with a semicolon. The method println knows how to print data on the system console (command window). Java method names are always followed by parentheses. If you see a method with empty parentheses, this means that this method does not have any arguments and doesn’t expect to receive any data. The above method println has one argument - a String with the value Hello World!.

System.out means that the variable out is defined inside the class System that comes with Java. How are you supposed to know that there’s something called out in the class System? IDEA will help you with this. After you type the word System and a dot, IDEA will show you everything that is available in this class. You can also put a cursor after the dot and press Ctrl-Space at any time to bring up a help box similar to this one:

This tells me that the Java class System has a variable out of type PrintStream. Are you curious as to what PrintStream is? Click on out in your code and select the menu View | Quick Documentation to read the dry documentation. The fact that a period goes after out followed by a method name - out.println() - tells us that out represents an object, which apparently has a method called println().

We call it a dot notation. We write class_name.method_name or variable_name.method_name. Say you have a class PingPongGame that has a method saveScore. If the method saveScore was declared with the two arguments player and score, you may call this method for Dave who won three games:

PingPongGame.saveScore("Dave", 3);

In this example, the arguments may be given to the method for some kind of processing like saving the score on the disk. Since the name Dave was placed in parentheses, we can guess that the first argument has a String type, which is used for text. The second argument is clearly of a numeric type but we can tell what’s the exact type only after reading the declaration of the method saveScore inside the source code of the class PingPongGame.

In the next chapter we’ll spend a lot more time seeing what Java classes consist of. :toc-placement!: :imagesdir: .

When programmers talk to each other, they may say "Do something with the class Player" or "Do something with the object Player". We need to learn the difference between the meaning of the words class and object.

If you ever covered algebra at any point in school, you are familiar with expressions like x=2, which means that the variable x represents the number 2. In programming, we use variables a lot. In programming a variable can store a value in computer’s memory so you can access these values from various methods in your classes. Using the same algebra example, we can say that we assign the value of 2 to the variable x. The equal sign represents the assignment of the value located to the right of the equal sign to the variable located on the left.

Java variables not only can store numbers, but other types of data as well so we need to declare the variable type, the name, and then assign some value to it. For example, the class attribute that has a value of the disk size can be stored in the variable of type String that’s called hardDiskSize, which can be declared like this:

If the size of the hard disk is 500GB, we can assign this value to the variable hardDiskSize as follows:

String values are placed inside the quotes, and the numbers aren’t.

The method parameters (a.k.a. arguments) are also stored in variables. The method saveStore has two arguments: playerName of type String and score of type int:

void saveScore(String playerName, int score)

Let’s design and create a class Pet. First we need to decide what actions our pet will be able to do. How about eat, sleep, and speak? We’ll program these actions in the methods of the class Pet. We’ll also give our pet the following attributes: age, height, weight, and color.

It’s time for hands-on work. Start IDEA IDE and create a new project as explained in Chapter 2. This time name it MyPet instead of Hello. Click on the src folder in IDEA and create a Java class called Pet using the menu File | New | Java Class.

Your screen should look similar to this one:

Now we are ready to declare attributes and methods in the class Pet. Java classes and methods enclose their bodies in curly braces.

To declare variables for class attributes we should pick data types for them. I suggest an int type for the age, float for weight and height, and String for the pet’s color.

The next step is to add some methods to this class. Before declaring a method you should decide if it should take any arguments and should return a value. This is what I suggest:

The new version of the class Pet will look like this:

This class represents these friendly little monsters from the "real world":

Let’s talk now about the signatures of each method in detail starting with the method sleep:

public void sleep()

This method signature tells us that sleep can be called from any other Java class ( because it’s public). This method does not return any data (the keyword void). The empty parentheses mean that this method does not take any arguments - it does not need any data from the outside world to print the same text.

The signature of the method eat is similar to sleep.

The signature of the method talk looks like this:

public String talk(String aWord)

This method can also be called from any other Java class, but has to return some text, which is prescribed by the keyword String in front of the method name. Besides, it expects some text data from outside, hence the argument String aWord.

How do you decide if a method should or should not return a value? If a method performs some data manipulations and has to give the result of these manipulations back to the calling class, it has to return a value. You may say that the class Pet does not have any calling class! That’s correct, so let’s create one called PetMaster. We’ll create it in the same IDEA project MyPet.

This class will need a method main to become a runnable program (the class Pet didn’t have one). Remember from Chapter 2, typing psvm followed by the Tab key will quickly create the method main. We’ll place the code communicating with the class Pet inside the method main.

To run the class PetMaster right-click on its name in the Project view in IDEA, and select the option Run PetMaster.main(). This program will output the following:

I’m so hungry,let me have a snack like nachos! OK!! OK!! Tweet!! Tweet!! Good night, see you tomorrow!

At this point the project MyPet consists of two Java classes: Pet and PetMaster. The role of the class Pet is to represent attributes and behavior of a pet, while the class PetMaster starts the program, instantiates the class Pet and calls its methods. Your typical projects will consist of multiple Java classes, but only one of them will have have the main method, which is the entry point of the application.

In the real life, every person inherits some features from his or her parents. Similarly, in the Java world you can also create a new class, based on the existing one. The class Pet will help us learn yet another important feature of Java called inheritance.

The class Pet can include behaviors and attributes that are shared by many pets – all of them eat and sleep, some of them make sounds, their skin has different colors, and so on. On the other hand, not all pets are the same. Dogs bark, fish swim and don’t make sounds, and parakeets speak better than dogs. But all of them eat and sleep. That’s why it’s easier to create a class Fish that will inherit some common behavior and attributes from the class Pet, rather than creating Dog, Parrot or Fish from scratch every time.

Java has a special keyword extends that will do the trick. Create a new class Fish in IDEA and then add to its declaration extends Pet so it’ll look as follows:

This class Fish is a subclass of the class Pet. Accordingly, the class Pet is a superclass of the class Fish. In other words, you use the class Pet as a template for creating a class Fish. The keyword extends defines relationship between classes. Since our Fish extends a Pet, we can say that a fish is a pet. But we can’t say that a pet is a fish.

Even if you will leave the class Fish empty as it is now, you can still use every method and attribute inherited from the class Pet, because a fish is a pet! Take a look, we’re creating an instance of the object Fish and are calling its method sleep:

Even though we have not declared any methods in the class Fish yet, we call (invoke) the method sleep, which was declared in its superclass Pet! In Java all classes are automatically inherited from the class Object. Even though we’ve declared the class Pet without using the keyword extends it still extends the class Object. With the keyword extends you can build class hierarchies. For example, many animal classes can extend the class Pet.

Let’s not forget, however, that we’ve created the class Fish as a subclass of Pet, because we wanted to add some additional features that only fish have and reuse some of the code that we wrote for a general pet.For instance, not all pets can dive, but fish certainly can. Let’s add a new method dive to the class Fish.

The method dive has an argument (a.k.a. parameter) howDeep that tells the fish how deep it should go. We’ve also declared a class variable currentDepth that will store and update the current depth every time you call the method dive. This method returns the current value of the variable currenDepth to the calling class. The plus sign in the pintln lines are not about addition - we’re building strings of characters by concatenating their pieces.

Using IDEA, create another class named FishMaster that will look like this:

The method main instantiates the object Fish and calls its method dive twice with different arguments - two and three. After that, it calls the method sleep. When you run the program FishMaster, it will print the following messages:

Have you noticed that beside the methods defined in the class Fish, the FishMaster also calls method sleep from its superclass Pet? This is what inheritance is all about – you do not have to copy and paste code from the class Pet – just use the keyword extends, and the class Fish can use Pet’s methods!

One more thing, even though the method dive returns the value of currentDepth, our FishMaster does not use it. That’s fine, because our class`FishMaster` does not use the returned value, but there may be some other classes that will also use the class Fish, and they may find knowing the current depth useful. For example, think of a class FishTrafficDispatcher that has to know positions of other fish under the sea before giving permissions to dive to avoid traffic accidents.

As you know, fish do not speak, but our class Fish has been inherited from the class Pet that has the method talk. This means that nothing stops you from writing myFish.talk();.

Do you really want our fish to talk? If you do not want this to happen, the class Fish has to override the Pet’s typical behavior - the method talk. If you declare a method with exactly the same signature in a subclass as in its superclass, the subclass' method will be used instead of the method of the superclass. Let’s add the following method talk to the class Fish.

Now add the following three lines to the method main of the class FishMaster (after creating the instance of the Fish):

Run the program and it’ll print

Don’t you know that fish do not talk?

This proves that Pet’s method talk has been overridden, or in other words, suppressed.

Wow! We’ve learned a lot in this chapter – let’s just take a break.

You can add any text comments to your program to explain what a particular line, method or class is for. First of all, someone else may read your program so comments would help in understanding your intentions. Second, even the author of the code can’t remember every program he or she wrote. Besides, if a professional programmer decides to change the employer, if would be nice to leave well-commented code behind.

There are three different types of comments - single-line comments, block comments, and a javadoc comments. Here’s what they are for:

If your comment fits in one line, start it with two slashes:

If you want to write multi-line comments, instead of starting each line with two slashes, just surround the entire text with these symbols: /* and */, for example:

Java comes with a special program javadoc that can extract all comments from your programs into a separate help file that can be displayed by any Web browser. This file can be used as a technical documentation for your programs. Such comments are enclosed in symbols /** and */. Note the two asterisks after the first slash. Only the most important comments like the description of a class or a method should be placed between these symbols.

The javadoc tool can process your code, extract all comments that start with /** and create program documentation that can be published online or kept locally on the company server. We are not going to use javadoc in this book, but if you’re interested in learning more about this tool, read Oracle’s tutorial How to Write Doc Comments for the Javadoc Tool.

From now on, I’ll be adding comments to code samples to give you a better idea how and where to use them.

We always make decisions in our life: If she is going to tell me this – I’m going to answer that, otherwise I’ll do something else. You can write a Java program that will "make decisions" with the help of if and switch statements. You can also build more complex either-or conditions using logical operators.

Class ReportCard declares a variable grade inside the method convertGrades(). If you declare a variable inside any method, such variable is called local. This means that this variable is available only for the code within this method. When the method is complete, this variable automatically gets removed from memory.

Programmers use the word scope to say how long a variable will live, for example you can say that variables declared inside a method have a local scope. If a variable is declared within the code block surrounded with curly braces (e.g. in the if statement), it has a block scope and won’t be visible outside of this block.

If a variable has to be reused by several method calls, or it has to be visible from more than one method in a class, you should declare such a variable outside of any method. In the class Fish from Chapter 3, the currentDepth is a member variable. The member variable currentDepth is alive until the instance of the object Fish exists in the computer’s memory. You can call currentDepth a instance variable, because its declaration doesn’t include the keyword static, which we’ll discuss shortly.

Member variables can be shared and reused by all methods of the class, and we can make them visible from external classes too, if need be. For example the method main of the class ReportCard includes the statement System.out.println(). It uses the class variable out that was declared in the Java class System.

You’ve already learned that Java uses the operator new to create instances of objects in memory, for example:

Fish myFish = new Fish();

Parentheses after the word Fish tell us that this class has some method called Fish. Yes, there are special methods that are called constructors, and these methods have the following features:

Any class can have more than one constructor. If you do not create a constructor for the class, Java automatically creates one during the compilation time - it’s so-called default no-argument constructor. That’s why Java compiler has never complained about the statements new Fish() or new ReportCard(), even though neither class Fish nor class ReportCard has any explicitly declared constructor.

In general, constructors are used to assign initial values to member variables of the class, for example the next version of the class Fish has a one-argument constructor that just assigns the argument’s value to the instance variable currentDepth for future use.

Now the class FishMaster can create an instance of the Fish and assign the initial position of the fish. The next example creates an instance of the Fish that is “submerged” 20 feet under the sea:

Fish myFish = new Fish(20);

If a constructor with arguments has been defined in a class, you can no longer use the default no-argument constructor. If you’d like to have a constructor without arguments - write one.

The keyword this is useful when your code needs to refer to the instance of the object, where this code is running. Look at the next code example, which is a slight modification of the previous one:

Have you noticed that the member variable and the constructor’s argument have the same name? The keyword this helps to avoid name conflicts. In this code sample this.currentDepth refers to the object’s member variable currentDepth, while the currentDepth refers to the argument’s value. In other words, the code points at the current instance of the Fish object.

You’ll see another important example of using the keyword this in Chapter 6 in the section How to Pass Data Between Classes.

An array is an object that holds several values of the same type - primitives or objects. Let’s say your program has to store the names of four game players. Instead of declaring four different String variables, you can declare one String array that has four elements. Arrays are marked by placing square brackets either after the variable name, or after the data type:

String [] players;

or

String players[];

These declarations just tell the Java compiler that you are planning to store several text strings in the array players. Each element has its own index (position number) starting from zero. The next sample actually creates an instance of an array that can store four String elements and assigns the values to the elements of this array:

You must declare the size of the array before assigning values to its elements. If you do not know in advance how many elements you are going to have, you cannot use arrays, but you should look into other classes - Java collections. For example the ArrayList object does not require you to announce the exact number of elements in advance. I’ll show you some examples of using the ArrayList collection in Chapter 10 about data collections.

Any array has an attribute called length that stores the number of elements in this array, and you can always find out how many elements are there:

int totalPlayers = players.length;

If you know all the values that will be stored in the array at the time when you declare it, Java allows you to declare and initialize such array in one shot:

String [] players = {"David", "Daniel", "Anna", "Gregory"};

Imagine that the second player is a winner and you’d like to write the code to congratulate this kid. If the players’ names are stored in an array get its second element:

The output from these two lines of code will look like this:

Congratulations, Daniel!

Do you know why the second element has the index [1]? Of course you do, because the index of the first element is always [0].

The array of players in our example is called one-dimensional array. Imagine the players sitting like ducks in a row. The single dimension is the seat number here. If the players (or game spectators) will occupy several rows, then we’ll have two dimensions - the row number and a set number within the row. This is the case where we’d need to declare a two-dimensional array. Java allows creation of multi-dimensional arrays, and I’ll show you how to do this in Chapter 10.

A loop is a language construct that allows to repeat the same action multiple times. For example, if we need to print congratulation to several winners, the printing code should be invokes several times in a loop. When you know in advance how many times this action has to be repeated, you can use a loop with a keyword for:

The above code means the following:

Print the value of the element from the players array whose number is the same as the current value of the counter. Start from the element number 0: _ counter=0), _and increment the value of the counter by one: (counter++). Keep doing this while the counter is less than totalPlayers`: `counter<totalPlayers.

JVM executes every line between the curly braces and then returns back to the first line of the loop to increment the counter and check the conditional expression.

There is another flavor of the for loop known as for each loop. It allows the program to repeat the same action to every element of the collection without even knowing how many are there. You are basically saying, do this for each element.The for-each loop allows to congratulate players in a more concise manner:

You can read the above code as follows:

The variable pl has the type String - the same as as the array’s elements. Use this variable as a cursor, point it to each element in the array players one by one and repeatedly execute the code inside the curly brackets for the current element.

There is another keyword for writing loops - while. In these loops you do not have to declare exactly how many times to repeat the action, but you still need to know when to end the loop. Let’s see how we can congratulate players using the while loop that will end when the value of the variable counter becomes equal to the value of totalPlayers:

In Chapter 9 you’ll learn how to save the data on the disk and how to read the saved data back into computer’s memory. If you read game scores from the disk file, you do not know in advance how many scores were saved there. Most likely you’ll be reading the scores using the while or for-each loop, which don’t require you to state the number of iterations upfront.

You can also use two important keywords with loops: break and continue.

As with switch statements, the keyword break is used to jump out of the loop when some particular condition is true. Let’s say we do not want to print more than 3 congratulations, regardless of how many players we’ve got. In the next example, after printing the array elements 0, 1 and 2, the break will make the code go out of the loop and the program will continue from the line after the closing curly brace.

The next code sample has the double equal sign == in the if statement. This means that you are comparing the value of the variable counter with number 3. A single equal sign in the here would mean assigning the value of 3 to the variable counter. Placing = in an if statement instead of == is a very tricky mistake, and it can lead to unpredictable program errors that may be dificcult to find.

The keyword continue allows the code to skip some code lines and return back to the beginning of the loop. Imagine that you want to congratulate everyone but David – the keyword continue will return the program back to the beginning of the loop:

There is yet another type of the while loop that starts with the word do, for example:

Such loops check an expression after executing the code between curly braces, which means that code in the loop will be executed at least once. Loops that start with the keyword while might not be executed at all if the loop expression is false to begin with.

While you can just create a Java class and implement all its methods there, a more formal way of declaring the behavior of the class in a separate interface. Then a class declaration would include the keyword implements followed by the name of the interface. This is a way to declare an application program interface (API) - what the class can do - so the programmer can quickly look at the short declaration of the interface rather than going through a longer code of the class.

For years, Java interfaces were used mainly for holding method declarations and final static variables. For example, the interface Talkable contains the declaration of just one method talk:

Since the method talk is not implemented here, it’s called abstract.

You should be thinking, "What’s the point of simply declaring a method without implementing it?" The thing is that more than one class can exhibit the same behavior. For example, a dog, a cat, and a parrot can "talk". But they "implement it" differently. A parrot can repeat words, while dogs bark. Cats talk by meowing. Accordingly you can declare three classes that will implement Talkative interface differently, as shown below:

These three classes use the Java keyword implements, which means they promise to implement all abstract methods in the interface(s) listed after the keyword implements otherwise the Java compiler will complain: "You promised to implement all abstract methods from Talkable, where are they? Keep your promise!"

What if we need to create the class Fish that uses interfaces? Fish don’t talk. But they swim. Dogs can talk (bark) and swim, right? Why won’t we declare yet another interface Swimmable with the methods swim and dive?

Now let’s leave the parrots alone. Let’s create a new class Fish and change the class Dog just a little bit. The Fish will implement Swimmable and the Dog will implement two interfaces:

When a class implements several interfaces, make sure to implement each and every abstract method declared in these interfaces. A class can extend another class and implement interfaces at the same time, for example:

If a method is not implemented we call it abstract, but classes can be declared abstract too, and Java has the keyword abstract for this. An abstract class is called abstract if it was declared with the keyword abstract, for example:

If a class is declared as abstract, you can’t create an instance of it. Typically, abstract classes have some non-implemented methods that are also declared with the abstract keyword:

The class Animal has two implemented methods: setName and sleep and one abstract method talk. Since the abstract class can not be instantiated, the programmer has to create a descendant class and implement the method talk there if he or she wants to create an instance of such a class, for example:

Strictly speaking, it’s not a must to implement the method talk in the class Dog, but in this case Dog remains abstract and can’t be instantiated. Maybe the programmer wants to create a class Puppy that extends Dog and implements the method talk there?

And again you might be wondering, "Why complicate a programmer’s life by declaring non-implemented methods?" If you want to build a hierarchy of classes that extend from Animal you might want to declare an unified method signature, so each class (Dog, Parrot, Fish et al.) will have the same way of initiating the talk.

If you need to use an object of certain type only once, you can kill two birds with one stone: declare an anonymous class and create an instance of it. In this case you don’t even need to give a class a name, hence why it’s anonymous. I’ll show you an example of a program that’s first written without and then written with them.

Let’s say I want to write a simple calculator in Java. In chapters 8 and 9 you’ll create a real calculator with the graphical Users Interface (GUI), but for now I’ll show you how to program operations such as addition and subtraction. The multiplication and division operations can be programmed similarly, so I won’t be implementing these operations.

I want to keep these examples in the package called calc. You can create a subdirectory named calc in your project and save your classes there. The other option is to right-click on the folder src in your IDEA project and select the menu New | Package and enter the package name there:

First comes the version that doesn’t use anonymous classes - I’ll just use one method for each operation. The code of the class Calculator is pretty simple. Note the first line that declares the package where the class Calculator belongs.

This class has two methods that manipulate numbers (one per operation), and its main method invokes each method passing the same values as arguments. After performing the arithmetic operation each method prints the result. Running this program produces the following output:

Now let’s redesign this application. Instead of writing a separate method for each operation, I want to write a generic method that can receive the code of the operation and two numbers to be operated upon. This method will have three arguments: the arithmetic operation, the first, and the second number.

The operation is a behavior, so let’s declare an interface to represent it using a functional interface with a single abstract method:

I’ll write two implementations of the ArithmeticOperation interface using anonymous classes - one for addition and one for subtraction. I will also write a method calculate that will take three arguments: the object that implements ArithmeticOperation and two numbers.

The output of the CalculatorWithAnonymousClasses program will be the same as from Calculator. What did we achieve by re-writing calculator this way? We separated the declaration of the behavior and its implementation. The behavior is declared in the interface, and if more than one class needs to implement ArithmeticOperation, we’ll reuse this interface. The anonymous classes allowed me to create a wrapper object around the method performOperation, so this object could be passed as an argument to the method calculate. In the next section I’ll rewrite this calculator again in a more elegant way with lambda expressions.

Up till now, to invoke a method we’ve been creating named or anonymous classes and instantiating objects, but lambda expressions allow to define and invoke a piece of code even without the need to declare classes or instantiate objects.

First, let me introduce a new term - a function. So far to implement any behavior you’d write a method that could be invoked by specifying the class name and a method name (static methods) or by specifying the object variable and a method name (non-static methods). This is a main idea of any object-oriented programming language - the classes and objects are the first-class citizens. You can’t write a program without them.

But there are functional programming languages that don’t need to wrap behavior inside classes. They allow you to implement behavior by writing functions, which are similar to methods in that they can have names, take arguments, and return results. But functions don’t have to be placed inside classes and can live independently.

A lambda expression is a function without a name or anonymous function that you can assign to a variable, pass as an argument to a method or return from a method. In earlier versions of Java you could pass a value to a method only if this value was an object or a primitive. But now a function (a piece of code) becomes a value that can be passed around. Now let’s see it in action.

In the new version of calculator I’ll declare each arithmetic operation as a lambda expression. I will reuse the same functional interface with the three-argument method calcuate, but will pass the lambda expression that implements ArithmeticOperation as the first argument.

The difference between CalculatorWithAnonymousClasses from the previous section and CalculatorWithLambdas is that the former implements the functional interface as anonymous classes and the latter as lambdas. Lambda expressions offer a concise way of implementation of functional interfaces. To write a lambda expression you need the play by the rules:

Review the code of the CalculatorWithLambdas. Both lambdas addition and subtraction abide by these rules.

You may wonder, "Why are there no data types specified for the lambda parameters first and second?" The reason being that Java compiler is smart enough to guess their data types because it knows which abstract method this lambda implements. An educated guess such as this is called type inference.

Part 1. In this part you’ll do an exercise to prove that you understand Java interfaces.

Part 2. In this part you’ll do an exercise to prove that you understand the basics of lambda expressions.

In code samples from previous chapters I’ve been using the keyword public in declaration of member variables and methods. This means that such a variable or method can be accessed by any other code from the project. You can declare a class, a method, or a member variable to be public, private, or protected. If one of these keywords is missing, Java compiler assumes that it’s a package access level - this element can be accessed only from the code located in the same package (directory).

One of the main features of object-oriented languages is encapsulation - the ability to hide and protect data or code. But who do you need to hide or protect the code from? This is not a protection from bad guys who are not allowed to see your code. You hide and protect the code from misuse. For example, another programmer extended your class and is trying to change the value of a variable in your class, which may result in bug.

Let’s consider an example from the real world. Think of a car – most people have no clue how many parts are under the hood, and what actually happens when a driver pushes the brake pedal. If car designers would not hide control of some of the under-the-hood operations, the driver would have to deal with hundreds of buttons, switches and gauges on the car’s dashboard.

When you design a class, hide methods and class member variables that should not be visible from outside. Some of the methods of member variables are meant to be used internally and not to be exposed to other classes.

We’ll start learning about hiding and protecting data with the private access level. If a variable or a method are declared private, they can be used only within the class where they were declared. The next code sample represents the class Car and declares some of its members as private. Note that I’ve created this class in the package vehicles.

By looking at this code I can say that the class Car exposes only one public method brake, which internally may invoke several other functions that a driver does not need to know about. For example, if the driver pushes the brakes pedal too hard, the car’s computer may apply special anti-lock brakes implemented in private methods.

I took the next screen shot in IntelliJ IDEA while writing a class CarMaster that uses Car. IDEA helps me with suggesting the Car class members that I can use in this context. Only the method brake is visible from the class Car (other methods are from the class Object).

The private access level is the most restrictive one. If you’re not sure when to use it, just declare all of your call member variables and methods as private, and loosen this restriction if other classes need to use these members.

What do you think will happen if you simply remove the private keyword from one of the methods of the class Car? Will the CarMaster see it? No, it won’t because the absence of the access qualifier gives a package access level to this member. Only classes that are located in the package vehicles can access it, and CarMaster is not one of them.

The class members declared with the protected keyword can be accessed from other members of the same class, from its descendants or classes located in the same package. Even if a descendant class is located in a different package, it’ll be able to access protected methods of its ancestors.

Some software developers are creating libraries or frameworks of classes to be used by other developers. These classes can be extended, and their creators may use the keyword protected trying to allow access to certain member only descendant classes. But in the real world no one can predict what the developer may want to do with their libraries, and the keyword protected may become an obstacle in achieving of their goals. I do not use the keyword protected in my projects. As you gain more experience with Java, see for yourself if the keyword protected brings some value to your programs.

In Java all classes are directly or indirectly inherited from the class Object, which is the root of the class hierarchy. In Figure 2 you’ve seen a class Car that has number of methods that we’ve never declared - they belong to the class Object, and the class Car extends Object even though we’ve never asked for it. So any of your application classes have an ancestor - Object.

When you declare a variable to represent an instance of your class, you can give it a type either of your class or any of its ancestors. For example, both of the following declarations are correct:

Java compiler can cast (convert) one data type to another as long they have inheritance relation. In particular, Java compiler can automatically cast the type to the class ancestors. This is called upcasting. But if a variable has the type of a super class, it won’t see any members of the subclass. The next screen shot shows that the variable myOtherCar doesn’t see the method brake declared in the class Car.

But you can say, "Doesn’t the variable myOtherCar point at the instance of the class Car, which has a public method brake?" That’s right, but since I declared this variable of the type Object the variable myOtherCar assumes that its just a general object. The programmer can downcast the general type to a more specific one, but this has to be done explicitly by placing the specific type of the object in parentheses before the variable of more general type, for example:

It’s like you’re saying, "I know that the variable myOtherCar is of type `Object, but it actually points at the Car instance". Now the variable myOtherCarAfterCasting will see the method brake declared in the class Car:

Why do we need all these complications? Can’t we just always declare variables of the specific types? Sometimes we can’t. For example, JDK comes with lots of other classes that were written to work with the Object data types. Data collection classes were written to be able to store instances of any objects.

Creators of data collections had no idea that you might need to store instances of Car or Fish there. But when you use the data collection object in your program, the data type is known. In the next section you’ll see an example of a FishTank program that stores instances of the class Fish in the ArrayList and then casts them back to the type Fish:

Now let’s see how to work with collections of data. Say you have a hundred songs in your MP3 player. It’s a collection. If you’ll create a class Song you can create a hundred of instances of this class (one for each song) and put it in a one of the special data structures called Java collections.

Java packages java.util and java.util.concurrent include classes that are quite handy when a program needs to store several instances of some objects in memory. There are dozens of collection classes in Java, but I’ll just show you a couple of them. Some of the popular collection classes from the package java.util are ArrayList, HashTable, HashMap, and List.

The package java.util.concurrent has collections useful in programs that require concurrent (simultaneous) access to some data by different parts of a program (by multiple threads). I’ll introduce you briefly to the concept of multi-threading later in this chapter, but the coverage of concurrent collections doesn’t belong to the introductory book like this one.

Java generics is a feature that allows you to create so called parameterized data types. For example, instead of just declaring a collection that can store any data you can pass it a parameter to allow only the objects of certain data types. Instead of declaring and instantiating a general collection to store friends like this:

you can do it with a parameter so it can store only String objects like this:

The parameter(s) goes in the angle brackets right after the data type. Note the so called diamond operator <> on the right. Since you already declared the required data type on the left, there is no need to repeat it on the right - compiler will guess the type. It’s also an example of type inference introduced in the previous lesson about lambda expressions. Now, if by mistake you’ll try to add an object of another type to friends the Java compiler will complain.

I was able to specify a parameter for ArrayList only because it was created with this ability. If you’ll read the online documentation for ArrayList you’ll see that it’s declared as follows:

That <E> means that you’re allowed to specify a parameter type of elements that will be stored in the the ArrayList. In case of the friends collection the Java compiler would see that in this collection <String> should be the <E>. The online documentation for the class Hashtable looks even scarier:

But <K,V> simply means that you can specify two parameters: K is the the key data type, and V for value.

Let’s write a program that illustrates the advantages of using generics. I’ll reuse the example from the previous section called HashTableDemo that stored ContactDetail instances. Actually, I’ll create two new versions of this program. The first one will be called HashTableBrokenDemo, and I’ll show how to break this program so it crashes during the runtime if we don’t use generics. After that, I’ll rewrite it as HashTableGenericsDemo, where I’ll use generics to show how to prevent the runtime errors from happening. Here’s the broken program:

The HashTableBrokenDemo adds the first object (for Jackie) of type ContactDetail to the friends collection, but the contact details for Art are added in the form of a String:

Java compiler sees no crime here - the Hashtable can store any descendants of the class Object. But if you’ll run this program, you’ll get an error in the line that tries to cast the collection element to ContactDetail type. This is how my IntelliJ IDEA screen with the error looks like:

The program failed on line 24 with the error ClassCastException. The runtime errors are called exceptions in Java, and I’ll explain error handling in Chapter 10. But my main point is that this program has crashed during the runtime just because I "forgot" that only the objects of type ContactDetail should be stored in the collection friends.

Now I’ll copy the code of HashTableBrokenDemo into the new class called HashTableGenericsDemo. I’ll make a small change there - I will declare the collection friends with parameters:

Now I’m explicitly stating that my intention is to use the String objects for keys, and ContactDetail objects as values. The program HashTableGenericsDemo is shown next - it won’t even compile!

The compiler will complain about the line, where I’m trying to call the method put with two String objects as arguments. The Java compiler will generate an error message that it can’t apply two String parameters to a Hashtable that was declared with parameters <String, ContactDetail>.

Another important thing to note is that there is no casting needed when the program gets the information about Jackie’s phone. Now the friends collection knows from the very beginning that it stores not just some Object types, but the ContactDetail instances.

What have we achieved? The program HashTableBrokenDemo allowed us to store anything in the collection but crashed during the runtime, but HashTableGenericsDemo prevented this error from happening. Having a compiler’s error it’s a lot better than getting surprises during the runtime, isn’t it? Besides, with generics we’ve eliminated the need to cast objects.

I’ve been using the parameterized data type Hashtable that was conveniently offered by the creators of Java, but you can define your own classes with parameters too. Creating your own parameterized classes is one of the more advanced topics, and I won’t be covering it in this book. Check out Oracle’s tutorial if interested.

So far, all our programs perform actions in a sequence – one after another. So if a program calls two methods, the second method is invoked only after the first one completes. In other words, such a program has only one thread of execution, where the code works sequentially.

In a real life though, we can do several things in parallel like eat, talk on the phone, watch TV, and do the homework. To do all these actions in parallel we use several "processors": hands, eyes, and mouth.

Today, only your grandma’s computer has a single processor (a.k.a. Central Processing Unit or CPU). A CPU performs calculations, sends commands to the monitor, hard disk or a solid state drive, remote computers on the Internet, and so on. Most likely your computer has at least two CPU’s and a GPU (Graphics Processing Unit) for processing graphics if any.

But even a single processor can perform several actions at once if a program uses multiple threads. One Java class can start several threads of execution that will take turns in getting time slices of the processor’s time. For example, the program asks the user a question and waits for the response. Meantime the CPU can be used for performing some other application logic instead of idling as shown in Figure 7.

A good example of a program that creates multiple threads is a Web browser. For instance, you can browse the Internet while downloading some files so one program (the browser) runs two threads of execution (browsing and downloading) in parallel.

In this exercise I’d like you to try create your own collection that uses ArrayList, generics, private variables and public getters and setters.

With JavaFX you can create Graphic User Interface in two ways:

I’ll show you both ways, but let’s start with some basics of development with JavaFX. Let’s set the stage - JavaFX uses theater terminology.

IntelliJ IDEA will help you to get started quickly. Just create a new project (the menu File | New Project), select JavaFX application as the project type and give it a name. In a second new project will be created with two Java classes Main and Controller and a file named sample.fxml as shown below.

The Main class of a JavaFX application extends Application and is an entry point of your application. JavaFX classes are located in the packages whose names start with javafx (e.g. javafx.stage and javafx.scene).The main method invokes the method launch from Application, which creates a stage by calling its method start, which was was declared as abstract. Hence, we must override start in our Main class. When the method start is invoked, it’ll receive a reference to the Stage object - this is where your GUI components will live and perform.

Pretend that you’re a play director and need to set up one or more scenes (views) on stage. But if in a real scene you’d expect to see some chairs, tables and other pieces of furniture, each JavaFX scene consists of GUI containers and components. In JavaFX you’ll create components, add them to the scene and then add a scene to the stage. When the stage is ready, open the curtain by calling the method show.

All GUI components are subclasses of the class javafx.scene.Node, and when I’ll be using the word node just think of a GUI component. Now you have a choice: create these nodes using Java classes or load the pre-created design from the .fxml file as it was done in the code generated by IDEA.

The method start loads the file sample.fxml, sets the title of the stage and creates a Scene 300 by 275 pixels.The content of the generated sample.fxml looks like this:

FXML is a markup language based on XML (a popular data presentation format). The idea is to separate the creation of the GUI in a declarative language (FXML) from the application logic (Java). If we didn’t use IDEA, the FXML would be generated by the Scene Builder itself. In FXML the GUI is represented by tags in angle brackets, e.g. <GridPane>. Each tag has a matching closing tag that starts with a forward slash, e.g. </GridPane> and may have attributes (e.g. alignment="center"). The <GridPane> tag corresponds to the Java class GrindPane, which is one of the JavaFX layouts - I’ll explain them very shortly. Every FXML tag has a corresponding Java class behind it.

The generated Java class Controller has just the pair of curly braces at this point, but in the next chapter we’ll be writing the application logic there. Later on you’ll connect the generated FXML views with the Java code of the Controller. Run the Main program and it’ll show an empty window shown next:

Users of your application can have computer monitors of different screen sizes and resolutions. JavaFX comes with layouts that help with arranging GUI controls on the scene and keeping the arrangement for different stage sizes (think window sizes). There are following layout container Java classes (and similarly named FXML tags):

The HBox class (the horizontal box) places controls in a row next to each other. The vertical box VBox places controls vertically. The FlowPane places the nodes in a row and then wraps to the next row if there is no room left in the current one.

The GridPane allows to arrange UI controls in rows and columns and assign constraints (properties) to each cell.

The BorderPane splits the scene into five regions, which are called left, top, right, bottom, and center.

The TilePane layout is similar to the FlowPane, but it places each GUI components in a cell of the same size similarly to tiles on the wall. Say, you need to display several images in a tile layout. Adding the ImageView components to the TilePane will shows them as tiles next to each other.

The StackPane layout works as a deck of playing cards - only one child node will be shown at a time covering the other nodes.

The AnchorPane lets you to anchor nodes at left, top, right, and bottom of the scene. Imagine a music player application with the buttons Rewind on the left and the Fast Forward on the right. For example, the AncorPane allows you to force the Rewind button to always remain at 20 pixels from the left border of the window and 10 pixels from the bottom even when the window resizes. For that you can use the leftAnchor and bottomAnchor properties. For example,

Components that are located in a container are considered children of this container. Accordingly, a container is called a parent of these components. If you’d be writing the code manually in Java, you’d be going through the following steps with any layout:

In this chapter we’ll use only some of the JavaFX layouts, but for detailed coverage of layouts visit Oracle tutorial at http://docs.oracle.com/javafx/2/layout/builtin_layouts.htm.

It’s easier to create layouts and components using a visual tool, and this is what we’ll do next.

Scene Builder 2.0 is a visual layout tool for JavaFX applications by Oracle. Download it from http://goo.gl/9jOse6. Follow the installation instructions for your operational system and install Scene Builder on your computer. In this section I’ll show you how to quickly get started with Scene Builder, but you should also watch this helpful Youtube video.

You can start the Scene Builder either independently or from IDEA. For example, if you right-click on the sample.fxml file in your newly generated IDEA project it’ll show you a popup menu, which includes the item Open in SceneBuilder. Select this item. The very first time IDEA will ask you to confirm the location of Scene Builder application on your computer. Then it’ll open sample.fxml in Scene Builder. This is how it looks on my computer:

On the left panel you can select containers, controls, menus, shapes and drag and drop them onto the central canvas area. Note the GridPanel layout shown at the bottom left - the arrangement of GUI components inside of this scene will be controlled by GridLayout. Let me select the Button from the Controls section on the left and drop it on the canvas in the middle. The Screen Builder’s window will look like this:

The right panel allows you to change the properties of this button. These little boxes with the digit one represent so called row and column constraints - we’ll discuss them shortly.

The Scene Builder’s menu Preview | Show Preview in Window will show how your GUI will look during the runtime. So far our one-button screen is not too fancy, and this is how it’s preview looks like:

Let’s save the changes in sample.fxml (menu File | Save) and open this file in the IDEA text editor. When IDEA generated sample.fxml there was no content between <GridPanel> and `</GridPanel>`in the generated sample.fxml, but now there is:

I’ll go through the details of the GridPane layout in the next section, but please note that Scene Builder created some tags to specify the constraints for the rows and columns of the grid. The Button component is placed inside the grid in the cell located in the intersection of the column 1 and row 1.

I’m not going to cover each JavaFX layout in detail, but will show you how to use a pretty powerful layout - GridPane. When we’ll work on the GUI for the calculator, I’ll also show you how to design a scene using a combination of layouts.

GridPane divides the area into rows and columns and places GUI components (the nodes) into the grid cells. With GridPane layout cells don’t have to have the same size - a node can span (be as wide or as tall as several others). If the screen size changes, the content won’t be rearranged and will maintain the grid look.

Before placing the node into a particular cell you have to specify the grid constraints such as rowIndex and columnIndex (the coordinate of the cell, which starts with 0,0). The rowSpans and columnSpan allow you to make the cell as wide (or as tall) as several other cells. The GridPane documentation describes lots of various constraints that can define the behavior of each cell’s content if the windows gets resized. I’ll show you a basic example that uses some of these constraints.