Java supports the same four basic arithmetic operations as a calculator—addition, subtraction, multiplication, and division. As you have already seen, addition and subtraction use the familiar + and - operators, and the * operator denotes multiplication. Division is indicated with a /, not a fraction bar. For example,

becomes

(a + b) / 2

Parentheses are used just as in algebra: to indicate in which order the subexpressions should be computed. For example, in the expression (a + b) / 2, the sum a + b is computed first, and then the sum is divided by 2. In contrast, in the expression

a + b / 2

only b is divided by 2, and then the sum of a and b / 2 is formed. Just as in regular algebraic notation, multiplication and division bind more strongly than addition and subtraction. For example, in the expression a + b / 2, the / is carried out first, even though the + operation occurs farther to the left.

Incrementing a value by 1 is so common when writing programs that there is a special shorthand for it, namely

items++;

This statement adds 1 to items. It is easier to type and read than the equivalent assignment statement

items = items + 1;

As you might have guessed, there is also a decrement operator --. The statement

items--;

subtracts 1 from items.

Figure 4.1. Incrementing a Variable

Division works as you would expect, as long as at least one of the numbers involved is a floating-point number. That is,

7.0 / 4.0
7 / 4.0
7.0 / 4

all yield 1.75. However, if both numbers are integers, then the result of the division is always an integer, with the remainder discarded. That is,

7 / 4

evaluates to 1, because 7 divided by 4 is 1 with a remainder of 3 (which is discarded). Discarding the remainder is often useful, but it can also be a source of subtle programming errors—see Common Error 4.1 on page 142.

If you are interested only in the remainder of an integer division, use the % operator:

7 % 4

is 3, the remainder of the integer division of 7 by 4. The % symbol has no analog in algebra. It was chosen because it looks similar to /, and the remainder operation is related to division.

Here is a typical use for the integer / and % operations. Suppose you want to know how much change a cash register should give, using separate values for dollars and cents. You can compute the value as an integer, denominated in cents, and then compute the whole dollar amount and the remaining change:

final int PENNIES_PER_NICKEL = 5;
final int PENNIES_PER_DIME = 10;
final int PENNIES_PER_QUARTER = 25;
final int PENNIES_PER_DOLLAR = 100;

// Compute total value in pennies
int total = dollars * PENNIES_PER_DOLLAR + quarters * PENNIES_PER_QUARTER
      + nickels * PENNIES_PER_NICKEL + dimes * PENNIES_PER_DIME + pennies;

// Use integer division to convert to dollars, cents
int dollars = total / PENNIES_PER_DOLLAR;
int cents = total % PENNIES_PER_DOLLAR;

For example, if total is 243, then dollars is set to 2 and cents to 43.

To compute xⁿ, you write Math.pow(x, n). However, to compute x² it is significantly more efficient simply to compute x * x.

To take the square root of a number, you use the Math.sqrt method. For example, √x is written as Math.sqrt(x).

In algebra, you use fractions, superscripts for exponents, and radical signs for roots to arrange expressions in a compact two-dimensional form. In Java, you have to write all expressions in a linear arrangement.

Figure 4.2. Analyzing an Expression

For example, the subexpression

of the quadratic formula becomes

(-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a)

Figure 2 shows how to analyze such an expression. With complicated expressions like these, it is not always easy to keep the parentheses ( ) matched—see Common Error 4.2 on page 143.

Table 2 shows additional methods of the Math class. Inputs and outputs are floating-point numbers.

Occasionally, you have a value of type double that you need to convert to the type int. Use the cast operator (int) for this purpose. You write the cast operator before the expression that you want to convert:

double balance = total + tax;
int dollars = (int) balance;

Cast

The cast (int) converts the floating-point value balance to an integer by discarding the fractional part. For example, if balance is 13.75, then dollars is set to 13.

The cast tells the compiler that you agree to information loss, in this case, to the loss of the fractional part. You can also cast to other types, such as (float) or (byte).

