10A

In this problem you will write several static methods to work with arrays and ArrayLists. Remember that a static method does not work on the instance variables of the class. All the data needed is provided in the parameters. Call the class StaticPractice. Notice how the methods are invoked in StaticPracticeTester.

StaticPractice is a utility class. It has no instance variables and should not have a constructor

• public static int max(int[] numbers) gets the maximum value in the array. Use the enhanced for loop
• public static int max(ArrayList<Integer> numbers) Gets the maximum value in the ArrayList as an int. You can assume the ArrayList contains at least one element. Use the enhanced for loop
• public static boolean containsTwice(int[] list, int target) determines if the target is in the array at least two times. Returns true if it is, otherwise returns false
• public static boolean containsTwice(ArrayList<Integer> list, int target) determines if the target is in the ArrayList at least two times. Returns true if it is, otherwise returns false

Notice that there are two methods called max and two methods called contains. These are examples of overloading - methods with the same name but different number and type of parameters. The compiler tells them apart because in each case, one takes an array and one an ArrayList as a parameter.

When using the enhanced for loop, the implementation of the pairs of methods will be very similar. The exact same loop works for both

Provide Javadoc. Look at the documentation produced for StaticPractice. The Javadoc utility works on static methods, too.

For the draft, implement first the max method

10A draft:
10A final:

10B

Now we are going to use the design pattern for collecting objects. We are going to model a GardenStore with plants. A GardenStore uses an ArrayList to keep track of Plant objects. You will write both a GardenStore class and a Plant class.

A Plant has a name and a price. Provide a constructor that takes name and price, in that order. Provide getters and setters for the instance variables. This is the design pattern for managing properties of objects.

A GardenStore has a constructor that takes no parameters. Remember it must initialize the instance variable

It has methods

• add() Adds the specified Plant to the GardenStore
• sum() Finds the total cost of all  Plants in the GardenStore
• contains() determines if a Plant with a given name is in the GardenStore. Returns true if a Plant with that name is in the GardenStore. Otherwise false.
• plantList() gets an ArrayList<String> containing the names of the Plants  in the GardenStore.(Updated 11/10)

Provide Javadoc for both classes.

For the draft: implement the Plant class

Note: The Plant class will not change in the final, but you will need to submit it again so that GardenStore can find it.

10B draft:
10B final:

10C

In this problem you will use the design pattern for maintaining state. Write a Zebra class. A Zebra has 4 states. You will define and use these static constants to represent the states.

• public static final int NOT_HUNGRY = 1;
• public static final int SOMEWHAT_HUNGRY = 2;
• public static final int HUNGRY = 3;
• public static final int VERY_HUNGRY = 4;

While in your code you can not assume what the value is for any of the constants, you can assume that they the values are consecutive integers. That is, VERY_HUNGRY will be 1 greater than HUNGRY, etc.

Zebras roam the Serengeti Plain in Tanzania.

A Zebra runs across the plain and as it runs, it becomes more hungry. If it is NOT_HUNGRY, it becomes SOMEWHAT_HUNGRY. If it is SOMEWHAT_HUNGRY, it becomes HUNGRY and so on. When the Zebra sees food, if it is in any of the "hungry states", it will eat and become one level less hungry. If the Zebra is VERY_HUNGRY when it sees food, it will eat and become HUNGRY. The next time it sees food, it will eat again and become SOMEWHAT_HUNGRY. If it is NOT_HUNGRY, it does not eat and its state does not change.

The Zebra can not be less than NOT_HUNGRY or more than VERY_HUNGRY.

The constructor takes no parameters. A Zebra is very hungry when it is creates so the constructor must initialize the state to VERY_HUNGRY.

Provide methods:

• public void run() the Zebra becomes more hungry if not already VERY_HUNGRY
• public void seeFood() the Zebra will eat if it is hungry and become less hungry
• public int getState() Gets the integer representing the state, an integer 1 through 4.
• public String getHungerLevel() Gets a string describing the current hunger state of the Zebra: "Not hungry", "Somewhat hungry ,"Hungry", or "Very hungry"

Provide Javadoc

For the draft, provide the static constants, implement the constructor, and the getState() method. Implement the other methods as stubs. Provide Javadoc

10C draft:
10C final: