checkpoint

bowbahdoe · bowbahdoe · commit be430e41ba55 · 2025-02-24T14:45:20.000-05:00
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
@@ -138,6 +138,10 @@
   - [Initialization with new](./arrays/initialization_with_new.md)
   - [Challenges](./arrays/challenges.md)
 
+# Projects
+
+- [The Boston Molasses Disaster Game]() <!-- Make sure they know it was because of deregulation -->
+
 # Control Flow II
 
 - [Loops II](./loops_ii.md)
@@ -172,7 +176,6 @@
   - [Challenges](./methods/challenges.md)
 
 - [Arguments](./arguments.md)
-
   - [Declaration](./arguments/declaration.md)
   - [Invocation with Arguments](./arguments/invocation_with_arguments.md)
   - [Reassignment](./arguments/reassignment.md)
@@ -192,6 +195,10 @@
   - [Unreachable Statements](./return_values/unreachable_statements.md)
   - [Challenges](./return_values/challenges.md)
 
+# Projects
+
+- [Tic-Tac-Toe]()
+
 # Data Types III
 
 - [null](./null.md)
@@ -215,6 +222,11 @@
   - [Populate Arrays](./arrays_ii/populate_arrays.md)
   - [Challenges](./arrays_ii/challenges.md)
 
+# Projects II
+
+<!-- https://michaelxing.com/UltimateTTT/v3/ -->
+- [Ultimate Tic-Tac-Toe]()
+
 # Code Structure II
 
 - [Classes](./classes.md)
