Java supports many data types, but probably the most basic data type is the integer. Integers represent whole numbers, which are numbers that have no decimal point. There are several types of integer that you may use depending on the size of number you need to store. Table 2.1 shows the types of integers you can use and their attributes.

Since Java programs can run on a wide variety of computer systems (this is called cross-platform support), you might be wondering whether these data type values will be the same on every system. After all, a Java program can run on a little cell phone or it can run on a supercomputer, such as a Cray Red Storm system.

Java gets around the data type inconsistency in C++ by defining that data types will be exactly the same, regardless of the computer system on which the Java program is running. It’s the job of the Java Runtime Environment (JRE) to determine at runtime how the current computer system will handle the data types your Java program is trying to use, and it does this seamlessly behind the scenes.

There are two data types available in Java for working with floating-point numbers. A floating-point represents a decimal value. The float data type stores a 32-bit single-precision number. The double data type stores a 64-bit double-precision number. Table 2.2 shows the specifics of these two data types.

The easiest way to determine the range for a numeric data type is to use the MIN_VALUE and MAX_VALUE properties of the base data type classes. Although we use lowercase to specify the type of a numeric variable (byte, short, int, long, float, and double), these base numeric types are actually instances of Java classes (Byte, Short, Integer, Long, Float, and Double). Therefore, we can take a peek inside these base classes to find some goodies. The MIN_VALUE and MAX_VALUE properties will give you the range of values for a particular data type.

I have written a program called DataTypes that displays these values in an applet window. The output is shown in Figure 2.1, and the source code listing follows. This program is on the companion website (www.courseptr.com/downloads) in the sourceschapter02DataTypes folder.

Figure 2.1. The DataTypes program displays the range for each numeric data type.

import java.awt.*;
import javax.swing.*;
public class DataTypes extends JFrame {
    public DataTypes() {
        super("DataTypes");
        setSize(600,400);
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public void paint(Graphics g) {
        g.setFont(new Font("Courier New", Font.PLAIN, 16));
        g.drawString("Byte : " +
            Byte.MIN_VALUE + " to " + Byte.MAX_VALUE, 20, 50);
        g.drawString("Short : " +
            Short.MIN_VALUE + " to " + Short.MAX_VALUE, 20, 70);
        g.drawString("Int : " +
            Integer.MIN_VALUE + " to " + Integer.MAX_VALUE, 20, 90);
        g.drawString("Long : " +
            Long.MIN_VALUE + " to " + Long.MAX_VALUE, 20, 110);
        g.drawString("Float : " +
            Float.MIN_VALUE + " to " + Float.MAX_VALUE, 20, 130);
        g.drawString("Double : " +
            Double.MIN_VALUE + " to " + Double.MAX_VALUE, 20, 150);
    }
    public static void main(String[] args) {
        new DataTypes();
    }
}

There are two data types in Java for working with character data: char and String. Note that char is a base data type, while String is automatically recognizable as a class (due to the uppercase first letter). Java tries to make programming easy for C++ programmers by using many of the same basic data types in order to make it easier to convert C and C++ programs to Java. So we have a base char and a String class; of course, as you now know, every data type in Java is a class already.

You define a char variable like this:

char studentgrade;
char examscore = 'A';

The char data type can only handle a single character, not an entire string. Note that a character is identified with single quotes (’A’) rather than double quotes, necessary for strings. The String data type (or rather, class) is very easy to use and is used by many of the Java library methods. (Remember, a method is a function.) For instance, you have seen a lot of the Graphics class so far in this chapter because it is the main way to display things (such as text) in an applet window. Here are a couple of different ways to create a string:

String favoritegame = "Sid Meier's Civilization V"
String username;
username = "John" + " R. " + "Doe";

In addition to supporting the plus operator for combining strings (something that C programmers look upon with envy), the String class also comes equipped with numerous support methods for manipulating strings. I won’t go over every property and method in the String class here because that is the role of a Java reference book—to cover every single detail.

One good example of a function we’ve been using in this chapter is Graphics .drawString(). This function has many overloaded versions available (overloading is explained later in this chapter, in the section entitled “Object-Oriented Programming”) that give you a lot of options for printing text to the applet window, but the main version I use is this:

drawString(String str, int x, int y)

Table 2.3 lists just some of the useful methods in the String class. This is by no means a complete list.

If you want to see all of the properties and methods in a class (such as String), the easiest way to get a list, aside from using a reference book, is to create an instance of a class (such as String s) and then use the dot operator (.) to cause NetBeans or Eclipse to bring up the contents of the class. This built-in “look” feature works with the Java language classes as well as classes you have written yourself, as shown in Figure 2.2.

Figure 2.2. NetBeans displays the contents of a class with a pop-up window.

Possibly the single-most beneficial advantage to using an IDE is the built-in help system, which is available in tools such as NetBeans. If you aren’t using an IDE that provides context-sensitive help and class member lists, then you will need a good reference book or website.

The Boolean data type can be set to either true or false, and it is useful as a return value for methods. For instance, in some of the example programs you’ve seen so far, there have been methods that returned a Boolean based on whether the code succeeded. You can declare a boolean variable like so:

boolean gameover = false;

Here is a short method that returns a Boolean value based on whether a value is within a boundary of a minimum and maximum value:

   public boolean checkBounds(long val, long lower, long upper) {
         if (val < lower || val > upper)
           return false;
       else
           return true;
   }

Here is an example of using the checkBounds method to determine whether a sprite’s position on the screen (in the horizontal orientation) is within the screen’s boundary:

spriteX = spriteX + 1;
if (checkBounds(spriteX, 0, 639) == true)
    spriteX = 0;

This short example assumes that the spriteX variable has already been declared earlier in the program. The sprite’s X position on the screen will wrap around to the left edge anytime the sprite moves off the right edge of the screen. This Boolean method can also be written like this, where the == true is assumed in the if statement:

if (checkBounds(spriteX, 0, 639)) ...

Note that I have left out the == true in this line of code. This is possible because Java evaluates the return value of the checkBounds method and replaces the method call with the return value when the program is running. Thus, if the checkBounds method returns true, the if statement becomes this:

if (true) . . .

This is why we can leave the == true out of the equation. Conversely, when you want to test for a false return value, you can insert == false in the if statement or you can use the logical negative operator (!) in the statement:

if (!checkBounds(spriteX, 0, 639)) ...

The result is that if checkBounds returns false, the if statement will execute the code that follows; otherwise, the code is not executed. Speaking of which, you may include a single line of code after an if statement, or you may include a code block enclosed in curly braces as follows. This is especially helpful if you want to do more than one thing after a conditional statement returns true or false:

   public boolean checkBounds(long val, long lower, long upper) {
         if (val < lower || val > upper) {
   
                       . . .
                   return false;
              } else {
   
                  . . .
                  return true;
              }
     }

The use of curly braces in this new version of checkBounds might not change anything, but it does allow you to add more lines of code before each of the return statements. (For instance, you may want to display a message on the screen before returning.)

An array is a collection of variables of a specific data type that are organized in a manageable container. An array is created using one of the base data types, a Java library class, or one of your own classes. To tell Java that you want an array, attach brackets to the data type in your variable declaration:

int[] highScoreList;

But there are two steps to creating an array because an array must first be defined, and then memory must be allocated for it. First, you define the data type and array variable name, then you allocate the array by specifying the number of elements in the array with the new operator:

int[] studentGrades;
studentGrades = new int[30];

Note that I have allocated enough memory for this array to hold 30 elements in the studentGrades array. You can also define a new array with a single line of code:

int[] studentGrades = new int[30];

I don’t know about you, but I enjoy writing beautiful code like this. I get a chill when writing code like this because my imagination starts to take off with visions of scrolling backgrounds and spaceships and bullets and explosions, all of which are made possible with arrays. But the real power of an array is made obvious when you start iterating through an array with a loop. If you need to update the values of this array, you might access the array elements individually like this:

studentGrades[0] = 90;
. . .
studentGrades[29] = 100;

If you truly need to set each element in an array individually, then an array can still help to cut down on the clutter in your program. And an array will always benefit from processing in a loop when it comes to things such as printing out the contents of the array or storing it in a data file, or for any other purpose you may have for the array. Let’s set all of the elements in an array to a starting value of zero (this is good programming practice):

long[] speed = new long[100];
for (int i = 0; i < 100; i++) {
    speed[i] = 0;
}

There is another way to create an array by setting the initial values of the array right at the definition. This array of five floats is defined and initialized in memory with starting values at the same time.

float[] radioStations = { 88.5, 91.3, 97.7, 101.5, 103.0 };

You can also create multidimensional arrays. An array with more than one dimension will have a multiplicative number of elements (based on the number of elements in each dimension) because for every one element in the first dimension, there are N elements in the next dimension (based on the size of the next dimension). In my own experience writing games, I seldom use more than one dimension for an array because it is possible (and more efficient) to use a single-dimensioned array, and then index into it creatively to deal with multiple dimensions.

Here is an example two-dimensional array that stores the values for a game level. The pound characters (#) represent walls (or any other object you want in your game) while the periods (.) represent dirt, grass, or any other type of image. I presume that this is a level for a tile-based game, where each character in the array is drawn to the screen as a tile from a bitmap file.

char[][] gameLevel = {
    {'#','#','#','#','#','#','#','#','#','#'},
    {'#','.','.','.','.','.','.','.','.','#'},
    {'#','.','.','.','.','.','.','.','.','#'},
    {'#','.','.','.','.','.','.','.','.','#'},
    {'#','.','.','.','.','.','.','.','.','#'},
    {'#','.','.','.','.','.','.','.','.','#'},
    {'#','#','#','#','#','#','#','#','#','#'}
};

Another common practice is to create a game level with just numbers (such as 0 to 9). Some programmers prefer to use character-based levels because they sort of look more like a game level, and are, therefore, easier to edit. I tend to prefer integer-based game levels using a level editor such as Mappy, which exports levels as a comma-delimited array of numbers. Here is how Mappy might export the same level with numeric data:

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2

Can you make out the similarity between the two game levels shown here? It’s all the same data, just represented differently. When Mappy exports a level like this, it sends the data to a text file that you can then open and paste into your game’s source code. To make it work, you would define an array to handle the data like this:

int[][] gameLevel = {
    {2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
    {2, 1, 1, 1, 1, 1, 1, 1, 1, 2},
    {2, 1, 1, 1, 1, 1, 1, 1, 1, 2},
    {2, 1, 1, 1, 1, 1, 1, 1, 1, 2},
    {2, 1, 1, 1, 1, 1, 1, 1, 1, 2},
    {2, 1, 1, 1, 1, 1, 1, 1, 1, 2},
    {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}
};

I prefer to treat a game level (or other array-based data sequence) as a single-dimensioned array because data like this is easier to work with as a one-dimensional array. Here is how I would define it:

int[] gameLevel = {
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
    2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
    2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
    2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
    2, 1, 1, 1, 1, 1, 1, 1, 1, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2
};

Do you see the subtle difference between this 1D array and the 2D array defined before? All I need to know are the width and height of the array data, and then I don’t need multiple dimensions. In this example, this game level is 10 tiles wide and 10 tiles deep, for a total of 100 tiles. (A tile is a small bitmap used to build a game world in a 2D scrolling game, and it very closely resembles the analogy of floor tiles in the way it is used.)

Data hiding is a key concept of OOP because it provides a way to protect data within an object at runtime from direct manipulation. Instead of providing access to certain pieces of data, a class definition will include functions (often called methods or accessors/mutators in OOP lore) for retrieving and changing data (often called properties) that is hidden within the class definition. An accessor function retrieves a hidden variable; a mutator changes a hidden variable.

This way, the programmer can specify exactly what changes can be made to a private variable through the built-in mutator functions and return custom-formatted data through the accessor functions. For instance, if you want to make sure that a birth date is valid, the mutator function can restrict changes to a certain range (such as 0 to 120). The following source code demonstrates the concept of data hiding. I have intentionally kept the code listing simpler by not including any comments.

public class vehicle {
    private String make;
    private int numwheels;

    public String getMake() {
        return make;
    }
    public boolean setMake(String newmake) {
        if (newmake.length() > 0) {
            make = newmake;
            return true;
        } else {
            return false;
        }
    }

    public int getNumWheels() {
        return numwheels;
    }
    public boolean setNumWheels(int count) {
        if (count > 0 && count < 20)
        {
            numwheels = count;
            return true;
        } else {
            return false;
        }
    }
}

Encapsulation is related to data hiding in that it describes how information and processes are both handled internally by a class. These two concepts are often used interchangeably, depending on the opinion of the programmer. (I prefer to use the term encapsulation rather than data hiding.) I would suggest that encapsulation involves modeling a real-world entity, whereas data hiding describes the ability to use private variables in a class. It’s common to encapsulate a real-world entity by writing a class that describes the data and functions for working with that data. In the vehicle class example, I have encapsulated the specifications for a basic vehicle inside a class with hidden (or private) data members and public functions (or methods).

Inheritance describes the ability to reuse class definitions and to make changes to a subclass that relies on a base class. For instance, the vehicle class might be used as a basis for many subclasses covering a wide range of vehicles, from two-wheel motorcycles to 18-wheel semi trucks. When you are writing the code for a class, it is best to put each class inside its own source code file. Java allows you to inherit from a single base class.

For instance, the SimpleClass program includes the source code listing for the vehicle class, and it is stored in a file called vehicle.java. Also included in the SimpleClass project is the main source code file called SimpleClass.java—and this file “consumes” or uses the vehicle class defined in the vehicle.java file. Additional classes can be written and saved in their own source files.

A constructor is a method that is called whenever you create a new class in your program. I’m not talking about typing in a new class, but when a class is instantiated into an object at runtime. When a new class is created (with the new operator), the class definition is used to construct an object. See where the keyword comes in here? The new object is “constructed” when it is being created at runtime; the class is a blueprint used to build or construct the object at runtime.

When I click the OK button on the Class Wizard dialog box, a new file called truck.java is added to my project, and it contains this source code:

public class truck extends vehicle {
    public truck() {
    }
}

This is a nice, clean starting point for a new class. Note that this class inherits from the vehicle class (extends vehicle), and it includes a simple constructor (public truck()). This constructor is called whenever you use new to create a new truck object, using code like this:

trucksilverado = new truck();

The constructor is specified after the new operator in this line of code, and this is called an empty constructor. If you want to pass parameters to a constructor, you can do so by defining another version of the constructor, which is a topic that needs to be covered in the next section on polymorphism.

Polymorphism is a complex word that, when broken down, equates to poly (“many”) and morph (“shape”); therefore, polymorphism means “many shape” or “many shapes.” Java allows you to write many versions of a function (or method) with different sets of parameters. When you write more than one version of a method, you have overloaded that method. Overloading is a technical programming term that describes polymorphism at work.

The complete truck class source code listing demonstrates polymorphism. Note the constructor, truck(), which has been overloaded once with an alternative version with the following syntax:

public truck(String make, String model, String engine, int towing)

You will probably not pass all of the data to a class in this manner all at once, as it is not usually very practical. You may pass any values to the constructor that you think will help with the initialization of the object that is being instantiated, but keep in mind that there are methods available for reading and changing those variables (or properties) as well.

Do you see how the default constructor includes several method calls to set the private variables to some initial values? This is a good practice to do when creating a class definition, because it eliminates the chance of a null-pointer runtime error from occurring—which is common when working with strings that have not yet been set to a value. I’ve decided not to include a string length check in the set functions to make the source code easier to read, but this sort of built-in error handling is a good idea.

public class truck extends vehicle {
    private String model;
    private String engine;
    private int towingcapacity;
    public truck() {
        setMake("make");
        setNumWheels(4);
        setModel("model");
        setEngine("engine");
        setTowingCapacity(0);
    }

    public truck(String make, String model, String engine, int towing) {
        setMake(make);
        setModel(model);
        setEngine(engine);
        setTowingCapacity(towing);
    }

    public String getModel() {
        return model;
    }
    public void setModel(String newmodel) {
        model = newmodel;
    }

    public String getEngine() {
        return engine;
    }
    public void setEngine(String newengine) {
        engine = newengine;
    }

    public int getTowingCapacity() {
        return towingcapacity;
    }
    public void setTowingCapacity(int value) {
        towingcapacity = value;
    }
}

Now let’s make some changes to the main source code in the SimpleClass.java file. This is the part of the program that consumes, or uses, the vehicle and truck classes. Here is the complete listing:

import java.lang.*;
import javax.swing.*;
import java.awt.*;

public class SimpleClass extends JFrame {
    vehicle car;
    truck lightning;

    public SimpleClass() {
        super("SimpleClass");
        setSize(600,400);
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //initialize a vehicle object
        car = new vehicle();
        car.setMake("Ford");
        car.setNumWheels(4);
        //initialize a truck object using a constructor
        lightning = new truck("Ford SVT", "F-150 Lightning",
            "5.4L Triton V8", 7700);
        lightning.
    }

    public void paint(Graphics g) {
        //let's use a nice big font
        g.setFont(new Font("Verdana", Font.BOLD, 12));

        //display the car info
        g.drawString("Car make: " + car.getMake(), 20, 50);
        g.drawString("Number of wheels: " + car.getNumWheels(), 20, 70);

        //display the truck info
        g.drawString("Truck make: " + lightning.getMake(), 20, 90);
        g.drawString("Truck model: " + lightning.getModel(), 20, 110);
        g.drawString("Truck engine: " + lightning.getEngine(), 20, 130);
        g.drawString("Truck towing capacity: " +
                     lightning.getTowingCapacity(), 20, 150);
    }

    public static void main(String[] args) {
        new SimpleClass();
    }
}

What is the most significant part of this program that might seem unusual or surprising? Well, take a look at those last few lines of code where the truck information is displayed on the screen. The truck is using a method called getMake() that is not even defined in the truck class; this is a method found only in the vehicle class, from which the truck class was inherited. That is the real power of inheritance—the ability to reuse functionality while enhancing existing classes.

I have added the truck class to the SimpleClass program, which is where the vehicle class may also be found. You can open the SimpleClass project from the companion website materials (www.courseptr.com/downloads) in the sourceschapter02 folder. Figure 2.3 shows the output from the current version of the program up to this point.

Figure 2.3. The SimpleClass program now demonstrates inheritance with the truck class.