If you want to round a floating-point number to the nearest whole number, use the Math.round method. This method returns a long integer, because large floating-point numbers cannot be stored in an int.

long rounded = Math.round(balance);

If balance is 13.75, then rounded is set to 14.

Table 4.3. Arithmetic Expressions

Mathematical Expression	Java Expression	Comments
	(x + y) / 2	The parentheses are required; x + y / 2 computes x + y/2.
	x * y / 2	Parentheses are not required; operators with the same precedence are evaluated left to right.
	Math.pow(1 + r / 100, n)	Complex formulas are "flattened" in Java.
	Math.sqrt(a * a + b * b)	a * a is simpler than Math.pow(a, 2).
	(i + j + k) / 3.0	If i, j, and k are integers, using a denominator of 3.0 forces floating-point division.

n--;
n++;
n--;

7. What is the value of 1729 / 100? Of 1729 % 100?

8. Why doesn't the following statement compute the average of s1, s2, and s3?

double average = s1 + s2 + s3 / 3; // Error

9. What is the value of Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)) in mathematical notation?

10. When does the cast (long) x yield a different result from the call Math.round(x)?

11. How do you round the double value x to the nearest int value, assuming that you know that it is less than 2 · 10⁹?

Common Error 4.1: Integer Division

It is unfortunate that Java uses the same symbol, namely /, for both integer and floating-point division. These are really quite different operations. It is a common error to use integer division by accident. Consider this program segment that computes the average of three integers.

int s1 = 5; // Score of test 1
int s2 = 6; // Score of test 2
int s3 = 3; // Score of test 3
double average = (s1 + s2 + s3) / 3;  // Error

System.out.print("Your average score is ");
System.out.println(average);

What could be wrong with that? Of course, the average of s1, s2, and s3 is

Here, however, the / does not mean division in the mathematical sense. It denotes integer division, because the values s1 + s2 + s3 and 3 are both integers. For example, if the scores add up to 14, the average is computed to be 4, the result of the integer division of 14 by 3. That integer 4 is then moved into the floating-point variable average. The remedy is to make either the numerator or denominator into a floating-point number:

double total = s1 + s2 + s3;
double average = total / 3;

or

double average = (s1 + s2 + s3) / 3.0;

Common Error 4.2: Unbalanced Parentheses

Consider the expression

1.5 * ((-(b - Math.sqrt(b * b - 4 * a * c)) / (2 * a))

What is wrong with it? Count the parentheses. There are five opening parentheses ( and four closing parentheses ). The parentheses are unbalanced. This kind of typing error is very common with complicated expressions. Now consider this expression.

1.5 * (Math.sqrt(b * b - 4 * a * c))) - ((b / (2 * a))

This expression has five opening parentheses ( and five closing parentheses ), but it is still not correct. In the middle of the expression,

1.5 * (Math.sqrt(b * b - 4 * a * c))) - ((b / (2 * a))

there are only two opening parentheses ( but three closing parentheses ), which is an error. In the middle of an expression, the count of opening parentheses must be greater than or equal to the count of closing parentheses, and at the end of the expression the two counts must be the same.

Here is a simple trick to make the counting easier without using pencil and paper. It is difficult for the brain to keep two counts simultaneously, so keep only one count when scanning the expression. Start with 1 at the first opening parenthesis; add 1 whenever you see an opening parenthesis; subtract 1 whenever you see a closing parenthesis. Say the numbers aloud as you scan the expression. If the count ever drops below zero, or if it is not zero at the end, the parentheses are unbalanced. For example, when scanning the previous expression, you would mutter

and you would find the error.

x1 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);

x1=(-b+Math.sqrt(b*b-4*a*c))/(2*a);

Quality Tip 4.3: Factor Out Common Code

Suppose you want to find both solutions of the quadratic equation ax² + bx + c = 0. The quadratic formula tells us that the solutions are

In Java, there is no analog to the ± operation, which indicates how to obtain two solutions simultaneously. Both solutions must be computed separately:

x1 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);
x2 = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);

