Time and interfaces

Author: bowbahdoe

src/SUMMARY.md

@@ -458,7 +458,6 @@
   - [Integer to a Base 16 String](./integers_ii/integer_to_a_base_16_string.md)
   - [Underscores in Integer Literals](./integers_ii/underscores_in_integer_literals.md)
 
-- [🚧 Construction Zone 🚧]()
 
 # Interactive Programs III
 
@@ -471,6 +470,8 @@
   - [Create a Folder](./files/creating_a_folder.md)
   - [Challenges](./files/challenges.md)
 
+
+<!--
 # Data Structures & Algorithms II
 
 - [Hash Maps](./hash_maps.md)
@@ -483,7 +484,7 @@
   - [Growable Buckets](./hash_maps/growable_buckets.md)
   - [Keys and Values](./hash_maps/keys_and_values.md)
   - [Put Items](./hash_maps/put_items.md)
-  - [Get Items](./hash_maps/get_items.md)
+  - [Get Items](./hash_maps/get_items.md)-->
 
 
 # Code Structure IV
@@ -496,18 +497,24 @@
   - [@Override](./objects/override.md)
   - [equals and hashCode](./objects/equals_and_hashCode.md)
   - [Override equals and hashCode](./objects/override_equals_and_hashCode.md)
-  - [Variance and Casting](./objects/variance_and_casting.md)
-  - [Subclasses](./objects/subclasses.md)
+  <!--- [Variance and Casting](./objects/variance_and_casting.md)
+  - [Subclasses](./objects/subclasses.md)-->
+
+- [Generics](./generics.md)
+  - [Type Variables](./generics/type_variables.md)
+  - [Naming](./generics/naming.md)
+  - [Instantiation](./generics/instantiation.md)
+  - [Inference](./generics/inference.md)
+  - [Soundness](./generics/soundness.md)
+  - [Raw Types](./generics/raw_types.md)
 - [Interfaces](./interfaces.md)
   - [Interface Declaration](./interfaces/interface_declaration.md)
+  - [Implementation](./interfaces/implementation.md)
+  - [@Override](./interfaces/override.md)
   - [Naming](./interfaces/naming.md)
-  - [Instances](./interfaces/instances.md)
-  - [Fields](./interfaces/fields.md)
-  - [Methods](./interfaces/methods.md)
   - [Subtypes](./interfaces/subtypes.md)
-- [Generics](./generics.md)
-  - [Generic Parameters](./generics/generic_parameters.md)
-  - [Wildcards]()
+  - [Multiple Implementations](./interfaces/multiple_implementations.md)
+
 # Data Types V
 
 <!-- Note: Put a joke about the "A train leaves chicago at ..." problems.
@@ -529,7 +536,7 @@ Make them do one. -->
   - [Loop over items](./array_list/loop_over_items.md)
   - [Set an item](./array_list/set_an_item.md)
   - [Remove an item](./array_list/remove_an_item.md)
