Supplemental Material for Baldwin and Scragg, Algorithms and Data Structures: The Science of Computing; Charles River Media, 2004 (Now published by Cengage Learning)
This lab reinforces understanding of basic object oriented programming concepts (objects, classes and subclasses, methods) and their expression in Java. It also provides practice using non-object aspects of Java (loops, conditionals, etc.)
Understanding of Chapter 2 of Algorithms and Data Structures: The Science of Computing.
Understanding of basic Java syntax, as described in the appendix to Algorithms and Data Structures: The Science of Computing.
This lab exercises many of the object oriented programming concepts discussed in Chapter 2 of Algorithms and Data Structures: The Science of Computing (for instance, objects, messages, methods, classes and subclasses). The lab does this by asking students to extend the abilities of the robots introduced in Chapter 2, and then use the extended robots to solve a certain problem.
This lab involves defining a subclass of the Robot class from
Chapter 2 of Algorithms and Data Structures: The Science of Computing.
Programs that use the Robot class need to include two Java files:
Robot.java and RobotRoom.java. The “Final
Details” section
of this
document explains how to find these files and their documentation.
Any Java source file that refers to the Robot or RobotRoom classes
should “import” those classes, via the statement
import geneseo.cs.sc.*;at the beginning of the file.
A constructor is basically a method that initializes a new object (see Sections
3.4.2 and A.4.4 of Algorithms and Data Structures: The Science of Computing for
more on constructors). In Java, constructors have the same name as the class
they initialize — for example, the constructors for Robot objects
are named Robot, the constructors for instances of a hypothetical ExtendedRobot subclass
of
Robot would be named ExtendedRobot, and so forth.
Note that subclasses don’t inherit constructors from their
superclass the way they inherit other methods — for example, even if
a constructor for Robot logically does everything necessary to
initialize instances of an ExtendedRobot subclass, there is no
way to automatically apply this constructor to ExtendedRobot objects.
Even though Java doesn’t do it automatically, one often wants to initialize
instances of a subclass by just calling a superclass’s
constructor. This will probably be the case for the subclass of Robot defined
in this lab. To do this, define constructors for the subclass that do nothing
but call the corresponding superclass constructor. Within a constructor, the
word super can be used to call a superclass constructor. For example,
to allow instances of an ExtendedRobot subclass of Robot to
be initialized with their position, heading, and room (just like the four-parameter
constructor for Robot does), include the following constructor
in ExtendedRobot:
// Within the ExtendedRobot class...
public ExtendedRobot( int column, int row, int heading, RobotRoom room ) {
super( column, row, heading, room );
}A statement such as the following implicitly uses this constructor to initialize an extended robot:
ExtendedRobot r = new ExtendedRobot( 1, 3, Robot.NORTH, myRoom );Do the following…
Write a subclass of Robot that
handles the following messages. Don’t forget to test the subclass, to make
sure that each method works as intended:
Robot class (i.e., Robot.NORTH, Robot.EAST, Robot.SOUTH, Robot.WEST).Write a main program that creates two instances of the subclass from Part 1, positioned arbitrarily in a room, and then makes those two robots move until they are next to each other. More precisely, the code that moves the robots until they are next to each other should have preconditions
This code should establish the postcondition
(Notice that what these pre- and postconditions do not say is just as important as what they do say: for example, the preconditions do not allow assuming that the robots start in specific places, or with specific headings. The postconditions do not require the robots to be on particular tiles, or have particular headings.)
Some, but not necessarily all, of the messages handled by the new subclass will probably be helpful in making the robots stand next to each other.
Students can download both Robot.java and RobotRoom.java from the Web.
Documentation on both classes is also available on the Web. The main documentation page is an index to documentation for all the Java classes written for use with Algorithms and Data Structures: The Science of Computing. To see the documentation for a specific class, click on that class’s name in the left-hand panel of the page.
Turn in your work as directed by your instructor.
Copyright © 2004 Charles River Media. All rights reserved.
Revised Aug. 8, 2005 by Doug Baldwin