• The code for Student.java, as printed on pages 164-165 of your text without the additional constructors, is provided for you.  (You may copy/paste its contents.)
• Add the extra constructors as specified.  You will find them printed in your text on page 166.
• Your StudentTester class should:
  1. Instantiate and display a student object using the first additional (assignment) constructor.
  2. Instantiate another student object that is a copy of the first student object using the second additional (copy) constructor.
  3. Change the name of the first student object.
  4. Display the contents of both objects (using their toString methods), which shows that the second student's name still retains the original name even though the first student's name was changed.
• Continuing to follow the directions in text project 5-2, write a public method named validateData() and place in Student.java.  A student object's data is considered valid unless
  1. its name variable is empty
  2. one of its test scores is less than 0 (zero) or more than 100.
• If one of these invalid conditions is found to be true, an appropriate string literal is returned displaying one of the two messages "SORRY: name required" or "SORRY: must have 0 <= test score <= 100".  Otherwise, null is returned (see page 160).

• To save time in typing, you may copy/paste this starter code.
  • Code for Dice.java
  • The original Lesson 04 version of LuckySevens.java (make your changes to this).

• After initially creating this project, you will ADD a new file that you name "BankAccount.java" into which you will type the code for your new BankAccount class.

• Here are four images to use:
  • landscape.jpg
  • smokey.jpg
  • pony.jpg
  • dinosaur.jpg

• Write a Java program that uses Turtle Graphics to draw three horizontal line segments, each having the same length, and one of them is equidistant from the other two.

• Write a Java class named MyRect that has
  • four instance variables of type int that store the coordinates of the rectangle's upper left corner, the rectangles width, and the rectangle's height.
  • three constructors
    • a default constructor that sets the upper left corner to (-75,50), the width to 150, and the height to 100.
    • an assignment constructor that allows the client to instantiate a MyRect object while specifying the upper left corner, the width, and the height.
    • a copy constructor.
  • a mutator method named setLocation that allows the client to change the two integer values of the coordinates of the upper left corner.
  • a method named draw of type void that draws the rectangle using the instance variables and Turtle Graphics using one parameter of type Pen:  public void draw(Pen p)
• Write a Java program named MyRectangleDemo that declares and instantiates three MyRect objects.
  • The first object uses the default constructor.
  • The second object uses the assignment constructor.
  • The third object uses the copy constructor to instantiate a copy of the second MyRect object.  It then uses the setLocation mutator method to change its location.
  • Finally, the draw method of all three objects draws the objects on the Turtle Graphics window (make the window 500 by 500).
  • None of the rectangles drawn may touch each other and all should fit completely on the turtle's drawing panel.

• Input up to 10 integers. Place even ints in an array called EvenList, odd ints in an array called oddList, and negative ints in an array called negativeList.  After entry, display contents of all three lists.
• Files:
                IntLists.class                 IntLists01.java

• Input up to 10 floating-point numbers.  Display average followed by a list of all numbers greater than the average.
• Average must be calculated using a method that has an array at its parameter (if non-full, a second parameter for size will also be needed).
• Files:
             AverageDoubles.class                 AverageDoubles01.java   

k:\java\Chapter09\Statistics

• Input up to 10 integers.  Only 1 through 10 inclusive are valid values.  Others must be rejected.
• find the required information in any order
• but display them in this order:
• the original list
• the ordered list
• the table of frequencies first
• followed by the ordered list
• the mode* and the median
• the stardard deviation
• You MAY NOT sort any array.   You may, however, create a new array which is ordered as it is created, and as many other new arrays as needed to complete the project.


* if more than one mode, find and display only the smallest.

• Input 16 integers into a two-dimensional 4x4 array.
• Ignore the requirement to display the results in a text area.  This is a console application.  Simply report whether or not the square is a magic square.
• Files:
                MagicSquare.class                 MagicSquare01.java

• Pay close attention to the math of this project, as it was used in the 2003 Great Computer Challenge!
• Although it is possible to solve this problem using either a one or two-dimensional array, YOU MUST USE A TWO-DIMENSIONAL ARRAY WITH VARIABLE LENGTH ROWS (see page 320 in your text).
• To best determine the relationship between the numbers of each row, view them arranged in left-justified fashion instead of a triangle:

1
1  1
1  2  1
1  3  3  1
1  4  6  4  1
etc.
• Notice each row starts with one and ends with 1.  Each number in between is the sum of the pair of numbers just above it and to the left.

Sample runs:
---------------------------------------------------------
This project is named "Pascals Triangle..."
by Mr. C. Monroe
How many rows? (1-10): 5
            1
         1     1
      1     2     1
   1     3     3     1
1     4     6     4     1

Press Enter to continue . . .
-------------------------------------------
This project is named "Pascals Triangle..."
by Mr. C. Monroe
How many rows? (1-10): 6
               1
            1     1
         1     2     1
      1     3     3     1
   1     4     6     4     1
1     5     10    10    5     1

Press Enter to continue . . .

• Files:
                PascalTriangle.class                 PascalTriangle01.java

k:\java\Chapter09\PennyPitch

• Display the two-dimensional board of numbers using buttons.  My I suggest a gridbag layout.
• A "Toss" button, which, when clicked executes the toss, as directed in the text, and replaces the appropriate number with the letter P.
• A label to display a running total of the numbers hit by coin tosses.
• Your Square class should store:
• a boolean indicating whether or not it has been "hit" by a coin toss
• an integer storing its value--1, 2, or 3--or 0 if the letter P is to be displayed
• alternatively, instead of an integer, you could store a pointer to a component (a button)
• Your PennyPitch class should declare and instantiate a 5x5 array of Square objects.
• If your Square class stores a pointer to a button component, the PennyPitch class should declare and instantiate each button and pass its pointer to the Square.  Otherwise, the PennyPitch class will need to use a 5x5 array of buttons in parallel with the array of Square objects.
• At the very least, your program should display the running total of the numbers hit by coin tosses.
• Additionally add:
• The number of tosses
• The number of misses
• Logic to end the game when the number of misses reaches 10 or all 25 numbers have been hit.
• Optionally, reset all values and restart the game after each game ends.
• Still not sure what to do?  This applet version demonstrates how the game should work.

• A console project to demonstrate using class data (static data) to count instances of a class.
• Martians are appearing in orbit around the earth and some of them have landed!
• Design a project that will 
• prompt the user for how many Martians to initially be in orbit around the earth (at least one, please).
• ask the user to enter 1 to add another orbiting Martian, -1 to land a Martian, and 0 to end the program.
• a loop should continue this process until 0 is entered.
• After each input, the program should display the number of Martians still orbiting and the number of Martians that have landed.
• REQUIRED:  Write a class named Martian with the following
• Private class (static) integers to keep track of how many Martians are orbiting and how many have landed.
• When the default constructor creates a new Martian, it is placed in orbit (the orbit counter increases by one).
• A public method named Land() lands one Martian (the orbit counter decreases by one, the landed counter increases by one)--unless of course there are no Martians in orbit.
• The public toString() method displays the number of Martians in orbit and the number of Martians that have landed.

Project "MartianCounter" by Mr. C. Monroe.
How many Martians to begin? (at least one, please) 2
2 martians are in orbit.
0 martians have landed.
1=Another Martian, -1=Martian lands, 0=quit -1
1 martian is in orbit.
1 martian has landed.
1=Another Martian, -1=Martian lands, 0=quit -1
0 martians are in orbit.
2 martians have landed.
1=Another Martian, -1=Martian lands, 0=quit -1
Can't land a martian if none are in orbit.
0 martians are in orbit.
2 martians have landed.
1=Another Martian, -1=Martian lands, 0=quit 1
1 martian is in orbit.
2 martians have landed.
1=Another Martian, -1=Martian lands, 0=quit 2
1 martian is in orbit.
2 martians have landed.
1=Another Martian, -1=Martian lands, 0=quit 0
1 martian is in orbit.
2 martians have landed.

Press Enter to continue . . .

• Implement the project provided in your text on pages 357-358.
• Write a Java program that uses Turtle Graphics to draw a 50 x 50 pixel square centered in a turtle graphics window.

• Write a Java program that uses Turtle Graphics to draw a 75 x 75 pixel square centered in a turtle graphics window.  This time you should also draw the square's diagonals.

• Your teacher has placed a project named "DemoShapes" in your "Chapter10" folder that contains your "Chapter10" workspace.
• Add the project named "DemoShapes" to your "Chapter10" workspace and open it.
• Files provided are: 
• DemoShapes.java (contains public static void main), AbstractShape.java, Shape.java, Circle.java, Wheel,java, and Rect.java.
• Study these classes carefully.
• Students writes this code:
• Triangle (follow the guidelines provided in 10-4)
• Square
• Trapezoid