-- [HashMap](./hash_map.md)
+<!--- [HashMap](./hash_map.md)
 - [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
 - [Iterable and Iterator](./iterable_and_iterator.md)
 # Concepts II
@@ -541,7 +548,7 @@ Make them do one. -->
 - [Encapsulation](./encapsulation.md)
   - [Implementation Details](./encapsulation/implementation_details.md)
   - [Methods](./encapsulation/methods.md)
-  - [Classes](./encapsulation/classes.md)
+  - [Classes]()(./encapsulation/classes.md)
   - [Implicit Interfaces](./encapsulation/implicit_interfaces.md)
   - [Abstractions](./encapsulation/abstractions.md)
   - [Leaky Abstractions](./encapsulation/leaky_abstractions.md)
@@ -554,7 +561,7 @@ Make them do one. -->
   - [Iterable]()
   - [ArrayList]()
   - [Concurrent Modifications](./loops_iii/concurrent_modifications.md)
-  - [Reasons to go back]() <!-- -->
+  - [Reasons to go back]() <!-- 
 - [Switch III](./switch_iii.md)
   - [Fallthrough](./switch_iii/fallthrough.md)
   - [break](./switch_iii/break.md)
@@ -596,7 +603,7 @@ Make them do one. -->
   - [Pattern]()
 
 # Communication
-<!-- Should cover InputStream and OutputStream - maybe in Files part deux? -->
+<!-- Should cover InputStream and OutputStream - maybe in Files part deux? 
 - [TCP over IP](tcp_over_ip.md)
   - [Sockets](./tcp_over_ip/sockets.md)
   - [Low Level versus High Level](./tcp_over_ip/low_level_versus_high_level.md)
@@ -638,7 +645,7 @@ Make them do one. -->
 - [Pattern Matching]()
   - [Primitive Patterns]()
   - [Record Patterns]()
-
+-->
 <!--
 
 
@@ -865,3 +872,7 @@ multi dimensional arrays
 
 System.console() over Scanner?
 -->
+
+
+
+- [🚧 (More Chapters Planned) 🚧]()

src/generics.md

@@ -1,7 +1,6 @@
 # Generics
 
-Certain types of classes, like growable arrays
-and hash maps, are simply holders of data.
+Certain types of classes, like growable arrays, are simply holders of data.
 
 That is, almost none of how they work has to change to
 store different kinds of data.

src/generics/generic_parameters.md

@@ -0,0 +1,45 @@
+# Inference
+
+Sometimes Java has enough information to know
+what the right values for type variables would be without you
+specifying them.
+
+In these cases you can rely on the compiler to infer them by writing `<>` with no type variables
+in between.
+
+```java
+class Box<T> {
+    T data;
+}
+
+void main() {
+    // It is being assigned to a Box<String> on the left
+    // so Java can figure out what should be on the right.
+    Box<String> boxOfString = new Box<>();
+
+    boxOfString.data = "abc";
+
+    String s = boxOfString.data;
+
+    System.out.println(s);
+}
+```
+
+This inference does not work on the left-hand side of an `=`.
+
+```java,does_not_compile
+class Box<T> {
+    T data;
+}
+
+void main() {
+    // Use var if you want inference for local variables.
+    Box<> boxOfString = new Box<String>();
+
+    boxOfString.data = "abc";
+
+    String s = boxOfString.data;
+
+    System.out.println(s);
+}
+```

src/generics/inference.md

@@ -0,0 +1,23 @@
+# Instantiation
+
+When you make an instance of a class that takes generic parameters
+you are expected to provide the actual concrete types you want to be used
+in place of any type variables.
+
+You do this by writing the name of the types inside a `<>` alongside the call to `new`.
+
+```java
+class Box<T> {
+    T data;
+}
+
+void main() {
+    var boxOfString = new Box<String>();
+
+    boxOfString.data = "abc";
+
+    String s = boxOfString.data;
+
+    System.out.println(s);
+}
+```

src/generics/instantiation.md

@@ -0,0 +1,10 @@
+# Naming
+
+Type variables don't have to be only a single letter, though that is common. If you pick a longer name
+you are generally expected to name them as if they were classes.
+
+```java
+class Box<Data> {
+    Data data;
+}
+```

src/generics/naming.md

@@ -0,0 +1,51 @@
+# Raw Types
+
+If generics are cramping your style, you are
+technically allowed to turn them off.
+
+If you make an instance of a generic class without
+any `<>` we call that a "raw type."
+
+```java
+class Box<T> {
+    T data;
+}
+
+void main() {
+    Box b = new Box();
+}
+```
+
+When you have a raw type you will see `Object` in any place
+you put[^unbounded] a type variable. 
+
+This lets you do whatever you want without the burden of having to make sense to Java.
+
+```java
+class Box<T> {
+    T data;
+}
+
+void main() {
+    Box b = new Box();
+    b.data = 123;
+    b.data = "abc";
+
+    if (b.data instanceof String s) {
+        System.out.println(s);
+    }
+}
+```
+
+Raw types exist for two basic reasons
+
+1. Every now and then Java isn't smart enough. Trust that there are valid reasons to turn off generics, even
+I haven't shown you any yet. Avoid doing so yourself - at least for awhile.
+2. Generics weren't always in Java! Classes that later were made generic had to stay compatible with old "raw"
+usages somehow.
+
+All that is to say: Be aware raw types exist. Make sure you are always putting `<>` otherwise you are falling 
+into that mode. Avoid that mode.
+
+
+[^unbounded]: An "unbounded" type variable to be exact. We'll visit generic bounds later.

src/generics/raw_types.md

@@ -0,0 +1,22 @@
+# Soundness
+
+Even though every `String` is assignable to `Object`, 
+a `Box<String>` is not assignable to `Box<Object>`.
+
+If that was allowed then you could do something like the following.
+
+```java,no_run,does_not_compile
+Box<String> stringBox = new Box<>();
+// This might feel innocent
+Box<Object> objectBox = stringBox;
+// But now we can put anything,
+// like an Integer, in the Box
+objectBox.data = 123;
+// Which is a problem since that affects
+// stringBox as well
+String s = stringBox.data; // But its actually an Integer! Crash!
+```
+
+We call this property - that the types don't let you accidentally make
+silly situations - soundness. Java isn't _fully_ sound, but its sound enough
+for most people.

src/generics/soundness.md

@@ -0,0 +1,25 @@
+# Type Variables
+
+After the name of a class in the class definition you can put one or more "type variables."
+These look like `<` followed by a comma separated list of "type names" and ended by a `>`.
+
+```java,no_run
+class Box<T> {
+
+}
+```
+
+Inside a class definition you can use these type variables on fields, method arguments,
+and method return types.
+
+```java,no_run
+class Box<T> {
+    T data;
+
+    void setData(T newData) {
+        this.data = newData;
+    }
+}
+```
+
+This indicates that you would be okay with any type being used in place of the type variable (in the above code `T`).

src/generics/type_variables.md

@@ -86,31 +86,41 @@ class CarsCharacterHashMap {
         return carsCharacter.lastName().charAt(0);
     }
 
-    void put(CarsCharacter character) {
+    void put(String lastName, CarsCharacter character) {
         // 1. Compute the hash code
-        char hash = hashFunction(character);
+        char hash = hashFunction(lastName);
         // 2. Find the bucket
         Bucket bucket = buckets[indexFor(hash)];
         // 3. Add to the bucket
         bucket.add(character);
     }
+}
 
-    ` get(CarsCharacter character) {
+    CarsCharacter get(String lastName) {
         // 1. Compute the hash code
         char hash = hashFunction(character);
         // 2. Find the bucket
         Bucket bucket = buckets[indexFor(hash)];
-        // 3. Add to the bucket
-        bucket.add(character);
+        // 3. Go through everything in the bucket
+        for (int i = 0; i < bucket.size(); i++) {
+            CarsCharacter inBucket = bucket.get(i);
+            if (inBucket.equals(character)) {
+                return inBucket; // Return any matches
+            }
+        }
+
+        // Null if no matches
+        return null;
     }
 }
 
 void main() {
     var map = new CarsCharacterHashMap();
 
-    map.put(new CarsCharacter("Sally", "Carrera"));
-    map.put(new CarsCharacter("Doc", "Hudson"));
-    map.put(new CarsCharacter("Lightning", "McQueen"));
+    map.put("Carrera", new CarsCharacter("Sally", "Carrera"));
+    map.put("Hudson", new CarsCharacter("Doc", "Hudson"));
+    map.put("McQueen", new CarsCharacter("Lightning", "McQueen"));
+
 
     System.out.println(map.buckets[0].size());
     System.out.println(map.buckets[1].size());