are Explanations often given in the comments. Read the comments carefully.
Below are some important ideas for developing algoithms. They may make more
sense after you read/try the review questions. I put them up front to make
sure that you see them.
Important ideas for developing algoithms (learned from review questions below):
+ Try to identify when iterations are necessary
or
"Smell the iteration"
When you say to yourself "do something until some condition is met," that's
an iteration, like question 6 below. This is what we call indefinite
iteration--you don't know how many iterations before you stop. In this
case, $while$ is a good loop to use.
Ask yourself what is the condition for continuing the iteration and how to
update the variable(s) to be tested in that condition. Sometimes, some
"smart" initialization is needed to enter the loop correctly. Don't let
that bother you--just start by writing the general condition for
continuing the iteration and whatever initialization you can think of.
Then go back to check to see if you enter the loop correctly and make sure
that your update works properly. Now you're ready to make any necessary
changes to make the initialization/condition "smart."
When you say to yourself "one at a time," like "add one space at a time" in
question 4a, that's an iteration also. If you know when to stop (e.g.,
add $x$ spaces), a good choice is the $for$ loop.
+ Try to identify simple tasks within a complicated problem/procedure. In an
exam, we sometimes help you break down the problem by listing the methods or
saying that one method should call another. Tackle the simple tasks one at a
time, but occasionally jump around for inspiration. Don't forget to check
the whole thing in the end!
+ Give yourself a concrete example and draw some diagrams, box-scope or not.
If you went to the review session, think back to how we worked on
question 6. Sometimes we help you by giving you an example in the question
statement. Read (and analyze) the example and any example output carefully!
Lots of information/insights can be gained. E.g., instance vs static,
parameter types for methods, etc.
============================================================
Question 1: Box-scope diagram
Numbers in square brackets [] indicate step number. Please see
http://courses.cs.cornell.edu/cs100/2000sp/Prelims/box.txt
for step-by-step explanation.
class Frippy {
int x;
Frippy F;
}
class Boingo {
String a;
Frippy b;
}
public class Problem1 {
public static void main(String[] args) {
Frippy F1 = new Frippy();
Frippy F2 = new Frippy();
Boingo B1 = new Boingo();
Boingo B2 = new Boingo();
B2.a = "grok";
B1.b = new Frippy();
F2.F = B1.b;
B1.b.F = F1;
++B1.b.F.x;
Boingo B3;
F2 = null;
// ****draw the box/scope diagram up to this point***
}
}
class Problem1
+--------------------------------------------------------------[10]-+
| +---+ +---+ +----+ +---+ +---+ +---+ |
| args | *-+-+ F1 | * | F2 |null| B1 | * | B2 | * | B3 | ? | |
| +---+ | +-+-+ +-+--+ +-+-+ +-+-+ +---+ |
+------------+------+----------+----------+----------+--------------+
| | | | |
<----+ | [1] [11] X [2] [3] +--+ [4] +------+
class Frippy | | | |
+-------------------+----------+-------------+--------------+--------------+
| [12] V | | | [12] |
| +--\-------/ +----------+ >+----------+ | +----------+ | +--\-------/ |
| | \----+/| | \-/--+ | | +----+ | | | +----+ | | | \----+/| |
| | x |\ / | | x |0[9]|1| | x |0 | | | | x |0 | | | | x |\ / | |
| | +-\-/+ | | /-\--+ | | +----+ | | | +----+ | | | +-\-/+ | |
| | X | | | | [7] | | | | | | X | |
| | +-/-\+ | | +----+ | | +-\-/+ | | | +-\-/+ | | | +-/-\+ | |
| | F |/ \ | | F |null| | | F |nuXl*-+-+>| F |nuXl| | | | F |/ \ | |
| | /----+\| | +----+ | | +-/-\+ | | | +*/-\+ | | | /----+\| |
| +--/-------\ +----------+ +----------+ | +----+-----+ | +--/-------\ |
| [8] ^----------------+------+ ^ | |
+--------------------------------------------+--------+-----+--------------+
| | |
| [6] | |
class Boingo | | |
+--------------------------------------------+--------|-----+--------------+
| [12] [12] [12] | | | |
| +--\-------/ +--\-------/ +--\-------/ +>+------|---+ +>+----------+ |
| | \----+/| | \----+/| | \----+/| | +--|-+ | | +-\-/+ | |
| | a |\ / | | a |\ / | | a |\ / | | a |nu|l| | | a |nuXl*-+-+-+
| | +-\-/+ | | +-\-/+ | | +-\-/+ | | +--|-+ | | +-/-\+ | | |
| | X | | X | | X | | | | | | | |
| | +-/-\+ | | +-/-\+ | | +-/-\+ | | +-\*/+ | | +----+ | | |
| | b |/ \ | | b |/ \ | | b |/ \ | | b |nuXl| | | b |null| | | |
| | /----+\| | /----+\| | /----+\| | +-/-\+ | | +----+ | | |
| +--/-------\ +--/-------\ +--/-------\ +----------+ +----------+ | |
| | |
+--------------------------------------------------------------------------+ |
|
class String |
+----------------------+ |
| | [5] |
| "grok"<--------------+-----------------------------------------------------+
| |
+----------------------+
============================================================
Question 2: constructors, passing parameters
Solution: $swap4$ is the only method that swaps sucessfully. Use box-scope
diagrams to prove it to yourself.
//------------------------------------
// Class $FatInteger$ is a "wrapper class". Its purpose is to allow us to
// treat an $int$ as an object by simply storing the $int$ in an object.
// It provides constructors to create $FatInteger$s, a method to set the value
// of a $FatInteger$ from another $FatInteger$, and a $toString()$ method.
class FatInteger{
private int n; // the interger inside the object
// Constructor for default case ($n$=0), no argument
FatInteger(){}
// Constructor: assign to $n$ the value of an integer argument
FatInteger(int n){
this.n = n; // note: $this$ is necessary
}
// Constructor: assign to $n$ the value stored in the $FatInteger$ argument
FatInteger(FatInteger other){
this.n = other.n; // note: $this$ is NOT necessary
}
// Set the value of a FatInteger based on another FatInteger
void setValue(FatInteger other){
this.n = other.n; // note: $this$ is NOT necessary
}
// The toString() method for printing
public String toString(){
return "" + n;
}
}
class Swap{
public static void main(String arg[]){
// Call various methods to attempt to swap the variables that are
// passed to the methods. You determine which of them succeed.
// Predict the output from each of the four print statements.
int x = 5, y = 7;
swap1(x,y);
System.out.println("After swap1, x = " + x + ", y = " + y);
FatInteger p = new FatInteger(6);
FatInteger q = new FatInteger(8);
swap2(p,q);
System.out.println("After swap2, values in p, q are " + p + ", " + q);
FatInteger r = new FatInteger(15);
FatInteger s = new FatInteger(17);
swap3(p,q);
System.out.println("After swap3, values in r, s are " + r + ", " + s);
FatInteger t = new FatInteger(16);
FatInteger u = new FatInteger(18);
swap4(t,u);
System.out.println("After swap3, values in t, u are " + t + ", " + u);
}
static void swap1(int a, int b){
int temp;
temp = a;
a = b;
b = temp;
}
static void swap2(FatInteger a, FatInteger b){
FatInteger temp;
temp = a;
a = b;
b = temp;
}
static void swap3(FatInteger a, FatInteger b){
FatInteger temp;
temp = new FatInteger(a);
a = new FatInteger(b);
b = new FatInteger(temp);
}
static void swap4(FatInteger a, FatInteger b){
FatInteger temp = new FatInteger();
temp.setValue(a);
a.setValue(b);
b.setValue(temp);
}
}
============================================================
Question 3: Returning multiple values in methods via objects
Write the code for method $calcStats$ to calculate some statistics given 3
numbers. Then fill in the missing code in method $main$ where you call the
$calcStats$ method. If necessary, check out the example in the book on
page 227 (in the grey box) for additional help.
//------------------------------------
//
class StatValues{
// instance variables
double average;
double minimum;
double maximum;
// constructor that does nothing
public StatValues(){}
}
class Statistics{
// main method
public static void main(String[] args){
// assign 3 double variables
// note: we forgot to declare num1,num2,num3 in the original question
double num1=12.32;
double num2=66.01;
double num3=32.39;
// call method $calcStats$ to get the average, minimum,
// and maximum for the 3 numbers above
//---------------------------------------------
StatValues mystat=calcStats(num1,num2,num3);
//---------------------------------------------
// Output
System.out.println("My avg: "+mystat.average);
System.out.println("My min: "+mystat.minimum);
System.out.println("My max: "+mystat.maximum);
}
// Determine the average, minimum, and maximum of exactly 3 $double$
// numbers. Return a reference to an object of class $Statvalues$ .
// (Once you know how arrays work you can easily change the code
// to determine these statistics for any number of numbers.)
public StatValues calcStats(double a,double b,double c){
StatValues result; // reference variable for results
StatValues();
result=new double sum=a+b+c;
double min,max;
// determine $max$ and $min$
if (a<=b){
min=a;
max=b;
}
if (min>c)
min=c;
if (max<c)
max=c;
// assign values to $result$
result.average=sum/3.0;
result.minimum=min;
result.maximum=max;
// return result
return result;
}
}
// What are the necessary changes if you make method $calcStats$ $private$?
// NONE (because method $calcStats$ is called and defined in the same class)
============================================================
Question 4: for-loop, encapsulation
Mistake in the original question: Change all occurrences of $Person$ to
$PersonWOutEncaps$
Part a: Complete class $PersonWOutEncaps$ by writing method $addstrings$
//------------------------------------
class PersonWOutEncaps {
// instance variables
public String firstname;
public String lastname;
// constructor
PersonWOutEncaps() { };
// Add blank spaces between 2 Strings. The number of spaces is passed as
// an Integer.
public String addstrings(int spaces, String start, String stop) {
// create middle string of blank spaces
String middle = "";
// iterate to get the correct number of spaces
for(int s = 1; s <= spaces; s++)
middle = middle + " ";
return (start + middle + stop);
} // method addstrings
} // class PersonWOutEncaps
Part b: Given the complete class $PersonWOutEncaps$ and the following class
$WOutEncaps$, make all changes necessary to implement encapsulation in both
classes and call the new classes $PersonWithEncaps$ and $WithEncaps$.
//------------------------------------
public class WOutEncaps {
public static void main(String args[]) {
// instantiate nic using constructor PersonWOutEncaps()
PersonWOutEncaps nic = new PersonWOutEncaps();
// assign values to instance variables of nic
nic.firstname="Nici";
nic.lastname ="Waldhausen";
// Retrieve individual values from nic
System.out.println(nic.firstname);
System.out.println(nic.lastname);
// Determine fullname
String f=nic.firstname;
String l=nic.lastname;
String fullname = addstring(2,f,l);
System.out.println(fullname);
} // method main
} // class WOutEncaps
Solution to Part b:
Read all comments carefully.
//------------------------------------
class PersonWithEncaps { // declare public if used in another file
// instance variables (hide)
private String firstname;
private String lastname;
// constructor
PersonWithEncaps() { };
// utility methods (hide)
// this method adds blanks spaces between 2 Strings
private String addstrings(int spaces, String start, String stop) {
// create middle string of blank spaces
String middle = "";
// iterate to get the correct number of spaces
for(int s = 1; s <= spaces; s++)
middle = middle + " ";
return (start + middle + stop);
} // method addstrings
// service methods (public)
// these are the getters and setters the user needs
public void set_firstname(String name) {
firstname = name;
} // method set_firstname
public void set_lastname(String name) {
lastname = name;
} // method set_lastname
public String get_firstname() {
return firstname;
} // method get_firstname
public String get_lastname() {
return lastname;
} // method get_lastname
public String get_fullname(int spaces) {
String fn = get_firstname();
String ln = get_lastname();
return addstrings(spaces, fn, ln);
} // method get_fullname
} // class PersonWithEncaps
public class Encaps {
public static void main(String args[]) {
// instantiate using constructor PersonWithEncaps()
PersonWithEncaps nic = new PersonWithEncaps();
// assign values to instance variables of nic
nic.set_firstname("Nici");
nic.set_lastname("Waldhausen");
// Retrieve individual values from nic
System.out.println(nic.get_firstname());
System.out.println(nic.get_lastname());
// Determine fullname
String fullname = nic.get_fullname(2);
System.out.println(fullname);
} // method main
} // class Encaps
/* OUTPUT
Nici
Waldhausen
Nici Waldhausen
*/
============================================================
Question 5: instance methods, test equality
Part a: Complete the class $Person$ with instance variables
$name$, $age$, and $friend$
a constructor
to initialize the $name$ and $age$
and instance methods
$describe$Print the Person's name, age, and one of the following:
"self sufficient" if the Person's friend is himself/herself;
"no friend" if the Person does not have a friend; or
the name of the Person's friend.
$makefriend$Get another Person, passed in the argument, as a friend.
$befriend$Become the friend of another Person passed in the argument
//------------------------------------
class Person{
String name;
int age;
Person friend;
// Constructor to initialize $name$ and $age$ based on passed arguments
Person(String n, int a) {
name = n; age = a;
}
// Print description of a Person
void describe(){
String s = "name "+name+"age "+age;
if (friend == this)
s += " self sufficient";
else if (friend == null)
s += " no best friend";
else
s += " friend " + friend.name;
System.out.println(s);
}
// Make a friend
void makefriend(Person p){
friend = p;
}
// Become another Person's friend
void befriend(Person p){
p.friend = this;
}
} // class Person
Part b: Write a method $main$ in class $Xfiles$ using the methods in class
$Person$ to create the people and relationships below and print a description
of each $Person$.
Scully, 31, has friend Mulder
Mulder, 31, has friend Scully
Skinner, 49, is his own best friend
CSM, 103, has no friend
//------------------------------------
class Xfiles{
public static void main(String[] args){
Person s, m, k, c;
s = n...