Spring Semester 2002

I include here a few problems for your review and exercise.

Write a program that produces random 8-letter words. Every time you run the program it gives you a new random word. (By word we mean, in this problem, a String of lowercase letters.)

frilled.cs.indiana.edu%javac One.java
frilled.cs.indiana.edu%java One
gknmhyzw
frilled.cs.indiana.edu%java One
kkbkzihm
frilled.cs.indiana.edu%java One
ydsyocnr
frilled.cs.indiana.edu%java One
nlewmvkx
frilled.cs.indiana.edu%

Here's an example of how your program might run:

frilled.cs.indiana.edu%javac One.java
frilled.cs.indiana.edu%java One
Welcome, we sort sequences of numbers.
Numbers> 1 2 3
OK, here's the array sorted: 1 2 3 
Numbers> 3 2 1
OK, here's the array sorted: 1 2 3 
Numbers> 1 3 2 4 5 7 6 8
OK, here's the array sorted: 1 2 3 4 5 6 7 8 
Numbers> 8 7 6 5 4 9 3 2 1 0
OK, here's the array sorted: 0 1 2 3 4 5 6 7 8 9 
Numbers> quit
Thanks for using this program. Good bye!
frilled.cs.indiana.edu%

Look at this program, and figure out what it does and how you can use it.

class Sum {
    public static void main(String[] args) {
	int sum = 0; 
	for (int i = 0; i < args.length; i++) {
	    try {
		sum += Integer.parseInt(args[i]); 
	    } catch (Exception e) {
		System.out.println("Bad input: " + args[i] + " not a number.");
	    }
	}
	System.out.println(sum); 
    }
}

We need to review these things as we move into Inheritance and Applets.

Problems 1-8, and 10 are for (strongly suggested, badly needed) practice.

(Problem 9 becomes the lab assignment, as indicated.)

Problem 1. Consider the following 'nonsense class'.

class A
{ public A() { n = 0; } 
  public A(int a) { n = a; } 
  public void f() { n++; } 
  public void g() { f(); n = 2 * n; f(); }
  public int h() { return n; } 
  public void k() { System.out.println(n); }   
  private int n; 
}

What kind of variable is n? (See chapter 3 and 7 in the book for more help with the terminology).

Problem 2. With the class defined by Problem 1, determine what this program prints and why (how).

public static void main(String[] args) {
  A a = new A(); 
  A b = new A(2); 
  A c = b;
  A d = new A(3); 
  a.f(); b.g(); c.f(); d.g(); 
  d.k(); 
  A e = new A(a.h() + b.h() + c.h()); 
  e.k(); 
}

• Work through the program by hand.
• Do not actually compile and run the program first.
• After you have an answer run the program and compare the results.

Problem 3. Implement all the methods of the following class:

class Person {
  Person() { ... }
  Person(String givenName, int yearOfBirth) { ... }
  String getName() { ... }
  String changeName(String name) { ... }
  int getAgeInYears(int currentYear) { ... }
  
  private String name;
  private int birthdayYear; 
}

You will notice that a Person resembles an Employee (or a Tigger, for that matter).

Problem 4. Implement a class Address. An address has

• a house number,
• a street,
• an optional apartment number,
• a city,
• a state and a
• postal code.

• one with an apartment number
• and one without.

• the street on one line and
• the city, state, and postal code on the next line.

Supply a method compareTo that

• tests whether one address comes before another
• when the addresses are compared by postal code.

Problem 5. Implement a class Account. An account has

• a balance,
• functions to add
• and withdraw money,
• and a function to inquire the current balance.

If no value is passed the initial balance should be set to $0.

Charge a $5 penalty if an attempt is made to withdraw more money than available in the account.

Enhance the Account class to compute interest on the current balance.

Problem 6. Implement a class Portfolio. Every Portfolio is composed of two things:

• a checking account (or, rather, Account)
• and a savings account

Implement four instance methods:

• deposit(double amount, String account)
• withdraw(double amount, String account)
• transfer(double amount, String account)
• printBalances()

• For the deposit or withdrawal, it indicates which account is affected.
• For a transfer it indicates the account from which the money is taken; the money is automatically transferred to the other account.

Problem 7. Define a class Country.

An object of type Country will store

• the name of the country,
• its population, and
• its area.

Problem 8. Write a class called Triangle that can be used to represent a triangle. It should include the following methods that return boolean values indicating if the particular property holds:

• isRight (a right triangle)
• isScalene (no two sides are the same length)
• isIsosceles (exactly two sides are the same length)
• isEquilateral (all three sides are the same length)

What comes next is:

A201/A597 LAB ASSIGNMENT TEN

This is the end of LAB ASSIGNMENT TEN. (Only Vehicle needs to be turned in).

But you may also be asked about the three programs at the very top of this document.

I also include here the text for the Fractions exercise that appears in the Dilbert lecture.

Problem 10. Define a class of Fractions (an abstraction for the concept) and use it in a test program.

Here's how one may get started:

class Fraction {

  int num;
  int den; 

  Fraction(int a, int b) { this.num = a; this.den = b; }

  public String toString() {
      return " (" + num + "/" + den + ") "; 
  }

  Fraction add(Fraction other) {
    return new Fraction(
             this.num * other.den + this.den * other.num, 
             this.den * other.den
           );
  }

  public static void main(String[] args) {

    Fraction a = new Fraction(1, 3);
    Fraction b = new Fraction(2, 3); 

    System.out.println(a.toString()); 

    System.out.println(b); 

    System.out.println(a.add(b));

  }

}

This class should supply a set of necessary operations on fractions

• addition
• subtraction
• multiplication
• division

Remember that a class encapsulates data structures with access and manipulation procedures. In designing a class, an important task is to decide on the internal data representation which is isolated from the outside view. Member methods will keep the data representation consistent. Outside methods are not allowed to create or modify the internal structures directly. They may do this by calling (other) methods in the class.

Here are some (internal) representation considerations to guide your design:

• A fraction is essentially a pair of integers called numerator and denominator.

• The numerator carries the sign of the fraction and can be positive, negative, or zero.

• The denominator is kept positive and can never be zero.

• Fractions with the same value may have different representations (for example ¹/₂, ²/₄, ³/₆). In our representation let's decide for equal fractions to have the same numerator and the same denominator. That means that all fractions must be reduced to their lowest terms. (A data representation in which all equal quantities are represented uniquely is known as a canonical representation. Keeping fractions canonical is desirable and we should enforce this.) The canonical representation of 0 (zero) as a fraction is ⁰/₁.

The constructor should take the two arguments n and d and construct a fraction n/d out of it. The denominator of the resulting Fraction should not be zero or negative. The fraction should be reduced by removing the gcd (greatest common divisor) between the numerator and the denominator. You should define a member method gcd that computes the gratest common divisor of two numbers and make the constructor use it to create canonical Fractions. gcd should be implemented as a classwide method since it is independent of Fraction instances. It should be declared private because it does not contribute to the public interface of the Fraction class.

We provided gcd in a separate class, Euclid (in Lecture Notes Fifteen).

The operations for fractions listed above should implement binary operations. In other words we are going to define methods such that a Fraction can be added to, subtracted from, multiplied with, or divided by another Fraction. The result should be a Fraction.

You should also define a few predicates.

Each Fraction that you create should be able to respond to the following questions:

• isZero()
• isInt()
• equals(anotherFraction)
• greaterThan(anotherFraction)

Testing your Fractions:

// TestFrac.java

class TestFrac {
  public static void main(String[] args) {
    Fraction x = new Fraction( 1, 20); 
    Fraction u = new Fraction(-1, 60); 
    Fraction v = new Fraction( 1, 30); 
    Fraction y; 
    y = x.plus(u).minus(v); // in one step!
    System.out.println( x + " + " + 
                        u + " - " + 
                        v + " = " + y); 
  }
}

One last, final question for this lab:

What's this program doing (and how)?

import java.util.*; 

class One {
    public static void main(String[] args) {
	
	System.out.println("Welcome, you know what you have to do. "); 

	ConsoleReader console = new ConsoleReader(System.in); 

	while (true) {

	    System.out.print("Enter> "); 

	    String line = console.readLine(); 
	    if (line.equals("quit") || line.equals("")) break; 

	    StringTokenizer nizer = new StringTokenizer(line); 

	    int[] numbers = new int[nizer.countTokens()]; 

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

		numbers[i] = Integer.parseInt(nizer.nextToken()); 

	    }

            One.process(numbers); 

	    System.out.print("Here's your line of input, processed: ");

	    One.show(numbers); 

	}

	System.out.println("Thank you for using this program."); 

    }

    public static void show(int[] args) {
	for (int i = 0; i < args.length; i++) {
	    System.out.print(args[i] + " "); 
	}
	System.out.println(); 
    }

    public static void process(int[] args) {

	for (int i = 0; i < args.length - 1; i++) {
	    for (int j = i; j < args.length; j++) {

		if (args[i] > args[j]) {
		    int temp = args[j];
		    args[j] = args[i];
		    args[i] = temp; 
		}

	    }
	}

    }

}