Chapter 2
An Introduction to Data and Control

2.1 Introduction

The first half of the chapter fills in three important areas. First, it examines expressions: how simple values are expressed in Java, particularly numeric data. Second, it discusses program elements called variables that can change in value as the program executes. Third, it details the workings of the print and println statements that produce output.

The second half of the chapter introduces your first control structure: the for loop. You use this structure to repeat actions in a program. This is useful whenever you find a pattern in a complex task like the creation of a complex figure, because you can use a for loop to repeat an action that creates a particular pattern. The challenge is finding each pattern and figuring out what repeated actions will reproduce it.

2.2 Data and Types

A decision was made early in the design of Java to have two very different kinds of data: primitive data and objects. The designers admit that this decision was made purely on the basis of performance to make Java programs run faster. This is unfortunate because it means that we have to learn two sets of rules about how data works. But this is one of those times when you simply have to pay the price if you want to use an industrial strength programming language. To make this a little easier, we will study the primitive data types first in this chapter and then turn our attention to objects in chapter 3.

There are eight primitive data types in Java but we will explore only four of them. The four types we will explore are listed below.

It may seem odd to have one type for integers and another type for real numbers. Isn't every integer a real number? The answer is yes, but these are fundamentally different types of numbers. The difference is so great that we make this distinction even in English. We don't ask, "How much sisters do you have?" or "How many do you weigh?" We realize that sisters come in discrete integer quantities (0 sisters, 1 sister, 2 sisters, 3 sisters, and so on) and we use the word "many" for integer quantities ("How many sisters do you have?"). Similarly, we realize that weight can vary by tiny amounts (175 pounds versus 175.5 pounds versus 175.25 pounds and so on) and we use the word "much" for these real-valued quantities ("How much do you weigh?").

In programming this distinction is even more important because integers and reals are represented in a different way in the computer's memory. Integers are stored exactly while reals are stored as approximations with a limited number of digits of accuracy. We will see that this leads to round-off errors when you use real values.

The name "double" for real values isn't very clear. It's an accident of history that we have this name in much the same way that we still talk about "dialing" a number on our telephones even though modern telephones don't have a dial. The C programming language introduced a type called "float" for storing real numbers (short for "floating point number"). But floats had limited accuracy and another type was introduced called "double," short for "double precision" (double the precision of a simple float). As memory has become cheaper, people have moved more towards using double as the default for floating-point values. In hindsight, it might have been better to use the word "float" for what is now called double and then used a word like "half" for the values with less accuracy, but it's tough to change habits that are so ingrained. So programming languages will continue to use the word "double" for floating point numbers and people will still talk about dialing people on the phone even if they've never touched a telephone dial.

You might be wondering about the other four primitive types that weren't in the table above. They are simply variations of these more commonly used types. Below is a table of all eight of the primitive types with a short description of each.

2.3 Expressions

In Java, you refer to values by using an expression.

Suppose, for example, that you want to know how many bottles of water you have. If you have two 6-packs, four 4-packs and 2 individual bottles, then you could compute the total number of bottles with the following expression:

        (2 * 6) + (4 * 4) + 2

The value obtained when an expression is evaluated is called the result.

Complex expressions are formed using operators. An operator is a special symbol (like "+" or "*") used to indicate an operation to be performed on one or more values. The values used in the expression are called operands. For example, consider the following simple expressions:

        3 + 29
        4 * 5

           3        +        29
           |        |         |
        operand  operator  operand

           4        8         5
           |        |         |
        operand  operator  operand

        (3 + 29) - (4 * 5)

          (3        +        29)     -      (4        *         5)
           |        |         |      |       |        |         |
        operand  operator  operand   |    operand  operator  operand
           |                  |      |       |                  |
           +------------------+      |       +------------------+
                 operand          operator          operand

You will see many different operators as you progress through the book, all of which can be used to form expressions. Expressions can be arbitrarily complex, with as many operators as you like. For that reason, when I tell you, "An expression can be used here," I will often point out that I mean "arbitrary expressions" to emphasize that you can use complex expressions as well as simple values.

2.3.1 Literals

The simplest expressions refer to values directly using what are known as literals. An integer literal (considered to be of type int) is a sequence of digits with or without a leading sign:

        3    482    -29434    0    92348    +9812

        298.4    0.284    207.    .2843    -17.452    -.98

        3.84e92    1e-5    2.458e12

Character literals (of type char) are enclosed in single quotation marks and can include just one character:

         'a'    'm'    'X'    '!'    '3'    '\\'

       '\''

        true    false

2.3.2 Arithmetic Operators

The basic arithmetic operators are as follows.

The addition and subtraction operators should be familiar to you. The asterisk as a multiplication operator might be a surprise for nonprogrammers but doesn't take long to get used to. Division is also fairly familiar, although as we'll see, there are really two different division operations. The remainder or mod operation is the one that will be most unfamiliar to people.

Division presents a problem in the domain of integers. When you divide 119 by 5, for example, you do not get an integer. Therefore, integer division is expressed as two different integers--a quotient and a remainder:

        119
        ---  =  23 (quotient) with 4 (remainder)
         5

        119 / 5 evaluates to 23
        119 % 5 evaluates to  4

               31
           _______
        34 ) 1079
             102
             ----
               59
               34
               --
               25

        1079 / 34 evaluates to 31
        1079 % 34 evaluates to 25

2.3.3 Precedence

Java expressions are like complex noun phrases in English. Such phrases are subject to ambiguity, as in, "the man on the hill by the river with the telescope." Is the river by the hill or by the man? Is the man holding the telescope, or is the telescope on the hill, or is the telescope in the river? You don't know how the various parts are grouped together.

You can get the same kind of ambiguity if parentheses aren't used to group the parts of a Java expression. For example, the expression 2 + 3 * 4 has two operators. Which is performed first? You could interpret this two ways:

        (2 + 3) * 4 = 6 * 4 = 24
        2 + (3 * 4) = 2 + 12 = 14

Rules of precedence are applied when the grouping of operators in an expression is ambiguous. An operator with low precedence is evaluated after operators of higher precedence. Within a given level of precedence the operators are evaluated in one direction, usually left to right.

For arithmetic expressions there are two levels of precedence. The multiplicative operators (*, /, %) have a higher level of precedence than the additive operators (+, -). So the expression 2 + 3 * 4 is interpreted as:

        2 + 3 * 4 = 2 + (3 * 4) = 2 + 12 = 14

        40 - 25 - 9 = (40 - 25) - 9 = 15 - 9 = 6

2.3.4 Mixing Types, Conversion and Casting

We often find ourselves mixing values of different types and wanting to convert from one type to another. Java has simple rules that avoid confusion and provides a mechanism for requesting that a value be converted from one type to another.

We often find ourselves mixing ints and doubles. We might, for example, ask Java to compute 2 * 3.6. This involves the integer literal 2 and the floating point literal 3.6. In this case Java converts the integer into a floating point and performs this computation entirely in floating point. If Java encounters an int where it was expecting a double, it always converts the int to a double.

This becomes particularly important when you form expressions that involve division. If the two operands are both of type int, then Java will use integer (truncated) division. If either of the two operands is of type double, however, then it will do real-valued (normal) division. For example, 23 / 4 evaluates to 5 but all of the following evaluate to 5.75: 23.0 / 4, 23. / 4, 23 / 4.0, 23 / 4., 23. / 4., 23.0 / 4.0.

Sometimes you want Java to go the other way, converting a double into an int. You can ask Java to do this with what is known as a cast. Think of it as "casting a value in a different light." You request a cast by putting the name of the type you want to cast to in parentheses in front of the thing you want to cast. For example, if you say:

        (int)4.75

       (int)2.5 / 0.15

        (int)(2.5 / 0.15)

In a later chapter we will explore the details of type char and we will see that every character has a corresponding integer value. Java is willing to automatically convert a value of type char into an int whenever it is expecting an int. For example, you can form the following rather strange expression:

        2 * 'a'

Java will not, however, automatically convert in the other direction. That is because the type char is in a sense a subset of the type int. Every char value has a corresponding int, but not every int has a corresponding char. That means that Java would always be able to turn a char into an int, but might not always be able to turn an int into a char. So in this case Java insists on a cast. This allows you to form expressions like the following:

    (char)('a' + 3)

