Checkpoint

Author: bowbahdoe

src/SUMMARY.md

@@ -606,11 +606,15 @@ Make them do one. -->
 # Data Types VI
 
 - [Collections](./collections.md)
-  - [Collection]()
-  - [List]()
-  - [Map]()
-  - [Set]()
+  - [List](./collections/list.md)
+  - [Map](./collections/map.md)
+  - [Set](./collections/set.md)
   - [Arrays](./collections/arrays.md) <!-- Odd duck out, Arrays.asList -->
+  - [UnsupportedOperationException](./collections/unsupported_operation_exception.md)
+  - [Factories](./collections/factories.md)
+  - [Specificity](./collections/specificity.md)
+
+
 - [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
   - [Declaration](./multi_dimensional_arrays/declaration.md)
   - [Array Initializers](./multi_dimensional_arrays/array_initializers.md)
@@ -664,21 +668,22 @@ Make them do one. -->
 # Code Structure VII
 - [Interfaces II](./interfaces_ii.md)
   - [Default Methods](./interfaces_ii/default_methods.md)
-  - [Interface Extension]()
-  - [Static Methods]()
-  - [Private Static Methods]()
+  - [Interface Extension](./interfaces_ii/interface_extension.md)
+  - [Static Methods](./interfaces_ii/static_methods.md)
+  - [Static Fields](./interfaces_ii/static_fields.md)
 - [Class Extension](./class_extension.md)
-  - [Extend a Class]()
-  - [Protected Fields]()
-  - [Protected Methods]()
-  - [Relation to Interfaces]()
-  - [Relation to Encapsulation]()
+  - [Extend a Class](./class_extension/extend_a_class.md)
+  - [Inheritance](./class_extension/inheritance.md)
+  - [Override](./class_extension/override.md)
+  - [Protected](./class_extension/protected.md)
+  - [Abstract Classes](./class_extension/abstract_classes.md)
+  - [Abstract Methods](./class_extension/abstract_methods.md)
+  - [Relation to Interfaces](./class_extension/relation_to_interfaces.md)
+  - [Relation to Encapsulation](./class_extension/relation_to_encapsulation.md)
   - [Final Classes](./class_extension/final_classes.md)
-- [Abstract Classes](./abstract_classes.md)
-  - [Relation to Interfaces]()
 
 
-# Data Types IV
+# Data Types VII
 
 - [Niche Numerics](./niche_numerics.md)
   - [byte](./niche_numerics/byte.md)
@@ -698,6 +703,22 @@ Make them do one. -->
   - [The Unnamed Module](./modules/the_unnamed_module.md)
   - [Module Imports](./modules/module_imports.md)
   - [Multi-Module Directory Layout]()
+- [Lambdas](./lambdas.md)
+  - [Functional Interfaces](./lambdas/functional_interfaces.md)
+  - [@FunctionalInterface](./lambdas/functional_interface_annotation.md)
+- [Streams]()
+
+# Sharing Code
+
+- [Compilation](./compilation.md)
+  - [javac]()
+- [Packaging]()
+  - [jar]()
+- [Documentation]()
+  - [javadoc]()
+  - [Documentation Comments](./documentation/documentation_comments.md)
+- [Distribution]()
+  - [jlink]()
 
 <!--- 
 PROJECT IDEAS:
@@ -764,10 +785,6 @@ PROJECT IDEAS:
   - [Primitive Patterns]()
   - [Record Patterns]()
 
-# Code Structure VII
-
-- [Modules]()
-
 -->
 <!--
 
@@ -836,11 +853,9 @@ Generics
 Maven
 XML
 Pom
-byte, short, long
 Multiversal Equality
 Reflection
     Cover Invoking *public* constructs
-Annotations
 Javadoc and Documentation comments
 -->
 

src/abstract_classes.md

@@ -1,2 +1,9 @@
 # Class Extension
 
+Just like interfaces can extend other interfaces, classes can extend other classes.
+
+```java
+class BodyOfWater {}
+
+class Ocean extends BodyOfWater {}
+```

src/class_extension.md

@@ -0,0 +1,50 @@
+# Abstract Classes
+
+Abstract classes are classes which you cannot make an instance of directly.[^concrete]
+
+```java,does_not_compile
+abstract class Plant {}
+
+void main() {
+    // You cannot make an instance because 
+    // it is an abstract class.
+    var p = new Plant();
+}
+```
+
+The use-case for these is making classes which are designed to be subclassed.
+An example of this that comes with Java is `AbstractList`. 
+
+`AbstractList` defines most of the methods required by the `List` interface and is intended to
+lower the effort required to make a custom `List` implementation.
+
+```java
+import java.util.AbstractList;
+
+// This subclass is a List containing the numbers 5 and 7
+class FiveAndSeven 
+    // Almost all of the implementation is inherited from AbstractList
+    extends AbstractList<Integer> {
+
+    @Override
+    public Integer get(int index) {
+        return switch (index) {
+            case 0 -> 5;
+            case 1 -> 7;
+            default -> throw new IndexOutOfBoundsException();
+        };
+    }
+
+    @Override
+    public int size() {
+        return 2;
+    }
+}
+
+void main() {
+    var l = new FiveAndSeven();
+    IO.println(l);
+}
+```
+
+[^concrete]: "Abstract" as a term here means something close to "not in reality." You will hear people refer to non-abstract classes as "concrete" classes.

src/class_extension/abstract_classes.md

@@ -0,0 +1,74 @@
+# Abstract Methods
+
+Methods on an `abstract` class may themselves be marked `abstract`.
+
+```java
+abstract class BodyOfWater {
+    long depth;
+
+    BodyOfWater(long depth) {
+        if (this.depth < 0) {
+            throw new IllegalArgumentException();
+        }
+        this.depth = depth;
+    }
+
+    // All classes which extend BodyOfWater must
+    // define what happens when you swim.
+    abstract void swim();
+}
+```
+
+Any non-abstract class extending from an `abstract` class must give a definition
+for `abstract` methods.
+
+```java
+abstract class BodyOfWater {
+    long depth;
+
+    BodyOfWater(long depth) {
+        if (this.depth < 0) {
+            throw new IllegalArgumentException();
+        }
+        this.depth = depth;
+    }
+
+    abstract void swim();
+}
+
+class Lake extends BodyOfWater {
+    // If you didn't define this it wouldn't work
+    @Override
+    void swim() {
+        IO.println("Relaxing time");
+    }
+}
+```
+
+But if an abstract class is being extended by another abstract class, you don't need to.
+
+```java,no_run
+abstract class Liquid {
+    abstract double viscosity();
+}
+
+// Water doesn't need to define volume()
+// because Water is abstract
+abstract class Water extends Liquid {
+    abstract double purity();
+}
+
+// But as soon as you get to a "concrete" implementation
+// you need to provide definitions
+class TownWater extends Water {
+    @Override
+    double viscosity() {
+        return 0.01;
+    }
+
+    @Override
+    double purity() {
+        return 0.99;
+    }
+}
+```

src/class_extension/abstract_methods.md

@@ -0,0 +1,47 @@
+# Extend a Class
+
+For a class to extend another one you need to write `extends` and then the name of the class
+which is being extended.
+
+```java
+class BodyOfWater {}
+
+class Ocean extends BodyOfWater {}
+```
+
+If the class being extended has non-zero argument constructors,
+the subclass must pass arguments to those constructors in it's constructor
+using `super()`.
+
+```java
+class BodyOfWater {
+    long depth;
+
+    BodyOfWater(long depth) {
+        if (this.depth < 0) {
+            throw new IllegalArgumentException();
+        }
+        this.depth = depth;
+    }
+}
+
+class Ocean extends BodyOfWater {
+    String name;
+
+    Ocean(String name, long depth) {
+        this.name = name;
+        // Before you exit, you must pass 
+        // arguments to the super-class constructor.
+        super(depth);
+    }
+}
+
+void main() {
+    Ocean pacific = new Ocean("Pacific", 36201L);
+    IO.println(
+        "The " + pacific.name + 
+        " ocean is " + pacific.depth + 
+        "' deep."
+    );
+}
+```

src/class_extension/extend_a_class.md

@@ -1 +1,42 @@
 # Final Classes
+
+If a class is marked `final` it cannot be extended.
+
+```java,does_not_compile
+final class Apple {}
+
+// Cannot extend a final class
+class RedApple extends Apple {}
+~void main() {}
+```
+
+Because thinking about what the implications are if someone extends a class is hard,
+it is reasonable to always declare your classes as `final` unless you have some reason not to.
+
+```java
+// It's not that something bad would happen if someone
+// extended this class. It's that not having to think
+// about it is useful.
+final class Saltine {
+    int saltiness;
+
+    Saltine(int saltiness) {
+        this.saltiness = saltiness;
+    }
+}
+```
+
+Records and Enums are always implicitly final.
+
+```java,does_not_compile
+record Pos(int x, int y) {}
+
+// Records are final
+class Pos2 extends Pos {}
+
+enum StopLight { RED, YELLOW, GREEN }
+
+// Enums are final
+class StopLight2 extends StopLight {}
+~class Main {void main() {}}
+```

src/class_extension/final_classes

@@ -0,0 +1,43 @@
+# Inheritance
+
+When one class extends another we say that it is "inheriting"
+from the superclass.
+
+What this means is that all the fields and methods of the class being extended
+carry over into the extending class.
+
+```java
+class BodyOfWater {
+    long depth;
+
+    BodyOfWater(long depth) {
+        if (this.depth < 0) {
+            throw new IllegalArgumentException();
+        }
+        this.depth = depth;
+    }
+
+    void swim() {
+        if (depth > 50) {
+            IO.println("You have drowned");
+        }
+        else {
+            IO.println("You are fine");
+        }
+    }
+}
+
+class Ocean extends BodyOfWater {
+    String name;
+
+    Ocean(String name, long depth) {
+        this.name = name;
+        super(depth);
+    }
+}
+
+void main() {
+    BodyOfWater pacific = new Ocean("Pacific", 36201L);
+    pacific.swim(); // The swim method is "inherited"
+}
+```