This approach has two problems. First, the computation of Math.sqrt(b * b - 4 * a * c) is carried out twice, which wastes time. Second, whenever the same code is replicated, the possibility of a typing error increases. The remedy is to factor out the common code:

double root = Math.sqrt(b * b - 4 * a * c);
x1 = (-b + root) / (2 * a);
x2 = (-b - root) / (2 * a);

You could go even further and factor out the computation of 2 * a, but the gain from factoring out very simple computations is too small to warrant the effort.

double f = 4.35;
int n = (int) (100 * f);
System.out.println(n); // Prints 434!

int n = (int) Math.round(100 * f); // OK, n is 435

balance += amount;

balance = balance + amount;

items *= 2;

items = items * 2;

In Java, strings are objects that belong to the class String. (You can tell that String is a class name because it starts with an uppercase letter. The primitive types int and double start with lowercase letters.)

You do not need to call a constructor to create a string object. You can obtain a string literal simply by enclosing a sequence of characters in double quotation marks. For example, the string literal "Harry" is an object of the String class.

The number of characters in a string is called the length of the string. As you have seen in Chapter 2, you can use the length method to obtain the length of a string. For example, "Hello".length() is 5, and the length of "Hello, World!" is 13. (The quotation marks are not part of the string and do not contribute to the length, but you must count spaces and punctuation marks.)

A string of length zero, containing no characters, is called the empty string and is written as "".

You can use the + operator to put strings together to form a longer string.

String name = "Dave";
String message = "Hello, " + name;

This process is called concatenation.

The + operator concatenates two strings, provided one of the expressions, either to the left or the right of a + operator, is a string. The other one is automatically forced to become a string as well, and both strings are concatenated.

For example, consider this code:

String a = "Agent";
int n = 7;
String bond = a + n;

Because a is a string, n is converted from the integer 7 to the string "7". Then the two strings "Agent" and "7" are concatenated to form the string "Agent7".

This concatenation is very useful to reduce the number of System.out.print instructions. For example, you can combine

System.out.print("The total is ");
System.out.println(total);

to the single call

System.out.println("The total is " + total);

The concatenation "The total is " + total computes a single string that consists of the string "The total is ", followed by the string equivalent of the number total.

Sometimes you have a string that contains a number, usually from user input. For example, suppose that the string variable input has the value "19". To get the integer value 19, you use the static parseInt method of the Integer class.

int count = Integer.parseInt(input);
   // count is the integer 19

To convert a string containing floating-point digits to its floating-point value, use the static parseDouble method of the Double class. For example, suppose input is the string "3.95".

double price = Double.parseDouble(input);
   // price  is the floating-point number 3.95

However, if the string contains spaces or other characters that cannot occur inside numbers, an error occurs. For now, we will always assume that user input does not contain invalid characters.

The substring method computes substrings of a string. The call

s.substring(start, pastEnd)

returns a string that is made up of the characters in the string s, starting at position start, and containing all characters up to, but not including, the position pastEnd. Here is an example:

String greeting = "Hello, World!";
String sub = greeting.substring(0, 5); // sub is "Hello"

The substring operation makes a string that consists of five characters taken from the string greeting. A curious aspect of the substring operation is the numbering of the starting and ending positions. The first string position is labeled 0, the second one 1, and so on. For example, Figure 3 shows the position numbers in the greeting string.

Figure 4.3. String Positions

The position number of the last character (12 for the string "Hello, World!") is always 1 less than the length of the string.

Let us figure out how to extract the substring "World". Count characters starting at 0, not 1. You find that W, the eighth character, has position number 7. The first character that you don't want, !, is the character at position 12 (see Figure 4).

Figure 4.4. Extracting a Substring

Therefore, the appropriate substring command is

String sub2 = greeting.substring(7, 12);

It is curious that you must specify the position of the first character that you do want and then the first character that you don't want. There is one advantage to this setup. You can easily compute the length of the substring: It is pastEnd - start. For example, the string "World" has length 12 − 7 = 5.

If you omit the second parameter of the substring method, then all characters from the starting position to the end of the string are copied. For example,