@@ -597,6 +609,15 @@ Make them do one. -->
   - [Set]()
   - [Arrays](./collections/arrays.md) <!-- Odd duck out, Arrays.asList -->
 - [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
+  - [Declaration](./multi_dimensional_arrays/declaration.md)
+  - [Array Initializers](./multi_dimensional_arrays/array_initializers.md)
+  - [Initialization with new](./multi_dimensional_arrays/initialization_with_new.md)
+  - [Access Individual Elements](./multi_dimensional_arrays/access_individual_elements.md)
+  - [Set Individual Elements](./multi_dimensional_arrays/set_individual_elements.md)
+  - [Initialization with Size](./multi_dimensional_arrays/initialize_with_size.md)
+  - [Default Values](./multi_dimensional_arrays/default_values.md)
+  - [Populate Values](./multi_dimensional_arrays/populate_values.md)
+  - [Ragged Arrays](./multi_dimensional_arrays/ragged_arrays.md)
 
 # Metaprogramming
 
@@ -609,7 +630,9 @@ Make them do one. -->
   - [Get all Methods](./reflection/get_all_methods.md)
   - [Get a Method](./reflection/get_a_method.md)
   - [Invoke a Method](./reflection/invoke_a_method.md)
-  - [Get a Constructor]()
+  - [Get a Constructor](./reflection/get_a_constructor.md)
+  - [Get all Constructors](./reflection/get_all_constructors.md)
+  - [Invoke a Constructor](./reflection/invoke_a_constructor.md)
 
 - [Annotations](./annotations.md)
   - [Declaration](./annotations/declaration.md)
@@ -621,8 +644,8 @@ Make them do one. -->
   - [@Retention](./annotations/retention.md)
   - [Reflective Access](./annotations/reflective_access.md)
   - [@Override](./annotations/override.md)
-  - [@Deprecated](./annotations/deprecated)
-  - [@Repeatable]() <!-- Note: When doing javadoc, write about @Documented -->
+  <!--  - [@Deprecated](./annotations/deprecated)
+  - [@Repeatable]()Note: When doing javadoc, write about @Documented -->
 
 # Concepts III
 
@@ -634,14 +657,26 @@ Make them do one. -->
   - [Elaboration](./abbreviations/elaboration.md)
 
 # Code Structure VII
-- [Interfaces II](./interface_extension.md)
+- [Interfaces II](./interfaces_ii.md)
   - [Default Methods]()
   - [Interface Extension]()
   - [Static Methods]()
   - [Private Static Methods]()
 - [Class Extension](./class_extension.md)
 - [Abstract Classes](./abstract_classes.md)
 
+# Data Types IV
+
+- [Niche Numerics]()
+  - [byte]()
+  - [short]()
+  - [long]()
+  - [Unsigned Operations]()
+  
+# Code Structure VIII
+
+- [Modules](./modules.md)
+
 <!--- [HashMap](./hash_map.md)
 
 
diff --git a/src/classes/the_meaning_of_the_word_class.md b/src/classes/the_meaning_of_the_word_class.md
@@ -11,5 +11,5 @@ it stores. The `String` class would specify all of that.[^heady]
 
 [^idiot]: What an [idiot](https://www.shardcore.org/spx/2015/05/15/diogenes-and-the-chicken/)
 
-[^heady]: If thats a bit too heady of an explanation don't fret. You will likely get it intuitively eventually.
+[^heady]: If that's a bit too heady of an explanation don't fret. You will likely get it intuitively eventually.
 There are like 50 different ways to explain it and eventually one will land for you.
diff --git a/src/collections.md b/src/collections.md
@@ -2,4 +2,5 @@
 
 Arrays, `ArrayList`, and `HashMap` are all "collections"
 of objects. Importantly, they also aren't the only possible
-kinds of collections.
+kinds of collections.
+
diff --git a/src/collections/arrays.md b/src/collections/arrays.md
@@ -1,6 +1,6 @@
 # Arrays
 
-Arrays are the odd duck out in the world of collections. They are basically a `List` but aren't `List`s.
+Arrays are the odd duck out in the world of collections. They are basically a `List` but aren't `List`s.[^history]
 
 You can make a `List` which is a view over an array with `Arrays.asList`.
 
@@ -66,4 +66,7 @@ class Main {
         furnitureList.add("Shelf");
     }
 }
-```
+```
+
+[^history]: Arrays are unique beasts. This is true both in Java the language and in the virtual machine Java code runs on.
+This is partially attributable to arrays coming first in the history - `List` and friends were not in the first version of Java.
diff --git a/src/inner_classes/new_operator.md b/src/inner_classes/new_operator.md
@@ -9,7 +9,7 @@ something like `new ClassName()`, you can make an instance of an
 inner class by using `.new` on a variable that holds an instance
 of the containing class.
 
-Thats a confusing verbal description, but it kinda makes sense once you see it.
+That's a confusing verbal description, but it kinda makes sense once you see it.
 
 ```java
 class Car {
diff --git a/src/interfaces_ii.md b/src/interfaces_ii.md
@@ -0,0 +1,2 @@
+# Interfaces II
+
diff --git a/src/modules.md b/src/modules.md
@@ -0,0 +1 @@
+# Modules
diff --git a/src/multi_dimensional_arrays/access_individual_elements.md b/src/multi_dimensional_arrays/access_individual_elements.md
@@ -0,0 +1,23 @@
+# Access Individual Elements
+
+Accessing an element in a multi-dimensional array works the same as
+accessing the elements of a one-dimensional array. 
+
+Each time you index into it you will get out another array, so you just keep writing `[]` until
+you've drilled down to an individual element.
+
+```java
+~void main() {
+String[][] ticTacToe = {
+    { "O", "",  "O" },
+    { "X", "O", "X" },
+    { "O", "X", "X" }
+}
+
+System.out.println(ticTacToe[2][1]);
+
+// This is equivalent to the above
+String[] row = ticTacToe[2];
+System.out.println(row[1]);
+~}
+```
diff --git a/src/multi_dimensional_arrays/array_initializers.md b/src/multi_dimensional_arrays/array_initializers.md
@@ -0,0 +1,16 @@
+# Array Initializers
+
+To give an initial value to a multi-dimensional array you can use multiple nested
+array initializers.
+
+These are the same as normal array initializers but with potentially more initializers inside.[^moray]
+
+```java,no_run
+String[][] ticTacToe = {
+    { "O", "",  "O" },
+    { "X", "O", "X" },
+    { "O", "X", "X" }
+}
+```
+
+[^moray]: When array initizalize and more initialize inside that's a moray.
diff --git a/src/multi_dimensional_arrays/declaration.md b/src/multi_dimensional_arrays/declaration.md
@@ -0,0 +1,16 @@
+# Declaration
+
+Declaring a multi-dimensional array is similar to declaring a normal array.
+
+The difference is that instead of only one `[]` following the type declaration, you add an extra `[]`
+for each extra dimension.
+
+```java,no_run
+// 2d array
+int[][] grid;
+// 3d array
+int[][][] cube;
+// 4d array
+int[][][][] hypercube;
+// ... and so on
+```
diff --git a/src/multi_dimensional_arrays/default_values.md b/src/multi_dimensional_arrays/default_values.md
@@ -0,0 +1,19 @@
+# Default Values
+
+When a multi-dimensional array is made by just providing a size, its elements
+are initialized to the same default values as they would be in a regular array.
+
+The difference is that each "nested array" will not be initialized to null.
+
+```java
+~void main() {
+String[][] ticTacToe = new String[3][3];
+
+// Each array will be non-null
+System.out.println(ticTacToe[0]);
+
+// But the elements of those arrays will be null
+// (or whatever the default value is for the type.)
+System.out.println(ticTacToe[0][0]);
+~}
+```
diff --git a/src/multi_dimensional_arrays/initialization_with_new.md b/src/multi_dimensional_arrays/initialization_with_new.md
@@ -0,0 +1,14 @@
+# Initialization with new
+
+Just like for one-dimensional arrays, adding `new` and the type of the array before an initializer
+will let you use a multi-dimensional array as an expression or for a delayed assignment.
+
+```java
+~void main() {
+int[][] numbers;
+numbers = new int[25][25];
+
+// I think 25 is my favorite number
+int length = (new int[25][25] {}).length;
+~}
+```
diff --git a/src/multi_dimensional_arrays/initialize_with_size.md b/src/multi_dimensional_arrays/initialize_with_size.md
@@ -0,0 +1,11 @@
+# Initialization with Size
+
+Multi-dimensional arrays are used for representing multi-dimensional things.
+These tend to also be large things for which writing out every value in an initializer is impractical.
+
+As such, you can initialize them with only an initial size for each dimension.
+
+```java
+// Will make a 2d array of 160x144 booleans
+boolean[][] pixels = new boolean[160][144];
+```
diff --git a/src/multi_dimensional_arrays/populate_values.md b/src/multi_dimensional_arrays/populate_values.md
@@ -0,0 +1,20 @@
+# Populate Values
+
+Once you've created a multi-dimensional array you can use loops
+to give initial values to its elements.
+
+Since you will end up nesting these loops, its a good example of a place where you should progress
+naming your variables `i -> j -> k`.
+
+```java
+// If you prefer true as the default over false
+// you need to do that work yourself
+boolean[][] booleanField = new boolean[25][25];
+for (int i = 0; i < booleanField.length; i++) {
+    for (int j = 0; j < booleanField[i].length; j++) {
+        booleanField[i][j] = true;
+    }
+}
+```
+
+This is helpful if the default values (`null`, `0`, `false`, etc.) are not what you'd prefer
diff --git a/src/multi_dimensional_arrays/ragged_arrays.md b/src/multi_dimensional_arrays/ragged_arrays.md
@@ -0,0 +1,42 @@
+# Ragged Arrays
+
+In relatively unique circumstances[^alreadyunique] you might want to make a "ragged array". That is, a multi-dimensional
+array where each array might be of a different size.
+
+You can do this by making the number of elements in nested initializers be different
+```java
+boolean[][] triangle = {
+    { false },
+    { false, false, false},
+    { false, false, false, false, false },
+    { false, false, false},
+    { false }
+}
+```
+
+Or by using arrays initialized with `new` inside of an initializer.
+
+```java,no_run
+boolean[][] triangle = {
+    new boolean[1],
+    new boolean[3],
+    new boolean[5],
+    new boolean[3],
+    new boolean[1]
+};
+```
+
+Or even by omitting the trailing dimensions on when initializing with new and later filling in each row.
+
+```java,no_run
+boolean[][] triangle = new boolean[5][];
+triangle[0] = new boolean[1];
+triangle[1] = new boolean[3];
+triangle[2] = new boolean[5];
+triangle[3] = new boolean[3];
+triangle[4] = new boolean[1];
+```
+
+
+
+[^alreadyunique]: And if you are using a multi-dimensional array, you are already doing something interesting.
diff --git a/src/multi_dimensional_arrays/set_individual_elements.md b/src/multi_dimensional_arrays/set_individual_elements.md
@@ -0,0 +1,18 @@
+# Set Individual Elements
+
+You can set the value for elements in a multi-dimensional array the same way
+as for one-dimensional arrays, just with an extra `[]` for each extra dimension.
+
+```java
+String[][] ticTacToe = {
+    { "", "", "" },
+    { "", "", "" },
+    { "", "", "" }
+}
+
+ticTacToe[0][0] = "X";
+
+// The above is a shorthand for this
+String[] row = ticTacToe[0];
+row[1] = "O";
+```
diff --git a/src/reflection/get_a_constructor.md b/src/reflection/get_a_constructor.md
diff --git a/src/reflection/get_a_method.md b/src/reflection/get_a_method.md
diff --git a/src/reflection/get_all_constructors.md b/src/reflection/get_all_constructors.md
diff --git a/src/reflection/get_all_fields.md b/src/reflection/get_all_fields.md
diff --git a/src/reflection/get_all_methods.md b/src/reflection/get_all_methods.md
diff --git a/src/reflection/invoke_a_constructor.md b/src/reflection/invoke_a_constructor.md
diff --git a/src/reflection/invoke_a_method.md b/src/reflection/invoke_a_method.md
diff --git a/src/reflection/write_to_a_field.md b/src/reflection/write_to_a_field.md

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`# Arrays`
`2`	`2`
`3`		-Arrays are the odd duck out in the world of collections. They are basically a `List` but aren't `List`s.
	`3`	+Arrays are the odd duck out in the world of collections. They are basically a `List` but aren't `List`s.[^history]
`4`	`4`
`5`	`5`	You can make a `List` which is a view over an array with `Arrays.asList`.
`6`	`6`
`@@ -66,4 +66,7 @@ class Main {`
`66`	`66`	`furnitureList.add("Shelf");`
`67`	`67`	`}`
`68`	`68`	`}`
`69`		-```
	`69`	+```
	`70`	`+`
	`71`	`+[^history]: Arrays are unique beasts. This is true both in Java the language and in the virtual machine Java code runs on.`
	`72`	+This is partially attributable to arrays coming first in the history - `List` and friends were not in the first version of Java.