Beginning Java Programming: The Object-Oriented Approach (Programmer to Programmer) (2015)

---

Autoboxing is an automatic conversion made by the Java compiler between primitive types and their corresponding wrapper classes. For example, converting a double to a Double is called boxing, and converting a Double back to a double is called unboxing.

For each primitive type, there is an associated wrapper class available:

· boolean wrapper class: Boolean

· byte wrapper class: Byte

· char wrapper class: Character

· float wrapper class: Float

· int wrapper class: Integer

· long wrapper class: Long

· short wrapper class: Short

· double wrapper class: Double

· void wrapper class: Void

The void wrapper class does not actually hold a value but is a representation for the void return type.

The mechanism of autoboxing entails that it is perfectly fine to write code like this:

Double d1 = 5.4;

double d2 = new Double(3.3);

You might be wondering if it makes sense to use the primitive types’ wrapper classes instead of the default keywords. The best practice, however, is simply to use the primitive keywords and the wrapper classes only when you need to, that is, when you want to access a primitive variable as an object. Later in this chapter, when you read about Java’s collection types, you will see a typical use case where this is necessary.

In Chapter 2, you read an overview on Java’s language structure, including the syntax for classes, methods, and variables, and the different types in Java. Don’t worry if you don’t recall all the details, as you will revisit these concepts again in the following sections and learn about them step-by-step.

You’ll now convert the example of the course administration system to an object-oriented Java program. The first thing you need to do is define the concepts—the blueprints, templates, and types—that will be used in your application. These are the classes. In this example, you can introduce two class definitions: one for a Course and one for a Student.

TRY IT OUT Course and Student Classes

To create some simple Java classes representing students and courses, follow these steps:

1. If you haven’t opened a project in Eclipse, or just prefer to follow along and create a new one, you should do so by navigating to File New and then selecting Java Project in Eclipse. A dialog window will open asking you to fill in a project name. ChooseCourseAdministration. You can then press Finish to create the project.

2. You will create two classes within the src folder: Course.java and Student.java. You do so by right-clicking the src folder in the package explorer in Eclipse and then selecting New Class. A window will pop up asking you to fill in some details. The number of options offered might seem a bit daunting at first, but remember that the only necessary element you need to provide is the class name. All other aspects can be modified directly in the class’ source code, or changed by moving the class around. Let’s start with the Student class. In the wizard screen, you should enter the class name without the .java suffix, as Eclipse will add this for you (you will receive a warning when you do add the file suffix). Do not pay attention for now to the"The use of the default package is discouraged" warning. You’re just starting out, and can thus afford to be a bit sloppy. You will learn about packages later.

3. The Student.java file is created and opened in the Eclipse code editor (if it is not, you can double-click the file to open it in the Eclipse editor), showing a bare-bones class definition:

4. public class Student {

5.

}

6. Edit Student.java to look like the following:

7. class Student {

8. int id;

9. String firstName;

10. String lastName;

11. int birthYear, birthMonth, birthDay;

}

12.Save your file. You have now created a bare-bones class definition for the Student concept, containing variables for the ID, first name, last name, and date of birth. (For now, you’ll use a combination of three integers to represent the date of birth. There is also a Date class that will be discussed later.)

13. Similarly, create a Course.java class with the following source code:

14. class Course {

15. int id;

16. String name;

}

How It Works

Now take a look at how it works.

1. In Java, classes are stored in .java files, which should bear the same name as the class that is defined in them. In the first two steps, you initiate a new Java project in Eclipse and add two class source files using the wizard: Course.java andStudent.java.

2. The student and course classes are defined by declaring some variables, such as id, firstName, and birthYear. You remove the public declaration Eclipse has automatically added to the class source, as you will learn about access modifiers (such aspublic) later.

3. This is all you do for now. You’re not actually running or executing anything yet. Feel free to experiment, however, by adding more variables you can think of using the primitive types you saw in Chapter 2 to familiarize yourself with the syntax (Eclipse will provide errors or warnings when you make a mistake).

If you’ve followed along with the Try It Out, you will have noticed that a class definition looks pretty straightforward at this point:

class CLASSNAME {

// VARIABLE DEFINITIONS

}

That is, class definitions start with the keyword class, followed by the class name. Java imposes almost no restrictions on which characters or names you can use for class names, except for the fact that class names should start with a letter, the underscore character (“_”) or a dollar sign (“$”). The following names can all be valid class names:

· Course

· Student

· _

· abcde

· Number0

· $DOLLAR$

·

·

Remember, as discussed in Chapter 2, keywords are not valid class names, meaning that class, true, null, and so on are not accepted as class names.

In general, however, it is a very good idea not to go overboard when defining classes and to stick to (western) alphabetical characters only. If you recall the section on naming conventions in Chapter 2, you will remember that you format class names in UpperCamelCase(meaning that each word in the class name starts with a capital letter). This is the widely accepted convention in the Java community, and one this book follows as well.

NOTE By the way, you might have tried to create a class named “” in Eclipse, only to have it show up as an empty file with Eclipse throwing a warning about character encodings. The reason for this is that Eclipse by default uses a subset of all possible characters for source code, called Cp1252. While this subset contains most Western characters, it does not contain Chinese, Japanese, Thai, or other characters found in non-Western languages. This implies that it is also not possible to include code such as this:

System.out.println("The word for student in " +

"Chinese and Japanese is written in the " +

"same way: ");

If you want to use all characters in Eclipse source code, you will need to open the Preferences window, navigate to General ➢ Workspace, and then select Other: UTF-8 under Text File Encoding. This will ensure that Eclipse saves your source files with Unicode encoding, and will thus allow you to use Unicode class names and output. (Unicode is a gigantic character set supporting and containing almost all character glyphs in use by humanity today; see www.unicode.org for more details.)

Before you rush off to the preferences to change this setting, keep in mind, however, that changing the source file encoding is generally a bad idea. The reason for this mainly stems from portability and compatibility. Not all operating systems and Java versions support Unicode equally well, meaning that Unicode characters that look and open fine on your workstation (with your version of Eclipse) might not show up correctly on other people’s machines.

But what if you just came up with a killer application and want to target the Chinese market? Surely, it should be possible to translate your program? When that happens, you have two ways to make this work. The first is to change your source file encoding (and deal with portability issues as they pop up). The second way is to use “escape” Unicode characters, like so:

System.out.println("The word for student in " +

"Chinese and Japanese is written in the " +

"same way: \u5B66\u751F");

To escape a Unicode character, you write a backslash (\), followed by the lowercase letter u, followed by four hexadecimal (0-9, A-F) characters representing the code point of the character. You can find tables and websites helping out with this task online. One such example that allows you to look up characters is: http://www.fileformat.info/info/unicode/char/search.htm

As a final note, you might have tried one of these code samples in Eclipse to see if the text appears in the output, only to see two question marks (??) or garbled text appearing where the Unicode characters should be. The reason behind this is that not only does your editor need to enable support for saving Unicode files, your console—which runs the program—must also be able to show them. By default, neither the Eclipse console nor the Windows console offers support for this (showing Unicode code characters in GUI applications, however, will work). On Linux—another operating system—the console does support Unicode character output.

This all being said, I’m sure you will agree that character encodings, Internationalization, and Unicode is a complex affair. In fact, this is not a problem with Java itself. Java actually provides very solid Unicode support compared to most other programming languages. This problem plagues all aspects of computing, programming, and software engineering. Computers in the 80s did not deal with languages other than English and thus supported only a very small, basic set of characters, the effects of which still have an impact on programming languages today. As such, I will keep things simple throughout this book and work with basic Western characters only.

The class’ body is surrounded by curly brackets, { and }. Within this body, you define the variables (the data) and the methods (the behaviors) of the class. Variable definitions start with a variable type, followed by one or more variable names, followed by a semicolon (used at the end of each statement in Java). Here are some examples:

· int id;

· String firstName, lastName;

· double discountPercentage;

Observe the use of the comma (,) as a shorthand to define variables of the same type. That is, you could also write String firstName, lastName; as:

String firstName;

String lastName;

Recall the naming convention of writing variable names in lowerCamelCase, whereby each word in the variable name is capitalized, except for the first one, which starts with a lowercase letter. This convention helps to distinguish variables from class names. Note that this convention is not as widely adhered to as CamelCase for class names. That is, you might find code that uses snake_case (using underscores) as well.