String tail = greeting.substring(7); // Copies all characters from position 7 on
sets tail to the string "World!".

If you supply an illegal string position (a negative number, or a value that is larger than the length of the string), then your program terminates with an error message.

In this section, we have made the assumption that each character in a string occupies a single position. Unfortunately, that assumption is not quite correct. If you process strings that contain characters from international alphabets or special symbols, some characters may occupy two positions—see Special Topic 4.5 on page 153.

15. Assuming the String variable river holds the value "Mississippi", what is the value of river.substring(1, 2)? Of river.substring(2, river.length() - 3)?

Exception in thread "main" java.lang.StringIndexOutOfBoundsException:
      String index out of range: −4
   at java.lang.String.substring(String.java:1444)
   at Homework1.main(Homework1.java:16)

java.lang.String.substring(String.java:1444)

Hello, "World"!

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

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

System.out.println("The secret message is in C:\Temp\Secret.txt");

The secret message is in C:TempSecret.txt

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

*
**
***

System.out.println("All the way to San Josu00E9!");

Special Topic 4.5: Strings and the char Type

Strings are sequences of Unicode characters (see Random Fact 4.2 on page 154). Character literals look like string literals, except that character literals are delimited by single quotes: 'H' is a character, "H" is a string containing a single character.

Characters have numeric values. For example, if you look at Appendix A, you can see that the character 'H' is actually encoded as the number 72.

You can use escape sequences (see Special Topic 4.4 on page 152) inside character literals. For example, ' ' is the newline character, and 'u00E9' is the character é.

When Java was first designed, each Unicode character was encoded as a two-byte quantity. The char type was intended to hold the code of a Unicode character. However, as of 2003, Unicode had grown so large that some characters needed to be encoded as pairs of char values. Thus, you can no longer think of a char value as a character. Technically speaking, a char value is a code unit in the UTF-16 encoding of Unicode. That encoding represents the most common characters as a single char value, and less common or supplementary characters as a pair of char values.

The charAt method of the String class returns a code unit from a string. As with the substring method, the positions in the string are counted starting at 0. For example, the statement

String greeting = "Hello";
char ch = greeting.charAt(0);

sets ch to the value 'H'.

However, if you use char variables, your programs may fail with some strings that contain international or symbolic characters. For example, the single character

If you call charAt(0) on the string containing the single character

Therefore, you should only use char values if you are absolutely sure that you won't need to encode supplementary characters.

Random Fact 4.2: International Alphabets

The English alphabet is pretty simple: upper- and lowercase a to z. Other European languages have accent marks and special characters. For example, German has three umlaut characters (ä, ö, ü) and a doubles character (ß). These are not optional frills; you couldn't write a page of German text without using these characters. German computer keyboards have keys for these characters.

A German Keyboard

Many countries don't use the Roman script at all. Russian, Greek, Hebrew, Arabic, and Thai letters, to name just a few, have completely different shapes (see The Thai Alphabet). To complicate matters, scripts like Hebrew and Arabic are written from right to left instead of from left to right, and many of these scripts have characters that stack above or below other characters, as those marked with a dotted circle do in Thai. Each of these alphabets has between 30 and 100 letters.

The situation is much more dramatic in languages that use Chinese script: the Chinese dialects, Japanese, and Korean. The Chinese script is not alphabetic but ideographic—a character represents an idea or thing rather than a single sound. Tens of thousands of ideographs are in active use.

The inconsistencies among character encodings have been a major nuisance for international electronic communication and for software manufacturers vying for a global market. Between 1988 and 1991 a consortium of hardware and software manufacturers developed a uniform encoding scheme called Unicode that is expressly designed to encode text in all written languages of the world (see www.unicode.org). In the first version of Unicode, about 39,000 characters were given codes, including 21,000 Chinese ideographs. A 2-byte code (which can encode over 65,000 characters) was chosen. It was thought to leave ample space for expansion for esoteric scripts, such as Egyptian hieroglyphs and the ancient script used on the island of Java.

