Assignment 2, perquack2 class hierarchy in Java, due 11:59 PM, Sunday March 16, 2014 Login into your account on acad/bill and do the following steps:

Transcription

1 CSC 243 Java Programming, Spring 2014, Dr. Dale E. Parson Assignment 2, perquack2 class hierarchy in Java, due 11:59 PM, Sunday March 16, 2014 Login into your account on acad/bill and do the following steps: 1. Do the following after logging into acad/bill (I will post it during the morning of Sunday March 2): cp ~parson/javalang/perquack2.problem.zip ~/JavaLang/perquack2.problem.zip cd ~/JavaLang unzip perquack2.problem.zip cd./perquack2 gmake clean test Initially you will get this far through the tests: ASSIGNMENT1 JAVA TESTS STARTED java perquack2.perquacky english.mthes.txt hermione harry ron < jtest1.tx t > jtest1.out 2>jtest1.error.out diff jtest1.out jtest1.ref > jtest1.dif diff jtest1.error.out jtest1.error.ref > jtest1.error.dif ASSIGNMENT2 JAVA TESTS STARTED java perquack2.testperquacky perquack2.perquacky english.mthes.txt hermione harry ron < jtest1.txt > jtest1.out 2>jtest1.error.out gmake: *** [test] Error 3 Notice the command line for the first assignment 2 test above. perquack2.perquacky is now the first command-line argument for program perquack2.testperquacky. TestPerquacky implements a plug-in loader similar to the one we went over in class for last year s CSC 243 project 2. TestPerquacky loads perquack2.perquacky (or whatever class appears on the command line) as a subclass of interface IPerquacky. The handout code solves the problems of assignment 1 as a starting point. Here is the error message from the first of two assignment 2 tests: -bash-3.00$ cat jtest1.error.out Class does not inherit from IPerquacky: perquack2.perquacky: class perquack2.perquacky The figure above shows the Java interface IPerquacky and three classes Perquacky, PerquackyException, and TestPerquacky handed out as the starting point of assignment 2. Perquacky continues to work as it did for assignment 1, giving identical output. I have refactored the play, page 1 Dr. Dale E. Parson, CSC 243, Spring, 2014,

2 playround and playplayer methods of assignment 1 into a single playword method that keeps track of the round and player by using additional data fields in the Perquacky object. The reason I made that change is to move the terminal I/O (input/output) interaction with the players out of the object methods of class Perquacky and into the test drivers (Perquacky.main and TestPerquacky.main), because when we get to designing a graphical user interface (GUI) for the game, the interaction with the players will reside in GUI classes, so it must be outside of the game code. The interaction loop that prints prompts to players and reads their data entries now resides in the test drivers in Perquacky.main and TestPerquacky.main. The figure below shows the interface and class structure that is the goal for this assignment. Not all of the work items appear in this class diagram, but they do appear in the following list of requirements. Please read the following list again, after all automated tests pass, because there is documentation to write as part of this assignment, and its absence will not show up in testing. Classes TestPerquacky and PerquackyException are complete as supplied, so you should not change them at all. Interface IPerquacky is complete except for Javadoc documentation that you must write in IPerquacky.java. Do not change any of the method declarations in IPerquacky and do not add any. 1. Make class Perquacky a direct subclass of interface IPerquacky using interface inheritance. That is a little different from the above diagram, where Perquacky is a subclass of abstract class PerquackyHelper using implementation inheritance, and PerquackyHelper is a subclass of IPerquacky. This is an intermediate step. You can find the syntax for making a class a subclass of an interface in my handout for the FillWord2 package from last year s Java course. 2. Go through Perquacky.java and change every occurrence of LinkedList<String> to List<String> except for the ones that say new LinkedList<String>. In other words, change all local variable declarations, object field declarations, and method parameter declarations that are currently LinkedList to the List interface. Do not change the new constructor calls, because you page 2 Dr. Dale E. Parson, CSC 243, Spring, 2014,

3 cannot construct a new object of an interface. An interface is a specification. Once this step is done, gmake clean test will pass these two tests: ASSIGNMENT1 JAVA TESTS STARTED and ASSIGNMENT2 JAVA TESTS STARTED. It will not pass ASSIGNMENT2 TESTS OF EXTENSION CLASS Perwhacky STARTED yet. 3. Write class Perwhacky that is a subclass of Perquacky. Perwhacky provides only two methods. The first is a constructor with a signature identical to Perquacky s constructor except that the constructor name is Perwhacky. The body of that constructor should just call Perquacky s constructor by using the super keyword with all of the constructor arguments. The second method is playword with the same signature as IPerquacky.playWord and Perquacky.playWord. Perwhacky.playWord must construct a String that is the reversal of its word argument esuoh becomes house and calls its base class Perquacky.playWord with that reversed String as the argument. Perwhacky forces the player to type words backwards. Once you have step 3 working, all of the tests should pass, including ASSIGNMENT2 TESTS OF EXTENSION CLASS Perwhacky STARTED. 4. Create abstract class PerquackyHelper that is a subclass of IPerquacky. MOVE all of the data fields at the top of class Perquacky, from vulnerablescore down through currentplayerwordset, into PerquackyHelper. Make sure to keep the Javadoc comments with the fields. Also, change the public and private modifiers for these fields into protected. All of the fields should be protected so that subclasses can access them. Later on we may make some of the constant fields variable so we can change scoring rules of games, but for now keep the static and final modifiers the way they are. MOVE the code for the Perquacky constructor into the PerquackyHelper constructor, and change the Perquacky to call the PerquackyHelper using super. MOVE all of the methods of Perquacky except playword and main into PerquackyHelper. Keep the public methods public, and make the private methods protected, since you may need to redefine them in subclasses that extend the game later on. Make Perquacky a subclass of PerquackyHelper. You can leave its inheritance to IPerquacky intact or take it out. Perquacky inherits from IPerquacky through PerquackyHelper. Declaring Perquacky as a subclass of IPerquacky is OK but optional. Your best bet is probably just to cp Perquacky.java PerquackyHelper.java and then edit the two files to change or remove fields and methods as required. You will need to change the class and constructor name for PerquackyHelper. At this point gmake clean test should work again. 5. Write Javadoc comments for the methods of tags as needed. When you have this done, after running a successful gmake clean test, run gmake javadoc to generate the HTML pages. You can then browse to where YOURID is your Unix login ID. Don t forget to prefix YOURID with a ~ symbol. Browse your Javadoc HTML pages to make sure IPerquacky does not have any missing or incorrect entries. page 3 Dr. Dale E. Parson, CSC 243, Spring, 2014,

4 Time management study survey: OPTIONAL 2% BONUS CREDITS I am collecting data for assessment that determines the associations between a) project start date, b) length of work sessions, c) time of day of work sessions, and d) conflicting schedule pressures, and student success on projects as measured by grades and grade improvements. You can earn half of these bonus points (1% additional for the project) by permitting me to collect file sizes, time stamps, time of change, and duration of work session. My automatic script uses a simple ls l command to list directory contents, and it keeps backup copies of your source files to determine amount of code changed per session. The log data goes to my account to keep your account from running out of file space. If you do not want to participate, run gmake optout to shut off data collection, and also notify me my using the subject line opt out. I will not collect your data, and if you have already turned some in, I will remove the files. You can earn an additional 1% bonus point by completing a survey in file survey.txt in the project directory. Please fully replace each ****** field with a number. To get this 1% you must also allow data collection for the previous 1%. This survey is not useful without the auto-collected log data. Thus, the total possible points for a project is 102%. The collected data in no way affects your grade, other than by contribution of bonus points. My assessment outlined in the first paragraph of this section could show an association between number of CSC courses that assign you big projects on the same week and the rate of problems encountered completing an assignment. I am looking for ways to improve success rates on projects in future semesters, and I need to collect data in survey.txt and by automatic data collection before I can analyze these data. This is not secret data mining, and I have no time or intention of analyzing the data until this summer. Again, if you wish to opt out of this optional part of assignments, there is no penalty. When you are all ready, do this from the assignment directory: gmake turnitin If it completes without an error message (after it prompts for a Carriage Return that you must enter), then your assignment has reached me. If you later make changes and want to turn in a revised assignment, just gmake turnitin again from the same directory. It will over-write any previous submission with the new one. Please start early, so you can come to see me with the problem if you get stuck. Notes on debugging. When gmake test runs a test like this: java perquack2.testperquacky perquack2.perquacky english.mthes.txt hermione harry ron < jtest1.txt > jtest1.out 2>jtest1.error.out diff jtest1.out jtest1.ref > jtest1.dif diff jtest1.error.out jtest1.error.ref > jtest1.error.dif page 4 Dr. Dale E. Parson, CSC 243, Spring, 2014,

5 If the java command stops with an error, your program has hit a run-time exception. Look at the bottom of the jtest1.error.out (or jtest2.error.out if that is what is on the command line) to see the error. If a diff command finds a difference between your output in the.out file and the expected output in the.ref file, look in the.dif file to see a listing of the differences. I often bring up two terminal windows and open the.out file in one and the.ref file in the other so I can inspect the differences. The.dif file tells me what line numbers to inspect. IPerquacky.java 1 // perquack2/iperquacky 2 // CSC 243 Java Programming Spring // Assignment package perquack2 ; 6 7 public interface IPerquacky { 8 public int getnumberofplayers(); 9 public String getplayername(int playerindex) throws PerquackyException; 10 public int getplayerscore(int playerindex) throws PerquackyException ; 11 public int getcurrentplayer(); 12 public String getcurrentplayerprompt(); 13 public String [][] getcurrentplayerwords(); 14 public void printcurrentplayerwords(); 15 public void playword(string word) throws PerquackyException ; 16 public boolean isrounddone(); 17 public boolean isgamedone(); 18 public int [] getwinners() ; 19 } PerquackyException.java 1 /* PerquackyException.java 2 An Exception thrown by a Perquacky-family game on an error. 3 Demonstration of Java interfaces and packages. 4 Dr. Dale Parson, CSC 243, Spring */ 6 7 package perquack2 ; 8 9 /** 10 Class PerquackyException is thrown by the Perquacky package classes 11 on any game error. 12 Professor Dale Parson 14 **/ 15 public class PerquackyException extends Exception { 16 // serialversionuid encodes MMDDYYYY of change to serializable state. 17 private static final long serialversionuid = L ; 18 /** page 5 Dr. Dale E. Parson, CSC 243, Spring, 2014,