You will learn about variable definitions in a little more detail later. For now, you’ll continue looking into the basic class definition, and seeing how you extend it to add method definitions:

class CLASSNAME {

// VARIABLE DEFINITIONS

// METHOD DEFINITIONS

}

The following Try It Out shows you how to add some simple methods to the Student and Course classes.

TRY IT OUT Adding Methods to the Course and Student Classes

You will use the Student class definition to add a number of methods.

1. Open the Student.java class you defined in the previous Try It Out in Eclipse, or create a blank class if you haven’t done so already.

2. Modify the class definition so that it looks as follows:

3. class Student {

4. int id;

5. String firstName;

6. String lastName;

7. int birthYear, birthMonth, birthDay;

8.

9. boolean isBirthday() {

10. // Return true if it's the student's birthday today.

11. return false;

12. }

13.

14. void giveWarning(boolean isFinalWarning) {

15. // You should study harder!

16. }

17.

18. int numberOfFriends() {

19. // Return the number of friends the student has.

20. return 0;

21. }

}

How It Works

Now take a look at how it works.

1. In the source code of this class, you have now added three method definitions: for isBirthday, giveWarning, and numberOfFriends, respectively.

2. Each of these methods starts with a return type (boolean, int, or void when no return type is expected), the name of the method, and a number of arguments the method takes as inputs.

3. The method bodies do not look particularly interesting as of now, and just return a value immediately or do nothing.

4. Again, you’re not running this code yet, but feel free to add more method definitions for the Student and Course classes. If you’re up to it, you can also try adding some code to the method bodies.

Again, if you’ve followed along with the Try It Out, you’ll recognize the same pattern showing up for each method definition. That is, methods start with a return type, followed by the name of the method, and then a number of arguments the method takes as inputs (for example, the isFinalWarning argument for the giveWarning method). Just as with variables, recall that method names are written in lowerCamelCase. The method’s “body” is surrounded by curly brackets, { and }, just as for classes. Note that this creates a hierarchy: methods are defined within the class body, and the code for the method itself is defined within the method body.

Methods can return any kind of type, meaning that the following can all be valid method definitions:

· String nickname(){ /* ... */ }

· int numberOfPartiesWentTo(){ /* ... */ }

· Student bestFriend(){ /* ... */ }

· String[] listOfFavoriteCountries(){ /* ... */ }

When a method returns something, you need to specify the return value by using a return statement in the method’s body. Even when a method does not return anything, you need to explicitly specify this fact by using the void keyword in the method’s definition, as shown, for example, in the giveWarning method in the Try It Out.

A method takes an arbitrary number of arguments. Arguments are separated by commas (,), and for each argument, the type needs to be specified. Even when a method takes no arguments, the parentheses () need to be added to the method name. Some examples:

· void drinkBeer(int nrOfGlasses){ /*...*/ }

· int numberOfCoursesPassed(boolean onlyIncludeFirstTry) { /*...*/ }

Take some time to get acquainted with these concepts and familiarize yourself with basic class definitions. Feel free to add more classes (Teacher and CourseRoom are fine examples) and come up with some variables and methods for them.

Schematically, a class definition with a variable and methods can be represented as shown in Figure 4.1.

Figure 4.1

You now know how to define the “blueprints” for these concepts, but you haven’t seen yet how to instantiate these blueprints. That is, how do you create objects from the blueprints you defined? The next section explains how to do so.

NOTE Recall that the basic class definition, for now, looks as follows:

class CLASSNAME {

// VARIABLE DEFINITIONS

// METHOD DEFINITIONS

}

You might be wondering if this ordering is strict, meaning whether the classes really have to start with variable definitions first, followed by method definitions. The answer is no. For example, it is perfectly okay (syntactically) to write a class like the following:

class Student {

boolean isBirthday() {

// Return true if it's the student's birthday today.

return false;

}

int id;

void giveWarning(boolean isFinalWarning) {

// You should study harder!

}

String firstName;

int numberOfFriends() {

// Return the number of friends the student has.

return 0;

}

int birthYear, birthMonth, birthDay;

String lastName;

}

While neither Eclipse nor Java will care about this, you—the programmer—should. Stylistically, this code scores badly. It’s hard to follow and will only serve to confuse you and others later. Therefore, it’s best to stick to the convention of “variables first, methods next.” In addition, keep in mind that code is read more often than written, no matter the language it is written in. Therefore, it is always a good idea to keep program code as clean, organized, structured, and readable as possible, as well as to follow common conventions and commenting where necessary.

Creating Objects

You have seen how to define simple classes in Java. Remember that classes are like blueprints or prototypes from which objects are created. For example, you defined the class Student as a concept having a name, an ID, and some methods describing its behavior, but you have not yet created an actual student. Now that you have defined the class, however, you can create, or instantiate, hundreds of students, each with their own properties. In object-oriented programming terms, you say that you want to create a student object that’s an instance of the class of objects known as Student.

Objects are created using the new keyword. For example, to create a new student, you would simply write the following statement:

new Student();

Of course, just creating a student in itself does not help you much, as you need to have a way to access this particular object later on. How do you do so? By simply assigning the newly created student to a variable, of course:

Student myFirstStudent = new Student();

Now you can use the myFirstStudent variable to access the first student later. You might be wondering why the parentheses appear at the end of student. It’s not a method definition, right? So, why not just write:

Student myFirstStudent = new Student; // Incorrect!

The reason is that when you instantiate a class, you are in fact actually calling a special method of the class called a constructor. Since it is a method, it can take a number of arguments. For example, you might have defined the class so that you immediately need to pass a name for the new student:

Student myFirstStudent = new Student("Sophie", "Last Name");

In fact, this is a better way to define the class, as it doesn’t make much sense to allow programmers to define students who do not have a name. Since you are just getting started with classes and objects, however, you can be a bit sloppy in the name of learning. Don’t worry, you will return to constructors later in this chapter. For now, the classes can be instantiated without any arguments.

NOTE Observant readers might wonder why the Student class definition does not contain a constructor method to create a new Student, even when this method does not take any arguments. For all the other methods, you see that you have written, for example:

int numberOfFriends() {

// Return the number of friends the student has.

return 0;

}

So where is the constructor method? The answer is that you do not have to define it. When you do not supply any constructor method, Java will be smart enough to know that it should just create a new Student object with all its variables set to the default values when you write:

Student myFirstStudent = new Student();

You will explore constructors in more detail later in this chapter.

Now that I am talking about constructors and Student objects being created without a name, it’s a good time to emphasize another important aspect, namely the fact that the name you give your Student variable has nothing to do with the variables of the Student. An example will help to illustrate this. Say you define a student as follows:

Student marc = new Student();

Even though the variable is named marc, this does not mean that the firstName variable of this object must be equal to marc. Of course, it makes sense to use marc as a variable name for the student named Marc, and no one in their right mind would use sophie as a variable name for the student named Marc, but there is nothing prohibiting you from doing so. The name of the Student variable is just a handle to refer to the Student object itself, and has nothing to do with the internals of that object.

The following Try It Out will show you how to create some students in the example course administration program.

TRY IT OUT Creating Student Objects

You will use the Student class definition as a blueprint to create a number of Student objects. If you have not followed along with the previous Try It Outs, you should create a Student class now with the following content:

class Student {

int id;

String firstName;

String lastName;

int birthYear, birthMonth, birthDay;

boolean isBirthday() {

// Return true if it's the student's birthday today.

return false;

}

void giveWarning(boolean isFinalWarning) {

// You should study harder!

}

int numberOfFriends() {

// Return the number of friends the student has.

return 0;

}

}

1. Add the following main method to the Student class definition as follows. Note the use of the new keyword to create objects:

2. public static void main(String[] args) {

3. Student firstStudent = new Student();

4. Student secondStudent = new Student();

5. firstStudent.id = 1;

6. firstStudent.firstName = "Marc";

7.

8. secondStudent.id = 2;

9. secondStudent.firstName = "Sophie";

10.

11. System.out.println("The student object referred to "+

12. "by the variable secondStudent has the first "+

13. "name: "+secondStudent);

}

14.You should now be able to run the Student class from Eclipse and observe the output given on the console.

How It Works

Now take a look at how it works.

1. The new keyword is used to create objects, which you will use to create a bunch of students. Note the use of the dot (.) operator in this code to access (read and write) the Student objects’ variables.

