Lab Notes Eight: Classes and objects revisited.

Some programs we developed in class today:

class One {
  public static void main(String[] args) {

    String word = ""; 
    char letter; 

    for (int i = 0; i < 8; i++) {

       int value =   (int)(Math.random() * (1 + 'z' - 'a')); 

       letter = (char) (value + 'a'); 

       word = word + letter; 
I include here a few problems for your review and exercise.

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; 
Identify the constructors, mutator, accessor and effector functions.

What kind of variable is n?

2. With the nonsense class from the preceding exercise, determine what the following program prints.

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(); 
  A e = new A(a.h() + b.h() + c.h()); 
Work through the program by hand.

Do not actually compile and run the program.

Then run it and compare the results.

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; 
Write a small test program that creates and works with objects of class Person as well.

4. Implement a class Address. An address has

Supply two constructors: Supply a print function that prints the address with

Supply a method compareTo that

5. Implement a class Account. An account has

Pass a value into a constructor to set an initial 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.

6. Implement a class Bank. This bank has two objects

of the type Account that was developed in the preceding exercise.

Implement four instance methods:

Here the account string is "S" or "C":

7. Define a class Country.

An object of type Country will store

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:

Write a simple tester program that creates a few triangles and asks them about their type.

Note: I will post solutions for problems 1-8 tonight. I think you'd benefit from trying to solve them, and when I post the solutions you could check your solutions against those posted.

What comes next is:


9. This problem has several parts:
  1. Write a simple Vehicle class that has fields for (at least) current speed, current direction in degrees, and owner name.

  2. Add a static field to your Vehicle class for the highest Vehicle Identification Number issued, and a non-static field that holds each vehicle's ID number.

  3. Write a main method for your Vehicle class that creates a few vehicles and prints out their field values. Note that you can also write a separate tester program as well.

  4. Add two constructors to Vehicle. A no-arg constructor and one that takes an initial owner's name. Modify the tester program from the previous step and test your design.

  5. Make the fields in your Vehicle class private, and add accessor methods for the fields. Which fields should have methods to change them and which should not?

  6. Add a changeSpeed method that changes the current speed of the vehicle to a passed-in value, and a stop method that sets the speed to zero.

  7. Add two turn methods to Vehicle. One that takes a number of degrees to turn, and one that takes simply either a Vehicle.TURN_LEFT or a Vehicle.TURN_RIGHT constant. Define the two constants accordingly.

  8. Add a static method to Vehicle that returns the highest identification number used so far.

  9. Add a toString method to Vehicle.
This problem is really following the steps developed in the Dilbert lecture so if you understand that lecture you will have no problem putting together the solution to this lab assignment.

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

I also include here the text for the Fractions exercise that appears in the lecture notes of yesterday.

10. Define a class of Fractions

Here's how we started in class:

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); 





Consider ordinary fractions like 3/4 and -1/2. A fraction is the ratio of two integers: a numerator and a denominator. Create a user-defined type for fractions by defining a class Fraction. The class should supply a set of necessary operations on fractions and should hide implementation details of data representation and internal manipulations.

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 methods in the class.

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

Your Fraction class can be designed to enforce such conventions, not just to have them as principles that one can choose to follow or ignore. This is one big advantage of object-oriented programming. The canonical representation conventions should be enforced by the Fraction constructor.

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.

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:

You should also add a toString method to Fraction (an instance method) that returns a String representation of a Fraction. It must be an instance method as it is used to produce a representation of the object in a textual context.

Testing your Fractions:


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 =; // in one step!
    System.out.println( x + " + " + 
                        u + " - " + 
                        v + " = " + y); 

Last updated: Jul 11, 2001 by Adrian German for A201