2.4 Variables

Primitive data can be stored in the computer's memory in a variable.

As with all Java words, variables are named by legal identifiers. Java is particular about the type of each object, so you must tell the computer the type of every variable you plan to use. Every variable has a memory location set aside where it stores its value. Values can change, but only one value can be stored at a time. When the variable changes, the old value goes away.

All variables must be declared by specifying their type and name, as in:

    int x;

      int x, y, z;

       int x = 3;

        int x = 3, y = 5, z = 19;

        int x = 2 + 3 * 4, y, z = 178 / 4 % 3;

2.4.1 Assignment Statement

The simplest way to give a value to a variable is to use an assignment statement:

        first = 47;

        second = 37 - 18 + 3;

         sum = first + second;

Even though Java uses the equals sign for assignment, don't confuse this with a statement of equality. This is a command to perform an action. For example, this is not a legal assignment statement:

        47 = first;

The assignment statement does not represent an algebraic relationship. In algebra if you say something like:

        x = y + 2

        second = first + 2;

Initially first and second are uninitialized:

              +---+                    +---+
        first | ? |             second | ? |
              +---+                    +---+

              +----+                   +---+
        first | 13 |            second | ? |
              +----+                   +---+

              +----+                   +----+
        first | 13 |            second | 15 |
              +----+                   +----+

              +----+                   +----+
        first | 50 |            second | 15 |
              +----+                   +----+

One very common assignment statement that points out the difference between algebraic relationships and program statements is:

        first = first + 1;

This section is titled "assignment statement" but in fact assignment is an operator, not a statement. That means that you can form expressions that have assignment operators embedded within them. Unlike most other operators, the assignment operator evaluates from right to left. This allows programmers to write statements like the following:

        int x, y, z;
        x = y = z = 2 * 5 + 4;

        x = (y = (z = 2 * 5 + 4));

        x = (y = 14);

While you can do assignments like these, it's not clear that you really want to do assignments like these. The chained assignment statement is fairly easy to read, but try to figure out what the following statement does:

        x = 3 * (y = 2 + 2) / (z = 2);

        y = 2 + 2;
        z = 2;
        x = 3 * y / z;

2.4.2 Other Operators

In addition to the standard assignment operator, Java has several special operators that are useful for a particular family of operations that are common in programming. You often find yourself increasing a variable by a particular amount which we call incrementing. You also often find yourself decreasing a variable by a particular amount, which we call decrementing. To accomplish this you write statements like the following:

        x = x + 1;
        y = y - 1;
        z = z + 2;

        x = x * 2;
        y = y * 3;
        z = z / 2;

        x += 1;
        y -= 1;
        z += 2;

        x *= 2;
        y *= 3;
        z /= 2;

Java has an even more concise way of expressing this for the particular case where you want to increment by 1 or decrement by 1 in which case you can use the operators "++" and "--". For example, you can say:

        x++;
        y--;

        ++x;
        --y;

Consider, for example, the following code fragment:

        int x = 10;
        int y = 20;
        int z = ++x * y--;

There is a simple mnemonic to remember this. When you see "x++" read it as "give me x, then increment" and read "++x" as "increment, then give me x." Here's another memory device that might help. Just remember that C++ is a bad name for a programming language. The expression "C++" would be interpreted as, "Return the old value of C and then increment C." In other words, even though you're trying to come up with something new and different, you're really stuck with the old awful language. The language you want is ++C, because then you'd improve the language and you'd get to work with the new and improved language rather than the old one. Some people have suggested that perhaps Java is ++C.

The "++" and "--" operators were first introduced in the C programming language. Java has them because the designers of the language decided to use the syntax of C as the basis for Java syntax. Many languages have made the same choice, including C++ and C#. There is almost a sense of pride among C programmers that these operators allow you to write extremely concise code. Many other people feel that they can make code unnecessarily complex. In this book you will see that I almost always use these operators as a separate statement so that it is obvious what is going on.

2.4.3 Output and Strings Revisited

