Lab 6

Due Friday, 4/6/2012, 5:00 p.m.

NOTE: 4/6 is a holiday, so help will NOT be available that day. We recommend that you get the lab done by Thursday, so that you can avail yourself of help from TA and professors.

NOTE #2: There were some bugs in initial OrderedStringList.java code, bugs fixed and changes uploaded on 3/30 @ 1:30 pm. If you have downloaded an earlier version, please redownload the revised version.

For your 6th lab, you will use inheritance to change the behavior of a data structure, and you will create some of the data structures that will be used for the next project.

    1. Ordered String List
    2. Consider the following OrderedStringList class, which implements an ordered string list (available to download here: OrderedStringList.java)
    3. import java.util.NoSuchElementException;
    4. public class OrderedStringList
    5. {
    6. String data[];
    7. int length;
    9. protected static final int DEFAULT_LENGTH = 10;
    11. public OrderedStringList()
    12. {
    13. data = new String[DEFAULT_LENGTH];
    14. length = 0;
    15. }
    17. public OrderedStringList(int initialAllocation)
    18. {
    19. data = new String[initialAllocation];
    20. length = 0;
    21. }
    23. public String minString()
    24. {
    25. if (length > 0)
    26. {
    27. return data[0];
    28. }
    29. else
    30. {
    31. throw new NoSuchElementException();
    32. }
    33. }
    35. public String maxString()
    36. {
    37. if (length > 0)
    38. {
    39. return data[length - 1];
    40. }
    41. else
    42. {
    43. throw new NoSuchElementException();
    44. }
    45. }
    47. public void add(String element)
    48. {
    49. if (data.length == length)
    50. {
    51. growData();
    52. }
    53. int insertIndex = length;
    54. while (insertIndex > 0 && element.compareTo(data[insertIndex-1]) < 0)
    55. {
    56. data[insertIndex] = data[insertIndex - 1];
    57. insertIndex--;
    58. }
    59. data[insertIndex] = element;
    60. length++;
    61. }
    62. protected void growData()
    63. {
    64. String newData[] = new String[data.length * 2];
    65. for (int i = 0; i < data.length; i++)
    66. {
    67. newData[i] = data[i];
    68. }
    69. data = newData;
    71. }
    73. public String toString()
    74. {
    75. String contents;
    76. if (length == 0)
    77. {
    78. contents = "";
    79. }
    80. else
    81. {
    82. contents = data[0];
    83. }
    84. for (int i = 1; i < length; i++)
    85. {
    86. contents += ", " + data[i];
    87. }
    88. return "[" + contents + "]";
    89. }
    91. String get(int index)
    92. {
    93. if (index < 0 && index >= length)
    94. {
    95. throw new IndexOutOfBoundsException();
    96. }
    97. return data[index];
    98. }
    101. void delete(int index)
    102. {
    103. length = length - 1;
    104. for(int i = index; i < length; i++)
    105. {
    106. data[i] = data[i+1];
    107. }
    108. }
    110. }
    111. This class implements an ordered string list. Strings can be added to the list (which will be added not to the end of the list, but at the appropriate place for the list to remain sorted), the largest and smallest element can be retrieved from the list, the string at a specific index can be deleted, and so on. For the first part of your lab you will write a class ReversedOrderedStringList, which will extend OrderedStringList. Your reverse ordered string list will be the same as the standard ordered string list, except that elements will stored in inverse sorted order.
    112. So, if we did:
    113. ReversedOrderedStringList list = new ReversedOrderedStringList();
    114. list.add("cat");
    115. list.add("ant");
    116. list.add("zoo");
    117. then list.get(0) would return "zoo", list.get(1) would return "cat", and list.get(2) would return "ant"
    118. likewise, list.minString() would return "ant", list.maxString() would return "zoo", and list.toString() would return
    119. "[zoo, cat, ant]"
    120. Your ReverseOrderedStringList must extend the given OrderedStringList, which must not be modified. All of the public methods defined in OrderedStringList must work properly for your ReverersedOrderedStringList. For full credit, reuse as much of the code in OrderedStringList as possible.
    121. For the second part of this lab, you will code the data structures for a Clue-like game (the next project will involve coding the rest of the game logic). There are 3 types of clue cards: Weapon cards, Location cards, and Person cards. You will define an abstract Card class, with three subclasses, PersonCard, WeaponCard, and LocationCard. In addition, you will create a Hand class, which holds a list of cards. Many (but not all!) of the required functionality can be tested using the HandTester class, included below. Your code needs to define all of the methods exactly as defined in the following documentation. Use the exact same names (case matters!), the same modifiers (public, abstract, etc.) See your professor or TA if you have any questions!
    122. Required classes:
      1. All documentation can be found in one place (with frames) here

Submission

Please submit your work in the following SVN directories:

For ReveresedOrderedStringList:

https://www.cs.usfca.edu/svn/<username>/cs112/lab6

For card game:

https://www.cs.usfca.edu/svn/<username>/cs112/project3