2. As Java is a fully object-oriented program, however, you need to find an appropriate place to create the students. Loose scripts cannot exist in Java, meaning that you have to create the students inside a method definition of a class.

3. To actually execute, that is, run the program, you add a so-called main method to the Student class. As Java has no way of knowing which particular method you want to use as the entry point of the program, a special method exists—the so-called mainmethod—that serves exactly this purpose.

4. When running this program from Eclipse, Java will call the class’ main method. The main method will create some students, set their variables, and print some information to Eclipse’s console.

5. You might be wondering what the public and static keywords are doing before the main method definition. Don’t worry about these too much for now. You will see what static does later on in this chapter and learn about the role of public in Chapter 8. For now, just keep in mind that the main method must be public, static, return nothing (void), and take a single argument: an array of strings, String[]. The name of the argument can be changed, but by convention, args is used. The reason for this is that this method argument will contain the list of arguments that was passed to Java.

6. Note that, generally speaking, mixing in this main method with the student class definition is not a good idea. Ask yourself the following: is a student responsible for creating some students? The answer is, of course, no.

7. As such, you can also put this program logic somewhere else. The question is then, of course, where? Think about this, which class of objects should be responsible for the behavior of creating some students? You might come up with different answers. For example, you might say, “I just want my program to create some students.” So what you can do is add a class, called MyProgram, to hold a single main method:

8. class MyProgram {

9. // I am the program managing your Student and Course objects.

10.

11. public static void main(String[] args) {

12. Student firstStudent = new Student();

13. Student secondStudent = new Student();

14. firstStudent.id = 1;

15. firstStudent.firstName = "Marc";

16.

17. secondStudent.id = 2;

18. secondStudent.firstName = "Sophie";

19.

20. System.out.println("The student object referred to "+

21. "by the variable secondStudent has the first "+

22. "name: "+secondStudent.firstName);

23. }

}

24.The behavior of managing students is now cleanly separated from the behavior a student itself exposes. Later, you might want to create an Administrator class to perform this sort of management, but for now, all you want to do is run this simple example program, so the current way of doing things is fine to illustrate the idea.

Figure 4.2 represents the creation of objects from classes, schematically.

Figure 4.2

You have now seen how to create simple class definitions in Java, containing variables and methods. By now, you should grasp the differences between classes and objects, and should be able to define classes and to instantiate them. You’ve been taken on a quick tour through the concepts of classes and objects in Java, so now that you get the bigger picture, you can take a step back and learn more about variables and methods, with all their intricacies, which is exactly what you will do in the following sections.

STORING DATA: VARIABLES

In the previous section, I defined the simple class outline as follows. A class contains a block of variable definitions (data) and methods (behaviors), like so:

class CLASSNAME {

// VARIABLE DEFINITIONS

// METHOD DEFINITIONS

}

You will now zoom in further on the aspect of defining variables within a class. Specifically, this section discusses:

· Instance variables: Variables that will be used to hold data of objects.

· Class variables: Variables that are not bound to an object but instead belong to the class as such, that is, to the blueprint of the object.

· Final variables: Variables that—after their initial assignment—cannot be modified.

Finally, I will also devote some words to the topic of variable scope. A scope of a variable is the context in which it’s defined. This means that, depending on how you define a variable, it will affect where and how this variable can be accessed.

Instance Variables

In object-oriented programming, an instance variable is a variable that’s defined in a class (as you have done before for firstName and lastName in the Student class, for instance). Instance variables are also commonly referred to as member variables or fields of a class.

Instance variables belong to objects, meaning that each object of the class keeps a separate copy of this variable. Let’s illustrate this idea with an example: instance variables can be introduced by simply defining them in the class body. Let’s say you want to create a class for the concept of a book. The bare-bones class then looks like this:

class Book {

}

(Feel free to follow along in Eclipse.) An empty class it not much fun to work with, so you need to think of some data. Well, since books have a title and an author, you might want to define some variables to represent this. Since a book can have multiple authors, you might even want to define this data aspect as a composite data type. Perhaps something like the following:

class Book {

String title;

String[] authors;

}

NOTE If you were thinking, “Wouldn’t it be a good idea to abstract authors away into a separate class, say, Author?”, you would be absolutely right, although it depends on the complexity you foresee your program having to deal with. Can you imagine keeping author information nicely separated with authors having their own data (first name, last name, and birth date) and behaviors? Then yes, it makes sense to create an Author class. If you are planning on keeping a simple string to represent author information for books (like you are doing here), the simple solution is fine.

To paraphrase the famous quote from Einstein, “Everything should be made as simple as possible, but no simpler.”

Now, you have already seen how to create some Book objects, that is, some books. For example, you might write a piece of code doing something like the following:

Book book1 = new Book();

book1.title = "Beginning Java";

book1.authors = new String[]{

"Bart Baesens",

"Aimee Backiel",

"Seppe vanden Broucke"

};

Book book2 = new Book();

book2.title = "Catcher in the Rye";

book2.authors = new String[]{"J. D. Salinger"};

This code creates two book objects—book1 and book2—and sets their title and author variables. As you can observe, each book object keeps its own copy of the title and author variables, which can be accessed and modified independently.

That is all you need to know to get the idea about what instance variables are all about. They are basically just a part of the class blueprint, and get instantiated for each object you define belonging to that class.

As a reminder, however, recall that you can define multiple variables of the same type by separating them with commas, like so:

int a, b, c;

In fact, this not only works for instance variables, but works for any variable you define no matter where and no matter of which type (it does not have to be a primitive type). For example, the code sample to create the two books could also be rewritten like so:

Book book1, book2; // Define two empty Book objects

book1 = new Book(); // Set first book

book1.title = "Beginning Java";

book1.authors = new String[]{

"Bart Baesens",

"Aimee Backiel",

"Seppe vanden Broucke"

};

book2 = new Book(); // Set second book

book2.title = "Catcher in the Rye";

book2.authors = new String[]{"J. D. Salinger"};

Every instance variable you define defaults to a particular value, depending on the variable type. For instance, you might wonder what happens if you ask for the title of a book, without specifying a title first:

Book book3 = new Book();

// Oops, forgot to set title...

System.out.println("Title equals: "+book3.title);

The answer is that “Title equals: null”. For variables with a class type, the default value is a special keyword representing emptiness, null. Since String is a non-primitive class, its default value is thus null. Remember, as discussed in Chapter 2, the default values, per data type, are:

· For boolean: false

· For byte: 0

· For short: 0

· For int: 0

· For long: 0L

· For float: 0.0f

· For double: 0.0d

· For char: \u0000 (the null character)

· For String or any object: null

Note that these default values apply only to fields (instance variables). That means if you try to be clever and add the following to the code snippet:

Book book;

System.out.println("Now, book equals: "+book);

book = new Book();

System.out.println("And now, book equals: "+book);

Eclipse will complain about the book variable not being initialized. This can be fixed like so:

Book book = null;

System.out.println("Now, book equals: "+book);

book = new Book();

System.out.println("And now, book equals: "+book);

The same applies for other variables you define that are not instance variables:

int a = 0;

System.out.println("int a equals"+a);

NOTE You might have tried to execute this code snippet to see something like the following appearing on-screen:

Now, book equals: null

And now, book equals: Book@709fa12f

What’s going on with this Book@709fa12f (your output will differ and return a different part after the @)? The reason for this is that all Java objects have a built-in method to return their so-called “String representation,” which can be extended by programmers to provide a friendly output for an object, that is, a String that textually represents the object (don’t worry about the specifics of this too much for now; you will get back to this later). The key aspect to know here is that, when no extension is provided by the programmer, Java will just resort to showing the class name (Book), followed by an @, followed by the hexadecimal representation of the object’s hashcode.

Hashcodes are an advanced Java concept and are used to provide a quick integer representation for an object, which can be used as a quick check to see if two objects are equal (they have the same hashcode). Again, the way a hashcode is calculated can be extended by the programmer. If this is not done, then the hashcode corresponds to the internal address of the object in memory, although the particular default behavior may vary from one JVM implementation to another.

Finally, you might be wondering what happens when you try to access an object’s field (instance variable) when an object was not created first, such as done here:

Book book = null;

System.out.println("Now, book title equals: "+book.title);

Eclipse will allow you to execute this code, but the program will quickly crash with the following message:

Exception in thread "main" java.lang.NullPointerException

at Book.main(Book.java:XX)

Not surprising, because accessing a variable of something that doesn’t exist is sure to give problems. In this code sample, it’s easy to see where the problem lies (Eclipse will even put up a warning regarding this foolish behavior), but in larger programs, it is a common pattern for methods to create objects, or return null in case something failed. When this object is then accessed (or passed on to another method, perhaps) without explicitly checking for null, a NullPointerException error will pop up as soon as you try to access a variable or method of this object, as the following code sample illustrates:

Book giveMeABook() {

//return new Book(); --> Sorry, no books available for now

return null; // Return null instead

}

Book myNewbook = giveMeABook();

// Forgot the check for null?

System.out.println("Title equals: "+myNewBook.title);

// This will give an error

NullPointerException errors are a prevalent problem when programming in Java, and oftentimes it is hard to track down the root cause behind them as you have to track down where and why a particular object has not been instantiated (i.e., the variable equals null). Therefore, it is a good idea either to program defensively and always check for null when retrieving an object and before moving on with using the object, or to program in such a way that only in a limited number of cases a null variable is passed from one part of your program to another.

This code also immediately illustrates that you are not forced to use the default values for instance variables. For example, you can modify the Book class to assign defaults to the title and author variables:

class Book {

String title = "Unknown Title";

String[] authors = new String[]{"Anonymous"};

}

And, combining this with the knowledge on how to define multiple variables of the same type in one go, you can add:

class Book {

String title = "Unknown Title";

String[] authors = new String[]{"Anonymous"};

int yearReleased = 2014, copiesSold = 0;

}

With this knowledge under your belt, you might be wondering, as each object keeps its own copy of instance variables, is there also a way to define a common variable, something that’s shared between all objects belonging to the same class? Indeed there is . . .

Class Variables

In object-oriented programming, a class variable, also denoted as a static variable, is a variable that’s been allocated “statically”—meaning that this variable is shared between all objects (instances) belonging to this class. Further, since class variables belong to the class blueprint, it is not necessary to create objects to be able to access and modify class variables. It is sometimes argued that class variables do not really adhere to “pure” object-oriented programming principles. Other, stricter programming languages, such as Scala, do not allow them, for instance. That said, this is not to be regarded as a shortcoming of Java, as we will see that class variables can come in handy in many cases. However, it is best not to overuse them.

I’ll explain this by providing an example. Let’s modify the Book class so it looks as follows:

class Book {

static int maxAmountOfPages = 500;

String title = "Unknown Title";

String[] authors = new String[]{"Anonymous"};

int yearReleased = 2014, copiesSold = 0, nrOfPages = 1400;

}

Note the static keyword in front of the maxAmountOfPages class variable. This variable denotes the maximum amount of pages you currently support for books, which could be used in combination with the nrOfPages instance variable to check whether you can publish a given book, for instance. Although the number of pages is different for each book you define, the maximum amount of pages the printers support is a global property throughout all Book objects, is defined as a class variable, and is thus accessible by all Book objects.

A code sample illustrating this concept might look like this:

Book superLargeBook = new Book();

superLargeBook.title = "Super Large Boring Book";

System.out.println("I have a book here with the title: "+superLargeBook.title);

System.out.println("Written by: "+superLargeBook.authors);

System.out.println("Released in: "+superLargeBook.yearReleased);

System.out.println("With number of pages: "+superLargeBook.nrOfPages);

System.out.println("However, we only support books with max. pages: "

+superLargeBook.maxAmountOfPages);

Running this code outputs:

I have a book here with the title: Super Large Boring Book

