Cleaned up examples for chapter 6 (Enums and Annotations)

Author: jbloch

src/effectivejava/chapter6/item34/Inverse.java

@@ -0,0 +1,25 @@
+package effectivejava.chapter6.item34;
+
+// Switch on an enum to simulate a missing method (Page 167)
+public class Inverse {
+    public static Operation inverse(Operation op) {
+        switch(op) {
+            case PLUS:   return Operation.MINUS;
+            case MINUS:  return Operation.PLUS;
+            case TIMES:  return Operation.DIVIDE;
+            case DIVIDE: return Operation.TIMES;
+
+            default:  throw new AssertionError("Unknown op: " + op);
+        }
+    }
+
+    public static void main(String[] args) {
+        double x = Double.parseDouble(args[0]);
+        double y = Double.parseDouble(args[1]);
+        for (Operation op : Operation.values()) {
+            Operation invOp = inverse(op);
+            System.out.printf("%f %s %f %s %f = %f%n",
+                    x, op, y, invOp, y, invOp.apply(op.apply(x, y), y));
+        }
+    }
+}

src/effectivejava/chapter6/item34/Operation.java

@@ -4,7 +4,7 @@
 
 import static java.util.stream.Collectors.toMap;
 
-// Enum type with constant-specific class bodies and data  (Page 161)
+// Enum type with constant-specific class bodies and data (Page 163-4)
 public enum Operation {
     PLUS("+") {
         public double apply(double x, double y) { return x + y; }
@@ -27,7 +27,7 @@ public enum Operation {
 
     public abstract double apply(double x, double y);
 
-    // Implementing a fromString method on an enum type
+    // Implementing a fromString method on an enum type (Page 164)
     private static final Map<String, Operation> stringToEnum =
             Stream.of(values()).collect(
                     toMap(Object::toString, e -> e));

src/effectivejava/chapter6/item34/PayrollDay.java

@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item34;
 
-// The strategy enum pattern
+// The strategy enum pattern (Page 166)
 enum PayrollDay {
     MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
     SATURDAY(PayType.WEEKEND), SUNDAY(PayType.WEEKEND);

src/effectivejava/chapter6/item34/Planet.java

@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item34;
 
-// Enum type with data and behavior  (157-158)
+// Enum type with data and behavior  (159-160)
 public enum Planet {
     MERCURY(3.302e+23, 2.439e6),
     VENUS  (4.869e+24, 6.052e6),
@@ -14,6 +14,7 @@ public enum Planet {
     private final double mass;           // In kilograms
     private final double radius;         // In meters
     private final double surfaceGravity; // In m / s^2
+
     // Universal gravitational constant in m^3 / kg s^2
     private static final double G = 6.67300E-11;
 

src/effectivejava/chapter6/item34/WeightTable.java

@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item34;
 
-// Takes earth-weight and prints table of weights on all planets - Page 158
+// Takes earth-weight and prints table of weights on all planets (Page 160)
 public class WeightTable {
    public static void main(String[] args) {
       double earthWeight = Double.parseDouble(args[0]);

src/effectivejava/chapter6/item35/Ensemble.java

@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item35;
 
-// Enum with integer data stored in an instance field (Page 166)
+// Enum with integer data stored in an instance field (Page 168)
 public enum Ensemble {
     SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5),
     SEXTET(6), SEPTET(7), OCTET(8), DOUBLE_QUARTET(8),

src/effectivejava/chapter6/item36/Text.java

@@ -1,16 +1,20 @@
 package effectivejava.chapter6.item36;
+
 import java.util.*;
 
-// EnumSet - a modern replacement for bit fields (Page 168)
+// EnumSet - a modern replacement for bit fields (Page 170)
 public class Text {
-    public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }
+    public enum Style {BOLD, ITALIC, UNDERLINE, STRIKETHROUGH}
 
     // Any Set could be passed in, but EnumSet is clearly best
-    public void applyStyles(Set<Style> styles) {   }
+    public void applyStyles(Set<Style> styles) {
+        System.out.printf("Applying styles %s to text%n",
+                Objects.requireNonNull(styles));
+    }
 
     // Sample use
     public static void main(String[] args) {
         Text text = new Text();
         text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));
     }
-}
+}

src/effectivejava/chapter6/item37/Phase.java

@@ -4,15 +4,15 @@
 
 import static java.util.stream.Collectors.*;
 
-// Using a nested EnumMap to associate data with enum pairs - (Pages 172-3)
+// Using a nested EnumMap to associate data with enum pairs - (Pages 174-5)
 public enum Phase {
     SOLID, LIQUID, GAS;
     public enum Transition {
         MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
         BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
         SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);
 
- // Adding a new phase (Page 173)
+//        // Adding a new phase (Page 175)
 //        SOLID, LIQUID, GAS, PLASMA;
 //        public enum Transition {
 //            MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
@@ -33,17 +33,20 @@ public enum Transition {
                 () -> new EnumMap<>(Phase.class),
                 toMap(t -> t.to, t -> t,
                         (x, y) -> y, () -> new EnumMap<>(Phase.class))));
+        
         public static Transition from(Phase from, Phase to) {
             return m.get(from).get(to);
         }
     }
 
     // Simple demo program - prints a sloppy table
     public static void main(String[] args) {
-        for (Phase src : Phase.values())
-            for (Phase dst : Phase.values())
-                if (src != dst)
-                    System.out.printf("%s to %s : %s %n", src, dst,
-                            Transition.from(src, dst));
+        for (Phase src : Phase.values()) {
+            for (Phase dst : Phase.values()) {
+                Transition transition = Transition.from(src, dst);
+                if (transition != null)
+                    System.out.printf("%s to %s : %s %n", src, dst, transition);
+            }
+        }
     }
 }

src/effectivejava/chapter6/item37/Plant.java

@@ -3,9 +3,9 @@
 import static java.util.stream.Collectors.groupingBy;
 import static java.util.stream.Collectors.toSet;
 
-// Using an EnumMap to associate data with an enum - Pages 169-171
+// Using an EnumMap to associate data with an enum (Pages 171-3)
 
-// Simplistic class representing a plant - Page 169
+// Simplistic class representing a plant (Page 171)
 class Plant {
     enum LifeCycle { ANNUAL, PERENNIAL, BIENNIAL }
 
@@ -31,7 +31,7 @@ public static void main(String[] args) {
             new Plant("Rosemary", LifeCycle.PERENNIAL)
         };
 
-        // Using ordinal() to index into an array - DON'T DO THIS!  (Page 170)
+        // Using ordinal() to index into an array - DON'T DO THIS!  (Page 171)
         Set<Plant>[] plantsByLifeCycleArr =
                 (Set<Plant>[]) new Set[Plant.LifeCycle.values().length];
         for (int i = 0; i < plantsByLifeCycleArr.length; i++)
@@ -44,7 +44,7 @@ public static void main(String[] args) {
                     Plant.LifeCycle.values()[i], plantsByLifeCycleArr[i]);
         }
 
-        // Using an EnumMap to associate data with an enum (P. 170)
+        // Using an EnumMap to associate data with an enum (Page 172)
         Map<Plant.LifeCycle, Set<Plant>> plantsByLifeCycle =
                 new EnumMap<>(Plant.LifeCycle.class);
         for (Plant.LifeCycle lc : Plant.LifeCycle.values())
@@ -53,11 +53,11 @@ public static void main(String[] args) {
             plantsByLifeCycle.get(p.lifeCycle).add(p);
         System.out.println(plantsByLifeCycle);
 
-        // Naive stream-based approach - unlikely to produce an EnumMap!  (Page 171)
+        // Naive stream-based approach - unlikely to produce an EnumMap!  (Page 172)
         System.out.println(Arrays.stream(garden)
                 .collect(groupingBy(p -> p.lifeCycle)));
 
-        // Using a stream and an EnumMap to associate data with an enum (Page 171)
+        // Using a stream and an EnumMap to associate data with an enum (Page 173)
         System.out.println(Arrays.stream(garden)
                 .collect(groupingBy(p -> p.lifeCycle,
                         () -> new EnumMap<>(LifeCycle.class), toSet())));

src/effectivejava/chapter6/item38/BasicOperation.java

@@ -1,6 +1,6 @@
 package effectivejava.chapter6.item38;
 
-// Emulated extensible enum using an interface - Basic implementation - Page 174
+// Emulated extensible enum using an interface - Basic implementation (Page 176)
 public enum BasicOperation implements Operation {
     PLUS("+") {
         public double apply(double x, double y) { return x + y; }