various generics exercise setup

Author: joshHug

lec14/exercises/hardMode/TestGoalOne.java

@@ -0,0 +1,27 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/** Tests goal one for hard mode exercises for lecture 14
+ *  @author Josh Hug
+ */
+
+public class TestGoalOne {
+    @Test
+    public void testVessel() {
+        Vessel<Integer> vi = new Vessel<Integer>();
+        int x = 5;
+        vi.put(x); //autoboxes into an Integer, Integer is-an Object
+        int y = vi.peek(); // no unboxing, returns an Object
+        assertEquals(5, y);
+        assertEquals((Integer) 5, vi.peek());
+
+        Vessel<String> vst = new Vessel<String>();
+        vst.put("hello");
+        assertEquals("hello", vst.peek());
+    }
+
+    /** Runs tests. */
+    public static void main(String[] args) {
+        jh61b.junit.textui.runClasses(TestGoalOne.class);
+    }
+} 

lec14/exercises/hardMode/TestMax.java

@@ -0,0 +1,22 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/** Tests VesselHelper
+ *  @author Josh Hug
+ */
+
+public class TestMax {
+    @Test
+    public void testMax() {
+        Vessel<Integer> v1 = new Vessel<Integer>();
+        Vessel<Integer> v2 = new Vessel<Integer>();
+        v1.put(1);
+        v2.put(2);
+        assertEquals((Integer) 2, VesselHelper.max(v1, v2));
+    }
+
+    /** Runs tests. */
+    public static void main(String[] args) {
+        jh61b.junit.textui.runClasses(TestMax.class);
+    }
+}   

lec14/exercises/hardMode/TestRatio.java

@@ -0,0 +1,23 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/** Tests VesselHelper
+ *  @author Josh Hug
+ */
+
+public class TestRatio {
+    @Test
+    public void testRatio() {
+        Vessel<Integer> vInteger = new Vessel<Integer>();
+        Vessel<Double> vDouble = new Vessel<Double>();
+        vInteger.put(20);
+        vDouble.put(2.0);
+
+        assertEquals((Double) 10.0, VesselHelper.ratio(vInteger, vDouble), 1e-5);
+    }
+
+    /** Runs tests. */
+    public static void main(String[] args) {
+        jh61b.junit.textui.runClasses(TestRatio.class);
+    }
+}   

lec14/exercises/hardMode/TestRemove.java

@@ -0,0 +1,29 @@
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/** Tests VesselHelper
+ *  @author Josh Hug
+ */
+
+public class TestRemove {
+    
+    @Test
+    public void testRemove() {
+        Vessel<Integer> v = new Vessel<Integer>();
+        v.put(5);
+        int occupant = VesselHelper.remove(v);
+        assertEquals(5, occupant);
+        assertEquals(null, v.peek());
+
+        Vessel<String> sV = new Vessel<String>();
+        sV.put("ketchupFriend");
+        String occupantString = VesselHelper.remove(sV);
+        assertEquals("ketchupFriend", occupantString);
+        assertEquals(null, sV.peek());
+    }
+
+    /** Runs tests. */
+    public static void main(String[] args) {
+        jh61b.junit.textui.runClasses(TestRemove.class);
+    }
+}   

lec14/exercises/hardMode/Vessel.java

@@ -0,0 +1,15 @@
+/** Your job: Convert this into a generic Vessel so that TestGoalOne works.
+ *  @author Josh Hug
+ */
+
+public class Vessel {
+    Integer occupant;
+
+    public void put(Integer x) {
+        occupant = x;
+    }
+
+    public Integer peek() {
+        return occupant;
+    }
+} 

lec14/exercises/hardMode/VesselHelper.java

@@ -0,0 +1,31 @@
+/** Does stuff with vessels in a contrived manner to draw out
+ *  annoying themes with Generics. 
+ *  @author Josh Hug
+ */
+
+/* Methods can have type parameters too!
+ * Specify them BEFORE the return type of the method. */
+
+public class VesselHelper {
+    /* Remove the item from the vessel and return it. */
+    public static Integer remove(Vessel<Integer> v) {
+        Integer rVal = v.peek();
+        v.put(null); // displace the occupant.
+        return rVal;
+    }
+
+    public static Integer max(Vessel<Integer> x, Vessel<Integer> y) {
+        Integer xVal = x.peek();
+        Integer yVal = y.peek();
+        if (xVal.compareTo(yVal) > 0) {
+            return xVal;
+        }
+        return yVal;
+    }
+
+    public static double ratio(Vessel<Integer> x, Vessel<Integer> y) {
+        Integer xVal = x.peek();
+        Integer yVal = y.peek();
+        return ((double) xVal) / ((double) yVal);
+    }
+} 

