CS 139 Algorithm Development
Lab12A: Let's Make Some Cars

Objectives

• Write a class from which objects will be created.
• Use this class to make several unique objects.

Background

Object Oriented programming switches the view of a program as a series of steps to a view of a program as an interaction between objects. You design the objects with what they should look like (attributes or fields) and what behaviors they should have (methods), then your program will control how those objects interact in the world.

Key Terms

• Class
• Object
• Constructor
• Accessor method
• Mutator method
• Fields (instance variables)
• Overloaded methods

Materials

You will write this program from scratch.

You may refer to Gaddis, Chapter 6, Programming Challenges 2, either edition.

Part 1 General Instructions:

1. Setup your program environment. Create a new folder for your files.

2. Create a new program named Car.java.

3. If you haven't done so already, watch the video to introduce you to objects.

Part 2 Create a basic Car class:

1. Create the Car class header and documentation.

2. Create three instance variables within the class: an int that holds the car's model year, a String that holds the car's make, an int that holds the car's speed. These should be listed as private. Private means that only methods within this class may use the variables. Any other class can only access the variable values indirectly through methods of the class.

3. Create a constructor (see video) that accepts the model year and make as parameters and sets the speed to 0. Note that either you should make the constructor's parameters a different name than the instance variables or use the "this" qualifier when placing the parameter's value into the instance variable. (Chapter 9.8)

4. Create a toString method that accepts NO parameters and returns a String. The String should be of the format("A %d %s that is going %d mph", year, make, speed)

   1. Some hints. First do not print anything in the method. It should only create and return the String.

   2. String.format() operates just like printf. So you can use this line directly to create a String.
5. Compile your Car class and correct any errors.

Part 3 Test your Car.

1. Create a CarTester class which contains a main method.

2. Create two Car objects of your choice. (Hint: you need to call the constructor with the values you want for your "dream cars").

3. Display the Car objects so that you know that your constructor is working correctly by calling the toString method and printing that result. (Hint, you will need to call the method with the Car objects that you created.)

4. The toString method is a special method in the print methods. If you use the name of an object in a print method call, the method will try to use the toString method of that object. If one is defined, it uses the defined method; if one is not, it will use a default method which includes the name of the class and a strange code which is a representation of the location of the object. Try this feature by just using the name of the car object as the argument to the print method in which you are printing the results.

Part 4 Refinement:

1. Edit Car.java.

2. Create accessor methods that let you access each individual element of the Car. They should be named with "get" followed by the name of the attribute. So one of your accessor methods would be getSpeed(). They should take no parameters and should return the value of that attribute. Add error checking such that no matter how many times we accelerate the speed does not exceed 150 mph. (Hmmm, this might make a good constant value...add the constant to the attribute area and call it MAX_SPEED).

3. Create two mutator methods, accelerate() and brake(). These methods are void methods and take no parameters. When called, the accelerate() method should increase the speed variable by 5 miles per hour. The brake() method should decrease the speed variable by 5 miles per hour. Add error checking such that no matter how many times we accelerate the speed does not exceed 150 mph. (Hmmm, this might make a good constant value...add the constant to the attribute area and call it MAX_SPEED). Also, insure that your brake method should not allow the speed to drop below 0 miles per hour. These error checks should not print anything, but they should insure that the data remains in a reasonable state for the object (speed between 0 and 150).

Part 5 Testing the refinement:

1. Edit CarTester.java.

2. For the first car, call the accelerate() method 5 times in a row and call the getSpeed() method in a print statement (with an appropriate label) for each increase.

3. Do the same for the second car but accelerate only 3 times in a row also calling getSpeed() in a print statement for each acceleration.

4. For the first car, call brake 5 times in a row calling getSpeed() with each pass.

5. Print the result of a call to the toString() method for each of the cars. The first car should be at zero and the second at 15 mph.

Part 6 - (OPTIONAL) Just for fun:

1. It is possible to pass one object into the method for another object. For example, the String method equals is called by a String object and is passed another String object: answer.equals("yes") for example.

2. Add a mutator method to your Car class called crash that takes a Car object as a parameter and returns nothing. It should display the message "CRASH" and then set the speed of both the calling object and the called object to 0. (See Chapter 8.2 for examples of passing an object into a method and 8.8 for examples of referencing two objects' fields (instance variables)).

3. In your tester, call accelerate for the first car until it is the speed of the second (15 mph). Call the first car's crash() method passing in the second car.

4. Display both of the cars after the crash() using the toString() method.

Part 7 Refinement (what is overloading all about):

1. Car has two mutator methods, accelerate() and brake().
   
   
2. Overloaded methods are two methods with the same name but different parameter lists. They can be used to specify different behaviors depending on the context of the method call. For example, we have two standard methods accelerate and brake which take no parameters and increase or decrease the speed by 5. But what if we want to jam on the brake or floor the accelerator. We might want to specify different amounts to increas or decrease the speed.
   
   
3. Now let's overload the methods. For each (accelerate and brake), create a new version of the method that takes a parameter for the amount to increase or decrease the speed. Adhere to the limits that you just placed into the former accelerate() and brake() methods.
   
   
4. In your tester, test that it's not possible to accelerate to more than 150 or to brake below 0. Be sure to test both versions of the methods.