The Thai Alphabet

Java was one of the first programming languages to embrace Unicode. All Unicode characters can be stored in Java strings, but which ones can actually be displayed depends on your computer system. The primitive type char denotes a 2-byte Unicode character.)

Unfortunately, in 2003, the inevitable happened. Another large batch of Chinese ideo-graphs had to be added to Unicode, pushing it beyond the 16-bit limit. Now, some characters need to be encoded with a pair of char values (see Special Topic 4.5).

Chinese Ideographs

Choose appropriate types for representing numeric data.

Write code that uses constants to document the purpose of numeric values.

Write arithmetic expressions in Java.

Distinguish between static methods and instance methods.

Process strings in Java programs.

Write programs that read user input.

java.io.PrintStream            max                      java.util.Scanner
   printf                      min                         next
java.lang.Double               pow                         nextDouble
   parseDouble                 round                       nextInt
java.lang.Integer              sin                         nextLine
   MAX_VALUE                   sqrt                     javax.swing.JOptionPane
   MIN_VALUE                   tan                         showInputDialog
   parseInt                    toDegrees                   showMessageDialog
   toString                    toRadians
java.lang.Math              java.lang.String
   E                           format
   PI                          substring
   abs                      java.lang.System
   acos                        in
   asin                     java.math.BigDecimal
   atan                        add
   atan2                       multiply
   ceil                        subtract
   cos                      java.math.BigInteger
   exp                         add
   floor                       multiply
   log                         subtract
   log10

R4.1 Write the following mathematical expressions in Java.

R4.2 Write the following Java expressions in mathematical notation.

R4.3 What is wrong with this version of the quadratic formula?

x1 = (-b - Math.sqrt(b * b - 4 * a * c)) / 2 * a;
x2 = (-b + Math.sqrt(b * b - 4 * a * c)) / 2 * a;

R4.4 Give an example of integer overflow. Would the same example work correctly if you used floating-point?

R4.5 Give an example of a floating-point roundoff error. Would the same example work correctly if you used integers and switched to a sufficiently small unit, such as cents instead of dollars, so that the values don't have a fractional part?

R4.6 Consider the following code:

CashRegister register = new CashRegister();
register.recordPurchase(19.93);
register.enterPayment(20, 0, 0, 0, 0);
System.out.print("Change: ");
System.out.println(register.giveChange());

The code segment prints the total as 0.07000000000000028. Explain why. Give a recommendation to improve the code so that users will not be confused.

R4.7 Let n be an integer and x a floating-point number. Explain the difference between

n = (int) x;

and

n = (int) Math.round(x);

R4.8 Let n be an integer and x a floating-point number. Explain the difference between

n = (int) (x + 0.5);

and

n = (int) Math.round(x);

For what values of x do they give the same result? For what values of x do they give different results?

R4.9 Consider the vending machine implementation in How To 4.1 on page 146. What happens if the givePennyStamps method is invoked before the giveFirstClassStamps method?

R4.10 Explain the differences between 2, 2.0, '2', "2", and "2.0".

R4.11 Explain what each of the following two program segments computes:

int x = 2;
int y = x + x;

and

String s = "2";
String t = s + s;

R4.12 True or false? (x is an int and s is a String)

R4.13 How do you get the first character of a string? The last character? How do you remove the first character? The last character?

R4.14 How do you get the last digit of an integer? The first digit? That is, if n is 23456, how do you find out that the first digit is 2 and the last digit is 6? Do not convert the number to a string. Hint: %, Math.log.

R4.15 This chapter contains several recommendations regarding variables and constants that make programs easier to read and maintain. Summarize these recommendations.

R4.16 What is a final variable? Can you declare a final variable without supplying its value? (Try it out.)

R4.17 What are the values of the following expressions? In each line, assume that

double x = 2.5;
double y = −1.5;
int m = 18;
int n = 4;

R4.18 What are the values of the following expressions? In each line, assume that

int n = 4;
String s = "Hello";
String t = "World";