lec14/exercises/hardMode/readme.md

@@ -0,0 +1,10 @@
+Your task is to complete the tasks listed here: https://docs.google.com/presentation/d/1j2vivowiaZWepIjUoWj6Cx3CdJiyuYslxkg8GsT8kxM/edit#slide=id.g631db3c57_367
+
+We provide you with non-generic versions of Vessel and VesselHelper. Your job is to make them generic so that the provided test files pass. Test files (and goals) should be done in this order:
+
+TestGoalOne (modify Vessel only)
+TestRemove (modify VesselHelper.remove only)
+TestMax (modify VesselHelper.max only)
+TestRatio (modify VesselHelper.remove only)
+
+All code should compile without warnings.

lec14/live1/VesselHelper.java

@@ -14,7 +14,7 @@ public static <Slaggathor> Slaggathor remove(Vessel<Slaggathor> v) {
         return rVal;
     }
 
-    public static <ZX extends Comparable> ZX max(Vessel<ZX> x, Vessel<ZX> y) {
+    public static <ZX extends Comparable<ZX>> ZX max(Vessel<ZX> x, Vessel<ZX> y) {
         ZX xVal = x.peek();
         ZX yVal = y.peek();
         if (xVal.compareTo(yVal) > 0) {
@@ -23,10 +23,36 @@ public static <ZX extends Comparable> ZX max(Vessel<ZX> x, Vessel<ZX> y) {
         return yVal;
     }
 
+    /* ratio is trickier */
+
+    /* Approach below will not work unless you pass EXACTLY a Vessel<Number>.
+     * For example, we could not pass in a Vessel<Integer>, because a 
+     * a Vessel<Integer> is-not-a Vessel<Number>. */
+    /*public static double ratio(Vessel<Number> v1, Vessel<Number> v2) {
+        double d1 = v1.peek().doubleValue();
+        double d2 = v2.peek().doubleValue();
+        return d1 / d2;
+    }    */
+
+
+    /** The preferred approach. */
+    public static double ratio(Vessel<? extends Number> x, Vessel<? extends Number> y) {
+        Number xVal = x.peek(); // assignment allowed since ? is-a Number, 
+        Number yVal = y.peek(); // even though we don't know what ? is.
+        return xVal.doubleValue() / yVal.doubleValue();
+    }
+
+    /*
+    This approach also works, but is a little more verbose than the version above.
+
+    Either approach is fine on project 1.
+
     public static <T1 extends Number, T2 extends Number> 
     double ratio(Vessel<T1> x, Vessel<T2> y) {
         T1 xVal = x.peek();
         T2 yVal = y.peek();
         return xVal.doubleValue() / yVal.doubleValue();
     }
+    */
+
 } 

lec14/live2/VesselHelper.java

@@ -25,9 +25,36 @@ public static <Plarp extends Comparable<Plarp>> Plarp max(Vessel<Plarp> v1, Vess
         return v2val;
     }
 
-    public static double ratio(Vessel<Number> v1, Vessel<Number> v2) {
+    /* ratio is trickier */
+
+    /* Approach below will not work unless you pass EXACTLY a Vessel<Number>.
+     * For example, we could not pass in a Vessel<Integer>, because a 
+     * a Vessel<Integer> is-not-a Vessel<Number>. */
+    /*public static double ratio(Vessel<Number> v1, Vessel<Number> v2) {
         double d1 = v1.peek().doubleValue();
         double d2 = v2.peek().doubleValue();
         return d1 / d2;
-    }    
+    }    */
+
+
+    /** The preferred approach. */
+    public static double ratio(Vessel<? extends Number> x, Vessel<? extends Number> y) {
+        Number xVal = x.peek(); // assignment allowed since ? is-a Number, 
+        Number yVal = y.peek(); // even though we don't know what ? is.
+        return xVal.doubleValue() / yVal.doubleValue();
+    }
+
+    /*
+    This approach also works, but is a little more verbose than the version above.
+
+    Either approach is fine on project 1.
+
+    public static <T1 extends Number, T2 extends Number> 
+    double ratio(Vessel<T1> x, Vessel<T2> y) {
+        T1 xVal = x.peek();
+        T2 yVal = y.peek();
+        return xVal.doubleValue() / yVal.doubleValue();
+    }
+    */
+
 } 

lec15/exercises/hardMode/Iteration/AListIteratorLauncher2.java

@@ -2,7 +2,7 @@
  *  @author Josh Hug
  */
 
-public class AListIteratorLauncher {
+public class AListIteratorLauncher2 {
     public static void main(String[] args) {
         AList L  = new AList();
         L.insertBack(50);