SortMarathon
k:\java\Lesson11\SortMarathon

• In this project we will write a GUI program that examines the relative speeds--in milliseconds--and others behaviors of various sort routines.
• It reads from a text file named "unsorted.txt" that contains 2,639 five-letter words--one on each line, all in upper case.  Based on user-input, it reads one or more of the words and stores them in an array.  For each sort routine, a copy of the original is sorted. The sort routines sort pointers, not actual data, which allows Java to perform sorting tasks on arrays much faster than other languages such as C++.
• The sort routines examined will include but not be limited to:
• Bubble Sort (with stop flag)
• Selection Sort*
• Insertion Sort*
• Shell Sort
• Quick Sort
• Merge Sort*

* these sorts are on the APCS A exam
• Starting code is provided.
• Complete the selection sort code.
• Add insertion, shell, quick and merge sorts.
• You may also add heap sort, if you can find the algorithm.
• The GUI includes
• an integer field to input the number of words (0 to 2700) to be sorted.  (This will read that many words from the file and quit.  If end of file is reached, the total words read will not be 2700.)
• a checkbox labeled "Show Words" which, when checked allows the words read to be displayed in the text area labeled "Words"--unsorted prior to sorting, sorted after sorting, and unsorted again in their original order.
• a text area labeled "Report" in which a neat chart is displayed when the user clicks the button labeled "Start the Marathon" as follows:
• The title of the program and the actual number of words read and sorted.
• Columns with appropriate column headings to display:
1. The name of the sort.
2. The time the sort started (hours, minutes, seconds, milliseconds).
3. The time the sort ended (hours, minutes, seconds, milliseconds).
4. How long the sort lasted (duration in hours, minutes, seconds, and thousandths of seconds).
5. The number of movements.  This is a count of the number of data movements (actually pointer movements) performed by the sort.  A swap is three movements.  Most other assignments are one movement each.
• By examining the starting code, you will also find out how to:
• read one line at a time from a text file.
• create a Date object and use it to store the date and time accurate to the nearest one thousandth of a second
• compute elapsed time
• display a time (either a Date object or a number of milliseconds) in the format "hh:mm:ss:ccc" ("ccc" = milliseconds).
• Sample run:

Sort Marathon.  Number of words sorted: 2345
Sort                   Start           End      Duration   Comparisons     Movements
Bubble          11:21:50:254  11:21:50:634  00:00:03:080       2747164       4105890
Selection       11:21:50:644  11:21:50:905  00:00:02:061       2748340          7008
Insertion       11:21:50:905  11:21:51:085  00:00:01:080       1370966       1373318
Shell           11:21:51:085  11:21:51:105  00:00:00:020         48361         49569
Merge           11:21:51:105  11:21:51:115  00:00:00:010         23350         50254
Quick           11:21:51:115  11:21:51:125  00:00:00:010         33999         20244
Heap            11:21:51:125  11:21:51:135  00:00:00:010         45384         72708

  Election
k:\java\Lesson11\Election

• Write a Java console application that calculates and displays simple election results based on simple data entered by the user.
• Data for each candidate is stored in a simple class that you design.  It should include at least
• private instance variables to store the candidate's last name and number of votes received
• an assignment constructor
• public access methods so the client can retrieve the candidate's data.
• Your program must use an ArrayList of candidate objects, not a simple Java array.
• You may have the user enter the number of candidates or you may terminate input using a sentinel value--your choice.
• Then, for each candidate, the user enters
• the last name
• the number of votes received
• once entered, into temporary variables, use the temporary variables to instantiate a candidate object and add the object to your ArrayList.
• The program will then display a chart
• the first line has headings for the columns
• The columns display
• the candidate name (left-justified)
• the number of votes received (right-justified)
• the percent of total votes (right-justified, rounded to 2 decimal places)
• Two more lines display
• The total number of votes (also left and right justified)
• Who won.

Sample OUTPUT might be:
Candidate     Votes Received   % of Total Votes
Simpson           5000              25.91
Mergatroid        4000              20.72
Magillicuddy      6000              31.09
Haagendaas        2500              12.95
Van Helsing       1800               9.33
Total            19300
The Winner of the Election is Magillicuddy.