You saw in chapter 1 that you can output string literals using System.out.println. You can also output numeric expressions using System.out.println:

        System.out.println(12 + 3 - 1);

Consider, for example, the following program that computes the number of hours, minutes and seconds in a standard year.

        System.out.println("(" + x + ", " + y + ", " + z + ")");

2.4.4 Print versus Println

Java has a variation of the println command called print that allows you to produce output on the current line without going to a new line of output. The println command really does two different things: it sends output to the current line and then it positions to the beginning of a new line. The print command does only the first of these. Thus, a series of print commands will generate output all on the same line. Only a println command will cause the current line to be completed and a new line to be started. For example, consider these six statements:

        System.out.print("Hi Ho, ");
        System.out.print("my man.");
        System.out.print("Where are you bound?  ");
        System.out.println("My way, I hope.");
        System.out.print("This is");
        System.out.println(" for the whole family!")

        Hi ho,
               ^

        Hi ho, my man.
                      ^

        Hi ho, my man.Where are you bound?
                                            ^

        Hi ho, my man.Where are you bound?  My way, I hope.

        ^

        Hi ho, my man.Where are you bound?
        This is
               ^

        Hi ho, my man.Where are you bound?
        This is for the whole family!

        ^

        System.out.println("Hi ho, my man.Where are you bound?  My way, I hope.");
        System.out.println("This is for the whole family!")

It is possible to have empty println command:

        System.out.println();

2.5 The For Loop

Programming often involves specifying redundant tasks. The for loop helps to avoid such redundancy. Suppose you want to write out the squares of the first 5 integers. You can say:

        System.out.println(number + " squared = " + (number * number));

The general syntax of the for loop is as follows:

The for loop is the first example of a control structure, a syntactic structure that controls another statement. Java allows great flexibility in deciding what to include in the initialization part and the update and this allows us to use the for loop to solve all sorts of programming tasks. For right now, we will restrict ourselves to a particular kind of loop that declares and initializes a single variable that is used to control the loop. This variable is often referred to as the control variable of the loop. In the test we compare the control variable against some final desired value and in the update we change the value of the control variable, most often incrementing it by 1. Such loops are very common in programming. By convention, we often use variable names like i, j and k for such loops.

Each execution of the controlled statement of a loop is called an iteration of the loop, as in, "The loop halted after four iterations." Iteration also refers to looping in general, as in, "I solved the problem using iteration."

Consider another for loop:

        for (int i = -100; i <= 100; i++)
            System.out.println(i + " squared = " + (i * i));

        for (int i = (2 + 2); i <= (17 * 3); i++)
            System.out.println(i + " squared = " + (i * i));

        for (int i = 1; i <= 30; i++)
            System.out.println("+--------+")

        for (int i = -30; i <= -1; i++)
            System.out.println("+--------+")

        (ending value) - (starting value) + 1

Let's consider some borderline cases. What happens if you say:

        for (int i = 1; i <= 1; i++)
            System.out.println("+--------+")

        for (int i = 1; i <= 0; i++)
            System.out.println("+--------+")

2.5.1 Controlling Multiple Statements

What if you want to write a for loop that executes two statements? What if, for example, you want to produce 20 pairs of lines, the first of which has the word "hi" on it and the second of which has the word "ho"? You might try the following:

        for (int i = 1; i <= 20; i++)
            System.out.println("Hi!");
            System.out.println("Ho!");

You could define a static method called twoLines that performs these two printlns and could then call the method as the one statement in the for loop:

        for (int i = 1; i <= 20; i++)
            twoLines();

        for (int i = 1; i <= 20; i++) {
            System.out.println("Hi!");
            System.out.println("Ho!");
        }

        for (int i = 1; i <= 20; i++) {
            System.out.println("Hi!");
            System.out.println("Ho!");
            System.out.println("My");
            System.out.println("Man!")
        }

        for (int i = 1; i <= 20; i++)
        {
            System.out.println("Hi!");
            System.out.println("Ho!");
            System.out.println("My");
            System.out.println("Man!")
        }

2.5.2 For Loops within For Loops

The for loop controls a statement, and the for loop is itself a statement. This makes the following legal:

        for (int i = 1; i <= 10; i++)
            for (int j = 1; j <= 5; j++)
                System.out.println("Hi there.");

        for (int i = 1; i <= 50; i++)
            System.out.println("Hi there.");

        System.out.println("******************************");

        for (int column:= 1; column <= 30; column++)
            System.out.print("*");
        System.out.println();

        for (int row = 1; row <= 50; row++) {
            for (int column= 1; column <= 30; column++)
                System.out.print("*");
            System.out.println();
        }

2.5.3 Levels of Control

Block statements and control structures introduce different statement levels, the relative levels of control of statements within a block:

• statements controlled at the outer level are assigned level 1;
• statements controlled by level 1 statements are assigned level 2;
• statements controlled by level 2 statements are assigned level 3;
• and so on

        1{       for (int row = 1; row <= 50; row++) {
        2            for (int column= 1; column <= 30; column++)
        3                System.out.print("*");
        2            System.out.println();
        }        }

        1{       for (int row = 1; row <= 5; row++) {
        2{           for (int column = 1; column <= 15; column++) {
        3                System.out.print("|");
        3                for (int dashes = 1; dashes <= 3; dashes++)
        4                    System.out.print("-");
        }            }
        2            System.out.println();
        }        }

2.5.4 Scope, Local Variables and Loops

Now that we are dealing with block statements and nested statements, we need to understand the concept of scope.

We have seen that when it comes to declaring static methods, we can put them in any order whatsoever. The scope of a static method is the entire class in which it appears. Variables work differently. The simple rule is that the scope of a variable declaration extends from the point where it is declared to the end of the block enclosing the declaration. In other words, find the pair of curly braces that directly enclose the variable declaration. The scope of the variable is from the point where it is declared to the closing curly brace for that block.

There are several implications of this scope rule. Consider first what it means for different methods. Each method has its own set of curly braces to indicate the statements to be executed when the method is called. If variables are declared inside of a method's curly braces, then those variables won't be available outside the method. We refer to such variables as local variables and we refer to this process as localizing variables. We consider this a good programming practice. In general, we want to declare variables in the most local scope possible.

You might wonder why we would want to localize variables to just one method. Why not just declare everything in one outer scope? That certainly seems simpler. The idea is similar to the use of refrigerators in dormitories. Every dorm room can have its own refrigerator for use in that room. If you are outside of a room, you don't even know that it has a refrigerator in it. The contents of the room are hidden from you.

Localizing variables leads to some duplication and confusion, but provides more security. Our programs use variables to store values just as students use refrigerators to store beer, ice cream, and other valuables. The last time I was in a dorm I noticed that most of the individual rooms had refrigerators in them. This seems terribly redundant, but the reason is obvious. If you want to guarantee the security of something, you put it where nobody else can get it. You will use local variables in much the same way. Each individual block will have its own local variables to use, which means you don't have to consider possible interference from other parts of the program.

Scope rules are important to understand when we talk about the local variables of one method versus another method, but they also have implications for what happens inside a single method. We have seen that curly braces can be used to form a special kind of statement called a block statement that can appear inside a method. By nesting blocks inside of blocks and declaring variables in those blocks, we generate different scopes. Consider the following method.

        public static void illegalScope() {
            int x = 3;
            {
                int y = 7;
                System.out.println("x = " + x + ", y = " + y);
            }
            System.out.println("x = " + x + ", y = " + y);
        }

There are a few special cases for scope and the for loop is one of them. When a variable is declared in the initialization part of a for loop, then its scope is just the for loop itself (the 3 parts in the for loop header and the statement controlled by the for loop). That means that you can use the same variable name in multiple for loops:

        for (int i = 1; i <= 10; i++)
            System.out.println(i + " squared = " + (i * i));
        for (int i = 1; i <= 10; i++)
            System.out.println(i + " cubed = " + (i * i * i));

        for (int i = 1; i <= 5; i++)
            for (int i = 1; i <= 10; i++)
                System.out.println("hi there.");