P4.1 Enhance the CashRegister class by adding separate methods enterDollars, enterQuarters, enterDimes, enterNickels, and enterPennies.

Use this tester class:

public class CashRegisterTester
{
   public static void main (String[] args)
   {
      CashRegister register = new CashRegister();
      register.recordPurchase(20.37);
      register.enterDollars(20);
      register.enterQuarters(2);
      System.out.println("Change: " + register.giveChange());
      System.out.println("Expected: 0.13");
   }
}

P4.2 Enhance the CashRegister class so that it keeps track of the total number of items in a sale. Count all recorded purchases and supply a method

int getItemCount()

that returns the number of items of the current purchase. Remember to reset the count at the end of the purchase.

P4.3 Implement a class IceCreamCone with methods getSurfaceArea() and getVolume(). In the constructor, supply the height and radius of the cone. Be careful when looking up the formula for the surface area—you should only include the outside area along the side of the cone since the cone has an opening on the top to hold the ice cream.

P4.4 Write a program that prompts the user for two numbers, then prints

To do so, implement a class

public class Pair
{
   /**
      Constructs a pair.
      @param aFirst the first value of the pair
      @param aSecond  the second value of the pair
   */
   public Pair(double aFirst, double aSecond) { ... }

   /**
      Computes the sum of the values of this pair.
      @return the sum of the first and second values
   */
   public double getSum() { ... }
   ...
}

Then implement a class PairTester that constructs a Pair object, invokes its methods, and prints the results.

P4.5 Declare a class DataSet that computes the sum and average of a sequence of integers. Supply methods

Hint: Keep track of the sum and the count of the values. Then write a test program DataSetTester that calls addValue four times and prints the expected and actual results.

P4.6 Write a class DataSet that computes the largest and smallest values in a sequence of numbers. Supply methods

Keep track of the smallest and largest values that you've seen so far. Then use the Math.min and Math.max methods to update them in the addValue method. What should you use as initial values? Hint: Integer.MIN_VALUE, Integer.MAX_VALUE.

Write a test program DataSetTester that calls addValue four times and prints the expected and actual results.

P4.7 Write a program that prompts the user for a measurement in meters and then converts it into miles, feet, and inches. Use a class

public class Converter
{
   /**

*/
   public Converter(double aConversionFactor) { ... }

/**

*/
    public double convertTo(double fromMeasurement) { ... }

    /**

*/
    public double convertFrom(double toMeasurement) { ... }
}

In your ConverterTester class, construct and test the following Converter object:

final double MILE_TO_KM = 1.609;
Converter milesToMeters = new Converter(1000 * MILE_TO_KM);

P4.8 Write a class Square whose constructor receives the length of the sides. Then supply methods to compute

P4.9 Implement a class SodaCan whose constructor receives the height and diameter of the soda can. Supply methods getVolume and getSurfaceArea. Supply a SodaCanTester class that tests your class.

P4.10 Implement a class Balloon that models a spherical balloon that is being filled with air. The constructor constructs an empty balloon. Supply these methods:

Supply a BalloonTester class that constructs a balloon, adds 100 cm³ of air, tests the three accessor methods, adds another 100 cm³ of air, and tests the accessor methods again.

P4.11 Giving change. Enhance the CashRegister class so that it directs a cashier how to give change. The cash register computes the amount to be returned to the customer, in pennies.

Add the following methods to the CashRegister class:

Each method computes the number of dollar bills or coins to return to the customer, and reduces the change due by the returned amount. You may assume that the methods are called in this order. Here is a test class:

public class CashRegisterTester
{
   public static void main(String[] args)
   {
      CashRegister register = new CashRegister();

      register.recordPurchase(8.37);
      register.enterPayment(10, 0, 0, 0, 0);
      System.out.println("Dollars: " + register.giveDollars());
      System.out.println("Expected: 1");
      System.out.println("Quarters: " + register.giveQuarters());
      System.out.println("Expected: 2");
      System.out.println("Dimes: " + register.giveDimes());
      System.out.println("Expected: 1");
      System.out.println("Nickels: " + register.giveNickels());
      System.out.println("Expected: 0");
      System.out.println("Pennies: " + register.givePennies());
      System.out.println("Expected: 3");
   }
}