Written by: [Ljava.lang.String;@1271ba

Released in: 2014

With number of pages: 1400

However, we only support books with max. pages: 500

NOTE You might have spotted the following line:

Written by: [Ljava.lang.String;@1271ba

And wondered what’s up with this. This isn’t the default Anonymous author you set! The reason for this behavior is again due to the way Java derives a String representation of composite types, which is not very user friendly in this case. There are two ways to resolve this issue. The first is to loop through the array and show each element one by one (you will look at looping constructs in the next chapter). The second way is to use so-called “Collection” classes, which are similar to arrays in the sense that they hold a bunch of information, but are also much more flexible and efficient. In addition, their String representation looks much friendlier. You will learn about collections later in this chapter.

However, for the last line, when accessing the static variable, Eclipse complains about the fact that "The static field superLargeBook.maxAmountOfPages should be accessed in a static way". What is meant by this? Well, it means that it’s generally preferred to access and modify static variables not by accessing them through an object variable, but by using the class name directly, like so:

Book.maxAmountOfPages = 2000; // Let's increase the max amount of pages

System.out.println("We now support books with max. pages: "

+Book.maxAmountOfPages);

Accessing and modifying static variables in this manner has two benefits. First, you do not need to create an object in order to access the static variable. Second, this way makes it clear to readers that the variable being accessed is a static one, without them needing to read the class definition. Finally, speaking of class definitions, it’s generally a good idea to define class variables before defining instance variables when you write classes, just to keep things clean and readable.

Static variables are oftentimes used to define so-called constants: variables whose values will never change during the execution of a program. However, as you have seen, it is perfectly okay to change the maximum amount of pages by setting a new value toBook.maxAmountOfPages. If you want to keep variables fixed during the program’s execution, you need to consider another concept: final variables.

Final Variables

In Java, final variables are variables that can be initialized only once, either directly when defining the variable, or later in one of the class methods. Once a value has been given to the variable, however, it cannot be modified any longer.

You can see an example of a final variable by returning to the book class and modifying it a little, so the complete class looks as follows:

class Book {

final String title = "Unknown Title";

String[] authors = new String[]{"Anonymous"};

int yearReleased = 2014, copiesSold = 0, nrOfPages;

public static void main(String[] args) {

Book superLargeBook = new Book();

superLargeBook.title = "Super Large Boring Book";

superLargeBook.nrOfPages = 1400;

}

}

Note the change to the title variable, as it now has the final property. To keep things simple for now, I have also removed the static variable and have put some testing code in a main method, so you can execute this class.

NOTE The previous testing code snippets can also be placed in the main method of Book, but remember that it is generally not a good idea to “pollute” classes representing real-world concepts with main methods. Alternatively, you may also create aMyProgram class and put the code snippets in its main method, similar to what you did in the course administration example earlier in this chapter.

However, Eclipse will refuse to compile this code, as it complains that you cannot give the title variable a new value (“Super Large Boring Book”), as it has already received its value at the time of creating the object (“Unknown Title”). To get this code to work, you might be inclined to make title a blank final variable, like so:

class Book {

final String title;

final String[] authors;

final int yearReleased, nrOfPages;

int copiesSold = 0;

public static void main(String[] args) {

Book superLargeBook = new Book();

superLargeBook.title = "Super Large Boring Book";

superLargeBook.nrOfPages = 1400;

}

}

Note that I have also reworked some other variables, as it makes sense that the title, authors, number of pages, and the release date never change for a book (not taking into account reprints and other such intricacies at the moment). Hence, it makes sense to set these to read-only.

However, you will notice that Java will still complain about the title and nrOfPages assignments and refuse to compile this code fragment. Why? Especially when the following code (you can put this somewhere in the main method) does in fact work:

final int a;

a = 5;

The reason lies in the fact that title, authors, yearReleased, and so on are class variables, whereas the a integer is just a local variable. Remember that when you initialize an object, Java will assign default values to the instance and class variables for which no value was set. For final variables, on the other hand, Java will not set an initial value and will force you, the programmer, to explicitly provide an initial value. For local variables inside our main method, we can define a blank variable and initialize it later (before using it), as seen above, but for instance and class variables, this remark entails that we cannot do the following:

class Book {

final String title;

}

If we try to do this, Java will warn that we have not initialized the title variable.

Given this point, it might occur to you that final class variables are, for now, pretty useless. You have found no way to create books with a given initial title that’s kept as a read-only variable. To resolve this, you need to understand another concept: objectconstructors. Don’t worry, you will learn about these a few pages later, and you will revisit final class variables there as well.

There is, however, another way that final variables come in handy, and that is when you use them in combination with static variables. Change the Book class again to look like the following:

class Book {

final static int MAX_AMOUNT_OF_PAGES = 500;

final static int MIN_AMOUNT_OF_PAGES = 50;

String title;

String[] authors;

int yearReleased, nrOfPages;

int copiesSold = 0;

public static void main(String[] args) {

Book superLargeBook = new Book();

superLargeBook.title = "Super Large Boring Book";

superLargeBook.nrOfPages = 1400;

System.out.println("Check if your book has a correct amount of pages...");

System.out.println("- Minimum amount: "+Book.MIN_AMOUNT_OF_PAGES);

System.out.println("- Maximum amount: "+Book.MAX_AMOUNT_OF_PAGES);

System.out.println("- Your book: "+superLargeBook.nrOfPages);

}

}

Note the two final static variables at the top of the class body. This pattern is very heavily used by Java programmers to define constants, meaning that you desire to set the maximum and minimum amount of pages only once (they are final), and also to keep them shared by all objects (they are part of the class blueprint). Note by the way that Java has a const keyword, but it currently remains unused.

Also observe the change in naming convention when declaring constants with final static variables. Instead of writing in lowerCamelCase, you name them using CAPITALIZED_UNDERSCORE_SEPARATED form. Again, this is not required, but it’s a widely followed convention by Java programmers to indicate constant variables.

There is one final (no pun intended) important remark I need to make regarding final variables. Remember that I have stated that final variables can only be initialized once, and then keep their value. For primitive types, the effects of this are easy to grasp—a final integer set to the number five remains five for the remainder of its life. However, for more complex types, such as objects, the story is a little more complicated. Consider the following example:

class Book {

final static int MAX_AMOUNT_OF_PAGES = 500;

final static int MIN_AMOUNT_OF_PAGES = 50;

String title;

String[] authors;

int yearReleased, nrOfPages;

int copiesSold = 0;

public static void main(String[] args) {

final Book superLargeBook = new Book();

superLargeBook.title = "Super Large Boring Book";

superLargeBook.nrOfPages = 1400;

// Change the amount of copies sold

superLargeBook.copiesSold += 1000;

}

}

Note how superLargeBook is final. However, later on, you have to modify the number of copies sold for this object. How is this possible when the code declared this object as final? After all, you should not be able to change it, right? The reasoning here is that final affects the number of times a variable may be initialized, or set. It does not mean that all the fields of an object (when the variable represents an object) will become “frozen” as well.

To illustrate the difference, the following code shows what you cannot do:

class Book {

final static int MAX_AMOUNT_OF_PAGES = 500;

final static int MIN_AMOUNT_OF_PAGES = 50;

String title;

String[] authors;

int yearReleased, nrOfPages;

int copiesSold = 0;

public static void main(String[] args) {

final Book superLargeBook = new Book();

superLargeBook.title = "Super Large Boring Book";

superLargeBook.nrOfPages = 1400;

// Change the amount of copies sold

superLargeBook.copiesSold += 1000;

// Assign a new book

superLargeBook = new Book(); // EEK!

}

}

Eclipse throws an error, telling you that you are not allowed to assign a new book (or any other existing book) to the superLargeBook variable.

The same reasoning holds for composite types (arrays). The following code again shows an example:

final int[] numbers = new int[]{1,2,3};

numbers[0] = 10; // This is okay

int[] newNumbers = new int[]{10,20,30};

numbers = newNumbers; // This is not okay

There is one case, however, that’s a little bit special, namely Strings. As you have seen, Strings are not a primitive type in Java, and are, in fact, objects like any other. You might thus try something like the following:

final String myString = "Hi there";

myString = "bye";

However, this approach will not work, as this is actually a shorthand notation for the following:

final String myString = new String("Hi there");

myString = new String("bye");

When writing this piece of code, it becomes clear why you cannot do it this way. However, when you are particularly observant, you might say, since String is a class and I create String objects, surely the actual value of the String object must be stored somewhere, probably as an array of char’s. The answer is that, indeed, a String object keeps an internal representation of the actual textual value, but it cannot be publicly accessed or modified. This is done for performance reasons. But wait—why then can you execute the following:

String myString = "a";

myString = "b";

myString += "cde";

Again, the reason is that this is shorthand and Java helps you out. In fact, this code actually corresponds to:

String myString = new String("a");

myString = new String("b");

myString = new String(myString + "cde");

This immediately provides you with the reasoning behind the fact that changing Strings in Java are an intensive, relatively slow operation. For a few modifications, this does not matter, but when you have to modify a String many thousands of times, it is advisable to look at other text-representing classes, such as StringBuilder—more about this later.

NOTE Variables are not the only elements that can be defined as being final. Methods can also be set as being final—meaning that they cannot be overridden or hidden by subclasses. Classes can also be set to final, meaning that they cannot be subclassed at all.

Don’t worry about what subclassing and subclasses mean at this point, as I will explain them when we talk about advanced object-oriented concepts in Chapter 8. Just remember for now that “final” can serve as a way to allow for stricter and more secure coding (in fact, many of Java’s built-in classes are final so they cannot be tampered with).

A common misconception exists that says that declaring classes or methods as final helps to speed up execution. The explanation behind this oftentimes follows a reasoning such as, “Well, since the compiler knows this method will never be modified or extended by subclasses, it must be able to optimize on this.” This perception, however, is incorrect, as the Java JIT compiler does no such thing. In fact, declaring classes and methods final can be a great burden when programming, as they limit the options for code reuse and extending functionality of existing classes. Of course, there are good reasons to declare a class or method final, when you want to guarantee that classes and methods remain immutable (meaning that they cannot be extended or modified by other classes).

For instance variables, however (as seen here), the reasoning is so dissimilar that it’s almost confusing that we use the same final keyword. Not only is setting a variable to final a great way to enforce a read-only variable, which occurs more often than you might think (many variables are read-only), it also does help the compiler to optimize your program. As a final variable keeps the same value after initialization, the compiler is able to cache (store) this value to perform quick checks on this variable whenever it’s asked to.

Variable Scope

A very important aspect when working with variables in Java—and, in fact, other programming languages as well—is their scope. Without knowing anything about variable scope, trying to access variables can get confusing once the compiler starts yelling at you for making a mistake. Consider the following simple class with two methods:

class ScopeTest {

void makeA() {

int a = 5;

}

void readA() {

System.out.println("The value of a is: "+a);

}

}

If you try to enter this in Eclipse, you’ll get an error telling you that the variable a cannot be resolved. The reason for this is scope. A variable’s scope is basically the context in which the variable is known. Depending on where a variable is declared, you will be able or unable to access this variable. The following “levels” of scope can be defined:

· Local variables: Variables that are declared inside a method or block.

· Parameter variables: Variables that are declared as a method argument or a loop variable.

· Instance variables: Variables that are declared in the class definition.

These levels of scope are ordered so that variables that are defined in a higher level can be accessed from lower-level locations. To give the simplest example, instance variables (highest level) can be accessed by all methods inside the class. Method arguments (a parameter variable) can only be accessed by that method, but not by other methods. This is exactly why the previous example doesn’t work.

Figure 4.3 graphically illustrates the scope of an instance variable (instanceVar), a parameter variable (paramVar), and a local variable (localVarA).

Figure 4.3

As the example in Figure 4.3 shows, the instance variable (instanceVar) is accessible by each method in the class. Parameter variables are accessible only within their methods, and can thus re-use the same name throughout different method definitions. Finally, locally declared variables (such as localVarA) are accessible only within their method, meaning that method makeB will not be able to access localVarA.

Note that parameter variables are accessible only within their method or loop. What do I mean by their loop? I will leave the main explanation regarding loops for the next chapter, but the following example provides a sneak preview:

class ScopeTest {

void doTheLoop() {

String[] names = new String[]{"Alice", "Bob", "Mia", "Marcus"};

for (int i = 0; i < names.length; i++) {

System.out.println("Name number "+i+" equals: "+names[i]);

}

System.out.println("The value of i is now: "+i); // Will not work

}

}

Again, you have one class definition, with one method, taking no arguments this time. Inside the method, you have one local variable (names) followed by a so-called for loop. Don’t concern yourself with the specifics of this construct for now, just understand that this code basically says, “For an integer i going from 0 but not including the number of names. That is, for i equal to 0, 1, 2, and 3, do whatever’s inside this block.” What is important to know, however, is that the variable i is only available within the for block, which is why the last println statement in the previous code snippet will throw an error in Eclipse, as i is no longer accessible at this point. Another point to note is that the names variable is also accessible from within the loop block. Again, this illustrates the basic rule saying that variables that are declared at a higher level (locally in the method) can be accessed by a lower level (a loop block within the method).

I close this section on variable scope—and variables in general—with a number of important remarks. First, you might be wondering what happens whenever variables defined in different locations (that is, at a different level of scope) clash in terms of naming. For example, consider the following example:

class ScopeTest {

int a = 5;

void printA() {

int a = 10;

System.out.println("The value of a is now: "+a);

}

}

What will show up when the method printA is called? Again, remembering that rule that higher-level variables can be accessed from lower-level locations provides some guidance here, as accessing a variable will “bubble up” from the current scope. This means that Java will first try to access the variable locally, and then move outward until looking for instance variables or static class variables bearing the requested name. This means that in the previous example, the local variable gets precedence and the result displaying on the screen will thus be 10. This concept is known as “variable shadowing” (consider the local variable to overshadow the higher-level ones). Keep this in mind when naming variables. Note also that Eclipse will provide subtle formatting and coloring hints to indicate which variable is being accessed.

NOTE What if you really wanted to access the instance variable and not the local variable in this example, without renaming one of them? In that case, you have to explicitly tell Java you want the instance variable, using the keyword this, like so:

class ScopeTest {

int a = 5;

void printA() {

int a = 10;

System.out.println("The value of INSTANCE VARIABLE " +

"a is now: "+this.a);

}

}

And when a is a class variable, remember to use the class name:

class ScopeTest {

static int a = 5;

void printA() {

int a = 10;

System.out.println("The value of INSTANCE VARIABLE " +

"a is now: "+ScopeTest.a);

}

}

For now, it is best to stick to clear, unambiguous naming; you will return to learn about the keyword this in-depth in a later chapter.

Another important remark concerns the fact that local and parameter variables are forgotten once their scope is exited, meaning that method arguments will disappear once you exit the method (this allows you to use the same variable name for arguments throughout different methods), just as local variables will be discarded once the compiler steps out of its block (a method or loop body). To illustrate this once more, consider the following:

class ScopeTest {

void scopeTest(int a) {

int b = a + 10;

for (int c = 0; c < 10; c++) {

int d = c + 3;

b = b + 1;

}

}

}

Try to work out what is happening here. Variable d (local variable) is only accessible within the loop block. Variable c (parameter variable) is initialized for each iteration of the loop and is only accessible within the loop body. Variable b (local variable) is discarded after the method is exited but is accessible in the whole method. Variable a (parameter variable) is also discarded after the method is exited and is accessible in the whole method, but it’s passed as a method argument.

NOTE If you want to do so, note that you can also arbitrarily create your own scope blocks, different from class, method, or loop bodies. This is done simply by wrapping a piece—a block—of code in curly brackets: { and }. For example, the previous code snippet can be extended as such:

class ScopeTest {

void scopeTest(int a) {

int b = a + 10;

for (int c = 0; c < 10; c++) {

int d = c + 3;

{

int e = d + 3;

}

// e not accessible here

b = b + 1;

}

// c not accessible here

{

int c = 3;

}

// c also not accessible here

}

}

While this is an often forgotten tidbit of Java that can come in handy to structure complex pieces of code, it’s best not to rely on this feature too much. When you find yourself putting large amounts of code in blocks like this, it is probably a good idea to try to separate some behavior into multiple methods or classes to split things up.

This concludes the discussion of scope and the overview of different types of variables. You now know how to declare instance variables (member variables or fields), class (static) variables, and final variables, and are aware that variables are defined within a specific scope or context, which determines how they can be accessed.

The next section turns your attention to the other big part of classes: behavior as defined through methods. Just as with variables, there are different types of methods, but many of the aspects you learned here will return.

DEFINING BEHAVIOR: METHODS

Recall once more the simple class outline as follows. A class contains a block of variable definitions (data) and methods (behavior), like so:

class CLASSNAME {

// VARIABLE DEFINITIONS

// METHOD DEFINITIONS

}

Or, to be more specific:

class CLASSNAME {

// FINAL CLASS VARIABLE DEFINITIONS

// CLASS VARIABLE DEFINITIONS

// FINAL INSTANCE VARIABLE DEFINITIONS

// INSTANCE VARIABLE DEFINITIONS

// METHOD DEFINITIONS

}

This section discusses in full the concept of class behavior, as defined through its methods. Specifically, you will see:

· Instance methods: Methods that are accessible by objects.

· Class methods: Methods that are not bound to an object but instead belong to the class as such, that is, to the blueprint of the object.

· Constructors: A special method that governs how a class is instantiated; you have already read about this method.

· The main method: A special method definition that can be used to run your application.

Finally, you will also learn about argument passing. You have seen how methods can take argument variables to use within the method’s body. The way variables are passed to methods can be a little bit daunting in Java at first—and can introduce subtle bugs when you’re not aware—so it makes sense to learn about this in a separate section.

Instance Methods

Just as with instance variables, an instance method (or a member method) is a method that’s accessible only through objects belonging to that class—meaning that they can be accessed only through an initialized object.

A simple example can help to explain this. Suppose you create a Dog class with one method, bark, like so:

class Dog {

void bark() { // Instance method

System.out.println("Woof!");

}

}

Since bark is an instance method, you first need to create an object to call it, like so:

Dog myDog = new Dog();

// Call the instance method on the object myDog:

myDog.bark();

That’s all there is to defining instance methods. As a reminder, however, recall that methods always return a type or void if they don’t return anything. The following example modifies the Dog class to illustrate this once again:

class Dog {

boolean isSitting;

String getBarkSound() {

return "Woof!";

}

boolean isSitting() {

return isSitting;

}

void sit() {

isSitting = true;

}

void stand() {

isSitting = false;

}

}

NOTE Note that the sit, stand, and isSitting methods neatly illustrate the concept of encapsulation, meaning that data in a class (the isSitting variable) should be accessed through instance methods (myDog.sit()), instead of directly accessing its variables (myDog.isSitting = true). When you learn about advanced object-oriented programming concepts in Chapter 8, you will see how to effectively block accessing instance variables directly, forcing the use of methods.

Recall that methods returning something (that is, methods that do not return void) always need to include a reachable return statement in their body. Note that you can also place return statements in void methods. In this case, the return statement does not actually return something, but just exits the method. For example, if you want to exit out of the sit method before sitting down, you can change this method as follows:

void sit() {

if (isSitting)

return; // Exit out method if already sitting

isSitting = true;

}

This will especially come in handy for governing the control flow of your program. This aspect will be discussed in detail in the next chapter.

Recall that methods can also take one or more arguments. Consider, for example, the following method declarations:

· void giveCookie(Cookie cookie) { /*...*/ }

· void chaseDog(Dog dog) { /*...*/ }

· void lickPerson(Person person, int nrLicks) { /*...*/ }

· void giveNickNames(String[] nickNames) { /*...*/ }

· void giveNickNames(String... nickNames) { /*...*/ }

The last example in this listing will look unfamiliar to you, and it uses a construct called varargs (variable arguments). Basically, the last two methods are equivalent in the sense that the nickNames variable will be available as an array of strings in the method body, for instance:

void giveNickNames(String... nickNames) {

System.out.println("You have given me "+nickNames.length+" names");

}

The way these two methods are called, however, differs. In the first case (String[] nickNames), the method is called using an array of strings as an argument, as you’d expect:

String[] newNames = new String[] {"Puppers", "Droopy"};

myDog.giveNickNames(newNames);

In the second case, however (String... nickNames), you can just supply an arbitrary number of strings (including none at all), like so:

myDog.giveNickNames("Puppers", "Droopy");

// Or any other amount of strings:

myDog.giveNickNames("Puppers", "Droopy", "Tissues", "Clifford");

myDog.giveNickNames();

Varargs can provide a handy way of avoiding having to pass an array explicitly. However, keep in mind that the varargs argument (the one with the three dots, ...) must always be the last method argument, and only one varargs argument can be defined for a method. With arrays, on the other hand, you are free to define any number of arguments in any order you want. To illustrate:

· method(String... s1): Allowed

· method(String... s1, String s2): Not allowed

· method(String... s1, int s2): Not allowed

· method(String... s1, String... s2): Not allowed

· method(String... s1, Dog... dogs): Not allowed

· method(String[] s1): Allowed

· method(String[] s1, String s2): Allowed

· method(String[] s1, String[] s2): Allowed

· method(String[] s1, String[] s2, Dog[] dogs): Allowed

· method(int i1, String[] s1, int i2): Allowed

· method(int i1, String[] s1, String... s2): Allowed

· method(int i1, String... s1, String[] s2): Not allowed

You don’t have to memorize this list (or these rules), as Eclipse will simply warn you when you define a method incorrectly.

Class Methods

Just as you’ve seen for class variables, a class method, also denoted as a static method, is a method that has been defined statically, meaning that this method is shared between all objects (instances) belonging to the class. Again, as class methods belong to the class blueprint, it is not even necessary to create objects to be able to use them.

I’ll illustrate this concept with another example from the realm of pets. This time, let’s define a Cat class as follows:

class Cat {

static String preferredFood() {

return "Fish";

}

}

Note the static modifier in front of the method declaration is similar to what you’ve seen with static variables. preferredFood is defined as a blueprint method, returning the preferred food for all cats. Just as for instance methods, it is possible to call class methods through an object:

Cat myCat = new Cat();

System.out.println("A cat's preferred food is: "+myCat.preferredFood());

However, just as for class variables, this is not good practice, and Eclipse will warn you about such behavior. Again, you should clearly indicate that you’re accessing a static method by using the class name, instead of the object variable:

System.out.println("A cat's preferred food is: "+Cat.preferredFood());

This also clearly illustrates that you do not have to create an object to use static methods.

It is important to note that, since class methods operate on the class as a whole (as a blueprint), they are not able to access instance variables. For example, the following is not allowed:

class Cat {

String name;

static void changeName() {

name = "ANONYMOUS CAT";

}

}

What you can do, however, is the following:

class Cat {

static String preferredFood = "fish";

static String getPreferredFood() {

return preferredFood;

}

static void setPreferredFood(String newFood) {

preferredFood = newFood;

}

}

And call this code as follows:

System.out.println("A cat's preferred food is: "+Cat.getPreferredFood());

Cat.setPreferredFood("milk");

System.out.println("A cat's preferred food is now: "+Cat.getPreferredFood());

This last example illustrates the power of combining class variables with class methods, as they allow you to create class-global variables that can be changed if necessary.

NOTE Again, you are seeing the concept of encapsulation in practice here. Whereas earlier you would have accessed the class variable preferredFood by writing Cat.preferredFood directly, you now neatly use the getPreferredFood and setPreferredFoodmethods to do so. Does this mean you can no longer write Cat.preferredFood = “milk”? The answer is that—for now—you can, but again, you will see later how you can effectively block accessing instance variables directly, forcing the use of methods (and preventing tampering of variables outside their owning class).

Constructors

Constructors are special class methods that are used to initialize objects of that class. If you recall the discussion on final variables, you might remember that you had—at the time—no way to create Book objects with an initial title that’s kept as a read-only variable (using final). You might also recall that when you do the following:

Book myBook = new Book();

You are writing () as if you are invoking a method, because, in fact, you are—namely the constructor method for the class. Constructor methods are defined similarly as instance methods, with the following differences:

· Constructors bear the same name as the class in which they are defined.

· Constructors have no return type, not even void.

In all the classes you have seen so far, you will notice that you did not define a constructor method. The reason for this is that Java will automatically assume a “blank” constructor when you do not define one, meaning that defining a class like:

Class Book {

}

Is exactly the same as writing:

class Book {

Book() {

}

}

So far, this constructor does not really do much. What can they be used for? A constructor is invoked each time you instantiate (that is, “construct”) a new object using the new keyword. Most commonly, constructors will initialize default values for the object being created. To illustrate this, let’s return to the earlier issue: you aim to define a variable to hold the title of a book, but you want to define this variable so it can be set only once. As such, the following solution does not suffice:

class Book {

String title;

}

As there is nothing preventing multiple assignments to title in this case. You have seen that you can use the final keyword like so:

class Book {

final String title = "Initial Title";

}

But of course, you would like to make the initial title user-specified and different for each book. The previous solution does not allow you to write:

Book myBook = new Book();

myBook.title = "The Real Title";

Finally, you have seen that you can remove the initialization of the variable to make it a so-called blank final variable:

class Book {

final String title;

}

Recall, however, from our discussion regarding final variables that Java will complain about the fact that the title instance variable might not be initialized, as you need to explicitly assign a value. You have seen before that you can solve this by doing something like:

class Book {

final String title = "";

}

But again, we have no way to change the title variable to the title we actually want to give to a particular book. That is, Java will complain about doing something like:

Book myBook = new Book();

myBook.title = "The Real Title";

This happens because we have already initialized the title variable to "", preventing it from being changed again. So how do you deal with this problem? Well, by initializing final variables inside your own constructor, like so:

class Book {

final String title;

Book() {

title = "Initial Title";

}

}

To supply a user-specific title, you now can just modify the constructor method so that it takes an argument. Watch out when naming your constructor arguments. Remember that using local or parameter variables with the same name as instance variables will take precedence. Hence, you should modify the constructor like so:

class Book {

final String title;

Book(String t) {

title = t;

}

}

Now how do you call this constructor? Easily, by providing an argument when creating an object:

Book myBook = new Book("Title of the Book");

Note that you have seen how Java will assume the presence of a blank constructor taking no arguments when you do not define one in the class. If you do define a constructor with arguments—like you’ve just seen—the constructor taking no arguments will not be available any longer, unless you also explicitly define it. Meaning that for this example, you can no longer write:

Book myBook = new Book("Title of the Book"); // This works

Book myBook = new Book(); // This no longer works

You might be confused by the wording of “unless you also explicitly define it.” Is it possible to define multiple constructor methods? Indeed it is; consider, for example, the following class definition:

class Book {

final static int DEFAULT_YEAR = 2014;

final String title;

final int releaseYear;

int copiesSold;

Book(String t) {

title = t;

releaseYear = DEFAULT_YEAR;

// copiesSold will default to 0

}

Book(String t, int r) {

title = t;

releaseYear = r;

// copiesSold will default to 0

}

Book(String t, int r, int s) {

title = t;

releaseYear = r;

copiesSold = s;

}

}

Given everything you’ve seen so far, you should be able to understand this class. Take some time to figure out what is happening here, and make sure to note the following:

· Three constructors are available for this class, each taking a different number of arguments.

· One final static variable is acting as a constant that will be used as a default initializing value in one of the constructors.

· The two other blank final variables (non-static) need to be initialized by every constructor.

· Constructors can also initialize nonfinal variables.

NOTE Using methods with the same name—but taking different arguments—is provided by a feature called method overriding. As the name suggests, this feature is not only available for constructors, but in fact for every method. Method overriding provides advanced capabilities, so it’s covered in-depth in Chapter 8.

You might be annoyed by the fact that some statements, such as title = t;, are duplicated across different constructors, while in fact the constructors are forming a hierarchy. Luckily, it is possible for constructors to call other constructors to perform a piece of the requested initialization, as the following code snippet shows:

class Book {

final static int DEFAULT_YEAR = 2014;

final String title;

final int releaseYear;

int copiesSold;

Book(String t) {

// Call other constructor:

this(t, DEFAULT_YEAR, 0);

}

Book(String t, int r) {

// Call other constructor:

this(t, r, 0);

}

Book(String t, int r, int s) {

title = t;

releaseYear = r;

copiesSold = s;

}

}

Note the use of the keyword this here. I’ve briefly mentioned this keyword before when illustrating how you can use it to refer to the current object (this.title), but here it acts as a way to call another constructor. Again, don’t worry if this is still a bit overwhelming, as the this keyword will be revisited later. In fact, for now, I will avoid defining multiple constructors until you are ready to move a step further, so that you will not run into the intricacies relating to defining more than one constructor. So for now, just keep in mind that it is possible to create multiple constructors within a class.

NOTE When you think about the concept of constructors—or if you’re coming from other programming languages such as C++—you might wonder if the counterpart of destructors also exists. In Java, it does not, as the JVM itself will keep an eye out for objects that are no longer accessible and should thus be removed automatically. Consider for example:

Book myBook = new Book("My first book");

myBook = new Book("My second book");

myBook = null;

What happens with the "My first book" object stored in the myBook variable once you assign the second book (a new object) to this variable? Since you have no way to refer to this object anymore (which is now floating around nameless somewhere in the computer memory), the JVM will automatically clean up this piece of memory (this is performed by a mechanism called garbage collection) to remove (destroy) the object. The same happens when assigning null to the variable with the second object. The variable now refers to nothing, and the second object can also no longer be referenced, and is thus removed as well.

Whenever the JVM cleans up objects in this manner, it will call a special built-in method, finalize(), on them. Programmers can implement their own finalization method if they desire, which comes in handy when objects are utilizing resources that need to be cleanly closed when they are removed (think, for example, about open network connections). In practice, however, there is rarely a need to override the default behavior.

Again, you need to learn how to walk before you can run, so for now, just be glad about the fact that Java takes care of these cleanup aspects for you. You do not need to concern yourself with writing destructors.

The Main Method

Earlier in this chapter, you learned that there exists one special method used as an entry point to actually execute (run) your program—the so-called main method.

The main method can be defined in any class, but is always defined as:

public static void main(String[] args) {

}

Meaning that the main method:

· Is publicly accessible. (public is an access modifier. I have ignored access modifiers for now, but for the main method, you have to define it.)

· Is a static class method, as no objects exist yet when a program is started.

· Returns nothing (void).

· Takes one argument, the arguments passed to the program.

Let’s have a closer look at the main method. Suppose you once more define a simple Book class to look as follows:

class Book {

final String title;

final int releaseYear;

int copiesSold;

Book(String t, int r) {

title = t;

releaseYear = r;

}

void sell(int nrCopies) {

copiesSold += nrCopies;

}

int nrCopiesSold() {

return copiesSold;

}

}

If you now want to create an actual program that can be executed, the simplest way to do so is by creating a main method within this class, like so:

class Book {

final String title;

final int releaseYear;

int copiesSold;

Book(String t, int r) {

title = t;

releaseYear = r;

}

void sell(int nrCopies) {

copiesSold += nrCopies;

}

int nrCopiesSold() {

return copiesSold;

}

public static void main(String[] args) {

Book firstBook = new Book("First Book", 2004);

Book secondBook = new Book("Another Book", 2014);

firstBook.sell(200);

System.out.println("Number of copies sold of first book is now: "

+firstBook);

System.out.println("Title of the second book is: "+secondBook.title);

}

}

In general, however, it is not good practice to mix a main method with a class definition relating to a real-world concept. As such, it is better to create a separate “controller” class to separate program logic from class concepts, like so:

// File Book.java:

class Book {

final String title;

final int releaseYear;

int copiesSold;

Book(String t, int r) {

title = t;

releaseYear = r;

}

void sell(int nrCopies) {

copiesSold += nrCopies;

}

int nrCopiesSold() {

return copiesSold;

}

}

// File Program.java:

class Program {

public static void main(String[] args) {

Book firstBook = new Book("First Book", 2004);

Book secondBook = new Book("Another Book", 2014);

firstBook.sell(200);

System.out.println("Number of copies sold of first book is now: "

+firstBook);

System.out.println("Title of the second book is: "+secondBook.title);

}

}

Some developers like to supply main methods in their class definitions in larger programs as a quick way to test if the class is working correctly, without having to run the complete program and go through a series of steps. This is fine, so long as you keep these “test”mains small and short, for testing purposes only, and remember that there exist better ways to perform thorough code tests. This remark does illustrate another aspect, though, namely the fact that a Java project can contain multiple main methods. In fact, it’s possible to provide a main method in every class you define. So how does Eclipse or Java know how to execute which one? To figure this out, you’ll return to the very first example context you saw at the beginning of this chapter: the course administration program. The following Try It Out will guide you from beginning to end to re-create the course administration example, using all of the knowledge you’ve gained so far.

TRY IT OUT Course and Student Administration Revisited

Let’s revisit the course and student administration example you saw earlier, now applying all of the knowledge you’ve gained so far.

1. It’s best to create a new project in Eclipse. Remember you can do so by navigating to File New and then selecting Java Project in Eclipse. A dialog window will open asking you to fill in a project name, such as CourseAdministrationDoneWell. You can then press Finish to create the project.

2. Create the Course.java class by right-clicking the src folder in the package explorer in Eclipse and then selecting New Class. Define this class as follows:

3. import java.util.HashSet;

4.

5. class Course {

6. static int nextId = 0;

7.

8. final int id;

9. final String name;

10. final HashSet<Student> registeredStudents =

11. new HashSet<Student>();

12.

13. Course(String n) {

14. id = nextId;

15. nextId++;

16.

17. name = n;

18. }

19.

20. String getName() {

21. return name;

22. }

23.

24. void registerStudent(Student s) {

25. registeredStudents.add(s);

26. }

27.

28. void unregisterStudent(Student s) {

29. registeredStudents.remove(s);

30. }

31.

32. HashSet<Student> registeredStudents() {

33. return registeredStudents;

34. }

35.

36. int nrOfRegisteredStudents() {

37. return registeredStudents.size();

38. }

}

39. Similarly, create a Student class with the following content:

40. class Student {

41. static int nextId = 0;

42.

43. final int id;

44. final String firstName, lastName;

45.

46. Student(String fn, String ln) {

47. id = nextId;

48. nextId++;

49.

50. firstName = fn;

51. lastName = ln;

52. }

53.

54. String getFirstName() {

55. return firstName;

56. }

57.

58. String getLastName() {

59. return lastName;

60. }

61.

62. void registerForCourse(Course c) {

63. c.registerStudent(this);

64. }

65.

66. void unregisterForCourse(Course c) {

67. c.unregisterStudent(this);

68. }

}

69. Create a Program class containing the main method:

70. class Program {

71. public static void main(String[] args) {

72. p("Welcome to the course administration program");

73. p("--------------------------------------------");

74. p("");

75.

76. p("Creating two courses...");

77. Course courseA = new Course("First Course");

78. Course courseB = new Course("Second Course");

79.

80. p("- courseA ID is: "+courseA.id);

81. p("- courseA name is: "+courseA.getName());

82. p("- courseB ID is: "+courseB.id);

83. p("- courseB name is: "+courseB.getName());

84. p("");

85.

86. p("Creating two students...");

87. Student student1 = new Student("Alice", "The Student");

88. Student student2 = new Student("Bob", "McStudent");

89.

90. p("- student1 ID is: "+student1.id);

91. p("- student1 name is: "+student1.getFirstName()+", "+

92. student1.getLastName());

93. p("- student2 ID is: "+student2.id);

94. p("- student1 name is: "+student2.getFirstName()+", "+

95. student2.getLastName());

96. p("");

97.

98. p("Registering for courses...");

99. student1.registerForCourse(courseA);

100. student1.registerForCourse(courseB);

101. courseA.registerStudent(student2);

102.

103. p("- courseA number of students: "+courseA.nrOfRegisteredStudents());

104. p("- courseB number of students: "+courseB.nrOfRegisteredStudents());

105. }

106.

107. static void p(String l) {

108. System.out.println(l);

109. }

}

110. To run this program from Eclipse, make sure the Program class is open and the main method is active (by putting your cursor inside the method body), and then press the Run button. Eclipse will show you the name of the class that contains the mainmethod that will be run.

How It Works

Now take a look at how it works.

1. You’re creating two new Student and Course classes in a new Eclipse project.

2. For the Course class, note the use of the nextId variable to automatically use an incrementing counter to provide IDs for courses. This is a well-known pattern that you will see show up commonly in Java code. Also note the use of the HashSet object. AHashSet is a set, storing a bunch of objects (Student objects, in this case). The HashSet class is built-in by default in Java, but to enable its use, you first have to import it, hence the import statement before defining the class itself. Don’t concern yourself too much with its usage for now, but make sure you understand the registerStudent and unregisterStudent methods, which add and remove students to and from the set.

3. For the Student class, you’re using the keyword this to pass the current student object (meaning the object the method was called on) to the course object to register or unregister a student, as it is the course object that keeps a list of registered students.

4. The Program class contains the main method, and it creates two courses, gives some information about them, creates two students, and registers them in the courses. The p method just serves as a shorthand to avoid having to write System.out.println all the time.

5. You then run this program from Eclipse by invoking the main method in the Program class. Note that it is possible at this point to create another class containing a main method and run that one in Eclipse by just making sure the main method you want to run is open in the code editor.

ACCESS MODIFIERS