In all of the for loop examples we have looked at, the control variable is declared in the initialization part of the loop. This isn't a requirement. You can separate the declaration of the variable from the initialization of the variable, as in the following.

        int i;
        for (i = 1; i <= 5; i++)
            System.out.println(i + " squared = " + (i * i));

        int i;
        for (i = 1; i <= 5; i++)
            for (i = 1; i <= 10; i++)
                System.out.println("hi there.");

        int i;
        for (i = 1; i <= 10; i++)
            for (i = 1; i <= 5; i++)
                System.out.println("hi there.");

2.5.5 Programming with Pseudocode

The programs that you write describe a particular algorithm for solving a problem.

As you develop more and more complex algorithms, you will want to make use of the technique of writing pseudocode.

For example, you can describe the problem of drawing a box as:

        draw a box with 50 lines and 30 columns of asterisks.

        for (each of 50 lines)
            draw a line of 30 asterisks.

        for (each of 50 lines) {
           for (each of 30 columns)
               write one asterisk on the output line.
           go to a new output line.
        }

        for (each of 5 lines)
            draw one line of the triangle.

        for (each of 5 lines) {
            write some spaces (possibly 0) on the output line.
            write some asterisks on the output line.
            go to a new output line.
        }

You want to find a relationship between line number and the other two columns. This is simple algebra, because these columns are related in a linear way. The second column is easy to get from Line, it equals (line - 1). The third column is a little tougher. Because it goes down by 2 every time and the first column goes up by 1 every time, you need a multiplier of -2. Then you need an appropriate constant. The number 11 seems to do the trick, so that the third column equals (11 - 2 * line). You can improve your pseudocode, then, as follows:

        for line going 1 to 5 {
            write (line - 1) spaces on the output line.
            write (11 - 2 * line) asterisks on the output line.
            go to a new output line.
        }

2.5.6 For Loop Variations

How would you produce this figure?

        for (int i = 10; i >= 1; i--)
            System.out.println(i + " squared = " + (i * i));

        for (int i = 1; i <= 10; i++)
            System.out.println(2 * i + " squared = " + (2 * i * 2 * i));

        for (int i = 2; i <= 20; i += 2)
            System.out.println(2 * i + " squared = " + (2 * i * 2 * i));

2.5.7 Magic Numbers

The DrawCone program in the last section draws a cone with 5 lines. How would you modify it to produce a cone with 3 lines? One simple strategy is to change all the 5's to 3's, which will produce this output:

          *****
         *******
        *********

        2 * (number of lines) + 1

To make programs more readable and more adaptable, you should try to avoid magic numbers whenever possible. You do so by storing the magic numbers. You can use variables to store these values, but that is misleading, given that you are trying to represent values that don't change. Java offers an alternative. You can create objects that are guaranteed to have constant values. Not surprisingly, they are called "constants."

The first advantage of a constant is that you can name it. This allows you to choose a descriptive name that explains what the constant represents. You can then use that name instead of referring to the specific value to make your programs more readable and adaptable. For example, in the DrawCone program you might want to introduce a constant called LINES that will replace the magic number 5 (recall from chapter 1 that we use all uppercase letters for constant names). Also, you can use the constant as part of an expression to calculate a value. This allows you to replace the magic number 11 with a formula like (2 * LINES + 1).

Constants are declared with the keyword "final" which indicates the fact that their values cannot be changed once assigned. You can declare them anywhere you can declare a variable, as in:

        final int LINES = 5;

        public static final int HEIGHT = 10;
        public static final int WIDTH = 20;

How would you rewrite the DrawCone program with a constant to eliminate the magic numbers? You would introduce a constant for the number of lines:

        public static final int LINES = 5;

2.5.8 A Complex Figure

Now consider an example that is even more complex. To solve it, you will use static methods to decompose the task into subtasks. Consider the following figure:

        draw a solid line.
        draw the top half of the hourglass.
        draw the bottom half of the hourglass.
        draw a solid line.

        public static final int SUB_HEIGHT = 3;

        (2 * SUB_HEIGHT + 2)

        (2 * SUB_HEIGHT)

        write a plus on the output line.
        write (2 * SUB_HEIGHT) dashes on the output line.
        write a plus on the output line.
        go to a new output line.

    public static void drawLine() {
        System.out.print("+");
        for (int column = 1; column <= (2 * SUB_HEIGHT); column++)
            System.out.print("-");
        System.out.println("+");
    }

        | \  / |

         |               \                /             |
        bar  spaces  backslash  spaces  slash  spaces  bar

        for (each of SUB_HEIGHT lines) {
            write a bar on the output line.
            write some spaces on the output line.
            write a back slash on the output line.
            write some spaces on the output line.
            write a slash on the output line.
            write some spaces on the output line.
            write a bar on the output line.
            go to a new line of output.
        }