6 19 * Construct an exception for Game with message text. 20 */ 21 public PerquackyException(String text) { 22 super(text); 23 } 24 } TestPerquacky.java 1 // perquack2/testperquacky 2 // CSC 243 Java Programming Spring // D. Parson's solution to the first Perquacky problem. 4 5 package perquack2 ; 6 import java.util.scanner ; 7 import java.util.list ; 8 import java.util.linkedlist ; 9 10 /** 11 This is the test driver for classes that implement interface 12 IPerquacky. It provides a main method that loads a 13 IPerquacky-derived class as a plug-in and runs that game. D. Parson 15 **/ 16 public class TestPerquacky { 17 /** 18 * Validate command line arguments, then construct and play 19 * a game of IPerquacky to completion. Command line usage is 20 * java perquack2.testperquacky IPerquackyCLASS dictionaryfilename seed players * where there must be 2 or more players. 22 **/ 23 public static void main(string [] args) { 24 String usage = 25 "java perquack2.perquacky IPerquackyCLASS dictionaryfilename seed players..."; 26 if (args.length < 5) { 27 System.err.println(usage); 28 System.exit(1); 29 } 30 List<String> players = new LinkedList<String>(); 31 for (int i = 3 ; i < args.length ; i++) { 32 players.add(args[i]); 33 } 34 try { 35 // Load class args[0] from the file 36 // system and run its 3-param cons. 37 Class <? extends 38 IPerquacky> puzzleclass 39 = Class.forName(args[0]). 40 assubclass(iperquacky.class); 41 Class<?> [] consparams = new Class<?> [3]; 42 consparams[0] = String.class ; // constructor's param type page 6 Dr. Dale E. Parson, CSC 243, Spring, 2014,

7 43 consparams[1] = Long.class ; // constructor's param type 44 consparams[2] = List.class ; // constructor's param type 45 // NOTE: consargs[2] must be a List<String> 46 Object [] consargs = new Object [3]; 47 consargs[0] = args[1]; 48 consargs[1] = new Long(args[2]) ; 49 consargs[2] = players; 50 java.lang.reflect.constructor<? 51 extends IPerquacky> newcons = 52 puzzleclass.getconstructor(consparams); 53 IPerquacky game = (IPerquacky) 54 newcons.newinstance(consargs); 55 Scanner cin = new Scanner(System.in); 56 while (! game.isgamedone()) { 57 System.out.print(game.getCurrentPlayerPrompt()); 58 String word = cin.nextline().trim().tolowercase(); 59 try { 60 game.playword(word); 61 } catch (PerquackyException pex) { 62 System.err.println("GAME ERROR: " + pex.getmessage()); 63 } 64 } 65 int [] winners = game.getwinners(); 66 if (winners.length == 1) { 67 System.out.println("WINNER IS: " 68 + game.getplayername(winners[0])); 69 } else { 70 for (int j = 0 ; j < winners.length ; j++) { 71 System.out.println("TIE FOR WINNER: " 72 + game.getplayername(winners[j])); 73 } 74 } 75 // Print out the scores. 76 System.out.println("SCORES:"); 77 for (int i = 0 ; i < game.getnumberofplayers() ; i++) { 78 System.out.println("\t" + game.getplayerscore(i) 79 + " " + game.getplayername(i)); 80 } 81 } catch (PerquackyException px2) { 82 System.err.println("GAME ERROR: " + px2.getmessage()); 83 } catch (java.lang.classnotfoundexception cnx) { 84 System.err.println("Class not found: " + args[0] 85 + ": " + cnx.getmessage()); 86 // cnx.printstacktrace(); 87 System.exit(3); 88 } catch (java.lang.classcastexception ccx) { 89 System.err.println("Class does not inherit from IPerquacky: " 90 + args[0] 91 + ": " + ccx.getmessage()); 92 System.exit(3); 93 } catch (java.lang.nosuchmethodexception nnx) { page 7 Dr. Dale E. Parson, CSC 243, Spring, 2014,

8 94 System.err.println("Class constructor not found: " + args[0] 95 + ": " + nnx.getmessage()); 96 System.exit(3); 97 } catch (java.lang.instantiationexception inx) { 98 System.err.println("Class constructor error: " + args[0] 99 + ": " + inx.getmessage()); 100 System.exit(3); 101 } catch (java.lang.illegalaccessexception anx) { 102 System.err.println("Class constructor access error: " + args[0] ": " + anx.getmessage()); 104 System.exit(3); 105 } catch (java.lang.reflect.invocationtargetexception vnx) { 106 System.err.println("Class constructor call error: " + args[0] ": " + vnx.getmessage()); 108 System.exit(3); 109 } 110 System.exit(0); 111 } 112 } page 8 Dr. Dale E. Parson, CSC 243, Spring, 2014,