P4.12 In How To 4.1 on page 146, we represented the state of the vending machine by storing the balance in pennies. This is ingenious, but it is perhaps not the most obvious solution. Another possibility is to store the number of dollars that the customer inserted and the change that remains after giving out the first class stamps. Reimplement the vending machine in this way. Of course, the public interface should remain unchanged.

P4.13 Write a program that reads in an integer and breaks it into a sequence of individual digits in reverse order. For example, the input 16384 is displayed as

4
8
3
6
1

You may assume that the input has no more than five digits and is not negative. Declare a class DigitExtractor:

Declare a class DigitExtractor:
     public class DigitExtractor
     {
        /**
           Constructs a digit extractor that gets the digits
           of an integer in reverse order.
           @param anInteger the integer to break up into digits
        */
        public DigitExtractor(int anInteger) { ... }

        /**
           Returns the next digit to be extracted.
           @return the next digit
        */
        public int nextDigit() { ... }
     }

In your main class DigitPrinter, call System.out.println(myExtractor.nextDigit()) five times.

P4.14 Implement a class QuadraticEquation whose constructor receives the coefficients a, b, c of the quadratic equation ax² + bx + c = 0. Supply methods getSolution1 and getSolution2 that get the solutions, using the quadratic formula. Write a test class QuadraticEquationTester that constructs a QuadraticEquation object, and prints the two solutions.

P4.15 Write a program that reads two times in military format (0900, 1730) and prints the number of hours and minutes between the two times. Here is a sample run. User input is in color.

Please enter the first time: 0900
Please enter the second time: 1730
8 hours 30 minutes

Extra credit if you can deal with the case where the first time is later than the second:

Please enter the first time: 1730
Please enter the second time: 0900
15 hours 30 minutes

Implement a class TimeInterval whose constructor takes two military times. The class should have two methods getHours and getMinutes.

P4.16 Writing large letters. A large letter H can be produced like this:

}
}

Declare similar classes for the letters E, L, and O. Then write the message

in large letters.

P4.17 Write a class ChristmasTree whose toString method yields a string depicting a Christmas tree:

Remember to use escape sequences.

P4.18 Your job is to transform numbers 1, 2, 3, . . ., 12 into the corresponding month names January, February, March, . . ., December. Implement a class Month whose constructor parameter is the month number and whose getName method returns the month name. Hint:Make a very long string "January February March . . . ", in which you add spaces such that each month name has the same length. Then use substring to extract the month you want.

P4.19 Write a class to compute the date of Easter Sunday. Easter Sunday is the first Sunday after the first full moon of spring. Use this algorithm, invented by the mathematician Carl Friedrich Gauss in 1800:

Then Easter falls on day p of month n. For example, if y is 2001:

a = 6                g = 6               r = 6
b = 20               h = 18              n = 4
c = 1                j = 0, k = 1        p = 15
d = 5, e = 0         m = 0

Therefore, in 2001, Easter Sunday fell on April 15. Write a class Easter with methods getEasterSundayMonth and getEasterSundayDay.

Project 4.1 In this project, you will perform calculations with triangles. A triangle is defined by the x- and y-coordinates of its three corner points.

Your job is to compute the following properties of a given triangle:

Of course, you should implement a Triangle class with appropriate methods. Supply a program that prompts a user for the corner point coordinates and produces a nicely formatted table of the triangle properties.

This is a good team project for two students. Both students should agree on the Triangle interface. One student implements the Triangle class, the other simultaneously implements the user interaction and formatting.

Project 4.2 The CashRegister class has an unfortunate limitation: It is closely tied to the coin system in the United States and Canada. Research the system used in most of Europe. Your goal is to produce a cash register that works with euros and cents. Rather than designing another limited CashRegister implementation for the European market, you should design a separate Coin class and a cash register that can work with coins of all types.