The first and third sets of spaces fit the rule (line - 1), and the second number of spaces is (6 - 2 * line). But how do you account for possible magic numbers? There are many ways to do so. You could find the expressions for different heights and see how they differ. Or you could analyze the geometry of the figure and try to deduce the expressions. Or you could guess and hope that you are right. Any of those solutions would inevitably lead to the conclusion that the only magic number in the expressions above is 6, which comes from (2 * SUB_HEIGHT). Thus, the correct expressions are: (line - 1) and 2 * (SUB_HEIGHT - line). Therefore, the pseudocode should read:

        for (line going 1 to SUB_HEIGHT) {
            write a bar on the output line.
            write (line - 1) spaces on the output line.
            write a back slash on the output line.
            write 2 * (SUB_HEIGHT - line) spaces on the output line.
            write a slash on the output line.
            write (line - 1) spaces on the output line.
            write a bar on the output line.
            go to a new line of output.
        }

        +------+
        |  /\  |
        | /  \ |
        |/    \|
        |\    /|
        | \  / |
        |  \/  |
        +------+

2.5.9 Global Versus Local Constants

The program written in the last section raises an important issue. It declares a constant called SUB_HEIGHT that is used throughout the program. But the constant is not declared locally in the individual methods. That seems to violate our principle of localizing whenever possible. While localizing of variables is a good idea, the same, is not always true for constants. In this case a class-wide definition is more appropriate. We localize variables do avoid potential interference. That argument doesn't hold for constants, since they are guaranteed not to change. Another argument for using local variables is that it makes our static methods more independent. That argument has some merit, but not enough. It is true that global constants introduce dependencies between methods, but often that is really what you want. For example, the three methods of the hourglass program should not be independent of each other when it comes to the size of figures. Each subfigure has to use the same size constant. Imagine the potential disaster if each method had its own SUB_HEIGHT each with a different value. None of the pieces would fit together.

2.6 Programming Problems

1. Write a program that produces the following output:

           ****** //////////// ******
           *****  //////////\\  *****
           ****   ////////\\\\   ****
           ***    //////\\\\\\    ***
           **     ////\\\\\\\\     **
           *      //\\\\\\\\\\      *
                  \\\\\\\\\\\\
   

2. Write a program that produces the following output:

           +---------+
           |    *    |
           |   /*\   |
           |  //*\\  |
           | ///*\\\ |
           | \\\*/// |
           |  \\*//  |
           |   \*/   |
           |    *    |
           +---------+
           | \\\*/// |
           |  \\*//  |
           |   \*/   |
           |    *    |
           |    *    |
           |   /*\   |
           |  //*\\  |
           | ///*\\\ |
           +---------+
   

3. Write a program that displays Pascal's triangle:

                                  1
                                1   1
                              1   2   1
                            1   3   3   1
                          1   4   6   4   1
                        1   5  10  10   5   1
                      1   6  15  20  15   6   1
                    1   7  21  35  35  21   7   1
                  1   8  28  56  70  56  28   8   1
                1   9  36  84 126 126  84  36   9   1
              1  10  45 120 210 252 210 120  45  10   1
   

4. Write a program that produces the following output. Use a program constant to make it possible to change the number of stairs in the figure.

                                 O  *******
                                /|\ *     *
                                / \ *     *
                            O  ******     *
                           /|\ *          *
                           / \ *          *
                       O  ******          *
                      /|\ *               *
                      / \ *               *
                  O  ******               *
                 /|\ *                    *
                 / \ *                    *
             O  ******                    *
            /|\ *                         *
            / \ *                         *
           ********************************
   

   ---

   Stuart Reges
   Last modified: Fri Oct 1 15:03:41 PDT 2004