citiesStream = cities.stream()
+ .filter(city -> !city.startsWith("S"));
+
+// Dallas, London, Tokyo
+citiesStream.forEach(IO::println);
+
+// java.lang.IllegalStateException: stream has already been operated upon or closed
+citiesStream.forEach(IO::println);
+~}
+```
\ No newline at end of file
diff --git a/src/string_builder.md b/src/string_builder.md
new file mode 100644
index 00000000..efc1a74f
--- /dev/null
+++ b/src/string_builder.md
@@ -0,0 +1,19 @@
+# StringBuilder
+
+When you add `String`s together, the result is a new `String`.
+
+```java
+void main() {
+ String a = "a";
+ String b = "b";
+ String ab = a + b;
+
+ IO.println(ab);
+}
+```
+
+This is perfectly fine and what you would expect, but if you are adding strings
+together in a loop it can become an issue.
+
+```java
+```
\ No newline at end of file
diff --git a/src/stringbuilder.md b/src/stringbuilder.md
new file mode 100644
index 00000000..5c972348
--- /dev/null
+++ b/src/stringbuilder.md
@@ -0,0 +1,47 @@
+# StringBuilder
+
+`String`s cannot be changed in place. This means that every operation
+on a `String` needs to produce a brand new `String` as a result.
+
+Normally this is fine, but when you do something like that in a loop
+it can become a performance problem.
+
+```java
+String removeAllNumbers(String input) {
+ String result = "";
+ for (int i = 0; i < input.length(); i++) {
+ char c = input.charAt(i);
+ if (c < '0' || c > '9') {
+ result = result + c;
+ }
+ }
+ return result;
+}
+
+void main() {
+ String screenplay = "5".repeat(1000000);
+ // There are 1301 characters in the above text, meaning this method
+ // does around that many copies of the string
+ IO.println(removeAllNumbers(screenplay));
+}
+```
+
+```java
+String removeAllNumbers(String input) {
+ StringBuilder result = new StringBuilder();
+ for (int i = 0; i < input.length(); i++) {
+ char c = input.charAt(i);
+ if (c < '0' || c > '9') {
+ result.append(c);
+ }
+ }
+ return result.toString();
+}
+
+void main() {
+ String screenplay = "5".repeat(1000000);
+ // There are 1301 characters in the above text, meaning this method
+ // does around that many copies of the string
+ IO.println(removeAllNumbers(screenplay));
+}
+```
\ No newline at end of file
diff --git a/src/strings.md b/src/strings.md
index 0a64c462..83e3b730 100644
--- a/src/strings.md
+++ b/src/strings.md
@@ -1,5 +1,8 @@
# Strings
+
+
+
The `String` data type is used to represent text.
```java,no_run
diff --git a/src/strings/access_individual_characters.md b/src/strings/access_individual_characters.md
index 336cbfbe..c1f2978b 100644
--- a/src/strings/access_individual_characters.md
+++ b/src/strings/access_individual_characters.md
@@ -11,16 +11,16 @@ The second by using `1`, and so on.
String spy = "loid";
char l = spy.charAt(0);
-System.out.println(l);
+IO.println(l);
char o = spy.charAt(1);
-System.out.println(o);
+IO.println(o);
char i = spy.charAt(2);
-System.out.println(i);
+IO.println(i);
char d = spy.charAt(3);
-System.out.println(d);
+IO.println(d);
~}
```
@@ -34,7 +34,7 @@ String assassin = "yor";
int indexOfR = 2;
char r = assassin.charAt(indexOfR);
-System.out.println(r);
+IO.println(r);
~}
```
diff --git a/src/strings/challenges.md b/src/strings/challenges.md
index 2a115a22..b0a5da78 100644
--- a/src/strings/challenges.md
+++ b/src/strings/challenges.md
@@ -15,7 +15,7 @@ void main() {
String second = "2";
String result = first + second;
- System.out.println(result);
+ IO.println(result);
}
```
@@ -28,7 +28,7 @@ void main() {
String first = "1";
int second = 2;
- System.out.println(first + second);
+ IO.println(first + second);
}
```
@@ -43,7 +43,7 @@ void main() {
String second = "b";
String third = "ab";
- System.out.println((first + second).equals(second));
+ IO.println((first + second).equals(third));
}
```
@@ -59,7 +59,7 @@ void main() {
char a = 'a';
char b = 'b';
char c = 'c';
- System.out.println(a + b + c);
+ IO.println(a + b + c);
}
```
@@ -78,19 +78,19 @@ void main() {
int index = 6;
- System.out.print(racecar.charAt(index));
+ IO.print(racecar.charAt(index));
index += diff;
- System.out.print(racecar.charAt(index));
+ IO.print(racecar.charAt(index));
index += diff;
- System.out.print(racecar.charAt(index));
+ IO.print(racecar.charAt(index));
index += diff;
- System.out.print(racecar.charAt(index));
+ IO.print(racecar.charAt(index));
index += diff;
- System.out.print(racecar.charAt(index));
+ IO.print(racecar.charAt(index));
index += diff;
- System.out.print(racecar.charAt(index));
+ IO.print(racecar.charAt(index));
index += diff;
- System.out.println(racecar.charAt(index));
+ IO.println(racecar.charAt(index));
}
```
diff --git a/src/strings/common_escape_sequences.md b/src/strings/common_escape_sequences.md
index 3199d90d..98611208 100644
--- a/src/strings/common_escape_sequences.md
+++ b/src/strings/common_escape_sequences.md
@@ -21,11 +21,11 @@ String title = "The \"Honorable\" Judge Judy";
Since the backslash is used to escape characters, it too needs to escaped
in order to have it be in a `String`. So to encode `Β―\_(γ)_/Β―` into a String
-you need to escape the first backslash.
+you need to escape the first backslash.[^forwardslash]
```java
~void main() {
-// The first backslash needs to be escaped. Β―\_(γ)_/Β―
+// The backslash needs to be escaped. Β―\_(γ)_/Β―
String shruggie = "Β―\\_(γ)_/Β―";
~}
```
@@ -37,3 +37,5 @@ And much the same as with `char`, you need to use `\n` to write in a newline.
String letter = "To Whom It May Concern,\n\nI am writing this letter to complain.";
~}
```
+
+[^forwardslash]: We call `\` a "backslash" and `/` a "forward slash." In `Β―\_(γ)_/Β―` the left arm is drawn using the backslash and the right arm with a forward slash. What makes left "backwards" and right "forwards" is just social norms.
\ No newline at end of file
diff --git a/src/strings/concatenation.md b/src/strings/concatenation.md
index d78e560b..6e7169e9 100644
--- a/src/strings/concatenation.md
+++ b/src/strings/concatenation.md
@@ -9,7 +9,7 @@ String llo = "llo";
String hello = he + llo;
-System.out.println(hello);
+IO.println(hello);
~}
```
@@ -27,6 +27,6 @@ double dollars = 1.52;
String message = "I have " + numberOfApples +
" apples and $" + dollars + " in my pocket.";
-System.out.println(message);
+IO.println(message);
~}
```
diff --git a/src/strings/equality.md b/src/strings/equality.md
index 8d13b24e..034188ec 100644
--- a/src/strings/equality.md
+++ b/src/strings/equality.md
@@ -10,8 +10,8 @@ String lyricTwo = "Green, Green, Dress";
boolean areSameLyric = lyricOne.equals(lyricTwo);
boolean isMyName = lyricOne.equals("Bop Bop");
-System.out.println(areSameLyric);
-System.out.println(isMyName);
+IO.println(areSameLyric);
+IO.println(isMyName);
~}
```
@@ -28,6 +28,10 @@ String wow = "WOW";
boolean areNotSame = !bow.equals(wow);
-System.out.println(areNotSame);
+IO.println(areNotSame);
~}
```
+
+Note that you should **not** use `==`. Java will let you do it but you won't get what you expect.[^inaway]
+
+[^inaway]: It is confusing in a way that we aren't ready to explain yet. Just remember for `int`, `double`, `char`, etc. you can use `==`. For `String` use `.equals`.
diff --git a/src/strings/header.png b/src/strings/header.png
new file mode 100644
index 00000000..988d4136
Binary files /dev/null and b/src/strings/header.png differ
diff --git a/src/strings/length.md b/src/strings/length.md
index 75d09553..2a434002 100644
--- a/src/strings/length.md
+++ b/src/strings/length.md
@@ -8,8 +8,8 @@ String fruit = "strawberry";
int numberOfChars = fruit.length();
// strawberry is 10 characters long
-System.out.println(
- fruit + " is " numberOfChars + " characters long"
+IO.println(
+ fruit + " is " + numberOfChars + " characters long"
);
~}
```
diff --git a/src/strings_ii.md b/src/strings_ii.md
index 981c15da..bc002fab 100644
--- a/src/strings_ii.md
+++ b/src/strings_ii.md
@@ -1 +1,10 @@
# Strings II
+
+
+
+
+If you haven't already, you will eventually realize that `String`s are
+one of the most common data types you will use.
+
+As such, its worth it to keep revisiting the things you can do with them.
+Expect more sections like this the deeper you get.
\ No newline at end of file
diff --git a/src/strings_ii/UPPERCASE.md b/src/strings_ii/UPPERCASE.md
new file mode 100644
index 00000000..db62fc13
--- /dev/null
+++ b/src/strings_ii/UPPERCASE.md
@@ -0,0 +1,28 @@
+# UPPERCASE
+
+Similarly, if you have a `String` which potentially contains lower-cased letters, you can get a new `String` with everything
+transformed into upper-case using the `.toUpperCase()` method.
+
+```java
+void main() {
+ String message = "Happy Valentines Day";
+
+ String upperCased = message.toUpperCase();
+ IO.println(upperCased);
+}
+```
+
+This does not change the original `String` in place. It just makes a new `String` with all upper-case letters.
+
+Much like with `.toLowerCase()` you can optionally provide a `Locale` to get consistent behavior
+no matter what language the system is set to.
+
+```java
+void main() {
+ String message = "Happy Valentines Day";
+
+ // Same as above, no matter what.
+ String upperCased = message.toUpperCase(Locale.US);
+ IO.println(upperCased);
+}
+```
\ No newline at end of file
diff --git a/src/strings_ii/challenges.md b/src/strings_ii/challenges.md
new file mode 100644
index 00000000..1503c5dc
--- /dev/null
+++ b/src/strings_ii/challenges.md
@@ -0,0 +1,113 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Write a method named `isUpperCase` which tells you if a
+given `String` is already made of all upper-case characters.
+
+Hint: One way to do this is to call `.toUpperCase` and check
+if the result is the same as the input you were given.
+
+```java,editable
+boolean isUpperCase(String s) {
+ // -----------
+ // CODE HERE
+ // -----------
+}
+
+void main() {
+ // true
+ IO.println(isUpperCase("ABC"));
+ // false
+ IO.println(isUpperCase("abc"));
+ // false
+ IO.println(isUpperCase("AbC"));
+}
+```
+
+## Challenge 2.
+
+Do the same as above, but check if a given `String` is
+made of all lower case letters.
+
+```java,editable
+boolean isLowerCase(String s) {
+ // -----------
+ // CODE HERE
+ // -----------
+}
+
+void main() {
+ // false
+ IO.println(isLowerCase("ABC"));
+ // true
+ IO.println(isLowerCase("abc"));
+ // false
+ IO.println(isLowerCase("AbC"));
+}
+```
+
+## Challenge 3.
+
+Add an instance method named `scream` to the `Muppet` class. This
+should replace the name of the muppet with the name in upper case
+letters + an exclamation point (`!`) at the end.
+
+```java,editable
+class Muppet {
+ String name;
+
+ // -------------
+ // CODE HERE
+ // -------------
+}
+
+void main() {
+ var kermit = new Muppet();
+ kermit.name = "kermit";
+
+ // kermit
+ IO.println(kermit.name);
+
+ // KERMIT!
+ kermit.scream();
+ IO.println(kermit.name);
+}
+```
+
+## Challenge 4.
+
+Write a method called `echo`.
+
+If `echo` is given a non-blank `String`, it should print `You Said: <...>`
+where `<...>` is the `String` they
+gave minus any leading or trailing whitespace.
+
+If `echo` is given a `blank` `String`, it should print `You Didn't Say Anything`.
+
+```java,editable
+void echo(String s) {
+ // -------------
+ // CODE HERE
+ // -------------
+}
+
+void main() {
+ // You Said: Hello
+ echo("Hello");
+
+ // You Said: Hello
+ echo(" Hello ");
+
+ // You Didn't Say Anything
+ echo("");
+
+ // You Didn't Say Anything
+ echo(" ");
+}
+```
\ No newline at end of file
diff --git a/src/strings_ii/check_if_blank.md b/src/strings_ii/check_if_blank.md
new file mode 100644
index 00000000..ab31bcf6
--- /dev/null
+++ b/src/strings_ii/check_if_blank.md
@@ -0,0 +1,22 @@
+# Check if blank
+
+You can check if a `String` is blank by using the `.isBlank` method.
+
+The difference is that an empty `String` has actually zero characters. A blank `String` can have characters, so long as those characters are what we would consider whitespace.
+That is, things like spaces and newlines.
+
+```java
+void main() {
+ String brainSounds = """
+
+
+
+ """;
+
+ // false
+ IO.println(brainSounds.isEmpty());
+
+ // true
+ IO.println(brainSounds.isBlank());
+}
+```
\ No newline at end of file
diff --git a/src/strings_ii/check_if_empty.md b/src/strings_ii/check_if_empty.md
new file mode 100644
index 00000000..5edfa58f
--- /dev/null
+++ b/src/strings_ii/check_if_empty.md
@@ -0,0 +1,30 @@
+# Check if empty
+
+You can check if a `String` is empty in a few ways.
+
+The one you should already have been able to figure out[^noshame] is that you can get the `.length` of a `String`
+and see if that is zero.
+
+```java
+void main() {
+ String textMessages = "";
+ IO.println(
+ textMessages.length() == 0
+ );
+}
+```
+
+But another is to use the explicitly defined `.isEmpty()` method.
+
+```java
+void main() {
+ String textMessages = "";
+ IO.println(
+ textMessages.isEmpty()
+ );
+}
+```
+
+This can be more convenient. Both to write, as it is fewer characters to type, and to read later on.
+
+[^noshame]: Again, no shame if not. I didn't exactly call attention to it.
\ No newline at end of file
diff --git a/src/strings_ii/equality_ignoring_case.md b/src/strings_ii/equality_ignoring_case.md
new file mode 100644
index 00000000..f7abc7b9
--- /dev/null
+++ b/src/strings_ii/equality_ignoring_case.md
@@ -0,0 +1,19 @@
+# Equality ignoring case
+
+If you want to check if two `String`s contain the same contents
+but you do not care if those contents differ in the casing of letters, you can use the `.equalsIgnoreCase`
+method.
+
+```java
+void main() {
+ String historicalFigureOne = "St. Valentines";
+ String historicalFigureTwo = "st. valentines";
+
+ IO.println(
+ historicalFigureOne.equalsIgnoreCase(historicalFigureTwo)
+ );
+}
+```
+
+This is different from the result the `.equals` method will give you. That method will return `false` if there
+are any differences in the two `String`s.
\ No newline at end of file
diff --git a/src/strings_ii/header.png b/src/strings_ii/header.png
new file mode 100644
index 00000000..1f22864b
Binary files /dev/null and b/src/strings_ii/header.png differ
diff --git a/src/strings_ii/lowercase.md b/src/strings_ii/lowercase.md
new file mode 100644
index 00000000..7672c327
--- /dev/null
+++ b/src/strings_ii/lowercase.md
@@ -0,0 +1,42 @@
+# lowercase
+
+In English, letters can be either lower-cased (`a`, `b`, `c`) or upper-cased (`A`, `B`, `C`).
+
+If you have a `String` which potentially contains upper-cased letters, you can get a new `String` with everything
+transformed into lower-case using the `.toLowerCase()` method.
+
+```java
+void main() {
+ String message = "Happy Valentines Day";
+
+ String lowerCased = message.toLowerCase();
+ IO.println(lowerCased);
+}
+```
+
+This does not change the original `String` in place. It just makes a new `String` with all lower-case letters.
+
+Many other languages also have a distinction between upper-case and lower-case and, usually, `.toLowerCase()` does the "right thing" for them.
+
+```java
+~void main() {
+// Cyrillic
+IO.println("ΠΠ ΠΠΠΠ’".toLowerCase()); // prints "ΠΏΡΠΈΠ²Π΅Ρ"
+~}
+```
+
+In different languages the mapping between upper-case and lower-case letters can differ.
+
+For example, in Turkish the lower-case form of the letter `I` is `Δ±` and not `i`.
+By default, Java uses the rules for the language of the computer it is running on.
+So `"I".toLowerCase()` will return `"i"` on an English system and `"Δ±"` on a Turkish one.
+
+To get behavior that is consistent regardless of the machine it is being run on,
+you can use an explicit `Locale`.
+
+```java
+~void main() {
+IO.println("I".toLowerCase(Locale.US)); // i - on every computer
+IO.println("I".toLowerCase(Locale.forLanguageTag("tr-TR"))); // Δ± - on every computer
+~}
+```
diff --git a/src/strings_ii/strip_extra_whitespace.md b/src/strings_ii/strip_extra_whitespace.md
new file mode 100644
index 00000000..5fd937ac
--- /dev/null
+++ b/src/strings_ii/strip_extra_whitespace.md
@@ -0,0 +1,39 @@
+# Strip extra whitespace
+
+If you have a `String` which might contain some "trailing" whitespace or "leading"
+whitespace, you can remove that by using the `.strip` method.
+
+This will give a new `String` with both the leading and trailing whitespace removed.
+
+```java
+void main() {
+ String message = " Happy Valentines Day. ";
+
+ IO.print(message.strip());
+ IO.println("|");
+}
+```
+
+If you want to just remove the leading whitespace, you can use `.stripLeading`.
+
+```java
+void main() {
+ String message = " Happy Valentines Day. ";
+
+ IO.print(message.stripLeading());
+ IO.println("|");
+}
+```
+
+And to remove only trailing whitespace, `.stripTrailing`.
+
+```java
+void main() {
+ String message = " Happy Valentines Day. ";
+
+ IO.print(message.stripTrailing());
+ IO.println("|");
+}
+```
+
+All of these methods are useful when you get input from human beings. Humans are generally pretty bad at seeing if they hit the spacebar one too many times.
diff --git a/src/switch.md b/src/switch.md
index 6e65d240..50a2fded 100644
--- a/src/switch.md
+++ b/src/switch.md
@@ -1,5 +1,8 @@
# Switch
+
+
+
`if` and `else` let you branch logic based on whether any arbitrary
expression that evaluates to a boolean.
@@ -14,38 +17,38 @@ if (isLeapYear && !bloodMoon && (age > 30 || catName.equals("fred"))) {
But it can be burdensome if all you are doing is checking if some variable has a particular value.
-```java
+```java,no_run
~void main() {
if (food.equals("apple")) {
- System.out.println("Red");
+ IO.println("Red");
}
-else if (name.equals("grape")) {
- System.out.println("Purple");
+else if (food.equals("grape")) {
+ IO.println("Purple");
}
else if (food.equals("orange")) {
- System.out.println("Orange");
+ IO.println("Orange");
}
else {
- System.out.println("Other");
+ IO.println("Other");
}
~}
```
For these situations, you can use a `switch`.
-```java
+```java,no_run
switch (fruit) {
case "apple" -> {
- System.out.println("Red");
+ IO.println("Red");
}
case "grape" -> {
- System.out.println("Purple");
+ IO.println("Purple");
}
case "orange" -> {
- System.out.println("Orange");
+ IO.println("Orange");
}
default -> {
- System.out.println("Other");
+ IO.println("Other");
}
}
```
diff --git a/src/switch/case_and_default.md b/src/switch/case_and_default.md
index 163f1e19..faaf441d 100644
--- a/src/switch/case_and_default.md
+++ b/src/switch/case_and_default.md
@@ -13,16 +13,16 @@ and gives you a place to put "default" behavior.
void sayColor(String fruit) {
switch (fruit) {
case "apple" -> {
- System.out.println("Red");
+ IO.println("Red");
}
case "grape" -> {
- System.out.println("Purple");
+ IO.println("Purple");
}
case "orange" -> {
- System.out.println("Orange");
+ IO.println("Orange");
}
default -> {
- System.out.println("Other");
+ IO.println("Other");
}
}
}
diff --git a/src/switch/challenges.md b/src/switch/challenges.md
new file mode 100644
index 00000000..8d3983d4
--- /dev/null
+++ b/src/switch/challenges.md
@@ -0,0 +1,217 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Write a method named `isSorcerer`. If the method is given
+any of `"yuji"` or `"gojo"` return `true`. Otherwise return `false`.
+
+Start by writing this with `if` and `else`. Then alter the code so it uses
+`switch` instead.
+
+```java
+boolean isSorcerer(String name) {
+ // CODE HERE
+}
+
+void main() {
+ IO.println(
+ isSorcerer("yuji")
+ );
+
+ IO.println(
+ isSorcerer("gojo")
+ );
+
+ IO.println(
+ isSorcerer("yugi") // Wrong series
+ );
+}
+```
+
+## Challenge 2.
+
+Same basic challenge as above, but write a method named `didRedSoxWin`
+which takes an `int` representing a year.
+
+Return `true` if that is a year the Boston Red Sox won a world series.
+`false` otherwise. This time start off by using a switch.
+
+```java
+boolean didRedSoxWin(int year) {
+ // CODE HERE
+}
+
+void main() {
+ IO.println(
+ "2004: " + didRedSoxWin(2004)
+ );
+
+ IO.println(
+ "1998: " + didRedSoxWin(1998)
+ );
+
+ IO.println(
+ "2013: " + didRedSoxWin(2013)
+ );
+
+ IO.println(
+ "1903: " + didRedSoxWin(1903)
+ );
+}
+```
+
+
+## Challenge 3.
+
+Make a method named `transition` which takes in a `StopLight`
+and returns the next light it will transition to.
+
+For those who don't drive cars: red lights go to green,
+green lights go to yellow, and yellow lights go to red.
+
+This is a duplicate of a challenge from a previous section. This time
+do it using a `switch`.
+
+```java,editable
+enum StopLight {
+ RED,
+ YELLOW,
+ GREEN
+}
+
+StopLight transition(StopLight current) {
+ // ------------
+ // CODE HERE
+ // ------------
+}
+
+void main() {
+ var light = StopLight.RED;
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+}
+```
+
+## Challenge 4.
+
+In reality a `StopLight` can also be broken and not function
+at all. Alter `transition` so it accounts for a new `BROKEN`
+state which transitions to itself. (`BROKEN` goes to `BROKEN`).
+
+```java,editable
+enum StopLight {
+ RED,
+ YELLOW,
+ GREEN,
+ BROKEN
+}
+
+StopLight transition(StopLight current) {
+ // ------------
+ // CODE HERE
+ // ------------
+}
+
+void main() {
+ var light = StopLight.RED;
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+}
+```
+
+## Challenge 5.
+
+Given a type of bear, return the correct course of action
+if you run into one in the wild and it attacks you.
+
+If the bear is `null`, return `null` as the action to take.
+
+If you don't know what to do when you run into a bear, look it up. Use `switch`
+first then try writing the same logic using `if` and `else`.
+
+```java
+enum Bear {
+ POLAR,
+ BROWN,
+ BLACK,
+ PANDA,
+ KOALA
+}
+
+enum Action {
+ LAY_DOWN,
+ FIGHT_BACK,
+ RUN_AWAY,
+ YEET
+}
+
+Action inCaseOfBearAttack(Bear bear) {
+ // CODE HERE
+}
+
+void main() {
+ IO.println(
+ inCaseOfBearAttack(Bear.POLAR)
+ );
+
+ IO.println(
+ inCaseOfBearAttack(Bear.BROWN)
+ );
+
+
+ IO.println(
+ inCaseOfBearAttack(Bear.BLACK)
+ );
+
+ IO.println(
+ inCaseOfBearAttack(Bear.PANDA)
+ );
+
+ IO.println(
+ inCaseOfBearAttack(Bear.KOALA)
+ );
+
+ IO.println(
+ inCaseOfBearAttack(null)
+ );
+}
+```
\ No newline at end of file
diff --git a/src/switch/combining_cases.md b/src/switch/combining_cases.md
index a260f502..5d028165 100644
--- a/src/switch/combining_cases.md
+++ b/src/switch/combining_cases.md
@@ -20,6 +20,6 @@ String scientificName(String vegetable) {
}
~
~void main() {
-~ System.out.println(scientificName("cabbage"));
+~ IO.println(scientificName("cabbage"));
~}
```
\ No newline at end of file
diff --git a/src/switch/enums.md b/src/switch/enums.md
index aea07a4f..524ccc01 100644
--- a/src/switch/enums.md
+++ b/src/switch/enums.md
@@ -16,13 +16,13 @@ void main() {
StopLight light = StopLight.GREEN;
switch (light) {
case RED -> {
- System.out.println("Stop!");
+ IO.println("Stop!");
}
case YELLOW -> {
- System.out.println("Speed up, coward!");
+ IO.println("Speed up, coward!");
}
case GREEN -> {
- System.out.println("Go!");
+ IO.println("Go!");
}
}
}
diff --git a/src/switch/exhaustiveness.md b/src/switch/exhaustiveness.md
index ac79cfb8..829e771f 100644
--- a/src/switch/exhaustiveness.md
+++ b/src/switch/exhaustiveness.md
@@ -23,10 +23,36 @@ String describe(int number) {
}
```
-When you have something like an enum you don't need a `default` case
-because you can handle every variant explicitly.
+When you have something like an enum you might think you don't need a `default` case
+because you can handle every variant explicitly.[^sometimes]
-```java,no_run
+```java,no_run,does_not_compile
+enum Bird {
+ TURKEY,
+ EAGLE,
+ WOODPECKER
+}
+
+boolean isScary(Bird bird) {
+ switch (bird) {
+ case TURKEY -> {
+ return true;
+ }
+ case EAGLE -> {
+ return true;
+ }
+ case WOODPECKER -> {
+ return false;
+ }
+ }
+}
+```
+
+This is, unfortunately, not the case for a switch statement.
+You either need a `default` case or to have an explicit `case null` to handle the
+possibility that the enum value is `null`.[^lies]
+
+```java,no_run,does_not_compile
enum Bird {
TURKEY,
EAGLE,
@@ -44,6 +70,17 @@ boolean isScary(Bird bird) {
case WOODPECKER -> {
return false;
}
+ // Need to handle the possibility of null
+ // or give a "default ->"
+ case null -> {
+ // You might want to return a value or just crash
+ return false;
+ }
}
}
-```
\ No newline at end of file
+```
+
+[^sometimes]: This is sometimes the case! It is really just this specific form of switch that has this restriction.
+
+[^lies]: Remember at the very start when I said I was going to lie to you? This is one of those lies. The real reason for this restriction has to do with how Java compiles switch statements and a concept called "separate compilation." Basically
+even though we know you covered all the enum variants, Java still makes you account for if a new enum variant was added later on. It doesn't do this for all forms of `switch` though.
\ No newline at end of file
diff --git a/src/switch/header.png b/src/switch/header.png
new file mode 100644
index 00000000..93a39b67
Binary files /dev/null and b/src/switch/header.png differ
diff --git a/src/switch/ints.md b/src/switch/ints.md
index db496090..50579198 100644
--- a/src/switch/ints.md
+++ b/src/switch/ints.md
@@ -7,13 +7,13 @@ You can also use `int`s with switches.
int year = 2024;
switch (year) {
case 2023 -> {
- System.out.println("The Chiefs");
+ IO.println("The Chiefs");
}
case 2024 -> {
- System.out.println("The Chiefs");
+ IO.println("The Chiefs");
}
default -> {
- System.out.println("I don't know");
+ IO.println("I don't know");
}
}
~}
diff --git a/src/switch/null.md b/src/switch/null.md
index 5b6d77d9..3579b4e7 100644
--- a/src/switch/null.md
+++ b/src/switch/null.md
@@ -6,13 +6,13 @@ When a switch is given a `null` value a `NullPointerException` will be thrown im
void eat(String food) {
switch (food) {
case "dog food" -> {
- System.out.println("Crunch");
+ IO.println("Crunch");
}
case "cat food" -> {
- System.out.println("Slorp");
+ IO.println("Slorp");
}
default -> {
- System.out.println("Other food");
+ IO.println("Other food");
}
}
}
@@ -29,16 +29,16 @@ case labels. `default` will not suffice.
void eat(String food) {
switch (food) {
case "dog food" -> {
- System.out.println("Crunch");
+ IO.println("Crunch");
}
case "cat food" -> {
- System.out.println("Slorp");
+ IO.println("Slorp");
}
case null -> {
- System.out.println("No food");
+ IO.println("No food");
}
default -> {
- System.out.println("Other food");
+ IO.println("Other food");
}
}
}
@@ -54,13 +54,13 @@ A default branch and a null case can be combined by separating them with a comma
void eat(String food) {
switch (food) {
case "dog food" -> {
- System.out.println("Crunch");
+ IO.println("Crunch");
}
case "cat food" -> {
- System.out.println("Slorp");
+ IO.println("Slorp");
}
case null, default -> {
- System.out.println("Other food");
+ IO.println("Other food");
}
}
}
diff --git a/src/switch/omitted_default.md b/src/switch/omitted_default.md
index 17ff0aa4..4c850155 100644
--- a/src/switch/omitted_default.md
+++ b/src/switch/omitted_default.md
@@ -7,13 +7,13 @@ If you have no logic to put in it, you can omit the `default` case from a `switc
void react(String fruit) {
switch (fruit) {
case "apple" -> {
- System.out.println("WOW");
+ IO.println("WOW");
}
case "orange" -> {
- System.out.println("Zoinks!");
+ IO.println("Zoinks!");
}
case "grape" -> {
- System.out.println("Zoopers!");
+ IO.println("Zoopers!");
}
}
}
diff --git a/src/switch/strings.md b/src/switch/strings.md
index f64ae4c0..7aed3c8e 100644
--- a/src/switch/strings.md
+++ b/src/switch/strings.md
@@ -7,16 +7,16 @@ As already shown, you can use a case to match `String` values.
String veggie = "cucumber";
switch (veggie) {
case "cabbage" -> {
- System.out.println("A cabbage");
+ IO.println("A cabbage");
}
case "brussel sprout" -> {
- System.out.println("A brussel sprout");
+ IO.println("A brussel sprout");
}
case "cucumber" -> {
- System.out.println("A cucumber");
+ IO.println("A cucumber");
}
default -> {
- System.out.println("Other");
+ IO.println("Other");
}
}
~}
diff --git a/src/switch_ii.md b/src/switch_ii.md
new file mode 100644
index 00000000..d96264e9
--- /dev/null
+++ b/src/switch_ii.md
@@ -0,0 +1,41 @@
+# Switch II
+
+
+
+A common thing to do is have a `switch` statement which assigns a value
+to a variable in each branch.
+
+```java
+enum StopLight {
+ RED,
+ YELLOW,
+ GREEN
+}
+
+enum Action {
+ STOP,
+ SLOW_DOWN,
+ GO
+}
+
+void main() {
+ StopLight light = StopLight.GREEN;
+
+ Action action = null; // Delayed assignment rules are funky here.
+ switch (light) {
+ case RED -> {
+ action = Action.STOP;
+ }
+ case YELLOW -> {
+ action = Action.SLOW_DOWN;
+ }
+ case GREEN -> {
+ action = Action.GO;
+ }
+ }
+
+ IO.println(action);
+}
+```
+
+For this purpose, you can instead use a switch "as an expression."
\ No newline at end of file
diff --git a/src/switch_ii/challenges.md b/src/switch_ii/challenges.md
new file mode 100644
index 00000000..2ca608d3
--- /dev/null
+++ b/src/switch_ii/challenges.md
@@ -0,0 +1,52 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1
+
+Complete the switch expression such that it yields
+the appropriate value for each case.
+
+In the surfer case, make sure to print out "Radical!" before yielding
+the value.
+
+```java,editable
+enum Profession {
+ FIREFIGHTER,
+ PLUMBER,
+ SURFER
+}
+
+enum NaturalEnemy {
+ FIRE,
+ LEAKY_PIPES,
+ BODACIOUS_WAVES
+}
+
+NaturalEnemy enemy(Profession p) {
+ return switch (p) {
+ case FIREFIGHTER -> {
+ // CODE HERE
+ };
+ case PLUMBER -> {
+ // CODE HERE
+ }
+ case SURFER -> {
+ // CODE HERE
+ }
+ }
+}
+
+void main() {
+ IO.println(enemy(Profession.FIREFIGHTER));
+ IO.println(enemy(Profession.PLUMBER));
+ IO.println(enemy(Profession.SURFER));
+}
+```
+
+## Challenge 2
+
+Update your program above to omit `yield` in the two cases where it is not needed.
\ No newline at end of file
diff --git a/src/switch_ii/exhaustiveness.md b/src/switch_ii/exhaustiveness.md
new file mode 100644
index 00000000..f78fae27
--- /dev/null
+++ b/src/switch_ii/exhaustiveness.md
@@ -0,0 +1,61 @@
+# Exhaustiveness
+
+When a switch is used as an expression it needs to be exhaustive.
+
+```java
+~void main() {
+String name = "bob";
+
+boolean cool = switch (name) {
+ case "bob" -> false;
+ default -> true;
+};
+
+IO.println(cool);
+~}
+```
+
+If you attempt to make a non-exhaustive switch expression, Java will not let you.
+
+```java,does_not_compile
+~void main() {
+String name = "bob";
+
+boolean cool = switch (name) {
+ case "bob" -> false;
+};
+
+IO.println(cool);
+~}
+```
+
+Unlike in a switch statement, covering all the enum values in a switch expression
+is enough for that switch to be considered exhaustive. You do not need an
+extra `default` or `case null`[^reason].
+
+```java,no_run
+enum Species {
+ ALIEN,
+ PREDATOR,
+ HUMAN
+}
+
+void main() {
+ Species species = Species.valueOf(
+ IO.readln("What do you see? ").toUpperCase()
+ );
+ String message = switch (species) {
+ case ALIEN -> "Run";
+ case PREDATOR -> "Fight Back";
+ case HUMAN -> "RUN"
+ };
+
+ IO.println(message);
+}
+```
+
+[^reason]: The nitty gritty of why this is comes down to what Java will do if the code is
+run with an unexpected enum variant. With a switch statement the code will just move on and
+run none of the switch cases. With a switch expression Java will crash on an unexpected value.
+This difference is partially due to the fact that switch statements came first in the language
+and switch expressions came later. What a world, huh?
\ No newline at end of file
diff --git a/src/switch_ii/header.png b/src/switch_ii/header.png
new file mode 100644
index 00000000..9e943138
Binary files /dev/null and b/src/switch_ii/header.png differ
diff --git a/src/switch_ii/omitted_yield.md b/src/switch_ii/omitted_yield.md
new file mode 100644
index 00000000..803abf60
--- /dev/null
+++ b/src/switch_ii/omitted_yield.md
@@ -0,0 +1,61 @@
+# Omitted Yield
+
+If a branch of a switch just yields a value but does nothing else interesting you can
+omit the `yield` along with the surrounding `{` and `}`.
+
+```java
+~enum StopLight {
+~ RED,
+~ YELLOW,
+~ GREEN
+~}
+~
+~enum Action {
+~ STOP,
+~ SLOW_DOWN,
+~ GO
+~}
+~
+~void main() {
+StopLight light = StopLight.GREEN;
+
+Action action = switch (light) {
+ case RED -> Action.STOP;
+ case YELLOW -> Action.SLOW_DOWN;
+ case GREEN -> Action.GO;
+};
+
+IO.println(action);
+~}
+```
+
+Which can be mixed with cases that have explicit `yield`s and might do other things.
+
+```java
+~enum StopLight {
+~ RED,
+~ YELLOW,
+~ GREEN
+~}
+~
+~enum Action {
+~ STOP,
+~ SLOW_DOWN,
+~ GO
+~}
+~
+void main() {
+ StopLight light = StopLight.GREEN;
+
+ Action action = switch (light) {
+ case RED -> Action.STOP;
+ case YELLOW -> {
+ IO.println("Lemon Light!");
+ yield Action.SLOW_DOWN;
+ }
+ case GREEN -> Action.GO;
+ };
+
+ IO.println(action);
+}
+```
\ No newline at end of file
diff --git a/src/switch_ii/return_a_switch.md b/src/switch_ii/return_a_switch.md
new file mode 100644
index 00000000..877bfafe
--- /dev/null
+++ b/src/switch_ii/return_a_switch.md
@@ -0,0 +1,19 @@
+# Return a Switch
+
+If you choose to, you do not need to assign the result of a switch expression into a variable. You can directly return the result from a method.
+
+```java,no_run
+enum Bird {
+ TURKEY,
+ EAGLE,
+ WOODPECKER
+}
+
+boolean isScary(Bird bird) {
+ return switch (bird) {
+ case TURKEY -> true;
+ case EAGLE -> true;
+ case WOODPECKER -> false;
+ };
+}
+```
\ No newline at end of file
diff --git a/src/switch_ii/yield.md b/src/switch_ii/yield.md
new file mode 100644
index 00000000..ad263a23
--- /dev/null
+++ b/src/switch_ii/yield.md
@@ -0,0 +1,39 @@
+# Yield
+
+To use a "switch expression" you put the entire switch to the right hand side of an equals sign[^context] and, instead of assigning to a variable, you "`yield`" the value you want to assign.
+
+```java
+enum StopLight {
+ RED,
+ YELLOW,
+ GREEN
+}
+
+enum Action {
+ STOP,
+ SLOW_DOWN,
+ GO
+}
+
+void main() {
+ StopLight light = StopLight.GREEN;
+
+ Action action = switch (light) {
+ case RED -> {
+ yield Action.STOP;
+ }
+ case YELLOW -> {
+ yield Action.SLOW_DOWN;
+ }
+ case GREEN -> {
+ yield Action.GO;
+ }
+ };
+
+ IO.println(action);
+}
+```
+
+`yield` is very similar to `return`. The difference is that `return` will exit the entire method. `yield` just decides what the switch evaluates to.
+
+[^context]: Technically we are talking about an "expression context." Meaning a place where you are allowed to put an expression. The right hand side of an equals sign is one, but there are many others.
\ No newline at end of file
diff --git a/src/switch_iii.md b/src/switch_iii.md
new file mode 100644
index 00000000..627911ef
--- /dev/null
+++ b/src/switch_iii.md
@@ -0,0 +1,35 @@
+# Switch III
+
+
+
+
+The switch statement in Java originally came from a little language you might know
+about called `C`.
+
+In `C` switches work slightly differently than the ones you have seen so far in Java.
+But, due to this history, there is another kind of switch that doesn't use arrows (`->`)
+and instead uses a colon (`:`).
+
+```java
+class Main {
+ boolean shouldBeMainCharacter(String name) {
+ switch (name) {
+ case "Gohan":
+ return true;
+ case "Goku":
+ default:
+ return false;
+ }
+ }
+
+ void main() {
+ IO.println(
+ shouldBeMainCharacter("Goku")
+ );
+ }
+}
+```
+
+This "C-Style Switch" is important to learn chiefly because, for a long time,
+it was the only switch in Java. Therefore in your coding life you are very likely to
+run into it.
\ No newline at end of file
diff --git a/src/switch_iii/break.md b/src/switch_iii/break.md
new file mode 100644
index 00000000..b1d88e60
--- /dev/null
+++ b/src/switch_iii/break.md
@@ -0,0 +1,78 @@
+# break
+
+After each case label in a C-style switch, you should write `break;`.[^cookout]
+
+```java
+class Main {
+ void main() {
+ String name = "Piccolo";
+ switch (name) {
+ case "Squidward":
+ IO.println("Invited, but not coming.");
+ break;
+
+ case "Piccolo":
+ IO.println("Coming to the cookout.");
+ break;
+
+ case "Spider-Man":
+ IO.println("Not coming");
+ break;
+ }
+ }
+}
+```
+
+This is different from breaking out of a loop and won't break out of any surrounding loops.
+
+```java
+class Main {
+ void main() {
+ for (int i = 0; i < 3; i++) {
+ // Will still run 3 times
+ String name = "Piccolo";
+ switch (name) {
+ case "Squidward":
+ IO.println("Invited, but not coming.");
+ break;
+
+ case "Piccolo":
+ IO.println("Coming to the cookout.");
+ break;
+
+ case "Spider-Man":
+ IO.println("Not coming");
+ break;
+ }
+ }
+ }
+}
+```
+
+To break out of surrounding loops you can use a labeled break.
+
+```java
+class Main {
+ void main() {
+ outerLoop:
+ for (int i = 0; i < 3; i++) {
+ String name = "Piccolo";
+ switch (name) {
+ case "Squidward":
+ IO.println("Invited, but not coming.");
+ break;
+
+ case "Piccolo":
+ IO.println("Coming to the cookout.");
+ break outerLoop; // Will break out of the loop
+
+ case "Spider-Man":
+ IO.println("Not coming");
+ break;
+ }
+ }
+ }
+}
+```
+
+[^cookout]: [Who should be invited to the cookout?](https://www.youtube.com/watch?v=64SoFWJHSd8)
\ No newline at end of file
diff --git a/src/switch_iii/challenges.md b/src/switch_iii/challenges.md
new file mode 100644
index 00000000..5b72e126
--- /dev/null
+++ b/src/switch_iii/challenges.md
@@ -0,0 +1,95 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Convert this program which uses a switch without fallthrough
+to instead use fallthrough for all the common cases.
+
+```java,editable
+enum Character {
+ GOKU,
+ PICCOLO,
+ FRIEZA,
+ VEGETA,
+ PILAF,
+ GOHAN,
+ BEERUS
+}
+
+class Main {
+ String isEvil(Character c) {
+ switch (c) {
+ case GOKU -> {
+ // Man puts the multiverse in danger
+ // on account of wanting to fight!
+ return "debatable";
+ }
+ case PICCOLO -> {
+ return "not_anymore";
+ }
+ case FRIEZA -> {
+ return "yes";
+ }
+ case VEGETA -> {
+ return "not_anymore";
+ }
+ case PILAF -> {
+ return "not_anymore";
+ }
+ case GOHAN -> {
+ return "no";
+ }
+ case BEERUS -> {
+ // He's more a force of nature,
+ // but its relative.
+ return "debatable";
+ }
+ default -> {
+ return "unknown";
+ }
+ }
+ }
+
+ void main() {
+ IO.println("Goku: " + isEvil(Character.GOKU));
+ IO.println("Piccolo: " + isEvil(Character.PICCOLO));
+ IO.println("Frieza: " + isEvil(Character.FRIEZA));
+ IO.println("Vegeta: " + isEvil(Character.VEGETA));
+ IO.println("Pilaf: " + isEvil(Character.PILAF));
+ IO.println("Gohan: " + isEvil(Character.GOHAN));
+ IO.println("Beerus: " + isEvil(Character.BEERUS));
+ }
+}
+```
+
+## Challenge 2.
+
+Convert the previous program using fallthrough to also
+be directly returned as a switch expression using `yield`.
+
+## Challenge 3.
+
+Write a method named `aToZ` which, given a character
+between `a` and `z`, will print all the letters
+from that letter on until `z`.
+
+Make use of a switch with fallthrough instead of loops or any other mechanism.
+
+```java,editable
+class Main {
+ void aToZ(char c) {
+ // CODE HERE
+ }
+
+ void main() {
+ aToZ('z'); // z
+ aToZ('x'); // x y z
+ aToZ('a'); // a b c d ... x y z
+ }
+}
+```
diff --git a/src/switch_iii/default.md b/src/switch_iii/default.md
new file mode 100644
index 00000000..5747eb7d
--- /dev/null
+++ b/src/switch_iii/default.md
@@ -0,0 +1,65 @@
+# default
+
+Just like with normal switches, C-style switches can have a `default` label
+that matches when no other label does.
+
+```java
+class Main {
+ boolean shouldBeMainCharacter(String name) {
+ switch (name) {
+ case "Gohan":
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ void main() {
+ IO.println(
+ shouldBeMainCharacter("Goku")
+ );
+ }
+}
+```
+
+If you have a C-style switch over an enum you need this `default` case for exhaustiveness. Java does not
+otherwise accept that you have covered all the cases.
+
+```java,does_not_compile
+enum Technique {
+ KAMEHAMEHA,
+ INSTANT_TRANSMISSION,
+ KAIOKEN,
+ ULTRA_INSTINCT
+}
+
+class Main {
+ boolean didGokuStealItFromSomeoneElse(Technique technique) {
+ switch (technique) {
+ case KAMEHAMEHA:
+ IO.println("Master Roshi Taught it to him");
+ return true;
+ case INSTANT_TRANSMISSION:
+ IO.println("Space aliens");
+ return true;
+ case KAIOKEN:
+ IO.println("King Kai's name is in it!");
+ return true;
+ case ULTRA_INSTINCT:
+ IO.println("I'd say not");
+ return false;
+ // Even though we covered every option, Java doesn't trust us.
+ // You need a default label or to return later in the function
+ //
+ // default:
+ // throw new IllegalStateException("Unexpected: " + technique);
+ }
+ }
+
+ void main() {
+ IO.println(
+ didGokuStealItFromSomeoneElse(Technique.INSTANT_TRANSMISSION)
+ );
+ }
+}
+```
\ No newline at end of file
diff --git a/src/switch_iii/fallthrough.md b/src/switch_iii/fallthrough.md
new file mode 100644
index 00000000..fb2dbb7d
--- /dev/null
+++ b/src/switch_iii/fallthrough.md
@@ -0,0 +1,31 @@
+# Fallthrough
+
+If the code for a given label does not have a `break` then it will "fall through"
+to the cases below.
+
+This is what makes C-style switches strange. It can occasionaly be useful if the same code should
+run for some or all cases, but is annoyingly easy to do on accident.[^history]
+
+```java
+class Main {
+ void sayWhoTheyFought(String name) {
+ switch (name) {
+ case "Goku":
+ IO.println("Fought Pilaf");
+ IO.println("Fought The Red Ribbon Army");
+ case "Gohan": // "Goku" will fall through to this case
+ IO.println("Fought Frieza");
+ IO.println("Fought Cell");
+ IO.println("Fought Majin Buu");
+ }
+ }
+
+ void main() {
+ sayWhoTheyFought("Gohan");
+ IO.println("----------------------");
+ sayWhoTheyFought("Goku");
+ }
+}
+```
+
+[^history]: [This StackExchange Post](https://softwareengineering.stackexchange.com/questions/162615/why-dont-languages-use-explicit-fall-through-on-switch-statements) explains how this came about. I don't have a primary source on the "The reason that C did it that way is that the creators of C intended switch statements to be easy to optimize into a jump table." claim, but it lines up with my biases and preconceptions. Therefore it must be true!
\ No newline at end of file
diff --git a/src/switch_iii/header.png b/src/switch_iii/header.png
new file mode 100644
index 00000000..c853b5f2
Binary files /dev/null and b/src/switch_iii/header.png differ
diff --git a/src/switch_iii/return.md b/src/switch_iii/return.md
new file mode 100644
index 00000000..a33f2232
--- /dev/null
+++ b/src/switch_iii/return.md
@@ -0,0 +1,30 @@
+# return
+
+If you explicitly `return` from inside a C-style switch then there is no need to have a `break`
+to avoid fallthrough.
+
+```java
+class Main {
+ void sayWhoTheyFought(String name) {
+ switch (name) {
+ case "Launch":
+ IO.println("Fought Red Ribbon Army");
+ IO.println("Fought 3 nameless convicts");
+ return; // This will return from the whole method
+ case "Goku":
+ IO.println("Fought Pilaf");
+ IO.println("Fought The Red Ribbon Army");
+ case "Gohan":
+ IO.println("Fought Frieza");
+ IO.println("Fought Cell");
+ IO.println("Fought Majin Buu");
+ }
+ }
+
+ void main() {
+ sayWhoTheyFought("Launch");
+ }
+}
+```
+
+This should be intuitive.
diff --git a/src/switch_iii/yield.md b/src/switch_iii/yield.md
new file mode 100644
index 00000000..5003c9fb
--- /dev/null
+++ b/src/switch_iii/yield.md
@@ -0,0 +1,36 @@
+# yield
+
+If every branch of a C-style switch `yield`s a value, you can use that switch as an expression.
+
+```java
+enum Technique {
+ KAMEHAMEHA,
+ INSTANT_TRANSMISSION,
+ KAIOKEN,
+ ULTRA_INSTINCT
+}
+
+class Main {
+ boolean didGokuStealItFromSomeoneElse(Technique technique) {
+ boolean answer = switch (technique) {
+ case KAMEHAMEHA:
+ case INSTANT_TRANSMISSION:
+ case KAIOKEN:
+ yield true;
+ case ULTRA_INSTINCT:
+ yield false;
+ };
+
+ return answer;
+ }
+
+ void main() {
+ IO.println(
+ didGokuStealItFromSomeoneElse(Technique.INSTANT_TRANSMISSION)
+ );
+ }
+}
+```
+
+In this situation you do not need to have a `default` case for switches over enums. Java will believe that
+you covered every possibility.
\ No newline at end of file
diff --git a/src/tcp_over_ip.md b/src/tcp_over_ip.md
new file mode 100644
index 00000000..ca090496
--- /dev/null
+++ b/src/tcp_over_ip.md
@@ -0,0 +1,13 @@
+# TCP over IP
+
+Most of the internet is built on top of something called "TCP over IP"
+or "Transmission Control Protocol over Internet Protocol."
+
+If those words don't make it immediately obvious what that means, thats normal.
+The short version is that the "IP" part refers to how computers find eachother
+on the internet and the "TCP" part refers to the how those computers
+speak to eachother once they've found eachother.
+
+For the long version, I'll defer to this youtube video.
+
+
diff --git a/src/tcp_over_ip/low_level_versus_high_level.md b/src/tcp_over_ip/low_level_versus_high_level.md
new file mode 100644
index 00000000..011b1f0c
--- /dev/null
+++ b/src/tcp_over_ip/low_level_versus_high_level.md
@@ -0,0 +1,19 @@
+# Low Level versus High Level
+
+TCP over IP, and by extension Sockets, are generally
+considered to be a "low level" mechanism.
+
+When we say something is "low level" its usually in reference to
+a "high level" thing that is built on top of the lower level thing.
+In the case of TCP over IP, there are multiple protocols that use it
+behind the scenes but don't generally require a programmer
+to know some of the finer details of how that is used.
+
+We will get to a few of these eventually, but I bring this up
+mostly to try and break the cultural taboo of using a low level
+thing. There is a cultural bias in the programming field to prefer
+higher levels mechanisms. This can sometimes be well-founded
+but just as often be conditional on the situation.
+
+Which is all to say, if someone mocks you for using sockets directly
+don't feel bad about yourself. We are building up slowly for a reason.
\ No newline at end of file
diff --git a/src/tcp_over_ip/sockets.md b/src/tcp_over_ip/sockets.md
new file mode 100644
index 00000000..6b8d1b7b
--- /dev/null
+++ b/src/tcp_over_ip/sockets.md
@@ -0,0 +1,7 @@
+# Sockets
+
+To communicate with a server using TCP over IP you use the `Socket`
+class.
+
+// ----
+Th
\ No newline at end of file
diff --git a/src/text_editors.md b/src/text_editors.md
new file mode 100644
index 00000000..ea65ac58
--- /dev/null
+++ b/src/text_editors.md
@@ -0,0 +1,12 @@
+# Text Editors
+
+Code is written in "text files." These are files that just contain
+text.
+
+This is different from something like Microsoft Word or the notes app on a phone.
+Those kinds of programs are for "rich text." Meaning you can bold words, change font
+colors, embed images - all sorts of stuff.
+
+Text files only store text.
+
+To create and edit text files we use programs called "text editors."
\ No newline at end of file
diff --git a/src/text_editors/challenges.md b/src/text_editors/challenges.md
new file mode 100644
index 00000000..ae33bad3
--- /dev/null
+++ b/src/text_editors/challenges.md
@@ -0,0 +1,2 @@
+# Challenges
+
diff --git a/src/text_editors/chromebooks_and_phones.md b/src/text_editors/chromebooks_and_phones.md
new file mode 100644
index 00000000..a78c5925
--- /dev/null
+++ b/src/text_editors/chromebooks_and_phones.md
@@ -0,0 +1 @@
+# Chromebooks and Phones
diff --git a/src/text_editors/codespace_ai.png b/src/text_editors/codespace_ai.png
new file mode 100644
index 00000000..a20d009c
Binary files /dev/null and b/src/text_editors/codespace_ai.png differ
diff --git a/src/text_editors/codespace_continue_working.png b/src/text_editors/codespace_continue_working.png
new file mode 100644
index 00000000..41c65e6a
Binary files /dev/null and b/src/text_editors/codespace_continue_working.png differ
diff --git a/src/text_editors/codespace_extension_no.png b/src/text_editors/codespace_extension_no.png
new file mode 100644
index 00000000..98cbb3b0
Binary files /dev/null and b/src/text_editors/codespace_extension_no.png differ
diff --git a/src/text_editors/codespace_extension_prompt.png b/src/text_editors/codespace_extension_prompt.png
new file mode 100644
index 00000000..61bfb5bc
Binary files /dev/null and b/src/text_editors/codespace_extension_prompt.png differ
diff --git a/src/text_editors/codespace_first_view.png b/src/text_editors/codespace_first_view.png
new file mode 100644
index 00000000..ef6931c4
Binary files /dev/null and b/src/text_editors/codespace_first_view.png differ
diff --git a/src/text_editors/codespace_ignore_all.png b/src/text_editors/codespace_ignore_all.png
new file mode 100644
index 00000000..a30d11e5
Binary files /dev/null and b/src/text_editors/codespace_ignore_all.png differ
diff --git a/src/text_editors/codespace_instance_size.png b/src/text_editors/codespace_instance_size.png
new file mode 100644
index 00000000..c4c44d06
Binary files /dev/null and b/src/text_editors/codespace_instance_size.png differ
diff --git a/src/text_editors/codespace_repo_landing.png b/src/text_editors/codespace_repo_landing.png
new file mode 100644
index 00000000..2c9f89cd
Binary files /dev/null and b/src/text_editors/codespace_repo_landing.png differ
diff --git a/src/text_editors/codespace_run_code.png b/src/text_editors/codespace_run_code.png
new file mode 100644
index 00000000..a6ca703d
Binary files /dev/null and b/src/text_editors/codespace_run_code.png differ
diff --git a/src/text_editors/codespace_srcmainjava.png b/src/text_editors/codespace_srcmainjava.png
new file mode 100644
index 00000000..e890c930
Binary files /dev/null and b/src/text_editors/codespace_srcmainjava.png differ
diff --git a/src/text_editors/ides.md b/src/text_editors/ides.md
new file mode 100644
index 00000000..218b38f5
--- /dev/null
+++ b/src/text_editors/ides.md
@@ -0,0 +1,17 @@
+# IDEs
+
+A term you might have heard or will hear in the future is "IDE."
+
+IDE stands for "Integrated Development Environment." It is basically a text editor
+with a bunch of features "integrated" that ease "development" of software.
+
+Programs like [Eclipse](https://eclipseide.org/), [IntelliJ](https://www.jetbrains.com/idea/), and [Netbeans](https://netbeans.apache.org/front/main/index.html)
+are all considered Java IDEs. This is because they come integrated with
+functionality that makes developing specficially programs in Java easier.
+
+Text editors that have plugins available can often be juiced up enough that they will also
+be considered "IDEs." This is the case for [VSCode](https://code.visualstudio.com/)
+which has two Java plugins as well as plugins which support development in other languages.[^matter]
+
+[^matter]: Now does any of this matter right now? No. I just think its good to not get confused
+or get unneeded FOMO.
\ No newline at end of file
diff --git a/src/text_editors/install_java.md b/src/text_editors/install_java.md
new file mode 100644
index 00000000..8ae284aa
--- /dev/null
+++ b/src/text_editors/install_java.md
@@ -0,0 +1,60 @@
+# Install Java
+
+After you've got VSCodium set up the next step
+is to install Java.[^barebones]
+
+## Chromebooks and School Computers
+
+
+ Expand
+
+You can skip this step. The instructions I gave to get set up with Github Codespaces
+should have given you an environment where Java is already set up.
+
+
+
+
+## Windows
+
+
+ Expand
+
+Download the "JDK MSI" from [adoptium.net](https://adoptium.net/temurin/releases/?version=25&os=windows).
+Select whatever the newest version is. You will need at least Java 25 to follow along with the
+examples in this book.
+
+Run the installer, selecting all the default options. This should make the `java` command available to
+you.
+
+
+
+
+## Mac OS
+
+
+ Expand
+
+Download the "JDK .pkg" from [adoptium.net](https://adoptium.net/temurin/releases/?version=25&os=mac).
+Select whatever the newest version is. You will need at least Java 25 to follow along with the
+examples in this book.
+
+Run the installer, selecting all the default options. This should make the `java` command available to
+you.
+
+
+
+## Linux
+
+
+ Expand
+
+Linux is a little annoying. If you are using it you are likely used to it
+by now, but you can use [adoptium.net](https://adoptium.net/temurin/releases/?version=25&os=linux) like everyone else, but there is no universal installer there.
+
+You can either download the `.tar.gz` file that matches your machine, extract it,
+and add the `bin` folder to your `PATH`, or you can try to find an installer for your
+specific linux distribution.
+
+
+
+[^barebones]: Apologies if you find these instructions a little barebones.
\ No newline at end of file
diff --git a/src/text_editors/install_vscodium.md b/src/text_editors/install_vscodium.md
new file mode 100644
index 00000000..2f419187
--- /dev/null
+++ b/src/text_editors/install_vscodium.md
@@ -0,0 +1,158 @@
+# Install VSCodium
+
+To install VSCodium you need to go to this page:
+
+[https://github.com/VSCodium/vscodium/releases](https://github.com/VSCodium/vscodium/releases).
+
+Then follow the instructions below specific to what kind of computer you have.
+
+## Chromebooks and School Computers
+
+
+ Expand
+ Unfortunately the defining characteristic of a Chromebook is that you cannot install
+ "normal" software on it.
+ This is also generally true for computers provided to you by a school. Sometimes they will
+ be okay with you running things normally, sometimes not.
+ For these situations VSCodium is not an option so for now I am going to recommend falling
+ back to using a service called "Github Codespaces." This is a service provided by Microsoft
+ where they let you use VSCode in a web browser.
+ First, make an account on Github.
+ Then go to https://github.com/bowbahdoe/j25-codespace and press the . key on your keyboard.
+ 
+ After pressing . you should be redirected to a page that looks like this
+ 
+ Click the button on the bottom labeled "Continue Working in GitHub Codespaces."
+ 
+ Select the smallest instance size from the dropdown that appears.
+ 
+ After it loads for awhile you will see a pop-up in the bottom left of your screen asking
+ if you want to install an extension for Java files.
+ 
+ You want to say no to this.
+ 
+ You will also want to say no to all extension suggestions.
+ 
+ Next on the chopping block is the AI thing on the right. You want to uncheck the "Show View by Default." option on it then click the `x` to dismiss it.
+ 
+ After vanquishing evil, your next task is to type `java src/Main.java` into the "Terminal" area at the bottom of your screen.
+ 
+ Press the enter key and you should see "Hello, world" be printed out.
+ 
+ You can skip the next section on installing Java for now. You are ready to proceed with the book.
+
+
+
+## Windows
+
+
+ Expand
+ If you are on Windows you want to click this link.
+
+
+
+This will download a file. Double click it and it will open an installer like this. Follow it through to the end selecting all the default options
+
+
+
+When you open the program it installs you should see a screen like this.
+
+
+In the top-left corner select File -> Open Folder
+
+
+Make a folder somewhere on your computer to store your code. It doesn't matter what you call it.
+
+
+
+Then make a new file named src/Main.java
+
+
+
+Inside of this file put the following contents.
+
+```java,no_run
+void main() {
+ IO.println("Hello, world");
+}
+```
+
+ Now skip ahead to the next section on installing Java. Come back when you are done.
+
+ Once you are back you want to open a new terminal.
+
+
+
+ Type java src/Main.java in the terminal and press enter to run your first program.
+If this doesn't work you might need to restart your computer or you might have messed up a step.
+
+
+
+
+## MacOS
+
+
+ Expand
+ If you have an Apple M1 Mac or newer then you need to scroll down
+to the "ARM 64bits" section (of whatever the newest release is) and click this link.
+
+
+
+If you have an older Mac then you want to click this link.
+
+
+
+This will download a file. Double click it and it will open a window like this.
+
+
+Then drag the VSCodium logo to the Applications folder.
+
+
+Then you should be able to find and open the app from the Launchpad app.
+
+
+
+
+
+When you open it you should see a screen like this.
+
+
+In the top-right corner select File -> Open Folder
+
+
+Make a folder somewhere on your computer to store your code. It doesn't matter what you call it.
+
+
+Then make a new file named src/Main.java
+
+
+
+Inside of this file put the following contents.
+
+```java,no_run
+void main() {
+ IO.println("Hello, world");
+}
+```
+
+ Now skip ahead to the next section on installing Java. Come back when you are done.
+
+ Once you are back you want to open a new terminal.
+
+
+
+ Type java src/Main.java in the terminal and press enter to run your first program.
+If this doesn't work you might need to restart your computer or you might have messed up a step.
+
+
+
+
+
+## Linux
+
+
+ Expand
+ Select the installer that matches your system and go from there.
+ Sorry I don't have as nice of a walkthrough as I do for Windows and Mac. In my defense,
+ every Linux machine is its own beast.
+
+
+Early computers didn't have graphical interfaces with windows or buttons you could "click."
+Instead, they offered a text based interface.
+
+We call this sort of interface a "terminal," though you might hear the terms "shell"
+and "terminal emulator" used interchangibly.
diff --git a/src/the_terminal/bash.md b/src/the_terminal/bash.md
new file mode 100644
index 00000000..f695d1f0
--- /dev/null
+++ b/src/the_terminal/bash.md
@@ -0,0 +1,8 @@
+# Bash
+
+If you are programming on a computer running either Mac or Linux you should have easy access
+to a bash terminal. Just search your applications for something called "terminal" or that has the word "term" in it.
+
+This is the most common kind of terminal for working professionals to use.[^asterisk]
+
+[^asterisk]: Asterisks apply, of course. I didn't run or try to find a survey so this is mostly anecdotal.
\ No newline at end of file
diff --git a/src/the_terminal/challenges.md b/src/the_terminal/challenges.md
new file mode 100644
index 00000000..9358534c
--- /dev/null
+++ b/src/the_terminal/challenges.md
@@ -0,0 +1 @@
+# Challenges
diff --git a/src/the_terminal/changing_directories.md b/src/the_terminal/changing_directories.md
new file mode 100644
index 00000000..ae15af62
--- /dev/null
+++ b/src/the_terminal/changing_directories.md
@@ -0,0 +1,25 @@
+# Changing Directories
+
+You can change what your working directory is using the `cd` command.
+
+After the name of the command, you write the name of the directory you want to change in to.
+
+```bash
+$ pwd
+/Users/emccue
+$ cd Downloads
+$ pwd
+/Users/emccue/Downloads
+```
+
+If you want to go to a "parent" directory, you can write `..`. This means "one directory up".
+
+```bash
+$ pwd
+/Users/emccue
+$ cd ..
+$ pwd
+/Users
+```
+
+[^cd]: Short for "change directory"
\ No newline at end of file
diff --git a/src/the_terminal/chromebooks_and_school_computers.md b/src/the_terminal/chromebooks_and_school_computers.md
new file mode 100644
index 00000000..7015579f
--- /dev/null
+++ b/src/the_terminal/chromebooks_and_school_computers.md
@@ -0,0 +1,12 @@
+# Chromebooks and School Computers
+
+A very common thing that school systems will do is prevent students from accessing a terminal.
+
+This is a good thing if your goal is to prevent high schoolers from committing shenanigans. Less so if your goal is to learn how to program.
+
+There are also computer types, like chromebooks, which aren't really built with programming in mind. While you could access a terminal, the sorts of programs you would generally install to
+work with Java will be out of reach. It's a similar case for things like iPads.
+
+If you are in one of these situations I would recommend getting a "normal" computer if at all possible. You can make do for a time, but eventually it will be required to continue in this field.[^thems]
+
+[^thems]: Thems the ropes, kid. π€·
\ No newline at end of file
diff --git a/src/the_terminal/commands.md b/src/the_terminal/commands.md
new file mode 100644
index 00000000..80d85d2f
--- /dev/null
+++ b/src/the_terminal/commands.md
@@ -0,0 +1,15 @@
+# Commands
+
+The primary way you interact with a terminal is by running commands.
+
+You start with a blank prompt and write something like the following[^nottyped].
+
+```bash
+$ echo Hello
+Hello
+```
+
+The first word is the name of the program to run. In this case `echo`. Everything after
+that is an "argument" to the program.
+
+[^nottyped] You don't actually type the `$`. That is illustrative. Your terminal will give you something like a `$` or a `>` as a "prompt."
\ No newline at end of file
diff --git a/src/the_terminal/creating_directories.md b/src/the_terminal/creating_directories.md
new file mode 100644
index 00000000..368f66d7
--- /dev/null
+++ b/src/the_terminal/creating_directories.md
@@ -0,0 +1,11 @@
+# Creating Directories
+
+In order to create a directory you can use the `mkdir`[^mkdir] command.
+
+```bash
+$ mkdir project
+$ ls
+project
+```
+
+[^mkdir]: Make Directory.
\ No newline at end of file
diff --git a/src/the_terminal/creating_files.md b/src/the_terminal/creating_files.md
new file mode 100644
index 00000000..546281eb
--- /dev/null
+++ b/src/the_terminal/creating_files.md
@@ -0,0 +1,21 @@
+# Creating Files
+
+To create a blank file you can use the `touch`[^why] command.
+
+```bash
+$ touch hello.txt
+```
+
+This is situationally useful, but more often than not you will create files
+using a program called a "text editor."
+
+There are some text editors, like [`vim`](https://www.vim.org/), which run entirely
+inside the terminal.[^diehard]
+
+At the start of this book I showed you [VSCodium](https://vscodium.com/). If you weren't otherwise shown a different option, that is a decent default. You can use it to create and edit files.
+
+[^why]: This is called `touch` because it will "touch" a file and update its "last updated timestamp" but change nothing else.
+
+[^diehard]: These have their die hard supporters. The lunatics.
+
+[^thisbook]: This book has been written inside Visual Studio Code.
diff --git a/src/the_terminal/directories.md b/src/the_terminal/directories.md
new file mode 100644
index 00000000..ea7c559d
--- /dev/null
+++ b/src/the_terminal/directories.md
@@ -0,0 +1,15 @@
+# Directories
+
+Directories, also known as folders, are the places where files are in a computer.
+
+When you open a terminal, you are "inside" a particular directory.
+
+You can see the directory you are in by running the `pwd`[^pwd] command.
+
+```bash
+$ pwd
+/Users/emccue
+```
+
+
+[^pwd]: "Print Working Directory"
\ No newline at end of file
diff --git a/src/the_terminal/getting_used_to_it.md b/src/the_terminal/getting_used_to_it.md
new file mode 100644
index 00000000..f9ad555e
--- /dev/null
+++ b/src/the_terminal/getting_used_to_it.md
@@ -0,0 +1,8 @@
+# Getting Used to it
+
+So far this is only a shallow dive. It will take a good amount of time for you to get
+comfortable using the terminal for things.
+
+Thats normal. You'll get there eventually. Just know that at least some familiarity with the terminal is going to be needed.
+
+We'll get back to it eventually, but feel free to seek out some bash/terminal specific resources online in the meantime.
\ No newline at end of file
diff --git a/src/the_terminal/header.png b/src/the_terminal/header.png
new file mode 100644
index 00000000..e680f42e
Binary files /dev/null and b/src/the_terminal/header.png differ
diff --git a/src/the_terminal/java_programs.md b/src/the_terminal/java_programs.md
new file mode 100644
index 00000000..f4ad9fd0
--- /dev/null
+++ b/src/the_terminal/java_programs.md
@@ -0,0 +1 @@
+# Run Java Programs
diff --git a/src/the_terminal/listing_files.md b/src/the_terminal/listing_files.md
new file mode 100644
index 00000000..c5b03b91
--- /dev/null
+++ b/src/the_terminal/listing_files.md
@@ -0,0 +1,18 @@
+# Listing Files
+
+You can list the files in your current working directory with the `ls`[^ls] command.
+
+```bash
+$ ls
+Applications
+Camera
+Desktop
+Development
+Documents
+Downloads
+```
+
+This is useful for getting your bearings, but also to find a file you forget the name of or similar.
+
+
+[^ls]: Short for "List"
diff --git a/src/the_terminal/run_java_programs.md b/src/the_terminal/run_java_programs.md
new file mode 100644
index 00000000..6531ede1
--- /dev/null
+++ b/src/the_terminal/run_java_programs.md
@@ -0,0 +1,32 @@
+# Run Java Programs
+
+If you've properly set up Java on your machine you should be able to use the `java` command
+to run any code on your machine.
+
+Just write `java` followed by the path to a file containing Java code.[^eventually]
+
+Say we had this code in a file named `Main.java`
+
+```java
+void main() {
+ IO.println("Hello");
+}
+```
+
+To run this, say `java Main.java`.
+
+```bash
+$ java Main.java
+Hello
+```
+
+If the file is in a directory that is not your current working directory, you
+should include the full path.
+
+```bash
+$ java src/Main.java
+Hello
+```
+
+[^eventually]: You can get away with just using your editor's run button for awhile, but this
+will eventually become important to know.
\ No newline at end of file
diff --git a/src/the_terminal/windows_subsystem_for_linux.md b/src/the_terminal/windows_subsystem_for_linux.md
new file mode 100644
index 00000000..dce5cb02
--- /dev/null
+++ b/src/the_terminal/windows_subsystem_for_linux.md
@@ -0,0 +1,10 @@
+# Windows Subsystem for Linux
+
+If you are using Windows there are two terminals that come preinstalled. One is `cmd.exe`, where
+you write in a language called batch, and the other is "PowerShell."
+
+Both of these differ in significant ways from bash so, if at all possible, you should get set up with the [Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/about).
+
+This will let you follow along with the bash snippets you'll see later in this book.[^other_shells]
+
+[^other_shells]: It is certainly possible for me to also include instruction for PowerShell and batch but it doesn't feel practical. I spend most of my working hours using bash and can test commands on the machine I use to write this. It would be hard for me to do that with the Windows specific shells
\ No newline at end of file
diff --git a/src/time.md b/src/time.md
new file mode 100644
index 00000000..759a310b
--- /dev/null
+++ b/src/time.md
@@ -0,0 +1,10 @@
+# Time
+
+
+
+Wikipedia defines "time" as "The continued sequence of existence and events that occurs in an apparently irreversible succession from the past, through the present, and into the future."[^source]
+
+Most everything that interacts with the real world needs to understand information about time.
+As such, Java has various ways to work with data that holds information about time.
+
+[^source]: https://en.wikipedia.org/wiki/Time
\ No newline at end of file
diff --git a/src/time/challenges.md b/src/time/challenges.md
new file mode 100644
index 00000000..89c5b840
--- /dev/null
+++ b/src/time/challenges.md
@@ -0,0 +1,83 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Print out every day from January 1st to December 31st. When the program reaches your birthday
+make it print out "Happy Birthday \" instead of the date.
+
+```java,editable
+class Main {
+ void main() {
+ // CODE HERE
+ }
+}
+```
+
+## Challenge 2.
+
+Make a `Poison` class which has a `Duration` field which stores how long
+the poison will be potent for as well as an `Instant` at which the
+poison was brewed.
+
+Implement a method that takes an `Instant` and returns if the `Poison`
+will be expired by that point.
+
+```java,editable
+import java.time.Duration;
+import java.time.Instant;
+
+class Poison {
+ // CODE HERE
+}
+
+class Main {
+ void main() {
+ var hemlock = new Poison(Instant.now(), Duration.ofDays(365 * 3));
+
+ IO.println(hemlock.isPotentAt(Instant.now())); // true
+ IO.println(hemlock.isPotentAt(Instant.now().plus(Duration.ofDays(5))); // true
+ IO.println(hemlock.isPotentAt(Instant.now().plus(Duration.ofDays(365 * 10)))); // false
+ }
+}
+```
+
+## Challenge 3.
+
+Get as input using `IO.readln` a `day`, `month`, `year`, and UTC offset.
+
+Interpret that input as an `OffsetDateTime` then print how many seconds will have
+passed between that offset date time and midnight of January 1st 1983 GMT.
+
+```java,editable
+class Main {
+ void main() {
+ // CODE HERE
+ }
+}
+```
+
+## Challenge 4.
+
+A train leaves Boston at 12:50pm EDT on August 23rd 2025 and arrives in Chicago
+at 10:12am CDT August 24th 2025.
+
+How many minutes long was that train ride? Use the Java's time classes to figure out the answer.
+
+```java,editable
+class Main {
+ void main() {
+ // CODE HERE
+ }
+}
+```
+
+As a small hint, you will first want to represent those events as `ZonedDateTime`s, convert the `ZonedDateTime`s to `Instant`s, and then get the `Duration` between those `Instant`s. Then get the number
+of minutes in that `Duration`.
+
+
+
diff --git a/src/time/date.md b/src/time/date.md
new file mode 100644
index 00000000..7eec0265
--- /dev/null
+++ b/src/time/date.md
@@ -0,0 +1,59 @@
+# Date
+
+There is one class related to time that isn't much like the others: `java.util.Date`.
+
+Java did not originally come with the `java.time` classes. At first it just had `Date`.
+
+```java
+import java.util.Date;
+
+class Main {
+ void main() {
+ Date date = new Date();
+ IO.println(date);
+ }
+}
+```
+
+`Date` is somewhat of a chimera between `Instant` and `ZonedDateTime`. It represents an instant in time but specifically in the UTC timezone.[^gmt]
+
+It is important to know about because a lot of code, including code that comes with Java, makes use of it.
+
+Whenever you see `Date` in the wild you should usually turn it into an `Instant` by
+calling `.toInstant()`.
+
+```java
+import java.time.Instant;
+import java.util.Date;
+
+class Main {
+ void main() {
+ Date date = new Date();
+ IO.println(date);
+
+ Instant instant = date.toInstant();
+ IO.println(instant);
+ }
+}
+```
+
+You can also construct a `Date` from an `Instant` using `Date.from`. This is useful if there is some code that wants a `Date` as an argument.
+
+```java
+import java.time.Instant;
+import java.util.Date;
+
+class Main {
+ void main() {
+ var instant = Instant.now();
+ IO.println(instant);
+
+ Date date = Date.from(instant);
+ IO.println(date);
+ }
+}
+```
+
+To be clear though, `Date` has problems. We aren't ready to explain all of them yet. Just treat `Date` as haunted, as in by ghosts, and use the `java.time` alternatives when you can.
+
+[^gmt]: You will notice that when we print out the date we get GMT. GMT is basically the same as UTC, though [the documentation for `Date`](https://javadoc.mccue.dev/api/java.base/java/util/Date.html) explains the difference.
\ No newline at end of file
diff --git a/src/time/duration.md b/src/time/duration.md
new file mode 100644
index 00000000..3ea152d1
--- /dev/null
+++ b/src/time/duration.md
@@ -0,0 +1,58 @@
+# Duration
+
+A `Duration` stores a duration of time.
+
+You can make these with `Duration.ofMinutes`, `Duration.ofMillis`
+and other similarly named methods.
+
+```java
+import java.time.Duration;
+
+void main() {
+ var fiveMinutes = Duration.ofMinutes(5);
+ IO.println(fiveMinutes);
+
+ var twelveMilliSeconds = Duration.ofMillis(12);
+ IO.println(twelveMilliSeconds);
+}
+```
+
+You can use these to get the duration between two `Instant`s with
+`Duration.between`.
+
+```java
+import java.time.Instant;
+import java.time.Duration;
+
+void main() {
+ var january2nd = Instant.ofEpochMilli(86400000);
+ IO.println(january2nd);
+
+ var january3rd = Instant.ofEpochMilli(86400000 * 2);
+ IO.println(january3rd);
+
+ Duration twentyFourHours = Duration.between(january2nd, january3rd);
+ IO.println(twentyFourHours);
+}
+```
+
+And you can move `Instant`s by a given `Duration` of time using its `.plus` and `.minus`
+methods.
+
+```java
+import java.time.Instant;
+import java.time.Duration;
+
+void main() {
+ var january1st = Instant.ofEpochMilli(0);
+ IO.println(january1st);
+
+ IO.println(
+ january1st.plus(Duration.ofHours(45))
+ );
+
+ IO.println(
+ january1st.minus(Duration.ofHours(1))
+ );
+}
+```
diff --git a/src/time/header.png b/src/time/header.png
new file mode 100644
index 00000000..78904413
Binary files /dev/null and b/src/time/header.png differ
diff --git a/src/time/instant.md b/src/time/instant.md
new file mode 100644
index 00000000..39106f91
--- /dev/null
+++ b/src/time/instant.md
@@ -0,0 +1,29 @@
+# Instant
+
+A `java.time.Instant` stores information on a particular moment in time.
+
+You can get the current "instant" with `Instant.now`.
+
+```java
+import java.time.Instant;
+
+void main() {
+ var now = Instant.now();
+ IO.println(now);
+}
+```
+
+But if you happen to know the number of milliseconds since January 1, 1970 0:00 UTC[^epoch], you
+can get an `Instant` which represents that point in time with `Instant.ofEpochMilli`.
+
+```java
+import java.time.Instant;
+
+void main() {
+ var january2nd = Instant.ofEpochMilli(86400000);
+ IO.println(january2nd);
+}
+```
+
+[^epoch]: https://en.wikipedia.org/wiki/Unix_time
+
diff --git a/src/time/local_date.md b/src/time/local_date.md
new file mode 100644
index 00000000..64e7ea7f
--- /dev/null
+++ b/src/time/local_date.md
@@ -0,0 +1,30 @@
+# LocalDate
+
+A local date is something like "January 10th, 2024."
+
+This just records a day, month, and year. It doesn't know
+in what part of the world it was January 10th 2024, just
+that somewhere the "local" date was that.
+
+You can make a `LocalDate` with `LocalDate.of`.
+
+```java
+import java.time.LocalDate;
+
+void main() {
+ var jan10 = LocalDate.of(2024, 1, 10);
+ IO.println(jan10);
+}
+```
+
+And you can get the current `LocalDate` in whatever timezone
+your computer is programmed to be in with `LocalDate.now();`
+
+```java
+import java.time.LocalDate;
+
+void main() {
+ var now = LocalDate.now();
+ IO.println(now);
+}
+```
\ No newline at end of file
diff --git a/src/time/local_date_time.md b/src/time/local_date_time.md
new file mode 100644
index 00000000..c7c124dc
--- /dev/null
+++ b/src/time/local_date_time.md
@@ -0,0 +1,22 @@
+# LocalDateTime
+
+What do you get if you combine a `LocalDate` and a `LocalTime`? A `LocalDateTime`!
+
+A `LocalDateTime` stores dates and times.
+
+If you have both a `LocalDate` and a `LocalTime` you can combine them
+with `LocalDateTime.of`.
+
+```java
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.LocalDateTime;
+
+class Main {
+ void main() {
+ var jan10 = LocalDate.of(2024, 1, 10);
+ var tenTwentyFour = LocalTime.of(10, 24, 0);
+ IO.println(LocalDateTime.of(jan10, tenTwentyFour));
+ }
+}
+```
\ No newline at end of file
diff --git a/src/time/local_time.md b/src/time/local_time.md
new file mode 100644
index 00000000..98a98f21
--- /dev/null
+++ b/src/time/local_time.md
@@ -0,0 +1,29 @@
+# LocalTime
+
+In the same way a local date leaves off context about where
+it was and what time it was, a local time just stores the time.
+
+This means it will hold the exact time during the day, down to the nanoseconds.
+
+You can make a `LocalTime` with `LocalTime.of` giving it the hours, minutes, and
+seconds into the day.
+
+```java
+import java.time.LocalTime;
+
+void main() {
+ var tenTwentyFour = LocalTime.of(10, 24, 0);
+ IO.println(tenTwentyFour);
+}
+```
+
+And similarly you can get the current time your computer thinks it is with `LocalTime.now()`
+
+```java
+import java.time.LocalTime;
+
+void main() {
+ var now = LocalTime.now();
+ IO.println(now);
+}
+```
\ No newline at end of file
diff --git a/src/time/offset_date_time.md b/src/time/offset_date_time.md
new file mode 100644
index 00000000..07b17adc
--- /dev/null
+++ b/src/time/offset_date_time.md
@@ -0,0 +1,63 @@
+# OffsetDateTime
+
+An `OffsetDateTime` is similar to a `ZonedDateTime` but with the key difference
+that an `OffsetDateTime` doesn't record a moment in a specific time zone, but instead
+as an offset from the [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time)[^utc] timezone.
+
+This is useful because timezones change their rules frequently. If you had to pick a representation
+of dates and times to store, this is a good default.
+
+```java
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ var feb14 = LocalDate.of(2025, 2, 14);
+ var fiveTwentyThree = LocalTime.of(5, 23, 0);
+ var est = ZoneId.of("US/Eastern");
+
+ LocalDateTime localDateTime = LocalDateTime.of(feb14, fiveTwentyThree);
+ ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, est);
+ OffsetDateTime offsetDateTime = zonedDateTime.toOffsetDateTime();
+
+ IO.println(offsetDateTime);
+ }
+}
+```
+
+You can get the current `OffsetDateTime` for the time zone your computer is running in
+with `OffsetDateTime.now()`.
+
+```java
+import java.time.OffsetDateTime;
+
+class Main {
+ void main() {
+ var now = OffsetDateTime.now();
+
+ IO.println(now);
+ }
+}
+```
+
+And you can do the same for an arbitrary time zone by giving a `ZoneId` to
+`now`. Java knows the UTC offset for every time zone.
+
+```java
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ var now = OffsetDateTime.now(ZoneId.of("US/Eastern"));
+
+ IO.println(now);
+ }
+}
+```
+
+[^utc]: UTC stands for "Coordinated Universal Time" in English and "Temps Universel CoordonnΓ©" in French. The specific letter order of "UTC" (rather than "CUT" or "TUC") was chosen as [a compromise between the two languages](https://www.nist.gov/pml/time-and-frequency-division/how-utcnist-related-coordinated-universal-time-utc-international#7114136).
\ No newline at end of file
diff --git a/src/time/time_zones.md b/src/time/time_zones.md
new file mode 100644
index 00000000..f81d1a83
--- /dev/null
+++ b/src/time/time_zones.md
@@ -0,0 +1,64 @@
+# Time Zones
+
+Partially because of how day night cycles work
+and sometimes because of arcane rules made up
+to help out farmers, we have time zones.
+
+This means that while it might be 9am in Boston
+it would simultaneously be 10pm in Tokyo. Boston and Tokyo
+are in different time zones.
+
+You can get access to the time zone your computer
+is using with `ZoneId.systemDefault()`. This gives you
+a `ZoneId` which identifies a time zone.
+
+```java
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ ZoneId tz = ZoneId.systemDefault();
+
+ IO.println(tz);
+ }
+}
+```
+
+If you want to get the identifier for a different time zone
+you use `ZoneId.of` and give it a `String` identifying
+the time zone. These come from [a big list](https://www.iana.org/time-zones)
+published by the Internet Assigned Numbers Authority (IANA).
+
+
+```java
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ // Eastern Standard Time
+ ZoneId tz = ZoneId.of("US/Eastern");
+
+ IO.println(tz);
+ }
+}
+```
+
+While you won't be using this directly, every `ZoneId`
+has the information needed to determine what time it would
+be accessible via `getRules()`.
+
+```java
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ // Eastern Standard Time
+ ZoneId tz = ZoneId.of("US/Eastern");
+
+ IO.println(tz.getRules());
+ }
+}
+```
+
+And it is this machinery used by the parts of the time API which
+determine the exact time it would be in a given time zone.
diff --git a/src/time/zoned_date_time.md b/src/time/zoned_date_time.md
new file mode 100644
index 00000000..80149bc7
--- /dev/null
+++ b/src/time/zoned_date_time.md
@@ -0,0 +1,59 @@
+# ZonedDateTime
+
+A `ZonedDateTime` has all the information of
+a `LocalDateTime`, but with the addition of a time zone.
+
+These are useful for recording the time that events took place
+in a way that can be communicated.
+
+```java
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ var jan10 = LocalDate.of(2024, 1, 10);
+ var tenTwentyFour = LocalTime.of(10, 24, 0);
+ var est = ZoneId.of("US/Eastern");
+
+ LocalDateTime localDateTime = LocalDateTime.of(jan10, tenTwentyFour);
+ ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, est);
+
+ IO.println(zonedDateTime);
+ }
+}
+```
+
+You can get the current `ZonedDateTime` for the time zone your computer is running in
+with `ZonedDateTime.now()`.
+
+```java
+import java.time.ZonedDateTime;
+
+class Main {
+ void main() {
+ var now = ZonedDateTime.now();
+
+ IO.println(now);
+ }
+}
+```
+
+And you can do the same for an arbitrary time zone by giving a `ZoneId` to
+`now`.
+
+```java
+import java.time.ZonedDateTime;
+import java.time.ZoneId;
+
+class Main {
+ void main() {
+ var now = ZonedDateTime.now(ZoneId.of("US/Eastern"));
+
+ IO.println(now);
+ }
+}
+```
diff --git a/src/variables.md b/src/variables.md
index ceb18228..3b8ed1fa 100644
--- a/src/variables.md
+++ b/src/variables.md
@@ -1,18 +1,19 @@
# Local Variables
+
+
Mechanically, the next thing to cover is "variables".
```java
void main() {
String boss = "Jaqueline";
- System.out.println(boss);
+ IO.println(boss);
}
```
A variable declaration has three components - the "type", the "name", and the "initial value".
-```java,no_run
```java,no_run
String boss = "Jaqueline";
// type name initial value
@@ -26,8 +27,20 @@ hand side and you can use that name instead of the value.
```java
~void main() {
-// Does the same thing as System.out.println("Jaqueline");
+// Does the same thing as IO.println("Jaqueline");
String boss = "Jaqueline";
-System.out.println(boss);
+IO.println(boss);
~}
```
+
+You may even use that name to give an initial value to another variable.
+
+```java
+~void main() {
+// Does the same thing as IO.println("Jaqueline");
+String boss = "Jaqueline";
+// You can use variables on the right of the = too.
+String person = boss;
+IO.println(person);
+~}
+```
\ No newline at end of file
diff --git a/src/variables/challenges.md b/src/variables/challenges.md
index c098748c..1001e7f6 100644
--- a/src/variables/challenges.md
+++ b/src/variables/challenges.md
@@ -12,11 +12,11 @@ What will this program output when run? Write down your guess and then try runni
```java,editable
void main() {
String mascot = "The Noid";
- System.out.println(mascot);
+ IO.println(mascot);
mascot = "Pizza the Hut";
- System.out.println(mascot);
+ IO.println(mascot);
mascot = "Little Caesar";
- System.out.println(mascot);
+ IO.println(mascot);
}
```
@@ -29,18 +29,18 @@ void main() {
String fruit;
fruit = "apple";
- System.out.println(fruit);
+ IO.println(fruit);
final String vegetable = "carrot";
- System.out.println(fruit);
- System.out.println(vegetable);
+ IO.println(fruit);
+ IO.println(vegetable);
fruit = "orange";
vegetable = "celery";
- System.out.println(fruit);
- System.out.println(vegetable);
+ IO.println(fruit);
+ IO.println(vegetable);
}
```
@@ -58,11 +58,12 @@ void main() {
b = a;
a = b;
- System.out.println(a);
- System.out.println(b);
+ IO.println(a);
+ IO.println(b);
}
```
+
## Challenge 4
Only adding lines in the middle and without writing `"A"` or `"B"` again,
@@ -73,6 +74,7 @@ B
A
```
+
```java,editable
void main() {
String a = "A";
@@ -82,15 +84,35 @@ void main() {
// You can add code here
// Don't touch below this
- System.out.println(a);
- System.out.println(b);
+ IO.println(a);
+ IO.println(b);
}
```
+To be clear: you are not allowed to write `b = "A";` or `a = "B";`
+
+
+ Hint 1:
+ You can always make new variables.
+
+
+
+ Hint 2:
+ What you need to do is make a "temporary variable" to hold one of the values before you swap them.
+
+
+
+ Solution
+
+String temp = a;
+a = b;
+b = temp;
+
+
## Challenge 5
-Some of the variables in this program are named "wrong." Fix them.
+Some of the variables in this program are named "wrong."[^byconvention] Fix them.
```java,editable
void main() {
@@ -100,4 +122,6 @@ void main() {
String FASTRunner = "bolt";
String slowRunner = "tortoise";
}
-```
\ No newline at end of file
+```
+
+[^byconvention]: By currently prevalent social conventions. None are actually "wrong" from the perspective of Java.
\ No newline at end of file
diff --git a/src/variables/delayed_assignment.md b/src/variables/delayed_assignment.md
index 1a548b27..c701fb8d 100644
--- a/src/variables/delayed_assignment.md
+++ b/src/variables/delayed_assignment.md
@@ -8,7 +8,7 @@ void main() {
String contestWinner;
contestWinner = "Boaty McBoatface";
- System.out.println(contestWinner);
+ IO.println(contestWinner);
}
```
@@ -33,7 +33,7 @@ void main() {
String contestWinner;
// This will not run, since Java knows that
// you never gave contestWinner an initial value.
- System.out.println(contestWinner);
+ IO.println(contestWinner);
}
```
diff --git a/src/variables/final_variables.md b/src/variables/final_variables.md
index f8dd78a7..057fbefd 100644
--- a/src/variables/final_variables.md
+++ b/src/variables/final_variables.md
@@ -6,7 +6,7 @@ mark a variable as "final", meaning its value can never be reassigned.
```java
~void main() {
final String coolestChef = "Anthony Bourdain";
-System.out.println(coolestChef);
+IO.println(coolestChef);
~}
```
@@ -16,11 +16,11 @@ If you try to reassign a final variable, Java will not accept your program.
```java,does_not_compile
~void main() {
final String coolestChef = "Anthony Bourdain";
-System.out.println(coolestChef);
+IO.println(coolestChef);
// I'm sorry, but no. Cool guy, but no.
coolestChef = "Gordan Ramsey";
-System.out.println(coolestChef);
+IO.println(coolestChef);
~}
```
@@ -41,7 +41,7 @@ final String genie = "Robin Williams";
// ......
// You can still be sure "genie"
// has the value of "Robin Williams"
-System.out.println(genie);
+IO.println(genie);
```
Variables whose assignment is delayed can also be marked final.
@@ -50,7 +50,7 @@ Variables whose assignment is delayed can also be marked final.
~void main() {
final String mario;
mario = "Charles Martinet";
-System.out.println(mario);
+IO.println(mario);
~}
```
@@ -65,7 +65,7 @@ mario = "Charles Martinet";
// But you cannot reassign it afterwards
mario = "Chris Pratt";
-System.out.println(mario);
+IO.println(mario);
~}
```
diff --git a/src/variables/header.png b/src/variables/header.png
new file mode 100644
index 00000000..b7038a83
Binary files /dev/null and b/src/variables/header.png differ
diff --git a/src/variables/inferred_types.md b/src/variables/inferred_types.md
index df19bc27..214f33b8 100644
--- a/src/variables/inferred_types.md
+++ b/src/variables/inferred_types.md
@@ -11,7 +11,7 @@ be.
// of the = is in quotes, Java knows that
// it is a String.
var theDude = "Lebowski";
-System.out.println(theDude);
+IO.println(theDude);
~}
```
@@ -23,7 +23,7 @@ You cannot use `var` with variables whose assignment is delayed.
// Java doesn't know enough to infer the type
var theDude;
theDude = "Lebowski";
-System.out.println(theDude);
+IO.println(theDude);
~}
```
@@ -33,7 +33,7 @@ and cannot be reassigned.
```java
~void main() {
final var theDude = "Lebowski";
-System.out.println(theDude);
+IO.println(theDude);
~}
```
@@ -43,6 +43,6 @@ you might not be yet. There is no shame in writing out the type explicitly.
```java
~void main() {
String theDude = "lebowski";
-System.out.println(theDude);
+IO.println(theDude);
~}
```
diff --git a/src/variables/naming.md b/src/variables/naming.md
index 2c280ee8..7c23ae45 100644
--- a/src/variables/naming.md
+++ b/src/variables/naming.md
@@ -11,10 +11,10 @@ String apple = "Red Delicious";
If it is multiple words, the first word should be lowercase
and the others should start with a capital letter.
-This convention is called `camelCase` because the capitals looks like the humps on a Camels back[^camel].
+This convention is called `camelCase` because the capitals looks like the humps on a Camels back.
Just like proper formatting, sticking to this style will increase your chances of
someone online being able to help you with your code.
[^perry]: [Trapped! By societal convention!](https://youtu.be/CnOWLuN37D8?t=64)
-[^camel]: And because doing this will increase your body's ability to retain water by ~34%
+
diff --git a/src/variables/reassignment.md b/src/variables/reassignment.md
index 77a0451d..639b761e 100644
--- a/src/variables/reassignment.md
+++ b/src/variables/reassignment.md
@@ -5,9 +5,9 @@ After a variable is declared and assigned an initial value, that value can be la
```java
void main() {
String boss = "Jaqueline";
- System.out.println(boss);
+ IO.println(boss);
boss = "Chelsea";
- System.out.println(boss);
+ IO.println(boss);
}
```
@@ -26,9 +26,9 @@ the new value from that point in the program onwards.
void main() {
String boss = "Jaqueline";
// This will output "Jaqueline"
- System.out.println(boss);
+ IO.println(boss);
boss = "Chelsea";
// But this will output "Chelsea"
- System.out.println(boss);
+ IO.println(boss);
}
```
diff --git a/src/visibility.md b/src/visibility.md
new file mode 100644
index 00000000..e299a597
--- /dev/null
+++ b/src/visibility.md
@@ -0,0 +1,22 @@
+# Visibility
+
+
+
+When code is all in one file, everything is "visible." This means that
+if there is a method you are always allowed to call it.
+
+```java
+class Main {
+ void canCallThis() {
+ IO.println("of course!")
+ }
+
+ void main() {
+ canCallThis();
+ }
+}
+```
+
+And if there is a field you can read it, if there is a class you can make an instance of it, etc.
+
+Once we split into multiple files, you are allowed to make things less visible.
diff --git a/src/visibility/accessors.md b/src/visibility/accessors.md
new file mode 100644
index 00000000..2c895a55
--- /dev/null
+++ b/src/visibility/accessors.md
@@ -0,0 +1,61 @@
+# Accessors
+
+When a field is hidden that is usually because you want to control
+how it might be changed.
+
+To access the current value of a private field you need to go through a non-private method.
+If a method just provides access to a field we call that an "accessor."
+
+```java,no_run
+class Dog {
+ private String name;
+
+ Dog(String name) {
+ this.name = name;
+ }
+
+ // The name field is private, but
+ // you can access it by calling the name method.
+ String name() {
+ return this.name;
+ }
+}
+```
+```java
+class Main {
+ void main() {
+ var dog = new Dog("Daisy");
+
+ // dog.name won't work because the name field is private
+ // dog.name() will work because the name method is not
+ IO.println(dog.name());
+ }
+}
+~class Dog {
+~ private String name;
+~
+~ Dog(String name) {
+~ this.name = name;
+~ }
+~
+~ String name() {
+~ return this.name;
+~ }
+~}
+```
+
+We would also consider things like the `length` method on `String`s to be "accessors."[^notthat]
+
+```java
+void main() {
+ String s = "abc";
+ IO.println(
+ // We can't see what fields underly this,
+ // but we can access the length
+ s.length()
+ );
+}
+```
+
+[^notthat]: Not that the categorization matters much, but socially we expect "accessor"-looking methods to only give you a value and not "do stuff" like
+increment a number or mess with a file.
\ No newline at end of file
diff --git a/src/visibility/challenges.md b/src/visibility/challenges.md
new file mode 100644
index 00000000..ec4a65b9
--- /dev/null
+++ b/src/visibility/challenges.md
@@ -0,0 +1,92 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1
+
+The following `Ratio` class should have an invariant where `denominator`
+cannot be `0`.
+
+```java,no_run
+class Ratio {
+ int numerator;
+ int denominator;
+
+ Ratio(int numerator, int denominator) {
+ if (denominator == 0) {
+ throw new RuntimeException("Denominator cannot be zero");
+ }
+ }
+
+ double value() {
+ return ((double) numerator) / denominator;
+ }
+}
+```
+
+Unfortunately other classes can directly access the `denominator` field.
+
+Make the denominator field private and add an accessor method for other classes to use.
+You can name this accessor `.denominator()` or `.getDenominator()`.
+
+## Challenge 2
+
+Alter the code from the last challenge such that numerator is also private and only
+usable via an accessor method.
+
+## Challenge 3
+
+Alter the code from the last challenge such that you can not only access but also
+mutate the `numerator` and `denominator` fields via exposed methods.
+The method for mutating the `denominator` should throw an exception
+if someone tries to set it to zero.
+
+## Challenge 4
+
+Given this `Pineapple` class make every method except `digest` private.
+
+```java,no_run
+class Pineapple {
+ void digestProtein(String name) {
+ IO.println("Pineapple juice is digesting the proteins in " + name);
+ }
+
+ void eatPork() {
+ digestProtein("pork");
+ }
+
+ void eatChicken() {
+ digestProtein("chicken");
+ }
+
+ void eatBeef() {
+ digestProtein("beef");
+ }
+
+ void eatYou() {
+ IO.println("Pineapple juice is eating you from the inside.");
+ }
+
+ void digest(String thing) {
+ switch (thing) {
+ case "pork" -> eatPork();
+ case "chicken" -> eatChicken();
+ case "beef" -> eatBeef();
+ default -> eatYou();
+ }
+ }
+}
+```
+
+## Challenge 5
+
+Rewrite the code from the previous challenge such that the `digest`
+method on `Pineapple` does the same thing but no other private methods
+exist.
+
+Note when doing this that you wouldn't need to consider other code.
+The behavior of the only exposed method does not change so those private
+methods would only be "implementation details."
diff --git a/src/visibility/getter_and_setters.md b/src/visibility/getter_and_setters.md
new file mode 100644
index 00000000..f825d5eb
--- /dev/null
+++ b/src/visibility/getter_and_setters.md
@@ -0,0 +1,43 @@
+# Getters and Setters
+
+A very silly thing you are likely to see if you dig around on the internet
+is classes that look like this.
+
+```java
+class Person {
+ private String name;
+ private int age;
+
+ String getName() {
+ return this.name;
+ }
+
+ void setName(String name) {
+ this.name = name;
+ }
+
+ String getAge() {
+ return this.age;
+ }
+
+ void setAge(String age) {
+ this.age = age;
+ }
+}
+```
+
+So people make classes with all private fields and then for each field `thing` they
+have two methods - `getThing` and `setThing`.
+
+To which you might immediately ask - what is the difference between this and just having non-private fields.
+
+```java
+class Person {
+ String name;
+ int age;
+}
+```
+
+The answer to that is interesting. We'll get to it, but the short story is that its a bit of a holdover from a very weird period in the early 2000s.
+
+I mention it specifically so that you know that there isn't any important information you are missing and you are not crazy.
\ No newline at end of file
diff --git a/src/visibility/header.png b/src/visibility/header.png
new file mode 100644
index 00000000..4ae46581
Binary files /dev/null and b/src/visibility/header.png differ
diff --git a/src/visibility/invariants.md b/src/visibility/invariants.md
new file mode 100644
index 00000000..aa83d239
--- /dev/null
+++ b/src/visibility/invariants.md
@@ -0,0 +1,70 @@
+# Invariants
+
+Having private fields and methods is useful when you want
+to maintain some invariants.
+
+Say you wanted a class that holds an even number.
+
+```java
+class EvenNumberHolder {
+ int value;
+
+ EvenNumberHolder(int value) {
+ if (value % 2 == 1) {
+ throw new RuntimeException(value + " is not even");
+ }
+
+ this.value = value;
+ }
+}
+```
+
+You can always make the value `final` to prevent its value from being changed.
+
+```java
+class EvenNumberHolder {
+ final int value;
+
+ EvenNumberHolder(int value) {
+ if (value % 2 == 1) {
+ throw new RuntimeException(value + " is not even");
+ }
+
+ this.value = value;
+ }
+}
+```
+
+But if you actually wanted to change its value that isn't enough.
+
+By making the field private you can know that other code has to call methods to access or
+change the value. That gives you a clean place to "enforce" your invariants.
+
+```java
+class EvenNumberHolder {
+ private int value;
+
+ EvenNumberHolder(int value) {
+ // The constructor explicitly rejects an odd value
+ if (value % 2 == 1) {
+ throw new RuntimeException(value + " is not even");
+ }
+
+ this.value = value;
+ }
+
+ // There is no way to get an odd value now - you can only
+ // change it in steps of two.
+ int value() {
+ return this.value;
+ }
+
+ void addTwo() {
+ this.value += 2;
+ }
+
+ void subtractTwo() {
+ this.value -= 2;
+ }
+}
+```
\ No newline at end of file
diff --git a/src/visibility/private.md b/src/visibility/private.md
new file mode 100644
index 00000000..86620ac8
--- /dev/null
+++ b/src/visibility/private.md
@@ -0,0 +1,2 @@
+# Private
+
diff --git a/src/visibility/private_constructor.md b/src/visibility/private_constructor.md
new file mode 100644
index 00000000..4736b265
--- /dev/null
+++ b/src/visibility/private_constructor.md
@@ -0,0 +1 @@
+# Private Fields
diff --git a/src/visibility/private_fields.md b/src/visibility/private_fields.md
new file mode 100644
index 00000000..146f8d61
--- /dev/null
+++ b/src/visibility/private_fields.md
@@ -0,0 +1,25 @@
+# Private Fields
+
+Similar to private methods, you can also mark a field as private.
+
+```java
+class Kaiju {
+ private int timesLostToGodzilla;
+
+ Kaiju() {
+ this.timesLostToGodzilla = 0;
+ }
+
+ void fightGodzilla() {
+ this.timesLostToGodzilla++;
+ }
+
+ boolean isLoser() {
+ return this.timesLostToGodzilla > 0;
+ }
+}
+```
+
+This makes it so that code in other files cannot see or change the field directly.
+
+
diff --git a/src/visibility/private_methods.md b/src/visibility/private_methods.md
new file mode 100644
index 00000000..2db9a450
--- /dev/null
+++ b/src/visibility/private_methods.md
@@ -0,0 +1,28 @@
+# Private Methods
+
+If a class has a method that it uses but that you do not want other code to see,
+you can mark it `private`.
+
+```java,no_run
+class RiceCooker {
+ int temperature;
+
+ private boolean shouldTurnOff() {
+ return temperature > 100;
+ }
+
+ void operate() {
+ if (shouldTurnOff()) {
+ turnOff();
+ }
+ else {
+ // ...
+ }
+ }
+}
+```
+
+This makes it so that code in `RiceCooker.java` can see and call the `shouldTurnOff` method but code in other files cannot.
+
+This is useful if you want to box up some logic but don't want to have to think about
+what happens if other code calls it.
\ No newline at end of file
diff --git a/src/visibility/the_game.md b/src/visibility/the_game.md
new file mode 100644
index 00000000..a3a82cbe
--- /dev/null
+++ b/src/visibility/the_game.md
@@ -0,0 +1,11 @@
+# The Game
+
+The only reason you would care about how visible a particular method or field is
+if you were playing what I call "the game[^that]"
+
+In the game you take some unit of code, like a class, and pretend that someone is going to
+try and do every possible thing that you can do with it.
+
+If you have methods named `stepOne()`, `stepTwo()` and `stepThree()` - what happens if someone calls them in the wrong order. If you have a field named `denominator` - what happens if someone sets it to zero. That sort of thing.
+
+[^that]: Not the game that you just lost by remembering you were playing the game.
\ No newline at end of file
diff --git a/src/visibility_ii.md b/src/visibility_ii.md
new file mode 100644
index 00000000..56494749
--- /dev/null
+++ b/src/visibility_ii.md
@@ -0,0 +1 @@
+# Visibility II
diff --git a/theme/book.js b/theme/book.js
index 0524af90..24a6c552 100644
--- a/theme/book.js
+++ b/theme/book.js
@@ -115,10 +115,10 @@ function playground_text(playground, hidden = true) {
let text = playground_text(code_block);
var params = {
- release: '21',
+ release: '25',
runtime: 'latest',
action: 'run',
- preview: true,
+ preview: false,
code: text,
};
diff --git a/theme/index.hbs b/theme/index.hbs
index bbd3fd6a..bc69a981 100644
--- a/theme/index.hbs
+++ b/theme/index.hbs
@@ -138,23 +138,23 @@
+
+Comments are useful when reading code. Since they can contain any text,
+you can use them to clarify your intent, make note of issues to address
+later, etc.
+
+```java
+class Main {
+ // TODO: Make this actually add one
+ int addOne(int x) {
+ return x + 2;
+ }
+
+ // The return value here will always be non-negative
+ int absoluteValue(int x) {
+ if (x < 0) {
+ return -x;
+ }
+ else {
+ return x;
+ }
+ }
+
+ void main() {
+ IO.println(addOne(5));
+ IO.println(absoluteValue(-25));
+ }
+}
+```
+
+The problem with comments is that they are just text. It would be difficult to write a program
+that acts upon or uses information in a comment.
+
+Annotations, which you can think of as "structured comments", are useful for this purpose.
+
+```java
+class Main {
+ @TODO("Make this actually add one")
+ int addOne(int x) {
+ return x + 2;
+ }
+
+ @NonNegative int absoluteValue(int x) {
+ if (x < 0) {
+ return -x;
+ }
+ else {
+ return x;
+ }
+ }
+
+ void main() {
+ IO.println(addOne(5));
+ IO.println(absoluteValue(-25));
+ }
+}
+```
\ No newline at end of file
diff --git a/src/annotations/challenges.md b/src/annotations/challenges.md
new file mode 100644
index 00000000..b6699d6b
--- /dev/null
+++ b/src/annotations/challenges.md
@@ -0,0 +1,48 @@
+# Challenges
+
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Declare your own `@Favorite` and `@LeastFavorite`
+annotations.
+
+Use them to mark the code you have written so far that is your
+favorite and the code that is your least favorite.
+
+## Challenge 2.
+
+Declare a `@LoFi` annotation. It should have an element for the `author`
+and another element for the `song` that you were listening to on
+the "[24/7 Lofi Hip Hop Radio - Beats to Relax/Study To](https://www.youtube.com/watch?v=jfKfPfyJRdk)"
+stream when you were writing the annotated code.
+
+Chill out to some tunes, write some code, and use that annotation.
+
+## Challenge 3.
+
+Write a method that takes in an `Object`. Use reflection to print out the values in that `Object`'s
+declared fields. Skip any that are non-public but also any marked with a `@Skip` annotation
+that you should also define.
+
+```java
+// CODE HERE
+
+class Table {
+ public boolean flowerPot = true;
+ public String scissors = "green";
+
+ @Skip
+ public String cat = "tabby";
+}
+
+class Main {
+ void main() {
+ // CODE HERE
+ }
+}
+```
diff --git a/src/annotations/declaration.md b/src/annotations/declaration.md
new file mode 100644
index 00000000..d276869e
--- /dev/null
+++ b/src/annotations/declaration.md
@@ -0,0 +1,12 @@
+# Declaration
+
+To declare an annotation you use `@interface` followed by a type name.
+
+```java,no_run
+@interface NonNegative {
+}
+```
+
+We call these "annotation interfaces."[^shared]
+
+[^shared]: They share some properties with regular interfaces but it's best to think of them as their own thing.
\ No newline at end of file
diff --git a/src/annotations/defaults.md b/src/annotations/defaults.md
new file mode 100644
index 00000000..33ccf94e
--- /dev/null
+++ b/src/annotations/defaults.md
@@ -0,0 +1,63 @@
+# Defaults
+
+You can give a default value for an element by writing `default` followed by a value.
+
+You don't need to explicitly specify a value for any elements that have a default.
+
+```java
+enum Priority {
+ HIGH,
+ LOW
+}
+
+@interface Todo {
+ String description();
+ Priority priority() default Priority.LOW;
+}
+
+// Priority does not need to be specified since
+// it has a default specified
+@Todo(description="Write the code")
+class Code {
+ // But you can still specify it in situations where you want to
+ @Todo(description="Write main method", priority=Priority.HIGH)
+ void main() {
+ }
+}
+```
+
+If all values have defaults then you don't need to specify anything.
+
+```java
+enum Priority {
+ HIGH,
+ LOW
+}
+
+@interface Todo {
+ String description() default "Do Stuff";
+ Priority priority() default Priority.LOW;
+}
+
+@Todo
+class Code {
+}
+```
+
+And if the only element that doesn't have a default value is named `value`, and thats the only one you want to specify, you don't need to give its name.
+
+```java
+enum Priority {
+ HIGH,
+ LOW
+}
+
+@interface Todo {
+ String value();
+ Priority priority() default Priority.LOW;
+}
+
+@Todo("Really need to write something in here")
+class Code {
+}
+```
\ No newline at end of file
diff --git a/src/annotations/deprecated b/src/annotations/deprecated
new file mode 100644
index 00000000..d57b74bf
--- /dev/null
+++ b/src/annotations/deprecated
@@ -0,0 +1 @@
+# @Deprecated
diff --git a/src/annotations/elements.md b/src/annotations/elements.md
new file mode 100644
index 00000000..1ec5d9dd
--- /dev/null
+++ b/src/annotations/elements.md
@@ -0,0 +1,66 @@
+# Elements
+
+Annotation interfaces can contain any number of elements.
+
+```java,no_run
+@interface Todo {
+ String description();
+}
+```
+
+These are declared in the same way as methods in an interface, save for some
+important restrictions.
+
+The method should take no arguments.
+
+```java,no_run,does_not_compile
+@interface Todo {
+ // Cannot take arguments
+ String description(int x);
+}
+```
+
+And the return value needs to be one of a few built-in types like `Class`, `String`, `int`, `boolean`, etc.[^fulllist], an `enum`, another annotation interface, or an array of one of those.
+
+```java,no_run,does_not_compile
+enum Priority {
+ HIGH,
+ LOW
+}
+
+@interface Deadline {
+ int year();
+ int month();
+ int day();
+}
+
+class PersonInCharge {}
+
+@interface Todo {
+ // String β
+ String description();
+
+ // int β
+ int someNumber();
+
+ // boolean β
+ boolean isImportant();
+
+ // Class β
+ Class someRelatedClass();
+
+ // Arrays β
+ String[] notes();
+
+ // Enums β
+ Priority priority();
+
+ // Other annotations β
+ Deadline deadline();
+
+ // Other classes β
+ PersonInCharge personInCharge();
+}
+```
+
+[^fulllist]: You can find the full list [here](https://docs.oracle.com/javase/specs/jls/se25/html/jls-9.html#jls-9.6). It is a short list.
diff --git a/src/annotations/header.png b/src/annotations/header.png
new file mode 100644
index 00000000..ace3923d
Binary files /dev/null and b/src/annotations/header.png differ
diff --git a/src/annotations/override.md b/src/annotations/override.md
new file mode 100644
index 00000000..bdbc3f05
--- /dev/null
+++ b/src/annotations/override.md
@@ -0,0 +1,33 @@
+# @Override
+
+The `@Override` you can put on methods to have Java check that you are properly overriding them
+is an annotation.
+
+There's not much else to say besides "hey, thats what that was!" but I think its
+worth noting.
+
+```java,no_run
+interface Num {
+ boolean odd();
+
+ boolean even();
+}
+
+class IntNum implements Num {
+ final int x;
+
+ IntNum(int x) {
+ this.x = x;
+ }
+
+ @Override // This is an annotation?
+ public boolean odd() {
+ return x % 2 != 0;
+ }
+
+ @Override // Always has been.
+ public boolean even() {
+ return !odd();
+ }
+}
+```
\ No newline at end of file
diff --git a/src/annotations/reflective_access.md b/src/annotations/reflective_access.md
new file mode 100644
index 00000000..f889f624
--- /dev/null
+++ b/src/annotations/reflective_access.md
@@ -0,0 +1,56 @@
+# Reflective Access
+
+If something is annotated with a runtime retained annotation,
+you can get an object holding that data using `.getAnnotation`.
+
+This will either return `null` if the field, method, class, etc. is not
+annotated with that annotation or it will give you an object
+with methods you can call to see the values specified in the annotation.
+
+```java
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Field;
+
+class Main {
+ void main() {
+ Class
+
If methods always had to do the same thing each time they were run, they wouldn't be that useful.
The way to customize what happens when a method is called is to have them take "arguments."
```java
void sayHello(String name) {
- System.out.println("Hello " + name + "!");
+ IO.println("Hello " + name + "!");
}
void main() {
diff --git a/src/arguments/aliasing.md b/src/arguments/aliasing.md
index a27b6dc0..3c8b7d50 100644
--- a/src/arguments/aliasing.md
+++ b/src/arguments/aliasing.md
@@ -12,14 +12,14 @@ void main() {
int[] nums = new int[] { 8 };
// The first number is 8
- System.out.println(
+ IO.println(
"The first number is " + nums[0]
);
incrementFirst(nums);
// Now it is 9
- System.out.println(
+ IO.println(
"Now it is " + nums[0]
);
}
diff --git a/src/arguments/challenges.md b/src/arguments/challenges.md
index cc834883..810facd5 100644
--- a/src/arguments/challenges.md
+++ b/src/arguments/challenges.md
@@ -16,16 +16,16 @@ The `size` argument should control how big of a square is output.
void main() {
printSquare(4);
- System.out.println();
+ IO.println();
printSquare(3);
- System.out.println();
+ IO.println();
printSquare(2);
- System.out.println();
+ IO.println();
printSquare(1);
- System.out.println();
+ IO.println();
}
```
@@ -41,15 +41,51 @@ was given.
void main() {
printSquare(3);
- System.out.println();
+ IO.println();
printSquare(-3);
- System.out.println();
+ IO.println();
- System.out.println();
+ IO.println();
printSquare(-2);
- System.out.println();
+ IO.println();
printSquare(2);
}
```
## Challenge 3.
+
+Write a method with four overloads such that
+the code in `main` can run unchanged.
+
+```java,editable
+// CODE HERE
+
+void main() {
+ f(2);
+ f("b");
+ f('9');
+ f(new String[] { "s" });
+}
+```
+
+## Challenge 4.
+
+Call the defined methods in a way that outputs "I did it!"
+
+```java,editable
+void i() {
+ IO.print("I");
+}
+
+void did(String what) {
+ IO.println("did " + what);
+}
+
+void space() {
+ IO.print(" ");
+}
+
+void main() {
+ // Code here
+}
+```
\ No newline at end of file
diff --git a/src/arguments/declaration.md b/src/arguments/declaration.md
index fad2eb41..d162200a 100644
--- a/src/arguments/declaration.md
+++ b/src/arguments/declaration.md
@@ -9,14 +9,14 @@ Each argument declaration looks the same as a variable declaration and has both
// This declares a single argument named "food" that
// has a type of "String".
void eat(String food) {
- System.out.println("I ate " + food);
+ IO.println("I ate " + food);
}
// This declares two arguments
// "to", which is a String and
// "age", which is an int.
void happyBirthday(String to, int age) {
- System.out.println(
+ IO.println(
"Happy " + age + "th birthday " + to + "!"
);
}
diff --git a/src/arguments/final_arguments.md b/src/arguments/final_arguments.md
index 70903f6e..60aedd9a 100644
--- a/src/arguments/final_arguments.md
+++ b/src/arguments/final_arguments.md
@@ -5,7 +5,7 @@ Just like normal variable declarations, arguments can be marked
```java
void eat(final String food) {
- System.out.println("I ate " + food);
+ IO.println("I ate " + food);
}
void main() {
@@ -17,10 +17,10 @@ If you try to reassign a final argument, Java will not accept your program.
```java,panics
void eat(final String food) {
- System.out.println("I ate " + food);
+ IO.println("I ate " + food);
// Will not work
food = "toast";
- System.out.println(food);
+ IO.println(food);
}
void main() {
diff --git a/src/arguments/header.png b/src/arguments/header.png
new file mode 100644
index 00000000..ef2b4b5c
Binary files /dev/null and b/src/arguments/header.png differ
diff --git a/src/arguments/inferred_types.md b/src/arguments/inferred_types.md
index 54261180..cfd507ad 100644
--- a/src/arguments/inferred_types.md
+++ b/src/arguments/inferred_types.md
@@ -20,7 +20,7 @@ You must always explicitly write out the types of arguments.
```java,no_run
void makeHorchata(double milkFatPercent) {
- System.out.println(
+ IO.println(
"Making a horchata with " + milkFatPercent + "% milk."
);
}
diff --git a/src/arguments/invocation_with_arguments.md b/src/arguments/invocation_with_arguments.md
index 1c8800f1..79ce887e 100644
--- a/src/arguments/invocation_with_arguments.md
+++ b/src/arguments/invocation_with_arguments.md
@@ -6,11 +6,11 @@ of literals or variable names ending with `)`.
```java
void eat(String food) {
- System.out.println("I ate " + food);
+ IO.println("I ate " + food);
}
void happyBirthday(String to, int age) {
- System.out.println(
+ IO.println(
"Happy " + age + "th birthday " + to + "!"
);
}
diff --git a/src/arguments/overloading.md b/src/arguments/overloading.md
index c96dcf56..fbc57eb0 100644
--- a/src/arguments/overloading.md
+++ b/src/arguments/overloading.md
@@ -6,15 +6,15 @@ or different numbers of arguments.
```java,no_run
void doThing(int x) {
- System.out.println(x);
+ IO.println(x);
}
void doThing(String name) {
- System.out.println("Hello " + name);
+ IO.println("Hello " + name);
}
void doThing(int x, int y) {
- System.out.println(x + y);
+ IO.println(x + y);
}
```
@@ -24,15 +24,15 @@ you are passing.
```java
void doThing(int x) {
- System.out.println(x);
+ IO.println(x);
}
void doThing(String name) {
- System.out.println("Hello " + name);
+ IO.println("Hello " + name);
}
void doThing(int x, int y) {
- System.out.println(x + y);
+ IO.println(x + y);
}
void main() {
diff --git a/src/arguments/reassignment.md b/src/arguments/reassignment.md
index df04c0d2..0c898de5 100644
--- a/src/arguments/reassignment.md
+++ b/src/arguments/reassignment.md
@@ -6,9 +6,9 @@ within the method body;
```java
void eat(String food) {
- System.out.println("I ate " + food);
+ IO.println("I ate " + food);
food = "nothing";
- System.out.println("Now I have " + food);
+ IO.println("Now I have " + food);
}
void main() {
@@ -21,15 +21,15 @@ any variables passed to the method by the caller.
```java
void eat(String food) {
- System.out.println("I ate " + food);
+ IO.println("I ate " + food);
food = "nothing";
- System.out.println("Now I have " + food)
+ IO.println("Now I have " + food);
}
void main() {
String fruit = "apple";
eat(fruit);
- System.out.println(
+ IO.println(
"But in the caller I still have an " + fruit
);
}
diff --git a/src/array_list.md b/src/array_list.md
new file mode 100644
index 00000000..51f8b5ff
--- /dev/null
+++ b/src/array_list.md
@@ -0,0 +1,18 @@
+# ArrayList
+
+
+
+
+Java comes with a generic growable array. It is called
+an `ArrayList`.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+ ArrayList
+
Arrays are used to represent a fixed-size collection of things.
```java,no_run
diff --git a/src/arrays/access_individual_elements.md b/src/arrays/access_individual_elements.md
index 17eb48ec..61ce8175 100644
--- a/src/arrays/access_individual_elements.md
+++ b/src/arrays/access_individual_elements.md
@@ -11,13 +11,13 @@ The first element can be accessed by using `0`, the second by using `1`, and so
String[] lyrics = { "you", "say", "goodbye" };
String you = lyrics[0];
-System.out.println(you);
+IO.println(you);
String say = lyrics[1];
-System.out.println(say);
+IO.println(say);
String goodbye = lyrics[2];
-System.out.println(goodbye);
+IO.println(goodbye);
~}
```
@@ -28,7 +28,7 @@ The index of the element can also come from a variable.
int index = 2;
String[] lyrics = { "I", "say", "hello" };
-System.out.println(lyrics[index]);
+IO.println(lyrics[index]);
~}
```
@@ -39,7 +39,7 @@ you will get an error.
~void main(){
String[] lyrics = { "I", "say", "hi" };
// Crash!
-System.out.println(lyrics[999]);
+IO.println(lyrics[999]);
~}
```
@@ -47,6 +47,6 @@ System.out.println(lyrics[999]);
~void main(){
String[] lyrics = { "you", "say", "low" };
// Crash!
-System.out.println(lyrics[-1]);
+IO.println(lyrics[-1]);
~}
```
diff --git a/src/arrays/aliasing.md b/src/arrays/aliasing.md
index 8ac06229..008c6237 100644
--- a/src/arrays/aliasing.md
+++ b/src/arrays/aliasing.md
@@ -12,23 +12,59 @@ char[] lettersOne = { 'B', 'a', 't', 'm', 'a', 'n' };
char[] lettersTwo = lettersOne;
// Batman
-System.out.println(lettersOne);
+IO.print(lettersOne[0]);
+IO.print(lettersOne[1]);
+IO.print(lettersOne[2]);
+IO.print(lettersOne[3]);
+IO.print(lettersOne[4]);
+IO.print(lettersOne[5]);
+IO.println();
// Batman
-System.out.println(lettersTwo);
+IO.print(lettersTwo[0]);
+IO.print(lettersTwo[1]);
+IO.print(lettersTwo[2]);
+IO.print(lettersTwo[3]);
+IO.print(lettersTwo[4]);
+IO.print(lettersTwo[5]);
+IO.println();
lettersOne[0] = 'C';
// Catman
-System.out.println(lettersOne);
+IO.print(lettersOne[0]);
+IO.print(lettersOne[1]);
+IO.print(lettersOne[2]);
+IO.print(lettersOne[3]);
+IO.print(lettersOne[4]);
+IO.print(lettersOne[5]);
+IO.println();
// Catman
-System.out.println(lettersTwo);
+IO.print(lettersTwo[0]);
+IO.print(lettersTwo[1]);
+IO.print(lettersTwo[2]);
+IO.print(lettersTwo[3]);
+IO.print(lettersTwo[4]);
+IO.print(lettersTwo[5]);
+IO.println();
lettersTwo[0] = 'R';
// Ratman
-System.out.println(lettersOne);
+IO.print(lettersOne[0]);
+IO.print(lettersOne[1]);
+IO.print(lettersOne[2]);
+IO.print(lettersOne[3]);
+IO.print(lettersOne[4]);
+IO.print(lettersOne[5]);
+IO.println();
// Ratman
-System.out.println(lettersTwo);
+IO.print(lettersTwo[0]);
+IO.print(lettersTwo[1]);
+IO.print(lettersTwo[2]);
+IO.print(lettersTwo[3]);
+IO.print(lettersTwo[4]);
+IO.print(lettersTwo[5]);
+IO.println();
~}
```
diff --git a/src/arrays/challenges.md b/src/arrays/challenges.md
index c210ab03..da73b000 100644
--- a/src/arrays/challenges.md
+++ b/src/arrays/challenges.md
@@ -13,13 +13,13 @@ Edit the following program so that the output is zero.
void main() {
// Only change this line
String[] words = { "Sam", "I", "Am" };
- System.out.println(array.length);
+ IO.println(words.length);
}
```
## Challenge 2
-Using only `System.out.println` and array accesses,
+Using only `IO.println` and array accesses,
print `hello world` to the screen.
```java,editable
@@ -59,7 +59,7 @@ void main() {
total += numbers[index];
index += 1;
}
- System.out.println(total);
+ IO.println(total);
}
```
@@ -78,6 +78,11 @@ void main() {
// -----------
char[] toPrint = name;
- System.out.println(toPrint);
+ int index = 0;
+ while (index < toPrint.length) {
+ IO.print(toPrint[index]);
+ index++;
+ }
+ IO.println();
}
```
diff --git a/src/arrays/difference_between_initializer_and_literal.md b/src/arrays/difference_between_initializer_and_literal.md
index b3c71b03..eb12780e 100644
--- a/src/arrays/difference_between_initializer_and_literal.md
+++ b/src/arrays/difference_between_initializer_and_literal.md
@@ -7,30 +7,38 @@ When you have a literal, like a `String` literal, you can assign that to a varia
then use that `String` afterwards.
```java
+~void main() {
String name = "Alana";
// l
-System.out.println(name.charAt(1));
+IO.println(name.charAt(1));
+~}
```
But you can also perform those operations using the literal itself, without an intermediate variable.
```java
+~void main() {
// l
-System.out.println("Alana".charAt(1));
+IO.println("Alana".charAt(1));
+~}
```
Array initializers work in the case where you first assign them to a variable before using
the array.
```java
+~void main() {
char[] name = { 'A', 'm', 'a', 'n', 'd', 'a' };
// m
-System.out.println(name[1]);
+IO.println(name[1]);
+~}
```
But they do not work to perform operations on directly.
```java
+~void main() {
// Will not run
-System.out.println({ 'A', 'm', 'a', 'n', 'd', 'a' }[1]);
+IO.println({ 'A', 'm', 'a', 'n', 'd', 'a' }[1]);
+~}
```
diff --git a/src/arrays/empty_array.md b/src/arrays/empty_array.md
index 12f8da9c..531962fe 100644
--- a/src/arrays/empty_array.md
+++ b/src/arrays/empty_array.md
@@ -3,7 +3,7 @@
If you use an array initializer that has no elements between the `{` and `}`
you can create an empty array.
-```java
+```java,no_run
char[] emptyCharArray = {};
```
@@ -11,12 +11,14 @@ An empty array is very similar to an empty `String`. It has a length of 0, it ha
and it is generally useful only as a placeholder value for when you have no data yet but will
be able to reassign the variable holding it when you get some.
-```java
+```java,panics
+~void main() {
char[] emptyCharArray = {};
// 0
-System.out.println(emptyCharArray.length);
+IO.println(emptyCharArray.length);
// Crash
-System.out.println(emptyCharArray[0]);
+IO.println(emptyCharArray[0]);
+~}
```
\ No newline at end of file
diff --git a/src/arrays/header.png b/src/arrays/header.png
new file mode 100644
index 00000000..4cb55c50
Binary files /dev/null and b/src/arrays/header.png differ
diff --git a/src/arrays/initialization_with_new.md b/src/arrays/initialization_with_new.md
new file mode 100644
index 00000000..107b2b77
--- /dev/null
+++ b/src/arrays/initialization_with_new.md
@@ -0,0 +1,51 @@
+# Initialization with new
+
+Before the initializer for an array, you are allowed to write
+`new` followed by a space, the type of thing in the array,
+and an empty `[]`.
+
+```java
+~void main() {
+char[] mainCharacter = { 'A', 'a', 'n', 'g' };
+IO.println(mainCharacter[0]);
+IO.println(mainCharacter[1]);
+IO.println(mainCharacter[2]);
+IO.println(mainCharacter[3]);
+IO.println();
+
+char[] sideCharacter = new char[] { 'A', 'a', 'n', 'g' };
+IO.println(sideCharacter[0]);
+IO.println(sideCharacter[1]);
+IO.println(sideCharacter[2]);
+IO.println(sideCharacter[3]);
+IO.println();
+~}
+```
+
+This is required for performing delayed initialization of a variable
+holding an array.
+
+```java
+~void main() {
+char[] element;
+
+element = new char[] { 'f', 'i', 'r', 'e' };
+IO.println(element[0]);
+IO.println(element[1]);
+IO.println(element[2]);
+IO.println(element[3]);
+IO.println();
+
+// This would not work
+// element = { 'f', 'i', 'r', 'e' };
+~}
+```
+
+One ability this gives you is to use an array in an expression. I.E.
+the initializer coupled with the `new char[]` is akin to an "array expression."
+
+```java
+~void main() {
+IO.println(new char[]{ 'K', 'a', 't', 'a', 'r', 'a' }[1]);
+~}
+```
\ No newline at end of file
diff --git a/src/arrays/initialization_without_initializer b/src/arrays/initialization_without_initializer
deleted file mode 100644
index 90f0f138..00000000
--- a/src/arrays/initialization_without_initializer
+++ /dev/null
@@ -1 +0,0 @@
-# Initializion without Initializer
diff --git a/src/arrays/initialization_without_initializer.md b/src/arrays/initialization_without_initializer.md
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/arrays/length.md b/src/arrays/length.md
index 82c269f8..1cb840e1 100644
--- a/src/arrays/length.md
+++ b/src/arrays/length.md
@@ -8,7 +8,7 @@ String[] veggies = { "brussels", "cabbage", "carrots" };
int numberOfElements = veggies.length;
// veggies is 3 elements long
-System.out.println(
+IO.println(
"veggies is " + numberOfElements + " characters long"
);
~}
diff --git a/src/arrays/printing_the_contents_of_an_array.md b/src/arrays/printing_the_contents_of_an_array.md
index eed6ad4a..a44186f3 100644
--- a/src/arrays/printing_the_contents_of_an_array.md
+++ b/src/arrays/printing_the_contents_of_an_array.md
@@ -1,6 +1,6 @@
# Printing the Contents of an Array
-If you try to use `System.out.println` to output a `String[]`
+If you try to use `IO.println` to output a `String[]`
you won't see the contents of the array. Instead you will see
something like `[Ljava.lang.String;@1c655221`.
@@ -8,7 +8,7 @@ something like `[Ljava.lang.String;@1c655221`.
~void main() {
String[] shout = { "fus", "ro", "dah" };
// [Ljava.lang.String;@5a07e868
-System.out.println(shout);
+IO.println(shout);
~}
```
@@ -18,26 +18,15 @@ A similar thing will happen with `int[]`, `boolean[]`, and `double[]`.[^gibberis
~void main() {
int[] nums = { 11, 11, 11 };
// [I@5a07e868
-System.out.println(nums);
+IO.println(nums);
boolean[] bools = { true, false };
// [Z@5a07e868
-System.out.println(bools);
+IO.println(bools);
double[] doubles = { 1.1, 1.1, 1.1 };
// [D@5a07e868
-System.out.println(bools);
-~}
-```
-
-The only kind of array which will include its contents when printed is a `char[]`.
-It will be printed as if it were a `String`.
-
-```java
-~void main() {
-char[] continent = { 'T', 'a', 'm', 'r', 'i', 'e', 'l' };
-// Tamriel
-System.out.println(continent);
+IO.println(bools);
~}
```
@@ -45,14 +34,17 @@ If you want to actually see the contents of an array, you should
use a loop.[^future]
```java
+~void main() {
String[] factions = { "empire", "stormcloaks", "dragons" };
int index = 0;
while (index < factions.length) {
- System.out.println(factions[index])
- index++
+ IO.println(factions[index]);
+ index++;
}
+~}
```
[^gibberish]: What `[I@5a07e868` and co. mean isn't really important. Try not to get too distracted by it.
+
[^future]: Later on, there will be easier ways to do this sort of inspection. This is just the one I can demonstrate now.
diff --git a/src/arrays/reassignment.md b/src/arrays/reassignment.md
index 2b09a02d..94b8303c 100644
--- a/src/arrays/reassignment.md
+++ b/src/arrays/reassignment.md
@@ -12,15 +12,15 @@ So to reassign an `int[]` you need to write something like `new int[] { 1, 2, 3
~void main() {
int[] numbers = { 1, 2 };
// 2
-System.out.println(numbers.length);
+IO.println(numbers.length);
numbers = new int[] { numbers[0], numbers[1], 3 };
// 3
-System.out.println(numbers.length);
+IO.println(numbers.length);
~}
```
-This reassignment will not be affect any variables which
+This reassignment will not affect any variables which
are aliases for the variable's old value.
```java
@@ -28,29 +28,75 @@ are aliases for the variable's old value.
char[] wordOne = { 'g', 'o' };
char[] wordTwo = wordOne;
// go
-System.out.println(wordOne);
+IO.print("wordOne Length: ");
+IO.println(wordOne.length);
+IO.print(wordOne[0]);
+IO.print(wordOne[1]);
+IO.println();
// go
-System.out.println(wordTwo);
+IO.print("wordTwo Length: ");
+IO.println(wordTwo.length);
+IO.print(wordTwo[0]);
+IO.print(wordTwo[1]);
+IO.println();
+
+IO.println("-------");
wordOne = new char[] { wordOne[0], wordOne[1], 's', 'h' };
// gosh
-System.out.println(wordOne);
+IO.print("wordOne Length: ");
+IO.println(wordOne.length);
+IO.print(wordOne[0]);
+IO.print(wordOne[1]);
+IO.print(wordOne[2]);
+IO.print(wordOne[3]);
+IO.println();
// go
-System.out.println(wordTwo);
+IO.print("wordTwo Length: ");
+IO.println(wordTwo.length);
+IO.print(wordTwo[0]);
+IO.print(wordTwo[1]);
+IO.println();
+
+
+IO.println("-------");
wordTwo[0] = 'n';
// gosh
-System.out.println(wordOne);
+IO.print("wordOne Length: ");
+IO.println(wordOne.length);
+IO.print(wordOne[0]);
+IO.print(wordOne[1]);
+IO.print(wordOne[2]);
+IO.print(wordOne[3]);
+IO.println();
// no
-System.out.println(wordTwo);
+IO.print("wordTwo Length: ");
+IO.println(wordTwo.length);
+IO.print(wordTwo[0]);
+IO.print(wordTwo[1]);
+IO.println();
+
+
+IO.println("-------");
wordOne[0] = 'p';
// posh
-System.out.println(wordOne);
+IO.print("wordOne Length: ");
+IO.println(wordOne.length);
+IO.print(wordOne[0]);
+IO.print(wordOne[1]);
+IO.print(wordOne[2]);
+IO.print(wordOne[3]);
+IO.println();
// no
-System.out.println(wordTwo);
+IO.print("wordTwo Length: ");
+IO.println(wordTwo.length);
+IO.print(wordTwo[0]);
+IO.print(wordTwo[1]);
+IO.println();
~}
```
diff --git a/src/arrays/relation_to_final_variables.md b/src/arrays/relation_to_final_variables.md
index 3472c8b2..193bbdcb 100644
--- a/src/arrays/relation_to_final_variables.md
+++ b/src/arrays/relation_to_final_variables.md
@@ -9,10 +9,15 @@ that the array's contents cannot be changed directly or through an alias.
~void main() {
final char[] catchphrase = { 'w', 'o', 'a', 'h', '!' };
// woah!
-System.out.println(catchphrase);
+IO.print(catchphrase[0]);
+IO.print(catchphrase[1]);
+IO.print(catchphrase[2]);
+IO.print(catchphrase[3]);
+IO.print(catchphrase[4]);
+IO.println();
// Cannot reassign
-// catchphrase = { 'e', 'g', 'a', 'd', 's' }
+// catchphrase = new char[] { 'e', 'g', 'a', 'd', 's' }
// but can set elements directly
catchphrase[0] = 'e';
catchphrase[1] = 'g';
@@ -24,6 +29,11 @@ alias[3] = 'd';
alias[4] = 's';
// egads
-System.out.println(catchphrase);
+IO.print(catchphrase[0]);
+IO.print(catchphrase[1]);
+IO.print(catchphrase[2]);
+IO.print(catchphrase[3]);
+IO.print(catchphrase[4]);
+IO.println();
~}
```
diff --git a/src/arrays/set_individual_elements.md b/src/arrays/set_individual_elements.md
index 3b5661a9..e518484f 100644
--- a/src/arrays/set_individual_elements.md
+++ b/src/arrays/set_individual_elements.md
@@ -9,10 +9,26 @@ the new value.[^strings]
```java
~void main() {
String[] sentence = { "you", "are", "found", "guilty" };
-System.out.println(sentence);
+IO.println(
+ sentence[0]
+ + " "
+ + sentence[1]
+ + " "
+ + sentence[2]
+ + " "
+ + sentence[3]
+);
sentence[1] = "aren't";
-System.out.println(sentence);
+IO.println(
+ sentence[0]
+ + " "
+ + sentence[1]
+ + " "
+ + sentence[2]
+ + " "
+ + sentence[3]
+);
~}
```
@@ -22,16 +38,36 @@ The index of the element to set can also come from a variable.
~void main() {
int index = 2;
String[] response = { "and", "it", "isn't", "opposite", "day" };
-System.out.println(response);
+IO.println(
+ response[0]
+ + " "
+ + response[1]
+ + " "
+ + response[2]
+ + " "
+ + response[3]
+ + " "
+ + response[4]
+);
-response[2] = "is";
-System.out.println(response);
+response[index] = "is";
+IO.println(
+ response[0]
+ + " "
+ + response[1]
+ + " "
+ + response[2]
+ + " "
+ + response[3]
+ + " "
+ + response[4]
+);
~}
```
If you give a number equal to or greater than the length of the array or a number less than zero, you will get an error.
-```java
+```java,panics
~void main() {
String[] response = { "objection" };
// Crash
diff --git a/src/arrays_ii.md b/src/arrays_ii.md
index 9586633f..d083eb6f 100644
--- a/src/arrays_ii.md
+++ b/src/arrays_ii.md
@@ -1,5 +1,8 @@
# Arrays II
+
+
+
Fairly often you will want to have arrays in your program
which you either do not know the initial values for or which
are too big to physically type out every value in an initializer.
diff --git a/src/arrays_ii/challenges.md b/src/arrays_ii/challenges.md
new file mode 100644
index 00000000..ca4817cc
--- /dev/null
+++ b/src/arrays_ii/challenges.md
@@ -0,0 +1,111 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Make an empty `String` array without using an empty initializer.
+
+This means you cannot write `String[] empty = {}` or `String[] empty = new String[] {}`.
+
+```java,editable
+void main() {
+ String[] empty = ???;
+
+ // Should be 0
+ IO.println(empty.length);
+}
+```
+
+## Challenge 2.
+
+What will the following code output? Change the code
+between the lines so it instead outputs the following.
+
+```
+1.0
+2.0
+3.0
+4.0
+5.0
+```
+
+
+```java,editable
+void main() {
+ Double[] prices = new Double[5];
+
+ // ----------
+ // CODE HERE
+ // ----------
+
+ for (int i = 0; i < prices.length; i++) {
+ double price = prices[i];
+ IO.println(price);
+ }
+}
+```
+
+## Challenge 3.
+
+Only writing code between the lines and without reassigning the `sandwich` variable,
+make the following code output `egg and cheese`.
+
+```java,editable
+void main() {
+ char[] sandwich = new char[14];
+
+ // ----------
+ // CODE HERE
+ // ----------
+
+ IO.println(sandwich);
+}
+```
+
+## Challenge 4.
+
+Populate the `triangle` array such that the code
+prints a right triangle that looks like the following.
+
+```
+*
+**
+***
+```
+
+```java,editable
+void main() {
+ char[] triangle = new char[8];
+
+ // ----------
+ // CODE HERE
+ // ----------
+
+ IO.println(triangle);
+}
+```
+
+## Challenge 5.
+
+Make a method named `buildTriangle` which returns a `char[]`
+that can be printed out to display a right triangle of any height.
+
+You can ignore the possibility that a negative or zero height is given.
+
+```java,editable
+char[] buildTriangle(int height) {
+ // CODE HERE
+}
+
+void main() {
+ IO.println(buildTriangle(3));
+ IO.println("--------------");
+ IO.println(buildTriangle(5));
+ IO.println("--------------");
+ IO.println(buildTriangle(2));
+}
+```
\ No newline at end of file
diff --git a/src/arrays_ii/default_values.md b/src/arrays_ii/default_values.md
index 7345f27e..edf86c66 100644
--- a/src/arrays_ii/default_values.md
+++ b/src/arrays_ii/default_values.md
@@ -9,11 +9,11 @@ For primitive types like `int` and `double`, each element will be initialized to
~void main() {
int[] digits = new int[10];
// 0
-System.out.println(digits[0]);
+IO.println(digits[0]);
double[] readings = new double[5];
// 0.0
-System.out.println(readings[0]);
+IO.println(readings[0]);
~}
```
@@ -23,7 +23,7 @@ For `boolean`, each element will be initialized to `false`.[^funfact]
~void main() {
boolean[] pokedex = new boolean[10];
// false
-System.out.println(pokedex[0]);
+IO.println(pokedex[0]);
~}
```
@@ -34,11 +34,11 @@ the default value will be `null`.
~void main() {
String[] names = new String[10];
// null
-System.out.println(names[0]);
+IO.println(names[0]);
Integer[] scores = new Integer[26];
// null
-System.out.println(scores[0]);
+IO.println(scores[0]);
~}
```
diff --git a/src/arrays_ii/header.png b/src/arrays_ii/header.png
new file mode 100644
index 00000000..2618ac37
Binary files /dev/null and b/src/arrays_ii/header.png differ
diff --git a/src/arrays_ii/initialization_with_size.md b/src/arrays_ii/initialization_with_size.md
index 463ea053..109c9f7e 100644
--- a/src/arrays_ii/initialization_with_size.md
+++ b/src/arrays_ii/initialization_with_size.md
@@ -1,11 +1,11 @@
-# Initializion with Size
+# Initialization with Size
The Nintendo GameBoy had a screen resolution of 160 x 144.
To store the value of each pixel[^bw] you would need an array 23,040 items
long.
To support this without you writing the word `false` 23,040 times,
-arrays can be made with just by giving a size and skipping the initializer.
+arrays can be made just by giving a size and skipping the initializer.
```java,no_run
boolean[] pixels = new boolean[23040];
@@ -13,4 +13,5 @@ boolean[] pixels = new boolean[23040];
So you have to say `new` followed by the type of element in the array, `[`, the size of the array and `]`.
-[^bw]: The original GameBoy was just black and white, so a `boolean` works just fine to represent a pixel's state.
\ No newline at end of file
+
+[^bw]: The original GameBoy wasn't actually just black and white. It supported 7 shades of gray, so a `boolean` wouldn't technically be enough to represent a pixel's state. You'd have to use something with at least 8 states, not just 2.
diff --git a/src/arrays_ii/populate_arrays.md b/src/arrays_ii/populate_arrays.md
index c494e076..effe3d42 100644
--- a/src/arrays_ii/populate_arrays.md
+++ b/src/arrays_ii/populate_arrays.md
@@ -11,23 +11,6 @@ char[] letters = new char[26];
for (int i = 0; i < letters.length; i++) {
letters[i] = (char) ('a' + i);
}
-System.out.println(letters);
+IO.println(letters);
~}
```
-
-But if you are just writing some value to every index
-without any other interesting logic, you can use `Arrays.fill`.
-
-```java
-~void main() {
-int[] allNines = new char[123];
-Arrays.fill(allNines, 9);
-
-for (int i = 0; i < allNines.length; i++) {
- System.out.println(allNines[i]);
-}
-~}
-```
-
-You give that the array and the value to fill it with. In the example above, the array starts
-out with everything defaulted to `0` and is then filled with `9`s.
diff --git a/src/boolean.md b/src/boolean.md
index a5ac1282..46ae8a43 100644
--- a/src/boolean.md
+++ b/src/boolean.md
@@ -1,5 +1,7 @@
# Booleans
+
+
A `boolean` is either `true` or `false`.
```java,no_run
diff --git a/src/boolean/challenges.md b/src/boolean/challenges.md
index 5e204f30..e209490d 100644
--- a/src/boolean/challenges.md
+++ b/src/boolean/challenges.md
@@ -18,7 +18,7 @@ void main() {
boolean result = a || b && c || !d;
- System.out.println(result);
+ IO.println(result);
}
```
@@ -35,7 +35,7 @@ void main() {
boolean result = !(a || b && c || !d) || (a && b || c);
- System.out.println(result);
+ IO.println(result);
}
```
@@ -51,7 +51,7 @@ void main() {
boolean validChoice = < YOUR CODE HERE >;
- System.out.println(validChoice);
+ IO.println(validChoice);
}
```
diff --git a/src/boolean/header.png b/src/boolean/header.png
new file mode 100644
index 00000000..289abe26
Binary files /dev/null and b/src/boolean/header.png differ
diff --git a/src/boolean/not.md b/src/boolean/not.md
index 0b20f8c1..925d5f80 100644
--- a/src/boolean/not.md
+++ b/src/boolean/not.md
@@ -4,7 +4,7 @@ Booleans can also be "negated" using the "not" operator - `!`.
```java,no_run
boolean haveOreosInHouse = true;
-boolean stuckToCalorieLimit = !haveOreos;
+boolean stuckToCalorieLimit = !haveOreosInHouse;
```
So in this case, I have stuck to my calorie limit if there are _not_ Oreos in the house.
diff --git a/src/boolean/operator_precedence.md b/src/boolean/operator_precedence.md
index dfec44e8..78662d51 100644
--- a/src/boolean/operator_precedence.md
+++ b/src/boolean/operator_precedence.md
@@ -2,14 +2,14 @@
The operators that work on booleans have a "precedence order."
-This is defines an order of operations similar to mathematics, where multiplication and division happen before
+This defines an order of operations similar to mathematics, where multiplication and division happen before
addition and subtraction.
For booleans `!` always happens first. This is followed by `&&` and then by `||`.
```java,no_run
boolean a = true;
-boolean b = false
+boolean b = false;
boolean c = false;
// just as 2 + 5 * 3 "evaluates" 5 * 3 before adding 2
diff --git a/src/boolean/or.md b/src/boolean/or.md
index 59984d97..62d4a859 100644
--- a/src/boolean/or.md
+++ b/src/boolean/or.md
@@ -20,7 +20,7 @@ walking the dog looks nice.
## Exclusive vs. Inclusive
-It is important too note that this is not an "exclusive" OR.
+It is important to note that this is not an "exclusive" OR.
An exclusive OR would be something like
a child being allowed to have ice cream _or_ a cookie, but not both.
diff --git a/src/boxed_primitives.md b/src/boxed_primitives.md
index d28e9788..29040b00 100644
--- a/src/boxed_primitives.md
+++ b/src/boxed_primitives.md
@@ -1,5 +1,8 @@
# Boxed Primitives
+
+
+
The fact that `int`, `double`, `char`, and `boolean` cannot have `null` values
can be limiting.
@@ -8,10 +11,10 @@ For this reason there are versions of those primitive[^primitive] types which do
```java
void sayAge(Integer age) {
if (age == null) {
- System.out.println("Age is not yet known");
+ IO.println("Age is not yet known");
}
else {
- System.out.println("Age is " + age);
+ IO.println("Age is " + age);
}
}
@@ -24,7 +27,7 @@ void main() {
}
```
-We call these primitives which might be null "Boxed Primitives" because you they are made by taking
+We call these primitives which might be null "Boxed Primitives" because they are made by taking
the underlying thing and putting it in a "box."[^boxing]
diff --git a/src/boxed_primitives/arrays_of_boxed_primitives.md b/src/boxed_primitives/arrays_of_boxed_primitives.md
index 5cece930..6e3509ea 100644
--- a/src/boxed_primitives/arrays_of_boxed_primitives.md
+++ b/src/boxed_primitives/arrays_of_boxed_primitives.md
@@ -13,5 +13,31 @@ numbersOne = numbersTwo;
numbersTwo = numbersOne;
```
+This means that to turn something like a `boolean[]` into a `Boolean[]` or vice-versa,
+you must manually make a new array and copy over elements. Doing this in either
+direction will work because boxing and unboxing conversions exist between the primitives
+and their boxed variants.
+
+```java
+~void main() {
+boolean[] yesAndNo = new boolean[] { true, false };
+
+Boolean[] yesAndNoCopy = new Boolean[] { false, false };
+for (int i = 0; i < yesAndNo.length; i++) {
+ // Here a boxing conversion takes place
+ yesAndNoCopy[i] = yesAndNo[i];
+}
+
+boolean[] yesAndNoCopyCopy = new boolean[] { false, false };
+for (int i = 0; i < yesAndNoCopy.length; i++) {
+ // And here an unboxing conversion
+ yesAndNoCopyCopy[i] = yesAndNoCopy[i];
+}
+~}
+```
+
+
+
+
[^interesting]: The reasons for this are deeply interesting and have to do with the nitty gritty of how
Java is actually implemented. It might also change in the future.
\ No newline at end of file
diff --git a/src/boxed_primitives/boolean.md b/src/boxed_primitives/boolean.md
index 2de4fc64..23a878a2 100644
--- a/src/boxed_primitives/boolean.md
+++ b/src/boxed_primitives/boolean.md
@@ -6,7 +6,7 @@ The type to use for a `boolean` that might be null is `Boolean`.
```java
~void main() {
Boolean b = null;
-System.out.println(b);
+IO.println(b);
b = true;
-System.out.println(true);
+IO.println(b);
~}
\ No newline at end of file
diff --git a/src/boxed_primitives/boxing_conversion.md b/src/boxed_primitives/boxing_conversion.md
index 13e24494..6e1f7a30 100644
--- a/src/boxed_primitives/boxing_conversion.md
+++ b/src/boxed_primitives/boxing_conversion.md
@@ -9,8 +9,8 @@ automatically do that conversion.[^obvious]
int x = 5;
Integer y = x;
-System.out.println(x);
-System.out.println(y);
+IO.println(x);
+IO.println(y);
~}
```
diff --git a/src/boxed_primitives/challenges.md b/src/boxed_primitives/challenges.md
index 9358534c..53908acf 100644
--- a/src/boxed_primitives/challenges.md
+++ b/src/boxed_primitives/challenges.md
@@ -1 +1,137 @@
# Challenges
+
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+
+## Challenge 1.
+
+Will this code run? Why or why not.
+
+```java
+int compute(int x) {
+ if (x == 0) {
+ return null;
+ }
+ else {
+ return x * x;
+ }
+}
+
+void main() {
+ IO.println(compute(5));
+}
+```
+
+## Challenge 2.
+
+Write a method which takes in an `Integer[]` representing
+a series of distances and prints out every distance
+followed by ` kilometers`.
+
+So if the array has `1`, `2`, and `3` you should output
+
+```
+1 kilometers
+2 kilometers
+3 kilometers
+```
+
+If this method is given `null`, it should act as if it
+was given an empty array.
+
+
+```java,editable
+void printDistances(Integer[] distances) {
+
+}
+
+void main() {
+ printDistances(new Integer[] {
+ 45,
+ 99,
+ 23
+ });
+}
+```
+
+## Challenge 3.
+
+Write a method called `onlyPositive` which takes in an `int` and returns
+the same value out if the number is greater than zero.
+
+If the number is less than or equal to zero, return `null`.
+
+```java,editable
+// Write onlyPositive here
+
+void main() {
+ // 45
+ IO.println(
+ onlyPositive(45)
+ );
+
+ // 46
+ IO.println(
+ onlyPositive(45) + 1
+ );
+
+ // null
+ IO.println(
+ onlyPositive(0)
+ );
+
+ // null
+ IO.println(
+ onlyPositive(-1)
+ );
+}
+```
+
+## Challenge 4.
+
+Will the following code work? Why or why not?
+
+```java
+void main() {
+ int ducks = 5;
+ Integer sparrows = 3;
+
+ int birds = ducks + sparrows;
+
+ IO.println(birds);
+}
+```
+
+## Challenge 4.
+
+Will the following code work? Why or why not?
+
+```java
+void main() {
+ char[] face = new char[] { ':', ')' };
+ Character[] smile = face;
+
+ IO.println(smile);
+}
+```
+
+## Challenge 5.
+
+Will the following code work? Why or why not?
+
+```java
+void main() {
+ char[] face = new char[] { ':', ')' };
+
+ Character[] smile = new Character[face.length];
+ for (int i = 0; i < face.length; i++) {
+ smile[i] = face[i];
+ }
+
+ IO.println(smile);
+}
+```
\ No newline at end of file
diff --git a/src/boxed_primitives/character.md b/src/boxed_primitives/character.md
index 7ec17ce8..1c4dbe40 100644
--- a/src/boxed_primitives/character.md
+++ b/src/boxed_primitives/character.md
@@ -5,7 +5,8 @@ The type to use for a `char` that might be null is `Character`.
```java
~void main() {
Character c = null;
-System.out.println(c);
+IO.println(c);
c = '%';
-System.out.println(c);
-~}
\ No newline at end of file
+IO.println(c);
+~}
+```
diff --git a/src/boxed_primitives/double.md b/src/boxed_primitives/double.md
index 6655c41d..7cc1e6dd 100644
--- a/src/boxed_primitives/double.md
+++ b/src/boxed_primitives/double.md
@@ -5,7 +5,18 @@ The type to use for a `double` that might be null is `Double`.
```java
~void main() {
Double d = null;
-System.out.println(d);
+IO.println(d);
d = 3.14;
-System.out.println(d);
-~}
\ No newline at end of file
+IO.println(d);
+~}
+```
+
+If you try to do any math on a `Double` which holds `null` you will
+get a `NullPointerException`.
+
+```java,panics
+~void main() {
+Double d = null;
+IO.println(d + 1);
+~}
+```
\ No newline at end of file
diff --git a/src/boxed_primitives/header.png b/src/boxed_primitives/header.png
new file mode 100644
index 00000000..82799080
Binary files /dev/null and b/src/boxed_primitives/header.png differ
diff --git a/src/boxed_primitives/integer.md b/src/boxed_primitives/integer.md
index 95f8cf04..aa1de817 100644
--- a/src/boxed_primitives/integer.md
+++ b/src/boxed_primitives/integer.md
@@ -5,8 +5,18 @@ The type to use for an `int` that might be null is `Integer`.
```java
~void main() {
Integer i = null;
-System.out.println(i);
+IO.println(i);
i = 5;
-System.out.println(i);
+IO.println(i);
+~}
+```
+
+If you try to do any math on an `Integer` which holds `null` you will
+get a `NullPointerException`.
+
+```java,panics
+~void main() {
+Integer i = null;
+IO.println(i * 5);
~}
```
\ No newline at end of file
diff --git a/src/boxed_primitives/unboxing_conversion.md b/src/boxed_primitives/unboxing_conversion.md
index c0005f9e..6a066433 100644
--- a/src/boxed_primitives/unboxing_conversion.md
+++ b/src/boxed_primitives/unboxing_conversion.md
@@ -11,7 +11,7 @@ Integer x = 5;
int y = 3;
int z = x * y;
-System.out.println(z);
+IO.println(z);
~}
```
@@ -21,7 +21,7 @@ As well as `Boolean`s in logical expressions.
~void main() {
Boolean hasHat = true;
if (hasHat) {
- System.out.println("You have a hat!");
+ IO.println("You have a hat!");
}
~}
```
diff --git a/src/branching_logic/boolean_expressions.md b/src/branching_logic/boolean_expressions.md
index be6542ff..754584d9 100644
--- a/src/branching_logic/boolean_expressions.md
+++ b/src/branching_logic/boolean_expressions.md
@@ -18,7 +18,7 @@ else {
// or
// boolean canRent = age > 25 ? true : false;
-System.out.println(canRent);
+IO.println(canRent);
~}
```
@@ -30,6 +30,6 @@ itself already evaluates to a `boolean`. You can directly assign the variable to
int age = 22;
boolean canRent = age > 25;
-System.out.println(canRent);
+IO.println(canRent);
~}
```
diff --git a/src/branching_logic/challenges.md b/src/branching_logic/challenges.md
index aa102ec8..452b2fac 100644
--- a/src/branching_logic/challenges.md
+++ b/src/branching_logic/challenges.md
@@ -41,8 +41,8 @@ void main() {
## Challenge 4
-Write code that will assign the string `The number is {x} even` to `message` if `x` is an even number
-and `The number is {x} odd` if `x` is an even number.
+Write code that will assign the string `The number {x} is even` to `message` if `x` is an even number
+and `The number {x} is odd` if `x` is an odd number.
So if `x` is 12 the string you should assign `The number 12 is even` to `message`.
@@ -57,6 +57,6 @@ void main() {
// < YOUR CODE HERE >
- System.out.println(message);
+ IO.println(message);
}
```
diff --git a/src/branching_logic/conditional_operator.md b/src/branching_logic/conditional_operator.md
index de895a00..91c2b284 100644
--- a/src/branching_logic/conditional_operator.md
+++ b/src/branching_logic/conditional_operator.md
@@ -12,7 +12,7 @@ String message = age < 25
? "You cannot rent a car!"
: "You might be able to rent a car";
-System.out.println(message);
+IO.println(message);
~}
```
diff --git a/src/branching_logic/else.md b/src/branching_logic/else.md
index 940fa271..33cef235 100644
--- a/src/branching_logic/else.md
+++ b/src/branching_logic/else.md
@@ -7,10 +7,10 @@ and another when that same condition evaluates to `false` you can use `else`.
~void main() {
int age = 30; // πββοΈ
if (age < 25) {
- System.out.println("You cannot rent a car!");
+ IO.println("You cannot rent a car!");
}
else {
- System.out.println("You might be able to rent a car.");
+ IO.println("You might be able to rent a car.");
}
~}
```
@@ -34,7 +34,7 @@ When the condition evaluates to `false`, the code inside of `else`'s `{` and `}`
```java,does_not_compile
~void main() {
else {
- System.out.println("No if.");
+ IO.println("No if.");
}
~}
```
diff --git a/src/branching_logic/else_if.md b/src/branching_logic/else_if.md
index 1c0a04db..db6ae231 100644
--- a/src/branching_logic/else_if.md
+++ b/src/branching_logic/else_if.md
@@ -8,14 +8,14 @@ If you have an `if` nested in an `else` branch, you can simplify that by using
boolean cool = true; // πΆοΈ
int age = 30; // πββοΈ
if (age < 25) {
- System.out.println("You cannot rent a car!");
+ IO.println("You cannot rent a car!");
}
else {
if (!cool) {
- System.out.println("You failed the vibe check.");
+ IO.println("You failed the vibe check.");
}
else {
- System.out.println("You are rad enough to rent a car.");
+ IO.println("You are rad enough to rent a car.");
}
}
~}
@@ -29,13 +29,13 @@ boolean cool = true; // πΆοΈ
int age = 30; // πββοΈ
if (age < 25) {
- System.out.println("You cannot rent a car!");
+ IO.println("You cannot rent a car!");
}
else if (!cool) {
- System.out.println("You failed the vibe check.");
+ IO.println("You failed the vibe check.");
}
else {
- System.out.println("You are rad enough to rent a car.");
+ IO.println("You are rad enough to rent a car.");
}
~}
```
@@ -49,19 +49,19 @@ boolean cool = true; // πΆοΈ
int age = 100; // π΄
if (age < 25) {
- System.out.println("You cannot rent a car!");
+ IO.println("You cannot rent a car!");
}
else if (!cool) {
- System.out.println("You failed the vibe check.");
+ IO.println("You failed the vibe check.");
}
else if (age > 99) {
- System.out.println("You are too old to safely drive a car!");
+ IO.println("You are too old to safely drive a car!");
}
else if (age > 450) {
- System.out.println("There can only be one! βοΈπ΄σ §σ ’σ ³σ £σ ΄σ Ώ");
+ IO.println("There can only be one! βοΈπ΄σ §σ ’σ ³σ £σ ΄σ Ώ");
}
else {
- System.out.println("You are rad enough to rent a car.");
+ IO.println("You are rad enough to rent a car.");
}
~}
```
diff --git a/src/branching_logic/header.png b/src/branching_logic/header.png
new file mode 100644
index 00000000..d82370eb
Binary files /dev/null and b/src/branching_logic/header.png differ
diff --git a/src/branching_logic/if.md b/src/branching_logic/if.md
index 93e1a5db..3ec3a743 100644
--- a/src/branching_logic/if.md
+++ b/src/branching_logic/if.md
@@ -6,7 +6,7 @@ The way to represent a branching path in Java is by using an `if` statement.
~void main() {
int age = 5; // πΆ
if (age < 25) {
- System.out.println("You are too young to rent a car!");
+ IO.println("You are too young to rent a car!");
}
~}
```
@@ -31,7 +31,7 @@ and you will be told that you cannot rent a car.
~void main() {
int age = 80; // π΅
if (age < 25) {
- System.out.println("You are too young to rent a car!");
+ IO.println("You are too young to rent a car!");
}
~}
```
diff --git a/src/branching_logic/nested_ifs.md b/src/branching_logic/nested_ifs.md
index a4e04d24..ee366796 100644
--- a/src/branching_logic/nested_ifs.md
+++ b/src/branching_logic/nested_ifs.md
@@ -6,9 +6,9 @@ The code inside of the `{` and `}` can be anything, including more `if` statment
~void main() {
int age = 5; // πΆ
if (age < 25) {
- System.out.println("You are too young to rent a car!");
+ IO.println("You are too young to rent a car!");
if (age == 24) {
- System.out.println("(but it was close)");
+ IO.println("(but it was close)");
}
}
~}
@@ -17,7 +17,7 @@ if (age < 25) {
When an `if` is inside another `if` we say that it is "nested".
If you find yourself nesting more than a few `if`s that might be a sign that
-you should reach out for help.
+you should reach out for help[^or].
```java,no_run
if (...) {
@@ -30,3 +30,5 @@ if (...) {
}
}
```
+
+[^or]: Or a sign that you should keep reading. There are things I will show you that can help you avoid this - like "methods."
diff --git a/src/branching_logic/relation_to_delayed_assignment.md b/src/branching_logic/relation_to_delayed_assignment.md
index 570d54b5..c9106d37 100644
--- a/src/branching_logic/relation_to_delayed_assignment.md
+++ b/src/branching_logic/relation_to_delayed_assignment.md
@@ -17,7 +17,7 @@ else {
message = "You cannot rent a car!";
}
-System.out.println(message);
+IO.println(message);
~}
```
@@ -35,6 +35,6 @@ if (age > 25) {
// message is not always given an initial value
// so you cannot use it.
-System.out.println(message);
+IO.println(message);
~}
```
diff --git a/src/branching_logic/scoped_variables.md b/src/branching_logic/scoped_variables.md
index a9125802..096443fd 100644
--- a/src/branching_logic/scoped_variables.md
+++ b/src/branching_logic/scoped_variables.md
@@ -9,12 +9,12 @@ int age = 5;
if (age == 5) {
int nextAge = age + 1;
- System.out.println(nextAge);
+ IO.println(nextAge);
}
// If you uncomment this line, there will be an issue
// `nextAge` is not available to the scope outside of the `if`
-// System.out.println(nextAge);
+// IO.println(nextAge);
~}
```
@@ -34,7 +34,7 @@ else {
// This will not work, because although `message` is declared
// in all branches, it is not declared in the "outer scope"
-System.out.println(message);
+IO.println(message);
~}
```
diff --git a/src/branching_paths.md b/src/branching_paths.md
index d7603bea..77b33ea0 100644
--- a/src/branching_paths.md
+++ b/src/branching_paths.md
@@ -1,5 +1,7 @@
# Branching Paths
+
+
All the code I have shown you so far has run from top to bottom. That is, it has followed a single "path."
Not all programs can follow a single path though.
diff --git a/src/characters.md b/src/characters.md
index 398e3d86..bbf465da 100644
--- a/src/characters.md
+++ b/src/characters.md
@@ -1,5 +1,7 @@
# Characters
+
+
A character, represented by the data type `char`, is a single
letter or symbol.
diff --git a/src/characters/challenges.md b/src/characters/challenges.md
index 3f207994..94544fc1 100644
--- a/src/characters/challenges.md
+++ b/src/characters/challenges.md
@@ -15,7 +15,7 @@ Try to work it out on paper before running the program below.
void main() {
char x = 'x';
- System.out.println(x * x);
+ IO.println(x * x);
}
```
@@ -31,7 +31,7 @@ void main() {
boolean isLetter = ???;
- System.out.println(isLetter);
+ IO.println(isLetter);
}
```
diff --git a/src/characters/conversion_from_integers.md b/src/characters/conversion_from_integers.md
index 7ae90563..76211fb1 100644
--- a/src/characters/conversion_from_integers.md
+++ b/src/characters/conversion_from_integers.md
@@ -9,7 +9,7 @@ int x = 120;
char xAsChar = (char) x;
-System.out.println(xAsChar);
+IO.println(xAsChar);
~}
```
@@ -21,6 +21,6 @@ The initial value of a `char` can also be given by an integer literal if the int
~void main() {
char z = 122;
-System.out.println(z);
+IO.println(z);
~}
```
diff --git a/src/characters/conversion_to_integers.md b/src/characters/conversion_to_integers.md
index d3dccb6e..1e2d8f17 100644
--- a/src/characters/conversion_to_integers.md
+++ b/src/characters/conversion_to_integers.md
@@ -1,6 +1,6 @@
# Conversion to Integers
-All `char`s have a matching numeric value. `'a'` is `97`, `'b'` is `98`,
+All `char`s have a matching numeric value[^ascii]. `'a'` is `97`, `'b'` is `98`,
`'&'` is `38`, and so on.
Same as assigning an `int` to a `double`, you can perform a widening conversion
@@ -10,7 +10,7 @@ by attempting to assign a `char` to an `int`.
~void main() {
int valueOfA = 'a';
-System.out.println(valueOfA);
+IO.println(valueOfA);
~}
```
@@ -23,11 +23,13 @@ char gee = 'g';
// all the letters from a to z have consecutive numeric values.
boolean isLetter = gee >= 'a' && gee <= 'z';
-System.out.println(isLetter);
+IO.println(isLetter);
~}
```
This can be useful if you are stranded on Mars[^onmars] or
if you want to see if a character is in some range.
-[^onmars]: https://www.youtube.com/watch?v=k-GH3mbvUro
+[^ascii]: You can find some of these values in an "[ASCII Table](https://www.ascii-code.com/)."
+
+[^onmars]: [https://www.youtube.com/watch?v=0xkP_FQUsuM](https://www.youtube.com/watch?v=0xkP_FQUsuM)
diff --git a/src/characters/header.png b/src/characters/header.png
new file mode 100644
index 00000000..bbd23621
Binary files /dev/null and b/src/characters/header.png differ
diff --git a/src/class_extension.md b/src/class_extension.md
new file mode 100644
index 00000000..7199be5d
--- /dev/null
+++ b/src/class_extension.md
@@ -0,0 +1,11 @@
+# Class Extension
+
+
+
+Just like interfaces can extend other interfaces, classes can extend other classes.
+
+```java
+class BodyOfWater {}
+
+class Ocean extends BodyOfWater {}
+```
\ No newline at end of file
diff --git a/src/class_extension/abstract_classes.md b/src/class_extension/abstract_classes.md
new file mode 100644
index 00000000..3a39f4f4
--- /dev/null
+++ b/src/class_extension/abstract_classes.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
+
Up until now all the data types you have used - `int`, `String`, etc. -
came with Java. This works for awhile, but eventually you will need to define your own types.
diff --git a/src/classes/aliasing.md b/src/classes/aliasing.md
index 56195696..75baf720 100644
--- a/src/classes/aliasing.md
+++ b/src/classes/aliasing.md
@@ -19,8 +19,8 @@ void main() {
kermit.name = "Kermit The Frog";
// Kermit The Frog
- System.out.println(kermit.name);
+ IO.println(kermit.name);
// Kermit The Frog
- System.out.println(darkKermit.name);
+ IO.println(darkKermit.name);
}
```
\ No newline at end of file
diff --git a/src/classes/challenges.md b/src/classes/challenges.md
new file mode 100644
index 00000000..61e46417
--- /dev/null
+++ b/src/classes/challenges.md
@@ -0,0 +1,150 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+The following classes are named "wrong." Name them correctly.
+
+```java,editable
+class gonzo {}
+
+class fozzie_the_bear {}
+
+class MSPIGGY {}
+
+void main() {
+ IO.println(new gonzo());
+ IO.println(new fozzie_the_bear());
+ IO.println(new MSPIGGY());
+}
+```
+
+## Challenge 2.
+
+Make a variable named `movie` which is an instance of the `Movie` class.
+Set the value of its `title` field to `Muppets in Space`.
+
+```java,editable
+class Movie {
+ String title;
+}
+
+void main() {
+ // ---------------
+ // CODE HERE
+ // ---------------
+
+ IO.println(
+ movie.title
+ );
+}
+```
+
+## Challenge 3.
+
+Alter the `ThemePark` class so that the default value
+for its `entranceFee` field is `35.24`.
+
+```java,editable
+class ThemePark {
+ double entranceFee;
+}
+
+void main() {
+ ThemePark themePark = new ThemePark();
+
+ IO.println(
+ themePark.entranceFee
+ );
+}
+```
+
+## Challenge 4.
+
+Changing only the indicated line,
+make it so the word `Kermit` only appears twice in the
+program.
+
+Hint: Remember that inferred types exist.
+
+```java,editable
+class Kermit {
+ boolean angry = true;
+}
+
+void main() {
+ // ------------------------
+ // CHANGE ONLY THIS LINE v
+ Kermit kermit = new Kermit();
+ // ------------------------
+
+ IO.println(kermit.angry);
+}
+```
+
+## Challenge 5.
+
+Make a method named `squareRoot` which returns an
+instance of the `SquareRoot` class containing both
+the `positiveRoot` and `negativeRoot` of the given `double`.
+
+So if you are given `4` you should return a positive root
+of `2` and a negative root of `-2`.
+
+You do not have to account for the possibility of being given a negative
+number. You should use `Math.sqrt` to find the positive root and common
+sense to find the negative root.
+
+```java,editable
+class SquareRoot {
+ double positiveRoot;
+ double negativeRoot;
+}
+
+SquareRoot squareRoot(double value) {
+ // -----------
+ // CODE HERE
+ // -----------
+}
+
+void main() {
+ SquareRoot sqrtOfFour = squareRoot(4);
+ // 2
+ IO.println(sqrtOfFour.positiveRoot);
+ // -2
+ IO.println(sqrtOfFour.negativeRoot);
+
+ SquareRoot sqrtOfFifteen = squareRoot(15);
+ // 3.872983346207417
+ IO.println(sqrtOfFifteen.positiveRoot);
+ // -3.872983346207417
+ IO.println(sqrtOfFifteen.negativeRoot);
+}
+```
+
+## Challenge 6.
+
+Only writing code between the lines and without directly accessing any fields on or reassigning the `actor` variable, make the program output `Tim Curry`.
+
+Hint: The key word is "directly."
+
+```java,editable
+class Actor {
+ String name;
+}
+
+void main() {
+ Actor actor = new Actor();
+ actor.name = "Frog, Kermit the";
+
+ // --------------------------
+ // CODE HERE
+ // --------------------------
+
+ IO.println(actor.name);
+}
+```
\ No newline at end of file
diff --git a/src/classes/default_values.md b/src/classes/default_values.md
new file mode 100644
index 00000000..05415326
--- /dev/null
+++ b/src/classes/default_values.md
@@ -0,0 +1 @@
+# Default Values
diff --git a/src/classes/field_access.md b/src/classes/field_access.md
index 15706c6d..09865939 100644
--- a/src/classes/field_access.md
+++ b/src/classes/field_access.md
@@ -1,6 +1,6 @@
# Field Access
-You can access the value of any field on a class by writing the name of a variable holding an instance
+You can access the value of any field in a class by writing the name of a variable holding an instance
of that class, `.`, then the name of that field.
```java
@@ -13,6 +13,6 @@ void main() {
kermit.name = "Kermit The Frog";
// The .name accesses the "name" field
- System.out.println(kermit.name);
+ IO.println(kermit.name);
}
```
diff --git a/src/classes/field_default_values.md b/src/classes/field_default_values.md
index c80d269e..ed3f042e 100644
--- a/src/classes/field_default_values.md
+++ b/src/classes/field_default_values.md
@@ -17,12 +17,12 @@ void main() {
Muppet kermit = new Muppet();
// 0
- System.out.println(kermit.age);
+ IO.println(kermit.age);
// 0.0
- System.out.println(kermit.salary);
+ IO.println(kermit.salary);
// false
- System.out.println(kermit.talented);
+ IO.println(kermit.talented);
// null
- System.out.println(kermit.name);
+ IO.println(kermit.name);
}
```
\ No newline at end of file
diff --git a/src/classes/field_initialization.md b/src/classes/field_initialization.md
index 0a3461f7..43394880 100644
--- a/src/classes/field_initialization.md
+++ b/src/classes/field_initialization.md
@@ -2,7 +2,7 @@
You can set an initial value for a field in a few ways.
-One is to access to assign the field directly on the instance created.
+One is to assign the field directly on the instance created.
```java
class Muppet {
diff --git a/src/classes/header.png b/src/classes/header.png
new file mode 100644
index 00000000..98b4ac00
Binary files /dev/null and b/src/classes/header.png differ
diff --git a/src/classes/instances.md b/src/classes/instances.md
index 0546560d..6ebcce53 100644
--- a/src/classes/instances.md
+++ b/src/classes/instances.md
@@ -11,12 +11,12 @@ class Muppet {
void main() {
Muppet kermit = new Muppet();
- System.out.println(kermit);
+ IO.println(kermit);
}
```
-Very similarly to arrays, the output from printing an instance of a class might seem like gibberish (`Main$Muppet@1be6f5c3`).
+Very similar to arrays, the output from printing an instance of a class might seem like gibberish (`Main$Muppet@1be6f5c3`).
You will learn how to make it nicer later.
[^var]: I haven't used it in many code samples thus far, but if you remember `var` this is one of the times
-where it can be aethetically convenient. `var kermit = new Muppet();`
+where it can be aesthetically convenient. `var kermit = new Muppet();`
diff --git a/src/classes/multiple_instances.md b/src/classes/multiple_instances.md
new file mode 100644
index 00000000..174c783a
--- /dev/null
+++ b/src/classes/multiple_instances.md
@@ -0,0 +1,26 @@
+# Multiple Instances
+
+If you make multiple instances of a class with `new`
+those classes will each have their own values for
+fields.
+
+```java
+class Muppet {
+ String name;
+}
+
+void main() {
+ Muppet kermit = new Muppet();
+ kermit.name = "Kermit The Frog";
+
+ Muppet animal = new Muppet();
+ animal.name = "animal";
+
+ // kermit and animal are distinct muppets
+ // and thus each have their own name.
+ IO.println(kermit.name);
+ IO.println(animal.name);
+}
+```
+
+Each instance has what we would call its own "identity."
\ No newline at end of file
diff --git a/src/classes/return_multiple_values.md b/src/classes/return_multiple_values.md
index a78b9d48..16745174 100644
--- a/src/classes/return_multiple_values.md
+++ b/src/classes/return_multiple_values.md
@@ -15,18 +15,18 @@ class Location {
Location findTreasureIsland() {
Location location = new Location();
- location.latitude = 40.2085;
- location.longitude = -3.713;
+ location.latitude = 51.4075;
+ location.longitude = 0.4636;
return location;
}
void main() {
Location treasureIsland = findTreasureIsland();
- System.out.println(
+ IO.println(
"Treasure island is located at " +
- location.latitude +
+ treasureIsland.latitude +
" " +
- location.longitude +
+ treasureIsland.longitude +
"."
);
}
diff --git a/src/classes/the_meaning_of_the_word_class.md b/src/classes/the_meaning_of_the_word_class.md
index 2e42e04f..45b1252d 100644
--- a/src/classes/the_meaning_of_the_word_class.md
+++ b/src/classes/the_meaning_of_the_word_class.md
@@ -9,7 +9,7 @@ a `String` is classified by the set of things you can do to it and the data
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/)
+[^idiot]: What an [idiot](https://penelope.uchicago.edu/encyclopaedia_romana/greece/hetairai/diogenes.html)
-[^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.
\ No newline at end of file
diff --git a/src/classes/user_defined_types.md b/src/classes/user_defined_types.md
deleted file mode 100644
index 10d59774..00000000
--- a/src/classes/user_defined_types.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# User Defined Types
-
-Declaring a class
diff --git a/src/classes/zero_values.md b/src/classes/zero_values.md
deleted file mode 100644
index fd09e2ab..00000000
--- a/src/classes/zero_values.md
+++ /dev/null
@@ -1 +0,0 @@
-# Zero Values
diff --git a/src/code_is_read_more_than_written.md b/src/code_is_read_more_than_written.md
new file mode 100644
index 00000000..14fd731a
--- /dev/null
+++ b/src/code_is_read_more_than_written.md
@@ -0,0 +1,9 @@
+# Code is Read more than Written
+
+Now that you more or less can write a full program, it won't be long
+before you write a program of "signficant size."
+
+This makes it a good time to start drip feeding some of the higher level
+concepts around software development.
+
+The first of these is a statement: Code is read more then it is written.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/audience.md b/src/code_is_read_more_than_written/audience.md
new file mode 100644
index 00000000..ffe37473
--- /dev/null
+++ b/src/code_is_read_more_than_written/audience.md
@@ -0,0 +1,20 @@
+# Audience
+
+Consider this opening from an astrophysics paper I picked at random.[^arxiv]
+
+> The dearth of planets with sizes around 1.8 Rβ is a key demographic feature discovered by the Kepler mission. Two theories have emerged as potential explanations for this valley: photoevaporation and core-powered mass-loss. However, Rogers et al. (2021) shows that differentiating between the two theories is possible using the three-dimensional parameter space of planet radius, incident flux, and stellar mass.
+
+If you aren't an astrophysicist, this probably requires some explanation. If you are an astrophysicist, you
+probably understood that without issue.
+
+Whenever anyone writes anything, it is important to consider the audience you are writing to. This applies to code just as much as to any other form of writing.
+
+This is why shorthands like `for (int i = 0; i < length; i++)` are generally considered okay even though
+in most other situations `i` is pretty non-descript. Within the audience of programmers it is a known idiom.
+
+Its also why explaining every single line of code with comments is generally not okay. Programmers know what code
+is, you don't need to baby them through how loops work.[^offense]
+
+[^arxiv]: https://arxiv.org/abs/2302.00009
+
+[^offense]: No offense intended if you are still having trouble with loops. Its common, you will eventually get past it.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/implications.md b/src/code_is_read_more_than_written/implications.md
new file mode 100644
index 00000000..0abfb5f1
--- /dev/null
+++ b/src/code_is_read_more_than_written/implications.md
@@ -0,0 +1,10 @@
+# Implications
+
+This means that, sometimes, it makes sense to write code in a way that
+is "harder" than is absolutely needed.
+
+That's a bit of a fuzzy statement, but on the more obvious side it means
+doing things like spending extra time on code formatting, variable naming,
+function contracts, writing comments, etc.
+
+All of those things make it easier to read that code later on.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/information_density.md b/src/code_is_read_more_than_written/information_density.md
new file mode 100644
index 00000000..b93722bd
--- /dev/null
+++ b/src/code_is_read_more_than_written/information_density.md
@@ -0,0 +1,25 @@
+# Information Density
+
+An important related concept is information density.
+
+Yes, you can do things like add a comment on every line of code.
+This does mean that a later reader will have context on exactly what
+you were thinking as you were writing the code.[^literate]
+
+The downside is that there can be way more "extra" information than any
+educated person needs to understand the code. That extra information takes up space
+and spreads out the "important" information.
+
+Put another way, if something has a high information density it can be hard to read.
+
+> M.M.A.T.B.C
+
+Same as if it is has too low an information density.
+
+> Dearest sir, it would behoove you to meetest mineself posthaste after the school hours. I would perchance suggest that the location be betwixt the basketball courts.
+
+You want an information density that is "just right"
+
+> Meet me at the basketball court
+
+[^literate]: There is a whole sect of folks who write their programs as actual books. Look up "Literate Programming" to dive deeper in to that.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/meaning.md b/src/code_is_read_more_than_written/meaning.md
new file mode 100644
index 00000000..c18eedaf
--- /dev/null
+++ b/src/code_is_read_more_than_written/meaning.md
@@ -0,0 +1,14 @@
+# Meaning
+
+While I'm sure there are some statistics behind this[^ormaybe], its generally accepted that
+the majority of a programmer's time is taken up reading existing code rather than writing new code.
+
+This should make sense intuitively. If you get hired at Microsoft, chances are you won't be given
+a blank slate to make a brand new thing. Often you will be thrust into existing codebases. To make a change
+to an existing codebase, you need to understand the exisiting code.
+
+It gets to the point where you might spend a whole day reading a dozen or so files only to make a 6 line change
+to one of them.
+
+
+[^ormaybe]: Software Development is still a relatively new field. Some things we take for granted may end up not being true after all. It doesn't help that its also pretty poorly researched. Keep an eye out for that.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/practice.md b/src/code_is_read_more_than_written/practice.md
new file mode 100644
index 00000000..366da34b
--- /dev/null
+++ b/src/code_is_read_more_than_written/practice.md
@@ -0,0 +1,16 @@
+# Practice
+
+If you want to do programming as your job or as part of your job,
+and you want to be competent, it isn't enough to just practice writing code.
+You also need to practice reading.
+
+There are a lot of ways to go about that, but an easy one is to
+read the code of your classmates or of strangers on the internet.
+
+Read their code, try to understand all the (maybe wacky!) choices they made
+while writing it, and try to change it up a little bit.
+
+This will help you get an intuitive sense for what you like in
+a codebase as well as what you do not. It will also, more so than
+the early struggles you go through when learning to write, help you
+understand if you would actually like to do this for work.
\ No newline at end of file
diff --git a/src/collections.md b/src/collections.md
new file mode 100644
index 00000000..22440297
--- /dev/null
+++ b/src/collections.md
@@ -0,0 +1,14 @@
+# Collections
+
+
+
+
+Arrays, `ArrayList`, and `HashMap` are all "collections"
+of objects. Importantly, they also aren't the only possible
+kinds of collections.
+
+Java provides support for a wide range of different collection types
+through "The Collections Framework."[^marketing]
+
+[^marketing]: There is nothing really special about these interfaces and classes that mean they deserve such a name. I view it as a marketing term. There was a period of time before which Java did not have `ArrayList`, `HashMap`, etc. and when they were added they said "this is the new collections framework"
+instead of "we've added these dozen classes."
\ No newline at end of file
diff --git a/src/collections/arrays.md b/src/collections/arrays.md
new file mode 100644
index 00000000..74df3d37
--- /dev/null
+++ b/src/collections/arrays.md
@@ -0,0 +1,72 @@
+# Arrays
+
+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`.
+
+```java
+import java.util.List;
+import java.util.Arrays;
+
+class Main {
+ void main() {
+ String[] furniture = new String[] {
+ "Ottoman",
+ "Table",
+ "Dresser"
+ };
+
+ List
+
+When you run a program like so
+
+```
+java src/Main.java
+```
+
+Anything you put to the right of `src/Main.java` will be available to your program as a
+"command line argument."[^name]
+
+```
+java src/Main.java example
+```
+
+[^name]: They come from the command line and they are arguments to your program.
\ No newline at end of file
diff --git a/src/command_line_arguments/accessing_arguments.md b/src/command_line_arguments/accessing_arguments.md
new file mode 100644
index 00000000..67a281fe
--- /dev/null
+++ b/src/command_line_arguments/accessing_arguments.md
@@ -0,0 +1,41 @@
+# Accessing Arguments
+
+To access the command line arguments given to your program you need to change your main method.
+
+Instead of
+
+```java
+void main() {
+
+}
+```
+
+Have your main method take a string array as an argument.
+
+```java
+void main(String[] args) {
+
+}
+```
+
+This `String[]` will hold all the arguments passed.
+
+```
+java src/Main.java Duck Squirrel
+```
+
+```java
+~class Main {
+void main(String[] args) {
+ for (int i = 0; i < args.length; i++) {
+ IO.println(
+ "Hello Mr. " + args[i]
+ );
+ }
+}
+~}
+~// This is a little ugly
+~void main() {
+~ new Main().main(new String[] { "Duck", "Squirrel" });
+~}
+```
diff --git a/src/command_line_arguments/challenges.md b/src/command_line_arguments/challenges.md
new file mode 100644
index 00000000..154a78a8
--- /dev/null
+++ b/src/command_line_arguments/challenges.md
@@ -0,0 +1,50 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Make a program under `src/CLI.java`. The rest of these challenges will all be adding
+features to that program.
+
+```java
+class CLI {
+ // CODE HERE
+
+ void main(String[] args) {
+ // CODE HERE
+ }
+}
+```
+
+First, make it so that `java src/CLI.java` prints "No arguments provided"
+and immediately exits.
+
+## Challenge 2.
+
+Make it so that `java src/CLI.java 8` will print `64` and then exit.
+If you ran `java src/CLI.java 5` it would print `25` and so on.
+For any number it should print it's square.
+
+## Challenge 3.
+
+Make the operation to perform overridable. `java src/CLI.java --operation square 8`
+should do the same thing as `java src/CLI.java 8`. `java src/CLI.java --operation factorial 8`
+should print out `8` factorial (which is `40320`) instead of `64`.
+
+## Challenge 4.
+
+If a `-d` argument is provided then, instead of printing the result, the program
+should write the result to a file at the specified path.
+
+So `java src/CLI.java -d out.txt 9` should write `81` into a file named `out.txt`.
+The order that `-d` and `--operation` are provided should not matter. `java src/CLI.java -d out.txt --operation factorial 3` and `java src/CLI.java --operation factorial -d out.txt 3` should behave exactly the same.
+
+## Challenge 5.
+
+Make `java src/CLI.java --help` print out a help message describing the different flags
+you can provide and their meanings. To see what this should look somewhat like
+first run `java --help`.
\ No newline at end of file
diff --git a/src/command_line_arguments/conventions.md b/src/command_line_arguments/conventions.md
new file mode 100644
index 00000000..fc919e3a
--- /dev/null
+++ b/src/command_line_arguments/conventions.md
@@ -0,0 +1,17 @@
+# Conventions
+
+As it is just a `String[]`, you can interpret the arguments passed to your
+program in any way you choose.
+
+What you will notice, however, from using other tools in your terminal
+is that there are a few socially accepted conventions.
+
+If your tool takes "options" then you would expect `--option-name VALUE` to
+be how you specify it. So two dashes followed by the argument name.
+
+If you need a shorter version then you allow for one dash and sometimes a single
+letter value `-d VALUE`.
+
+And most importantly, if someone types `--help` you should give them the
+available options. Try `java --help` for an example.
+
diff --git a/src/command_line_arguments/header.png b/src/command_line_arguments/header.png
new file mode 100644
index 00000000..430b35c2
Binary files /dev/null and b/src/command_line_arguments/header.png differ
diff --git a/src/compilation.md b/src/compilation.md
new file mode 100644
index 00000000..f71f1bac
--- /dev/null
+++ b/src/compilation.md
@@ -0,0 +1,17 @@
+# Compilation
+
+
+
+The first step to sharing code you've written with other people is to
+compile it.
+
+Compilation in the context of programming languages means that a program
+reads all your code, ensures it abides by the rules of the language,
+and translates your code to some other form. Usually this other form
+is in some manner more directly "runnable" than the code you started with.
+
+We call programs that do this reading, ensuring, and translation "compilers."
+
+This happens behind the scenes when you run `java src/Main.java`
+but for sharing code you will need to do it yourself as a separate
+step.
diff --git a/src/compilation/challenges.md b/src/compilation/challenges.md
new file mode 100644
index 00000000..7405d034
--- /dev/null
+++ b/src/compilation/challenges.md
@@ -0,0 +1,30 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Take your code from one of the previous projects and compile all of it
+to class files.
+
+Make sure you can then run it using those class files.
+
+## Challenge 2.
+
+Take the code for one of the previous projects and put it in
+the multi-module directory layout.
+
+Compile it using the `--module-source-path` and `--module`
+options instead of listing the files out explicitly.
+
+Make sure you can then run it using the `--module-path` and `--add-modules ALL-MODULE-PATH`
+flags.
+
+
+## Challenge 3.
+
+Run the command from the previous command again, this time making sure to pass `-g`.
+Be sure to also clean whatever directory you used for output.
\ No newline at end of file
diff --git a/src/compilation/class_files.md b/src/compilation/class_files.md
new file mode 100644
index 00000000..b462843c
--- /dev/null
+++ b/src/compilation/class_files.md
@@ -0,0 +1,27 @@
+# Class Files
+
+The format that the Java compiler outputs is called a "class file."
+
+These class files are what is loaded into the "Java Virtual Machine" to actually run your program. This is
+in part because the Java Virtual Machine was conceived as a general tool not technicially specific to Java.
+
+There are other languages besides Java - such as [Clojure](https://clojure.org/) and [Kotlin](https://kotlinlang.org/) - which
+also can be compiled into class files.
+
+```text
+
+Java Source Code --> javac -------------\
+ ----> Class Files --> Java Virtual Machine
+Kotlin Source Code --> kotlinc ---------/ |
+ /
+Lombok Source Code --> lombokc ----------/
+
+... and more
+```
+
+This lets those languages make use of the Java Virtual Machine and all the millions
+of dollars and decades of work put into making it run code fast.[^bringup]
+
+[^bringup]: I bring this up because if you are only thinking about Java it might seem like a
+pointless extra step. It somewhat is, but at the same time it lets other languages "compete"
+on more or less even ground. The JVM is a labor of fill-in-the-blank, that is for sure.
\ No newline at end of file
diff --git a/src/compilation/clean.md b/src/compilation/clean.md
new file mode 100644
index 00000000..1afa87f6
--- /dev/null
+++ b/src/compilation/clean.md
@@ -0,0 +1,22 @@
+# Clean
+
+If you compile code multiple times you should "clean"
+your working directory before each compilation.
+
+This is because when you run `javac -d output ...` the compiler
+will simply dump class files into the destination folder.
+It will not remove any "stale" class files from earlier compiler runs.
+
+This can lead you to be in a state where you think your code is working
+but if you ever compiled it again, from scratch, you would get errors.
+
+The simplest way to handle this in bash is to use the `rm` tool. `rm` **r**e**m**oves
+files. Before you run the compiler clear out any old output with `rm -rf output`.
+`-rf` stands for "**r**ecursive" and "**f**orce." This is what you need to delete whole
+folders.[^simple]
+
+[^simple]: This technique - just deleting folders and doing the work from scratch again - can be slow.
+The upside of this approach is that it is simple to understand.
+It also probably doesn't matter since your computer is fast. When you need to really efficiently compile
+huge codebases you turn to a special kind of program called a build tool. These are complex beasts but can
+avoid unneccesary work.
\ No newline at end of file
diff --git a/src/compilation/g.md b/src/compilation/g.md
new file mode 100644
index 00000000..6b4aa4a6
--- /dev/null
+++ b/src/compilation/g.md
@@ -0,0 +1,39 @@
+# -g
+
+There are a lot of options you can pass to `javac` to alter its behavior.
+One of the ones that I find useful is `-g`. The `g` stands for "**g**enerate debug info."[^obvious]
+
+This makes sure the generated class files have information about things like what variables were named
+what. This, in turn, helps Java give better error messages
+
+For example, if you have a program like the following:
+
+```java
+class Main {
+ void main() {
+ String nocturne = null;
+ IO.println(nocturne.length());
+ }
+}
+```
+
+While in all situations it will ultimately crash with a `NullPointerException`, if
+you did not compile with `-g` you might get a stack trace like the following.
+You will probably need to scroll to the right to see the relevant bit.
+
+```text,no_run
+Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "
+
+If your age begins with the number `1` you are either near death or statistically
+very interested in Minecraft.
+
+A lot of people who learn Java do so in order to be able to write Minecraft
+mods or plugins for Minecraft servers, it is normal.
+
+Just a few words of caution:
+
+* The world of Minecraft development can be deeply exploitative. If you are not
+a full adult please do not try to "work" for anyone. Be careful. Talk to a
+parent or an adult you trust when people online seem to want something from you.
+* The kinds of code you write to make mods work will be pretty different than the
+kind of code you would write for most other kinds of software. This is partially
+because of what modding is (adjusting software whose evolution you do not control)
+and partially because of peculiarities around Minecraft in particular.
+
+With that all said: there are two basic "mod compatibility layers." These are
+"Fabric" and "Forge."
+
+The point of these is to give you code to program against that isn't the direct Minecraft source
+code, which can change very frequently, and to give your mod a fighting chance of being compatible
+across multiple Minecraft versions.
+
+Of the two: this book probably prepared you the best for Forge.
+
+Forge requires you to use Gradle which in turn will require at least a little knowledge of Kotlin.
+You don't need to take a full detour through that to get started, but you should put both of
+those on your list of things to learn.
+
+[Forge Getting Started here](https://docs.minecraftforge.net/en/latest/gettingstarted/)
+
+["Modded Minecraft" Discord here](https://discord.gg/moddedmc)
+
+["Minecraft Mod Development" Discord here](https://discord.com/invite/wpMz4AtAhn)
+
+Fabric pretty quickly requires you to interact with a concept called a "Mixin."
+This is a mechanism the Minecraft modding world made for magically editing the code inside Minecraft
+among other things. If you go this path just be ready for that.
+
+[Fabric Getting Started here](https://docs.fabricmc.net/develop/getting-started/introduction-to-fabric-and-modding)
+
+[Fabric community Discord here]([https://discord.gg/v6v4pMv](https://discord.gg/v6v4pMv))
+
+For making plugins that run on a custom Minecraft server - so things that handle custom
+chat commands and things of that nature - you have to use the plugin required by whatever
+server you are using. I am not the most up to date with Minecraft, but I know there
+is both Spigot and PaperMC. I have been told that Spigot is the preferred option
+as it allows for Bedrock players to play as well.
+
+[Docs for Spigot here](https://www.spigotmc.org/wiki/spigot-plugin-development/)
+
+[Spigot community Discord here](https://discord.gg/spigotmc)
+
+[Docs for PaperMC here](https://docs.papermc.io/)
+
+[PaperMC community Discord here](https://discord.gg/papermc)
+
+
+### Websites
+
+Making websites is a profitable career path. At least it is at the time of writing.
+There are a few essential things you will need to learn about to get started with that
+path.
+
+The first is how to make an HTTP Server. HTTP Servers are what web browsers talk
+to in order to render websites.
+
+There are a lot of tools for this in Java. A lot a lot. I would recommend
+starting with the one that comes built-in: the `jdk.httpserver` module.
+
+[Docs for `jdk.httpserver` here](https://javadoc.mccue.dev/api/jdk.httpserver/module-summary.html)
+
+Then you will need to learn about SQL databases and how to query from/insert into them from Java.
+
+A good start for that is SQLite - it is a database that runs self-contained in a single file.
+
+[SQLite tutorial here](https://www.sqlitetutorial.net/)
+
+After that - or as part of that - you should learn about JDBC. This is the way you interact with
+a database from Java.
+
+[I have a primer for that here](https://mccue.dev/pages/1-17-24-java-sql)
+
+Then from there you should learn about Dependency Injection
+
+[Good video on that here](https://www.youtube.com/watch?v=J1f5b4vcxCQ)
+
+And finally you can dive into the world of Spring - which is likely the
+most employable one of the many HTTP server options out there.
+
+[Spring Academy Courses here - the basic ones are free](https://spring.academy/)
+
+### Desktop Applications
+
+If you want to learn how to make desktop applications in Java you have basically
+two paths.
+
+Path #1 is to learn Java Swing. This is an old crusty GUI framework that is kinda difficult to use
+but has the pro of coming with Java and being able to run on every potato in existence.
+
+[Docs for `java.desktop` (Swing) here](https://javadoc.mccue.dev/api/java.desktop/module-summary.html)
+
+Path #2 is the learn JavaFX. By all accounts JavaFX is better software than Swing, but it was cursed
+by coming out at a point in history where desktop apps were no longer big business to develop. It
+was eventually removed from the JDK and you will need to procure it like any other dependency.
+
+[Docs for JavaFX here](https://openjfx.io/openjfx-docs/)
+
+## Learn a New Language
+
+An unfortunate truth is that you cannot use Java for everything.
+
+Sometimes this is intrinsic - Java would not be a good choice for code
+driving a pacemaker - and some of it is just how the ecosystems around languages
+are right now.
+
+Even if you could get away with only using Java, there is significant value in knowing multiple
+languages. Particuarly languages that are different than Java.
+
+### JavaScript
+
+
+
+To make highly interactive programs that run inside a browser you
+will need JavaScript. JavaScript and languages that compile to JavaScript
+are basically the only language it is practical
+to use for the frontend of a website[^wasm].
+
+It is probably worth your time to learn how to write JavaScript.
+
+[Mozilla Developer Network's JavaScript Guide here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide)
+
+The most popular language that compiles to JavaScript is TypeScript. After you've
+learned JavaScript that is a good one to touch next.
+
+[TypeScript tutorial here](https://www.typescripttutorial.net/)
+
+
+There are languages out there like TypeScript that compile to JavaScript -
+and you can find some projects out there that do much the same for Java -
+but just practically speaking learning JavaScript is going to be something
+you have to do at some point if you get into making websites.
+
+### C#
+
+
+
+C# is a language broadly similar to Java. It has a lot of features Java doesn't - for better or worse -
+but the basics are comparable.
+
+C# is very prevalent in the game development world. The Unity game engine,
+[corporate blunders notwithstanding](https://www.theverge.com/2024/9/12/24242937/unity-runtime-fee-cancelled-subscription-pricing), is still very big and still has you use C# for game scripts. Competitors like Godot [have C# Scripting as well](https://docs.godotengine.org/en/stable/tutorials/scripting/c_sharp/index.html).
+
+You will also find C# being used to make websites and desktop apps but it doesn't have
+as much unique pull there as it does in game development.
+
+[Microsoft's C# tutorial here](https://learn.microsoft.com/en-us/training/paths/get-started-c-sharp-part-1/)
+
+### Kotlin
+
+
+
+Kotlin is one of a family of languages that try to be a "better Java."
+Better is relative, but you are likely to learn _something_ when diving into it.
+
+Regardless, Kotlin is what you nowadays use to write Gradle build scripts in and
+Kotlin is the de-facto language for writing Android apps.
+
+This means that, while Java in some form is still technically an option,
+all the documentation for Android will be using Kotlin for their examples
+and most new frameworks will assume you are using Kotlin in preference to Java.
+
+And Gradle is a build tool that many Java projects choose to use. You probably don't need
+as deep of an understanding of Kotlin to work with Gradle build scripts as
+you do to make a full app in it, but it can't hurt.
+
+[Getting Started with Kotlin tutorial here](https://kotlinlang.org/docs/getting-started.html)
+
+[Kotlin Android Tutorial here](https://kotlinlang.org/docs/android-overview.html)
+
+If you want to make Desktop, Mobile, or Web apps in Kotlin it is probably also worth checking out
+Jetbrains Compose Multiplatfrom.
+
+[Getting Started for Jetbrains Compose Multiplatfrom here](https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-multiplatform-create-first-app.html)
+
+
+### Others
+
+Other languages you might want to learn that I haven't written up
+context for quite yet:
+
+* C
+
+
+
+* C++
+* Clojure
+* Elm
+* Haskell
+* Python
+
+
+
+* Ruby
+
+
+
+
+* Go
+
+
+
+
+* Rust
+* Zig
+* Clojure
+
+
+[^wasm]: Fight me, WebAssembly fans.
\ No newline at end of file
diff --git a/src/constr b/src/constr
deleted file mode 100644
index a902009c..00000000
--- a/src/constr
+++ /dev/null
@@ -1 +0,0 @@
-# Declaration
diff --git a/src/constructors.md b/src/constructors.md
index c4cbb0a9..98a28e0b 100644
--- a/src/constructors.md
+++ b/src/constructors.md
@@ -1,5 +1,8 @@
# Constructors
+
+
+
When defining a class, you are allowed to make a special kind of method
called a constructor.
diff --git a/src/constructors/arguments.md b/src/constructors/arguments.md
index 7a7073a7..fb26d309 100644
--- a/src/constructors/arguments.md
+++ b/src/constructors/arguments.md
@@ -19,7 +19,7 @@ void main() {
Muppet gonzo = new Muppet("Gonzo");
// "Gonzo"
- System.out.println(gonzo.name);
+ IO.println(gonzo.name);
}
```
diff --git a/src/constructors/challenges.md b/src/constructors/challenges.md
new file mode 100644
index 00000000..2974181c
--- /dev/null
+++ b/src/constructors/challenges.md
@@ -0,0 +1,149 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Write a `Shoe` class. Give each shoe a `name` field and a `quality` field.
+Have these fields be initialized inside of a constructor.
+
+```java,editable
+enum Quality {
+ SUPA_FINE,
+ FINE,
+ SUB_FINE
+}
+
+// CODE HERE
+
+void main() {
+ Shoe nike = new Shoe("Nikes", Quality.SUB_FINE);
+ IO.println(
+ "SHOE: " + nike.name + ", " + nike.quality
+ );
+
+
+ Shoe moccasin = new Shoe("Moccasins", Quality.SUPA_FINE);
+ IO.println(
+ "SHOE: " + moccasin.name + ", " + moccasin.quality
+ );
+}
+```
+
+## Challenge 2.
+
+Add a new `price` field to the `Shoe` class you wrote above.
+
+Add a new constructor which accepts a third argument to set the `price`.
+Keep the old two argument constructor around as well. When that one is
+used set `price` to `null`.
+
+Hint: Use `Double` to represent a nullable price.
+
+```java,editable
+enum Quality {
+ SUPA_FINE,
+ FINE,
+ SUB_FINE
+}
+
+// CODE HERE
+
+void main() {
+ Shoe jays = new Shoe("Air Jordans", Quality.FINE, 130.0);
+ IO.println(
+ "SHOE: " + jays.name + ", " + jays.quality + ", $" + jays.price
+ );
+
+ Shoe nike = new Shoe("Nikes", Quality.SUB_FINE, 25);
+ IO.println(
+ "SHOE: " + nike.name + ", " + nike.quality + ", $" + jays.price
+ );
+
+
+ Shoe moccasin = new Shoe("Moccasins", Quality.SUPA_FINE);
+ IO.println(
+ "SHOE: " + moccasin.name + ", " + moccasin.quality + ", $" + jays.price
+ );
+}
+```
+
+## Challenge 3.
+
+Alter the `Shoe` class so that the `price` field is final.
+Alter its constructors so that if they are given a negative
+value they throw an exception instead of finishing normally.
+
+Keep in mind that while `null` is allowed (you might not know the price)
+a negative number wouldn't be. Nobody is paying you to take their shoes.[^holes]
+
+```java,editable
+enum Quality {
+ SUPA_FINE,
+ FINE,
+ SUB_FINE
+}
+
+// CODE HERE
+
+void main() {
+ Shoe jays = new Shoe("Air Jordans", Quality.FINE, 130.0);
+ IO.println(
+ "SHOE: " + jays.name + ", " + jays.quality + ", $" + jays.price
+ );
+
+ Shoe nike = new Shoe("Nikes", Quality.SUB_FINE, 25);
+ IO.println(
+ "SHOE: " + nike.name + ", " + nike.quality + ", $" + jays.price
+ );
+
+
+ Shoe moccasin = new Shoe("Moccasins", Quality.SUPA_FINE);
+ IO.println(
+ "SHOE: " + moccasin.name + ", " + moccasin.quality + ", $" + jays.price
+ );
+
+ Shoe shouldCrash = new Shoe("Base Ball Cleats", Quality.SUPA_FINE, -10);
+}
+```
+
+[^holes]: If they do, you are going to dig holes in the desert in search of treasure that rightfully belongs
+to you.
+
+## Challenge 4.
+
+If you haven't yet, rewrite your `Shoe` constructors so only one of them actually sets fields
+and the other just delegates to that one.
+
+```java,editable
+enum Quality {
+ SUPA_FINE,
+ FINE,
+ SUB_FINE
+}
+
+// CODE HERE
+
+void main() {
+ Shoe jays = new Shoe("Air Jordans", Quality.FINE, 130.0);
+ IO.println(
+ "SHOE: " + jays.name + ", " + jays.quality + ", $" + jays.price
+ );
+
+ Shoe nike = new Shoe("Nikes", Quality.SUB_FINE, 25);
+ IO.println(
+ "SHOE: " + nike.name + ", " + nike.quality + ", $" + jays.price
+ );
+
+
+ Shoe moccasin = new Shoe("Moccasins", Quality.SUPA_FINE);
+ IO.println(
+ "SHOE: " + moccasin.name + ", " + moccasin.quality + ", $" + jays.price
+ );
+
+ Shoe shouldCrash = new Shoe("Base Ball Cleats", Quality.SUPA_FINE, -10);
+}
+```
\ No newline at end of file
diff --git a/src/constructors/declaration.md b/src/constructors/declaration.md
index 2ae1b365..27236a7c 100644
--- a/src/constructors/declaration.md
+++ b/src/constructors/declaration.md
@@ -25,7 +25,7 @@ class Muppet {
void main() {
Muppet gonzo = new Muppet();
- System.out.println(gonzo.talented);
+ IO.println(gonzo.talented);
}
```
diff --git a/src/constructors/final_fields.md b/src/constructors/final_fields.md
index 66542273..9c248266 100644
--- a/src/constructors/final_fields.md
+++ b/src/constructors/final_fields.md
@@ -17,7 +17,7 @@ class Muppet {
void main() {
Muppet gonzo = new Muppet("Gonzo");
- System.out.println(gonzo.name);
+ IO.println(gonzo.name);
// Cannot update the .name field later
// gonzo.name = "Gonzo, the great";
@@ -34,7 +34,7 @@ class Muppet {
void main() {
Muppet gonzo = new Muppet();
- System.out.println(gonzo.talented);
+ IO.println(gonzo.talented);
}
```
diff --git a/src/constructors/header.png b/src/constructors/header.png
new file mode 100644
index 00000000..69142a5d
Binary files /dev/null and b/src/constructors/header.png differ
diff --git a/src/constructors/invariants.md b/src/constructors/invariants.md
index c09a7bcc..13b96a25 100644
--- a/src/constructors/invariants.md
+++ b/src/constructors/invariants.md
@@ -25,7 +25,7 @@ class Muppet {
void main() {
Muppet bigBird = new Muppet("Big Bird", 6);
- System.out.println(
+ IO.println(
bigBird.name + " is " + bigBird.age + " years old."
);
}
diff --git a/src/constructors/overloads.md b/src/constructors/overloads.md
index 7ef5c4e4..bb309ea5 100644
--- a/src/constructors/overloads.md
+++ b/src/constructors/overloads.md
@@ -40,14 +40,14 @@ class Muppet {
}
void announce(Muppet muppet) {
- System.out.print(muppet.name);
+ IO.print(muppet.name);
if (muppet.talented) {
- System.out.print(" is ");
+ IO.print(" is ");
}
else {
- System.out.print(" is not ");
+ IO.print(" is not ");
}
- System.out.println("talented.");
+ IO.println("talented.");
}
void main() {
diff --git a/src/constructors/the_default_constructor.md b/src/constructors/the_default_constructor.md
index cd75169c..45a8573c 100644
--- a/src/constructors/the_default_constructor.md
+++ b/src/constructors/the_default_constructor.md
@@ -16,8 +16,8 @@ void main() {
Muppet gonzo = new Muppet();
// null
- System.out.println(gonzo.name);
+ IO.println(gonzo.name);
// false
- System.out.println(gonzo.talented);
+ IO.println(gonzo.talented);
}
```
\ No newline at end of file
diff --git a/src/distribution.md b/src/distribution.md
new file mode 100644
index 00000000..4a44067a
--- /dev/null
+++ b/src/distribution.md
@@ -0,0 +1,12 @@
+# Distribution
+
+If you are intending to run code on your own machine there isn't much reason to
+compile or package it. Compiling and packaging become useful when sharing
+code with other developers or when "deploying" code to a machine you (in some manner) control.
+
+But if you are making code intended to be used by a layperson it is insane to expect them
+to install Java special just for your program. It can also become burden on you
+since if you do get them to install Java, they won't keep it up to date.
+
+The solution is to bundle your code with the Java runtime itself. This gives you
+an "artifact" you can freely distribute and have someone "just run."
diff --git a/src/distribution/jars.md b/src/distribution/jars.md
new file mode 100644
index 00000000..f38d94b9
--- /dev/null
+++ b/src/distribution/jars.md
@@ -0,0 +1 @@
+# jars
diff --git a/src/documentation.md b/src/documentation.md
new file mode 100644
index 00000000..81a0fb42
--- /dev/null
+++ b/src/documentation.md
@@ -0,0 +1,16 @@
+# Documentation
+
+
+
+When sharing code that is intended to be used as a library it is important to explain
+how exactly your code should be used.
+
+If you can physically or digitally converse with the people you are sharing with this is a solved problem.
+They can ask you questions and you can answer them. Rinse and repeat until they no longer need to ask you
+questions.
+
+But seeing as there are millions of developers in the world that isn't always practical.[^grouptext]
+
+One tool we use to combat this reality is documentation. Documentation is where we write down what things are, what they do and why.
+
+[^grouptext]: Would make for one hell of a hectic group text.
\ No newline at end of file
diff --git a/src/documentation/challenges.md b/src/documentation/challenges.md
new file mode 100644
index 00000000..f413b408
--- /dev/null
+++ b/src/documentation/challenges.md
@@ -0,0 +1,24 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Run `javadoc` on some of your code. Add the command for doing so to a `Justfile`.
+Make sure to include cleaning stale of output.
+
+## Challenge 2.
+
+When you ran `javadoc` on your code you were almost certainly hit by a deluge of `warning: no comment`
+messages.
+
+Fix these by documenting that code enough that `javadoc` no longer gives you warnings.
+
+## Challenge 3.
+
+Read the [documentation for java.util.StringJoiner](https://javadoc.mccue.dev/api/java.base/java/util/StringJoiner.html).
+
+If you can, alter one of your projects to use it.
\ No newline at end of file
diff --git a/src/documentation/documentation_comments.md b/src/documentation/documentation_comments.md
new file mode 100644
index 00000000..dc7ccd4a
--- /dev/null
+++ b/src/documentation/documentation_comments.md
@@ -0,0 +1,21 @@
+# Documentation Comments
+
+To document our code we can use "documentation comments."
+
+These work the same as regular comments but instead of using two slashes (`//`)
+we use three slashes (`///`).[^old]
+
+You put these documentation comments above different elements of your program
+with text describing what the purpose of those elements are.
+
+```java
+/// This class represents a ninja
+public class Ninja {
+ /// Says a catchphrase
+ public void forsooth() {
+ // ..
+ }
+}
+```
+
+[^old]: There is an older way to make documentation comments using `/**` and `*/` (note the extra `*` in `/**`), but we prefer this one because the way you write the actual content of the comment is easier. You are sure to see these around though.
\ No newline at end of file
diff --git a/src/documentation/format.md b/src/documentation/format.md
new file mode 100644
index 00000000..7249b2e0
--- /dev/null
+++ b/src/documentation/format.md
@@ -0,0 +1,80 @@
+# Format
+
+```java,no_run
+import java.io.IOException;
+
+/// This class serves as a place to put examples
+/// of the different kinds of documentation as well
+/// as how to write documentation properly.
+///
+/// When specified after the three slashes
+/// you can write documentation using [Markdown](https://en.wikipedia.org/wiki/Markdown).
+///
+/// In Markdown you can just write text as you would in any file,
+/// line after line.
+///
+/// # For headings you can use a single hash
+///
+/// ## For subheadings you can use two
+///
+/// ### And so on
+///
+/// You can make unordered lists using hyphens
+///
+/// - A
+/// - B
+/// - C
+///
+/// And numbered lists like so
+///
+/// 1. One
+/// 2. Two
+/// 3. Thre
+///
+/// And so on. Definitely peruse up [tutorial on markdown](https://www.markdownguide.org/getting-started/)
+/// when you have the time.
+///
+/// There are some additions specific to Java though.
+/// We call these additions "tags."
+///
+/// One notable tag is the author tag. It lets you mark who worked
+/// on a given unit of code
+///
+/// @author Ethan McCue
+/// @see [https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html](https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html)
+public class DocumentationExample {
+ /// You can document the purpose of parameters
+ /// to constructors and methods with the param tag
+ ///
+ /// @param o Demonstrates a param tag on a constructor
+ public DocumentationExample(Object o) {
+
+ }
+
+ /// Generic parameters can also be documented using the param tag
+ /// as well.
+ ///
+ /// @param item The item to just return back
+ /// @param 
+
+One way of combatting the effects of Hyrum's Law
+is encapsulation.
+
+To encapsulate something is to hide it from the larger world. By doing
+so you lower the number of people who are able to observe what we would call
+"implementation details."
+
diff --git a/src/encapsulation/abstractions.md b/src/encapsulation/abstractions.md
new file mode 100644
index 00000000..b7f2969b
--- /dev/null
+++ b/src/encapsulation/abstractions.md
@@ -0,0 +1,8 @@
+# Abstraction
+
+A term closely related to encapsulation is abstraction.
+
+When you encapsulate something you have made an abstraction on top of it.
+
+You could say that "abstraction" is the noun and "encapsulation" is the verb.
+You encapsulate things, thereby making abstractions.
\ No newline at end of file
diff --git a/src/encapsulation/classes.md b/src/encapsulation/classes.md
new file mode 100644
index 00000000..d1a53df2
--- /dev/null
+++ b/src/encapsulation/classes.md
@@ -0,0 +1,65 @@
+# Classes
+
+One step above methods is classes.
+
+When classes have private fields and all interactions with those fields
+are mediated through methods
+
+The `ArrayList` class that comes with Java looks something like this.[^liberties]
+
+```java
+public class ArrayList
+
While you can use `String`, `int`, `boolean`, and friends
alongside your own custom classes to represent many situations,
that is not always enough.
@@ -17,4 +20,4 @@ enum StopLight {
}
```
-We call them enums because they enumerate multiple different possibilities.
\ No newline at end of file
+Enums are types with fixed sets of allowed values. We call them enums because they enumerate multiple different possibilities.
\ No newline at end of file
diff --git a/src/enums/challenges.md b/src/enums/challenges.md
new file mode 100644
index 00000000..b8928824
--- /dev/null
+++ b/src/enums/challenges.md
@@ -0,0 +1,107 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Make an enum named `Response` which
+has three variants. `YES`, `NO`, and `MAYBE_SO`.
+
+```java,editable
+// -------------
+// CODE HERE
+// -------------
+
+void main() {
+ IO.println(
+ Response.YES
+ );
+
+ IO.println(
+ Response.NO
+ );
+
+ IO.println(
+ Response.MAYBE_SO
+ );
+}
+```
+
+## Challenge 2.
+
+Write a method named `goodPerformer` which takes
+in a `String` representing the name of an artist.
+
+If that `String` is equal to `Pitbull` or `Billy Joel`
+return `YES`. If it is equal to `Shaggy` return `NO`.
+Otherwise return `MAYBE_SO`.
+
+Use the enum you defined above.
+
+```java,editable
+// ------------
+// CODE HERE
+// ------------
+
+void main() {
+ Response pitbull = goodPerformer("Pitbull");
+ IO.println(pitbull);
+
+ Response billyJoel = goodPerformer("Billy Joel");
+ IO.println(billyJoel);
+
+ Response shaggy = goodPerformer("Shaggy");
+ IO.println(shaggy);
+
+ Response chappelRoan = goodPerformer("Chappell Roan");
+ IO.println(chappelRoan);
+}
+```
+
+## Challenge 3.
+
+Make a method named `transition` which takes in a `StopLight`
+and returns the next light it will transition to.
+
+For those who don't drive cars: red lights go to green,
+green lights go to yellow, and yellow lights go to red.
+
+```java,editable
+enum StopLight {
+ RED,
+ YELLOW,
+ GREEN
+}
+
+StopLight transition(StopLight current) {
+ // ------------
+ // CODE HERE
+ // ------------
+}
+
+void main() {
+ var light = StopLight.RED;
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+
+ light = transition(light);
+ IO.println(light);
+}
+```
\ No newline at end of file
diff --git a/src/enums/comparison_to_boolean.md b/src/enums/comparison_to_boolean.md
index c889bd79..da139065 100644
--- a/src/enums/comparison_to_boolean.md
+++ b/src/enums/comparison_to_boolean.md
@@ -21,10 +21,10 @@ void main() {
Power power = Power.ON;
if (power == Power.ON) {
- System.out.println("The power is on");
+ IO.println("The power is on");
}
else {
- System.out.println("The power is off");
+ IO.println("The power is off");
}
}
```
diff --git a/src/enums/equality.md b/src/enums/equality.md
index 23b43757..84f4da80 100644
--- a/src/enums/equality.md
+++ b/src/enums/equality.md
@@ -14,10 +14,10 @@ void main() {
StopLight light = StopLight.RED;
if (light == StopLight.RED) {
- System.out.println("You must stop");
+ IO.println("You must stop");
}
else {
- System.out.println("Full speed ahead!");
+ IO.println("Full speed ahead!");
}
}
```
\ No newline at end of file
diff --git a/src/enums/header.png b/src/enums/header.png
new file mode 100644
index 00000000..f91a992e
Binary files /dev/null and b/src/enums/header.png differ
diff --git a/src/enums/switch.md b/src/enums/switch.md
index 5e103c97..9749d924 100644
--- a/src/enums/switch.md
+++ b/src/enums/switch.md
@@ -11,10 +11,10 @@ void main() {
StopLight light = StopLight.RED;
if (light == StopLight.RED) {
- System.out.println("You must stop");
+ IO.println("You must stop");
}
else {
- System.out.println("Full speed ahead!");
+ IO.println("Full speed ahead!");
}
}
```
\ No newline at end of file
diff --git a/src/enums/usage.md b/src/enums/usage.md
index 51f91ebb..3dffd1c6 100644
--- a/src/enums/usage.md
+++ b/src/enums/usage.md
@@ -16,7 +16,7 @@ enum StopLight {
void main() {
StopLight light = StopLight.RED;
- System.out.println(
+ IO.println(
"The light is " + light
);
}
diff --git a/src/ex b/src/ex
deleted file mode 100644
index f0aebb41..00000000
--- a/src/ex
+++ /dev/null
@@ -1 +0,0 @@
-# Exception Messages
diff --git a/src/exceptions.md b/src/exceptions.md
index b37b4725..73e86bc4 100644
--- a/src/exceptions.md
+++ b/src/exceptions.md
@@ -1,5 +1,8 @@
# Exceptions
+
+
+
When you do something that Java doesn't know how to handle, like
dividing a number by zero, your program will fail.
@@ -11,7 +14,7 @@ In "exceptional conditions" code will no longer be able to proceed.
```java,panics
void main() {
int x = 5 / 0;
- System.out.println("Won't get here, an exception will occur");
+ IO.println("Won't get here, an exception will occur");
}
```
diff --git a/src/exceptions/challenges.md b/src/exceptions/challenges.md
new file mode 100644
index 00000000..017c57bb
--- /dev/null
+++ b/src/exceptions/challenges.md
@@ -0,0 +1,166 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Write a method named `arise` which accepts a `String` parameter
+representing someone's name and prints `Awake 
+
+Perhaps unsurprisingly, `RuntimeException` is not the only kind of exception
+that can be thrown.
+
+There is a huge variety of exception types out there, but the most important thing to understand is the distinction between checked and unchecked
+exceptions.
\ No newline at end of file
diff --git a/src/exceptions_ii/challenges.md b/src/exceptions_ii/challenges.md
new file mode 100644
index 00000000..f2c2d898
--- /dev/null
+++ b/src/exceptions_ii/challenges.md
@@ -0,0 +1,76 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1
+
+Make a method named `parseIntChecked` that works the same as `Integer.parseInt`
+but throws a checked exception instead of an unchecked one.
+
+```java,editable
+// CODE HERE
+
+void main() throws Exception {
+ int x = parseIntChecked("45");
+ IO.println(x);
+
+ parseIntChecked("abc");
+}
+```
+
+## Challenge 2
+
+The following program will not compile. Make it compile by propagating the checked exception
+thrown by the `doesSomethingDangerous` method.
+
+```java,no_run
+int doesSomethingDangerous(int value) {
+ if (value == 1) {
+ throw new Exception("1 does not work");
+ }
+ return 3 * value + 2;
+}
+
+int compute(int start) {
+ return square(doesSomethingDangerous(start));
+}
+
+int square(int x) {
+ return x * x;
+}
+
+void main() {
+ int x = Integer.parseInt(IO.readln("Give a starting number: "));
+ IO.println(compute(x));
+}
+```
+
+## Challenge 3
+
+The following program is the same as the last one. Instead of propagating the exception, make it so that
+`compute` catches and rethrows the checked exception as an unchecked one.
+
+```java,no_run
+int doesSomethingDangerous(int value) throws Exception {
+ if (value == 1) {
+ throw new Exception("1 does not work");
+ }
+ return 3 * value + 2;
+}
+
+int compute(int start) {
+ return square(doesSomethingDangerous(start));
+}
+
+int square(int x) {
+ return x * x;
+}
+
+void main() {
+ int x = Integer.parseInt(IO.readln("Give a starting number: "));
+ IO.println(compute(x));
+}
+```
\ No newline at end of file
diff --git a/src/exceptions_ii/checked_exceptions.md b/src/exceptions_ii/checked_exceptions.md
new file mode 100644
index 00000000..4d8ff2e6
--- /dev/null
+++ b/src/exceptions_ii/checked_exceptions.md
@@ -0,0 +1,24 @@
+# Checked Exceptions
+
+When a part of your code might throw a "checked" exception, other
+parts of your code need to account for that possibility.
+
+```java,does_not_compile
+int divide(int x, int y) {
+ if (y == 0) {
+ // Will not work because nothing handles the exception
+ throw new Exception();
+ }
+
+ return x / y;
+}
+~void main() {
+~
+~}
+```
+
+We call them "checked" because you need to "check" for them.
+
+These are _generally_[^thisrule] used when you expect calling code to be able to do something intelligent to recover if the exception is thrown.
+
+[^thisrule]: This rule is merely a suggestion and people's definitions of "something intelligent" and "recover" vary wildly. Expect some things to throw checked exceptions and others to not and just know that you need to check for the checked ones.
diff --git a/src/exceptions_ii/exception.md b/src/exceptions_ii/exception.md
new file mode 100644
index 00000000..a33829eb
--- /dev/null
+++ b/src/exceptions_ii/exception.md
@@ -0,0 +1,13 @@
+# Exception
+
+The most vanilla[^vanillacopypasta] checked exception is `Exception`.
+
+If you want a checked exception and do not know of a better one, `Exception` will do.
+
+```java,panics
+void main() throws Exception {
+ throw new Exception("Crash!");
+}
+```
+
+[^vanillacopypasta]: people have the audacity to equate vanilla with βplainβ. the fruit of a delicate orchid pollinated by hand. worth its weight in solid gold and beyond. the fussy black-and-cream jewel of the american continent. you sick son of a bitch. imagine a world without vanilla. no blondies. no pound cakes. no crΓ¨me brΓ»lΓ©e, no coke floats. no cream soda. no satiny new york-style cheesecakes. no warm apple pie Γ la mode. no velvety complexity to bring out complex notes in chocolate desserts. no depth of flavour in your cakes and cookies and milkshakes. all in just a few precious seeds or grams of paste or perfumed teaspoons of liquid black platinum. what you donβt understand could fill the library of alexandria seven times over and then some. you ungrateful bastard iβm going to kill you - [Tumblr user "kirbyofthestars"](https://www.tumblr.com/peaceoutofthepieces/684810307611377664)
\ No newline at end of file
diff --git a/src/exceptions_ii/header.png b/src/exceptions_ii/header.png
new file mode 100644
index 00000000..50e15a95
Binary files /dev/null and b/src/exceptions_ii/header.png differ
diff --git a/src/exceptions_ii/main.md b/src/exceptions_ii/main.md
new file mode 100644
index 00000000..e9091ff7
--- /dev/null
+++ b/src/exceptions_ii/main.md
@@ -0,0 +1,12 @@
+# main
+
+The `main` method can be declared to throw any kind of checked exception.
+
+It is assumed that if an exception makes it all the way there that the way to handle it is crash
+the program.
+
+```java,panics
+void main() throws Exception {
+ throw new Exception("crash");
+}
+```
\ No newline at end of file
diff --git a/src/exceptions_ii/propagating_exceptions.md b/src/exceptions_ii/propagating_exceptions.md
new file mode 100644
index 00000000..bebd84b0
--- /dev/null
+++ b/src/exceptions_ii/propagating_exceptions.md
@@ -0,0 +1,36 @@
+# Propagating Exceptions
+
+Say we started out with code like this.
+
+```java
+void dream() {
+ IO.println("Shin Godzilla's Jaw unhinging like a snake...")
+}
+
+void sleep() {
+ dream();
+}
+
+void main() {
+ sleep();
+}
+```
+
+If a function is declared to throw an exception, that exception will have to "propagate" - meaning spread - to all calling functions.
+
+```java
+void dream() throws Exception {
+ throw new Exception("Something went wrong")
+}
+
+void sleep() throws Exception {
+ dream();
+}
+
+void main() throws Exception {
+ sleep();
+}
+```
+
+`dream` declares that it might throw `Exception` so `sleep` must declare that it might throw `Exception`. Because `sleep` might throw `Exception` now `main` might throw `Exception`.
+
diff --git a/src/exceptions_ii/rethrowing_exceptions.md b/src/exceptions_ii/rethrowing_exceptions.md
new file mode 100644
index 00000000..c1c9835c
--- /dev/null
+++ b/src/exceptions_ii/rethrowing_exceptions.md
@@ -0,0 +1,47 @@
+# Rethrowing Exceptions
+
+When you catch an exception you have the option of again throwing an exception.
+
+This is useful if you want to have behavior that occurs when something goes wrong but still
+ultimately throw an exception for the rest of the code to deal with.[^examples]
+
+```java,no_run
+void dream() throws Exception {
+ throw new Exception("Oh no");
+}
+
+void sleep() throws Exception {
+ try {
+ dream();
+ }
+ catch (Exception e) {
+ IO.println("Something went wrong while dreaming");
+ throw e;
+ }
+}
+```
+
+It is also an opportunity to "wrap" checked exceptions into unchecked ones.
+
+```java
+void dream() throws Exception {
+ throw new Exception("Oh no");
+}
+
+void sleep() {
+ try {
+ dream();
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+}
+
+void main() {
+ sleep();
+}
+```
+
+Which seems crazy, but remember that "the point" of a checked exception is to have the calling code make a choice about how to handle an error condition. If you are okay with just crashing, throwing an unchecked exception is a perfectly valid choice.
+
+[^examples]: These examples are all silly, I know. Once we get to files the mechanics will become useful.
\ No newline at end of file
diff --git a/src/exceptions_ii/runtime_exception.md b/src/exceptions_ii/runtime_exception.md
new file mode 100644
index 00000000..74b094c9
--- /dev/null
+++ b/src/exceptions_ii/runtime_exception.md
@@ -0,0 +1,17 @@
+# RuntimeException
+
+`RuntimeException` is an unchecked exception.[^naming]
+
+If you want a unchecked exception and do not know of a better one, `RuntimeException` will do.
+
+```java,panics
+void main() {
+ throw new RuntimeException("Crash!");
+}
+```
+
+[^naming]: You may be wondering why the names "`Exception`" and "`RuntimeException`" instead of the
+probably easier to understand "`CheckedException`" and "`UncheckedException`." Java was made by humans
+and initially - as I understand it - "normal" exceptions were expected to be checked. It was only
+exceptions that came from "The Java Runtime" that would be unchecked. So that is where the name "`RuntimeException`" comes from. It just very quickly became a choice that was too late to change
+without breaking all the Java code in the world.
\ No newline at end of file
diff --git a/src/exceptions_ii/throws.md b/src/exceptions_ii/throws.md
new file mode 100644
index 00000000..1cd2716b
--- /dev/null
+++ b/src/exceptions_ii/throws.md
@@ -0,0 +1,57 @@
+# throws
+
+One way to handle a checked exception is to add a `throws` to the end
+of your method declaration.
+
+```java
+int divide(int x, int y) throws Exception {
+ if (y == 0) {
+ throw new Exception();
+ }
+
+ return x / y;
+}
+
+~void main() {
+~
+~}
+```
+
+This will make it so that calling code needs to check for the possibility of that
+exception being thrown.
+
+```java,does_not_compile
+int divide(int x, int y) throws Exception {
+ if (y == 0) {
+ throw new Exception();
+ }
+
+ return x / y;
+}
+
+void doStuff() {
+ divide(1, 0);
+}
+
+~void main() {
+~
+~}
+```
+
+You can also declare unchecked exceptions using `throws` but you are never required to.[^doc]
+
+```java
+int divide(int x, int y) throws RuntimeException {
+ if (y == 0) {
+ throw new RuntimeException();
+ }
+
+ return x / y;
+}
+
+~void main() {
+~
+~}
+```
+
+[^doc]: This is one of many things that you might choose to do for the benefit of a human reader that isn't strictly needed for correct Java.
\ No newline at end of file
diff --git a/src/exceptions_ii/unchecked_exceptions.md b/src/exceptions_ii/unchecked_exceptions.md
new file mode 100644
index 00000000..065cb886
--- /dev/null
+++ b/src/exceptions_ii/unchecked_exceptions.md
@@ -0,0 +1,21 @@
+# Unchecked Exceptions
+
+When a part of your code might throw an "unchecked" exception, other
+parts of your code do not need to account for that possibility.
+
+```java
+int divide(int x, int y) {
+ if (y == 0) {
+ // Will work because you are not forced to handle
+ // an unchecked exception
+ throw new RuntimeException();
+ }
+
+ return x / y;
+}
+~void main() {
+~
+~}
+```
+
+We call them unchecked because you don't need to check for them.
\ No newline at end of file
diff --git a/src/files.md b/src/files.md
new file mode 100644
index 00000000..f9a011ee
--- /dev/null
+++ b/src/files.md
@@ -0,0 +1,11 @@
+# Files
+
+
+
+Files are how you store information
+on a[^normal] computer so that it can still be there when your program
+is done running.
+
+As such, reading files and writing files are tasks you will often want to do.
+
+[^normal]: *normal
\ No newline at end of file
diff --git a/src/files/challenges.md b/src/files/challenges.md
new file mode 100644
index 00000000..9d33aa6d
--- /dev/null
+++ b/src/files/challenges.md
@@ -0,0 +1,82 @@
+# Challenges
+
+Remember the rules for this are
+
+- Try to use only the information given up to this point in this book.
+- Try not to give up until you've given it a solid attempt
+
+## Challenge 1.
+
+Write a file named `hello.txt` and give it `Hello, world`
+as contents.
+
+## Challenge 2.
+
+Write a program that asks the user for a number and writes it into
+a file named `numbers.txt`.
+
+## Challenge 3.
+
+Update the previous program so that the list of numbers entered by a user
+is stored in the file. So if they give `1`, `2`, and `3` the file should contain
+something like the following.
+
+```
+1
+2
+3
+```
+
+Hint: `\n` is how you embed a newline character in `String`. You might find it useful.
+
+## Challenge 4.
+
+Update the previous program to also display the biggest number given so far
+if the user types `biggest` instead of a number.
+
+
+## Challenge 5.
+
+Make the previous program behave sensibly if the file contains data that is not numbers.
+
+## Challenge 6.
+
+Complete this program.
+
+```java
+import java.nio.file.Path;
+import java.io.IOException;
+
+class Main {
+ record Person(String name, int age) {}
+
+ void main() throws IOException {
+ var people = new Person[] {
+ new Person("Steve Smith", 15),
+ new Person("Stan Smith", 42),
+ new Person("Rodger", 1601)
+ };
+
+ var path = Path.of("people.txt");
+
+ save(path, people);
+
+ people = load(path);
+
+ IO.println(people[0]);
+ IO.println(people[1]);
+ IO.println(people[2]);
+
+ }
+
+ void save(Path path, Person[] people) throws IOException {
+ // Save to a file
+ }
+
+ Person[] load(Path path) throws IOException {
+ return null; // Make actually return an array
+ }
+}
+```
+
+
diff --git a/src/files/creating_a_folder.md b/src/files/creating_a_folder.md
new file mode 100644
index 00000000..697e2db0
--- /dev/null
+++ b/src/files/creating_a_folder.md
@@ -0,0 +1,19 @@
+# Creating a Folder
+
+To create a folder, you can use `Files.createDirectory`.
+
+```java
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+ void main() throws IOExeption {
+ Path folderPath = Path.of("example1");
+ Files.createDirectory(folderPath);
+ }
+}
+```
+
+This, like the other methods in `Files`, might throw an `IOException`.
+
+`Files.createDirectory` will fail if the folder already exists.
diff --git a/src/files/deleting_a_file.md b/src/files/deleting_a_file.md
new file mode 100644
index 00000000..ac636a41
--- /dev/null
+++ b/src/files/deleting_a_file.md
@@ -0,0 +1 @@
+# Delete a File
diff --git a/src/files/deleting_a_folder.md b/src/files/deleting_a_folder.md
new file mode 100644
index 00000000..2bb51457
--- /dev/null
+++ b/src/files/deleting_a_folder.md
@@ -0,0 +1 @@
+# Delete a Folder
diff --git a/src/files/header.png b/src/files/header.png
new file mode 100644
index 00000000..fd815711
Binary files /dev/null and b/src/files/header.png differ
diff --git a/src/files/ioexception.md b/src/files/ioexception.md
new file mode 100644
index 00000000..e96e72f4
--- /dev/null
+++ b/src/files/ioexception.md
@@ -0,0 +1,17 @@
+# IOException
+
+If some code is "doing IO" - by which we mean while it is trying to read some Input or write some Output - you should expect it to throw an `IOException`.
+
+This class lives in the `java.io` package so to use it by its simple name you need an import.
+
+```java
+import java.io.IOException;
+
+class Main {
+ void main() throws IOException {
+ throw new IOException("Something went wrong");
+ }
+}
+```
+
+Since reading a file is reading some input and writing to a file is writing some output, this exception is relevant to reading and writing files.
\ No newline at end of file
diff --git a/src/files/paths.md b/src/files/paths.md
new file mode 100644
index 00000000..17fa2b84
--- /dev/null
+++ b/src/files/paths.md
@@ -0,0 +1,22 @@
+# Paths
+
+All files and folders on your computer can be located by a "path"
+like "`Downloads/movie.mp4`."
+
+To store a path in a Java program we use the `Path` class from the `java.nio.file`[^nio]
+package. You create these `Path`s by giving a `String` to the `Path.of`
+static method.
+
+```java
+import java.nio.file.Path;
+
+class Main {
+ void main() {
+ Path pathToNotes = Path.of("notes.txt");
+
+ IO.println(pathToNotes);
+ }
+}
+```
+
+[^nio]: `nio` stands for "new IO." So yes, there was an old IO. We will use that too. Its one of many artifacts from Java's interesting and sordid history.
\ No newline at end of file
diff --git a/src/files/read_from_a_file.md b/src/files/read_from_a_file.md
new file mode 100644
index 00000000..c47ae6a0
--- /dev/null
+++ b/src/files/read_from_a_file.md
@@ -0,0 +1,58 @@
+# Read from a File
+
+To read a file's contents as a `String` you can use the `readString` static method
+from `java.nio.file.Files`.
+
+```java
+Path tasksPath = Path.of("tasks.txt");
+String tasks = Files.readString(tasksPath);
+```
+
+Similarly to `Files.writeString`, this can throw an `IOException` if
+something goes wrong[^filenotfound].
+
+This can be dealt with in the same way. Either declare the `IOException` in a `throws`
+clause or re-throw an unchecked exception.
+
+```java
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+ void main() throws IOExeption {
+ Path tasksPath = Path.of("tasks.txt");
+ String tasks = Files.readString(tasksPath);
+
+ IO.println(tasks);
+ }
+}
+```
+
+If you choose to re-throw any `IOException` as an unchecked exception then
+it might be helpful to remember that delayed assignment is allowed in that context.[^mostly]
+
+```java
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+ void main() {
+ Path tasksPath = Path.of("tasks.txt");
+
+ String tasks;
+ try {
+ tasks = Files.readString(tasksPath);
+ }
+ catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+
+ IO.println(tasks);
+ }
+}
+```
+
+[^filenotfound]: Usually we can hand-wave this as "when something goes wrong it throws `IOException`," but this is one of those cases where you might care about what exactly went wrong. Specifically, whether the reason you couldn't read a file because the file wasn't there. We'll use this method as an example when we go deeper into Exceptions
+so there will be a chance to talk about that.
+
+[^mostly]: Mostly just because it can let you "shrink the scope" of the try-catch.
\ No newline at end of file
diff --git a/src/files/uncheckedioexception.md b/src/files/uncheckedioexception.md
new file mode 100644
index 00000000..0a6407ef
--- /dev/null
+++ b/src/files/uncheckedioexception.md
@@ -0,0 +1,26 @@
+# UncheckedIOException
+
+The unchecked version of an `java.io.IOException` is `UncheckedIOException`.
+
+You can use this if you have a method which you don't want to propagate `IOException` but
+also want something more specific than `RuntimeException` to re-throw.
+
+
+And just like `IOException`, if you don't want to write
+out `java.io.UncheckedIOException` more than once you need to add an import.
+
+```java,no_run
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
+class Main {
+ void main() {
+ try {
+ doStuff();
+ }
+ catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ }
+}
+```
diff --git a/src/files/write_to_a_file.md b/src/files/write_to_a_file.md
new file mode 100644
index 00000000..9f35a270
--- /dev/null
+++ b/src/files/write_to_a_file.md
@@ -0,0 +1,58 @@
+# Write to a File
+
+To write a `String` to a file you can use the `Files` class from the `java.nio.file`
+package. It has a static method named `writeString`.
+
+```java,no_run
+Path tasksPath = Path.of("tasks.txt");
+String tasks = """
+ 1. Do dishes
+ 2. Do laundry
+ """;
+
+Files.writeString(tasksPath, tasks);
+```
+
+This method can throw an `IOException`, so to handle that you
+can have a `throws` declaration on the method calling it.
+
+```java,no_run
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+ void main() throws IOException {
+ Path tasksPath = Path.of("tasks.txt");
+ String tasks = """
+ 1. Do dishes
+ 2. Do laundry
+ """;
+
+ Files.writeString(tasksPath, tasks);
+ }
+}
+```
+
+The other option is to catch the `IOException` and re-throw it as an unchecked exception.
+
+```java,no_run
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+ void main() {
+ Path tasksPath = Path.of("tasks.txt");
+ String tasks = """
+ 1. Do dishes
+ 2. Do laundry
+ """;
+
+ try {
+ Files.writeString(tasksPath, tasks);
+ }
+ catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ }
+}
+```
\ No newline at end of file
diff --git a/src/files_ii.md b/src/files_ii.md
new file mode 100644
index 00000000..29ef6dde
--- /dev/null
+++ b/src/files_ii.md
@@ -0,0 +1 @@
+# Files II
diff --git a/src/files_ii/challenges.md b/src/files_ii/challenges.md
new file mode 100644
index 00000000..9358534c
--- /dev/null
+++ b/src/files_ii/challenges.md
@@ -0,0 +1 @@
+# Challenges
diff --git a/src/files_ii/input_stream.md b/src/files_ii/input_stream.md
new file mode 100644
index 00000000..446a71c5
--- /dev/null
+++ b/src/files_ii/input_stream.md
@@ -0,0 +1 @@
+# InputStream
diff --git a/src/files_ii/lines.md b/src/files_ii/lines.md
new file mode 100644
index 00000000..a294fde6
--- /dev/null
+++ b/src/files_ii/lines.md
@@ -0,0 +1 @@
+# Lines
diff --git a/src/files_ii/list_directory.md b/src/files_ii/list_directory.md
new file mode 100644
index 00000000..f3beb897
--- /dev/null
+++ b/src/files_ii/list_directory.md
@@ -0,0 +1 @@
+# Paths
diff --git a/src/files_ii/list_files.md b/src/files_ii/list_files.md
new file mode 100644
index 00000000..5f6e07da
--- /dev/null
+++ b/src/files_ii/list_files.md
@@ -0,0 +1 @@
+# List Files
diff --git a/src/files_ii/list_files_in_a_directory.md b/src/files_ii/list_files_in_a_directory.md
new file mode 100644
index 00000000..f3beb897
--- /dev/null
+++ b/src/files_ii/list_files_in_a_directory.md
@@ -0,0 +1 @@
+# Paths
diff --git a/src/files_ii/output_stream.md b/src/files_ii/output_stream.md
new file mode 100644
index 00000000..3903842d
--- /dev/null
+++ b/src/files_ii/output_stream.md
@@ -0,0 +1 @@
+# OutputStream
diff --git a/src/files_ii/paths.md b/src/files_ii/paths.md
new file mode 100644
index 00000000..f3beb897
--- /dev/null
+++ b/src/files_ii/paths.md
@@ -0,0 +1 @@
+# Paths
diff --git a/src/files_ii/read_lines.md b/src/files_ii/read_lines.md
new file mode 100644
index 00000000..6b6a5b54
--- /dev/null
+++ b/src/files_ii/read_lines.md
@@ -0,0 +1 @@
+# Read Lines
diff --git a/src/files_ii/reader.md b/src/files_ii/reader.md
new file mode 100644
index 00000000..284bef67
--- /dev/null
+++ b/src/files_ii/reader.md
@@ -0,0 +1 @@
+# Reader
diff --git a/src/files_ii/writer.md b/src/files_ii/writer.md
new file mode 100644
index 00000000..8e619c48
--- /dev/null
+++ b/src/files_ii/writer.md
@@ -0,0 +1 @@
+# Writer
diff --git a/src/first_steps.md b/src/first_steps.md
index d8bbf5b8..b5612c4b 100644
--- a/src/first_steps.md
+++ b/src/first_steps.md
@@ -1,10 +1,14 @@
# First Steps
-If you made it through the [Getting Started section](./getting_started/hello_world.md) you've successfully run this program.
+
+
+
+
+If you made it through the ["Set Up Your Computer" section](./text_editors/set_up_your_computer.md) you've successfully run this program.
```java
void main() {
- System.out.println("Hello, World!");
+ IO.println("Hello, World!");
}
```
@@ -26,21 +30,21 @@ So for all intents and purposes, this is the whole program.
```java
~void main() {
-System.out.println("Hello, World!");
+IO.println("Hello, World!");
~}
```
-This bit of magic here - `System.out.println` - is a "statement" that "prints" the text inside the `(` and `)` as well as a "new line" to the screen.
+This bit of magic here - `IO.println` - is a "statement" that "prints" the text inside the `(` and `)` as well as a "new line" to the screen.
-`print` with new `l`i`n`e.
+The "`IO`" part stands for "Input/Output" then it is **print** with new **l**i**n**e.
-If you were to replace it with `System.out.print`, then the output would lack that new line. This makes the following program be functionally identical to the first.
+If you were to replace it with `IO.print`, then the output would lack that new line. This makes the following program be functionally identical to the first.
```java
~void main() {
-System.out.print("Hello, ");
-System.out.print("World");
-System.out.println("!");
+IO.print("Hello, ");
+IO.print("World");
+IO.println("!");
~}
```
@@ -48,9 +52,9 @@ Which, when we add back `void main()`, looks like this.
```java
void main() {
- System.out.print("Hello, ");
- System.out.print("World");
- System.out.println("!");
+ IO.print("Hello, ");
+ IO.print("World");
+ IO.println("!");
}
```
@@ -58,4 +62,6 @@ You should get in the habit of, whenever you see some bit of code, trying to phy
tweak it, and play with it.
So try playing around with this program. If you actively engage then you will retain information better.
-So try playing around with this program. If you actively engage then you will retain information better.
+
+A lot of the code samples in the book are runnable in your browser. Hover
+your mouse on the one above. You should see a run button in the top right.
\ No newline at end of file
diff --git a/src/first_steps/challenges.md b/src/first_steps/challenges.md
index 0584a1bc..d22cb2e7 100644
--- a/src/first_steps/challenges.md
+++ b/src/first_steps/challenges.md
@@ -23,14 +23,14 @@ What will this program output when run? Write down your guess and then try actua
```text
void main() {
- System.out.println("A");
- //System.out.println("B");
- System.out.println("C");//
- System.out.println("D");
+ IO.println("A");
+ //IO.println("B");
+ IO.println("C");//
+ IO.println("D");
/*
- System.out.println("E");
- System.out.println("F");*/
- System.out.println("G");
+ IO.println("E");
+ IO.println("F");*/
+ IO.println("G");
}
```
@@ -42,9 +42,9 @@ How could you use that error to figure out where you might have forgotten to put
```java,editable
void main() {
- System.out.println("Apple");
- System.out.println("Banana");
- System.out.println("Clementine");
- System.out.println("Durian");
+ IO.println("Apple");
+ IO.println("Banana");
+ IO.println("Clementine");
+ IO.println("Durian");
}
```
diff --git a/src/first_steps/comments.md b/src/first_steps/comments.md
index 46b12a59..ee5b53d0 100644
--- a/src/first_steps/comments.md
+++ b/src/first_steps/comments.md
@@ -9,7 +9,7 @@ words.
```java
void main() {
// This prints hello world!
- System.out.println("Hello, World!");
+ IO.println("Hello, World!");
}
```
@@ -20,9 +20,9 @@ If you put `//` in front of something that is "code" and not an English explanat
```java
void main() {
- System.out.println("Hello, World!");
+ IO.println("Hello, World!");
// The line that prints out goodbye is "commented out"
- // System.out.println("Goodbye!");
+ // IO.println("Goodbye!");
}
```
@@ -50,7 +50,7 @@ void main() {
so sweet
and so cold
*/
- System.out.println("Hello, World!");
+ IO.println("Hello, World!");
}
```
diff --git a/src/first_steps/formatting.md b/src/first_steps/formatting.md
index 1bbbaf11..bbe65255 100644
--- a/src/first_steps/formatting.md
+++ b/src/first_steps/formatting.md
@@ -4,7 +4,7 @@ You may have noticed that after each `{` all the code that comes after it is "in
```java
void main() {
- System.out.println("Hello, World!");
+ IO.println("Hello, World!");
}
```
@@ -18,7 +18,7 @@ This is easier to show than to explain in detail. Just try to make your code loo
```java
void main() {
- System.out.println("Hello, World!");
+ IO.println("Hello, World!");
}
```
@@ -29,7 +29,7 @@ And not like this.
```java
void main()
{
-System.out.println("Hello, World!");}
+IO.println("Hello, World!");}
```
And keep in mind that this rule of thumb applies to every language construct that requires a `{` and `}` many of which I will introduce later.
diff --git a/src/first_steps/header.png b/src/first_steps/header.png
new file mode 100644
index 00000000..b899f11c
Binary files /dev/null and b/src/first_steps/header.png differ
diff --git a/src/first_steps/semicolon.md b/src/first_steps/semicolon.md
index 676991bf..4099b4b2 100644
--- a/src/first_steps/semicolon.md
+++ b/src/first_steps/semicolon.md
@@ -4,8 +4,8 @@ The `;` at the end of each of those lines is a "semicolon".
```java
~void main(){
-System.out.print("Hello, "); // <-- this thing
- // ^
+IO.print("Hello, "); // <-- this thing
+ // ^
~}
```
@@ -15,7 +15,7 @@ more complicated than these examples.
```java
~void main(){
-System.out.print(
+IO.print(
"Hello, "
);
~}
@@ -29,7 +29,7 @@ If you happen to have an extra semi-colon or two that is technically okay. It ju
```java
~void main() {
-System.out.print(
+IO.print(
"Hello, "
);;
~}
@@ -39,7 +39,7 @@ Or even
```java
~void main() {
-System.out.print(
+IO.print(
"Hello, "
);
diff --git a/src/floating_point_numbers.md b/src/floating_point_numbers.md
index 39d365fb..6ecaf08a 100644
--- a/src/floating_point_numbers.md
+++ b/src/floating_point_numbers.md
@@ -1,5 +1,8 @@
# Floating Point Numbers
+
+
+
Floating point numbers are used to represent numbers
which cannot be stored as Integers like `2.5` or `3.14`.
diff --git a/src/floating_point_numbers/addition.md b/src/floating_point_numbers/addition.md
index d0e4e5a6..e093163f 100644
--- a/src/floating_point_numbers/addition.md
+++ b/src/floating_point_numbers/addition.md
@@ -8,7 +8,7 @@ double x = 5.1;
// y will be 14.2
double y = x + 9.1;
-System.out.println(y);
+IO.println(y);
~}
```
@@ -22,7 +22,7 @@ Because of the previously mentioned inaccuracy, the results of additions might n
// z will be 19.299999999999997
double z = x + y;
-System.out.println(z);
+IO.println(z);
~}
```
@@ -35,9 +35,9 @@ double y = 4.4;
// z will be 9.4
double z = x + y;
-System.out.println(x);
-System.out.println(y);
-System.out.println(z);
+IO.println(x);
+IO.println(y);
+IO.println(z);
~}
```
@@ -51,8 +51,8 @@ double y = 4;
// this will not work. The result of the expression is a double.
int z = x + y;
-System.out.println(x);
-System.out.println(y);
-System.out.println(z);
+IO.println(x);
+IO.println(y);
+IO.println(z);
~}
```
diff --git a/src/floating_point_numbers/challenges.md b/src/floating_point_numbers/challenges.md
index ecf069f5..259b4aac 100644
--- a/src/floating_point_numbers/challenges.md
+++ b/src/floating_point_numbers/challenges.md
@@ -13,7 +13,7 @@ What will this program output when run? Write down your guess and then try runni
void main() {
double x = 5.1;
double y = 2.4;
- System.out.println(x + y);
+ IO.println(x + y);
}
```
@@ -25,7 +25,7 @@ What will this program output when run? Write down your guess and then try runni
void main() {
double x = 5.1;
double y = 2.1;
- System.out.println(x + y);
+ IO.println(x - y);
}
```
@@ -38,7 +38,7 @@ How can you make it give the "right" answer?
```java,editable
void main() {
double x = 5 / 2;
- System.out.println(x);
+ IO.println(x);
}
```
@@ -51,8 +51,8 @@ void main() {
double resultOne = (int) 5.0 / 2 + 5.0 / 2;
double resultTwo = (int) (5.0 / 2 + 5.0 / 2);
- System.out.println(resultOne);
- System.out.println(resultTwo);
+ IO.println(resultOne);
+ IO.println(resultTwo);
}
```
@@ -86,8 +86,8 @@ void main() {
double resultOne = ???;
double resultTwo = ???;
- System.out.println(resultOne);
- System.out.println(resultTwo);
+ IO.println(resultOne);
+ IO.println(resultTwo);
}
```
diff --git a/src/floating_point_numbers/comparison.md b/src/floating_point_numbers/comparison.md
index 076c068f..13213efb 100644
--- a/src/floating_point_numbers/comparison.md
+++ b/src/floating_point_numbers/comparison.md
@@ -11,8 +11,8 @@ double x = 1.5;
double y = 0.2;
// true
-System.out.println(x > y);
+IO.println(x > y);
// false
-System.out.println(x < y);
+IO.println(x < y);
~}
```
diff --git a/src/floating_point_numbers/conversion_from_integers.md b/src/floating_point_numbers/conversion_from_integers.md
index 54e39301..ff10c270 100644
--- a/src/floating_point_numbers/conversion_from_integers.md
+++ b/src/floating_point_numbers/conversion_from_integers.md
@@ -9,8 +9,8 @@ by Java when performing an assignment.
int x = 5;
double y = x;
-System.out.println(x);
-System.out.println(y);
+IO.println(x);
+IO.println(y);
~}
```
@@ -24,7 +24,7 @@ int y = 2;
// integer division of 7 and 2 gives 3.
double z = x / y;
-System.out.println(z);
+IO.println(z);
~}
```
@@ -39,6 +39,6 @@ int y = 2;
// so the result will be 3.5.
double z = (double) x / y;
-System.out.println(z);
+IO.println(z);
~}
```
diff --git a/src/floating_point_numbers/conversion_to_integers.md b/src/floating_point_numbers/conversion_to_integers.md
index 57f9f3fd..e0dfeb8f 100644
--- a/src/floating_point_numbers/conversion_to_integers.md
+++ b/src/floating_point_numbers/conversion_to_integers.md
@@ -29,7 +29,7 @@ double x = 5.0;
// will be 5
int y = (int) x;
-System.out.println(y);
+IO.println(y);
~}
```
@@ -42,9 +42,24 @@ int x = (int) 2.1;
int y = (int) 2.5;
int z = (int) 2.9;
-System.out.println(x);
-System.out.println(y);
-System.out.println(z);
+IO.println(x);
+IO.println(y);
+IO.println(z);
+~}
+```
+
+Negative numbers will also have their decimal part dropped. So numbers like `-7.2`, `-7.6`, and `-7.9` will
+all be converted into `-7`.
+
+```java
+~void main() {
+int x = (int) -7.2;
+int y = (int) -7.6;
+int z = (int) -7.9;
+
+IO.println(x);
+IO.println(y);
+IO.println(z);
~}
```
@@ -53,11 +68,11 @@ Any number that is too big to store in an `int` will be converted to the biggest
```java
~void main() {
// 2147483647
-System.out.println((int) 4207483647.0);
+IO.println((int) 4207483647.0);
double positiveInfinity = 5.0 / 0.0;
// 2147483647
-System.out.println((int) positiveInfinity);
+IO.println((int) positiveInfinity);
~}
```
@@ -66,11 +81,11 @@ Any number that is too small to store in an `int` will be converted to the small
```java
~void main() {
// -2147483648
-System.out.println((int) -9999999999.0);
+IO.println((int) -9999999999.0);
double negativeInfinity = -5.0 / 0.0;
// -2147483648
-System.out.println((int) negativeInfinity);
+IO.println((int) negativeInfinity);
~}
```
@@ -79,7 +94,7 @@ And `NaN` will be converted to zero.
```java
~void main() {
double nan = 0.0 / 0.0;
-System.out.println((int) nan);
+IO.println((int) nan);
~}
```
@@ -88,4 +103,4 @@ a place in the operator precedence order just like `+`, `-`, `==`, etc.
The main difference is that instead of appearing between two expressions like the `+` in `2 + 5`, it appears to the left of a single expression.
-[^cast]: https://english.stackexchange.com/questions/220001/etymology-of-type-cast
+[^cast]: [https://english.stackexchange.com/questions/220001/etymology-of-type-cast](https://english.stackexchange.com/questions/220001/etymology-of-type-cast)
diff --git a/src/floating_point_numbers/division.md b/src/floating_point_numbers/division.md
index 7563a95c..cd4c5528 100644
--- a/src/floating_point_numbers/division.md
+++ b/src/floating_point_numbers/division.md
@@ -10,9 +10,9 @@ double y = x / 2;
// z will be 1.3333333333333333
double z = y / 3;
-System.out.println(x);
-System.out.println(y);
-System.out.println(z);
+IO.println(x);
+IO.println(y);
+IO.println(z);
~}
```
diff --git a/src/floating_point_numbers/equality.md b/src/floating_point_numbers/equality.md
index fa72695b..81876162 100644
--- a/src/floating_point_numbers/equality.md
+++ b/src/floating_point_numbers/equality.md
@@ -9,7 +9,7 @@ double numberOfFingers = 10.0;
boolean humanGenerated = numberOfToes == numberOfFingers;
-System.out.println(humanGenerated);
+IO.println(humanGenerated);
~}
```
@@ -25,7 +25,27 @@ double z = x + y;
// this will be false.
boolean doesWhatYouExpect = z == 0.3;
-System.out.println(doesWhatYouExpect);
+IO.println(doesWhatYouExpect);
+~}
+```
+
+To account for that you can check if a number is "close enough" to another one
+by seeing if the "absolute value" of the difference is a small number.
+
+```java
+~void main() {
+double x = 0.1;
+double y = 0.2;
+// z will be 0.30000000000000004
+double z = x + y;
+
+double compare = 0.3;
+
+// this will be true.
+boolean doesWhatYouExpect =
+ Math.abs(z - 0.3) < 0.00001;
+
+IO.println(doesWhatYouExpect);
~}
```
@@ -39,6 +59,6 @@ double y = 5.0;
// will be true
boolean fiveIsFive = x == y;
-System.out.println(fiveIsFive);
+IO.println(fiveIsFive);
~}
```
diff --git a/src/floating_point_numbers/header.png b/src/floating_point_numbers/header.png
new file mode 100644
index 00000000..678252b1
Binary files /dev/null and b/src/floating_point_numbers/header.png differ
diff --git a/src/floating_point_numbers/multiplication.md b/src/floating_point_numbers/multiplication.md
index 24c126ea..5d6066a1 100644
--- a/src/floating_point_numbers/multiplication.md
+++ b/src/floating_point_numbers/multiplication.md
@@ -10,9 +10,9 @@ double y = x * 9;
// z will be 13.5
double z = y * 0.5;
-System.out.println(x);
-System.out.println(y);
-System.out.println(z);
+IO.println(x);
+IO.println(y);
+IO.println(z);
~}
```
@@ -23,6 +23,6 @@ multiplication on doubles. So long as any number being used is a `double` the ov
~void main() {
// a will be 3.0
double a = 1.5 * 2;
-System.out.println(a);
+IO.println(a);
~}
```
diff --git a/src/floating_point_numbers/nan.md b/src/floating_point_numbers/nan.md
index cf22e188..fdd3f94d 100644
--- a/src/floating_point_numbers/nan.md
+++ b/src/floating_point_numbers/nan.md
@@ -16,7 +16,7 @@ double nan = 0.0 / 0.0;
// will be false
boolean equalToItself = nan == nan;
-System.out.println(equalToItself);
+IO.println(equalToItself);
~}
```
@@ -28,7 +28,7 @@ System.out.println(equalToItself);
// will be false
boolean greaterThanItself = nan > nan;
-System.out.println(greaterThanItself);
+IO.println(greaterThanItself);
~}
```
@@ -40,7 +40,7 @@ System.out.println(greaterThanItself);
// will be false
boolean lessThanItself = nan < nan;
-System.out.println(lessThanItself);
+IO.println(lessThanItself);
~}
```
@@ -50,9 +50,9 @@ System.out.println(lessThanItself);
~void main() {
~double nan = 0.0 / 0.0;
// will all be false
-System.out.println(nan < 5);
-System.out.println(nan > 5);
-System.out.println(nan == 5);
+IO.println(nan < 5);
+IO.println(nan > 5);
+IO.println(nan == 5);
~}
```
diff --git a/src/floating_point_numbers/positive_and_negative_infinity.md b/src/floating_point_numbers/positive_and_negative_infinity.md
index d87468e3..570c544e 100644
--- a/src/floating_point_numbers/positive_and_negative_infinity.md
+++ b/src/floating_point_numbers/positive_and_negative_infinity.md
@@ -22,10 +22,10 @@ As you might expect, positive infinity is greater than any number and negative i
~double positiveInfinity = 1.0 / 0.0;
~double negativeInfinity = -1.0 / 0.0;
// true
-System.out.println(positiveInfinity > 99999999);
+IO.println(positiveInfinity > 99999999);
// true
-System.out.println(negativeInfinity < -99999999);
+IO.println(negativeInfinity < -99999999);
~}
```
@@ -38,9 +38,9 @@ Except for `NaN`, of course.
double nan = 0.0 / 0.0;
// false
-System.out.println(positiveInfinity > nan);
+IO.println(positiveInfinity > nan);
// false
-System.out.println(negativeInfinity < nan);
+IO.println(negativeInfinity < nan);
~}
```
diff --git a/src/floating_point_numbers/shorthands_for_reassignment.md b/src/floating_point_numbers/shorthands_for_reassignment.md
index 42ece4cd..d57d5744 100644
--- a/src/floating_point_numbers/shorthands_for_reassignment.md
+++ b/src/floating_point_numbers/shorthands_for_reassignment.md
@@ -6,30 +6,30 @@ All the same shorthands for reassignment work with `double`s the same as they do
~void main() {
double x = 0.5;
// 0.5
-System.out.println(x);
+IO.println(x);
x += 3;
// 3.5
-System.out.println(x);
+IO.println(x);
x -= 1;
// 2.5
-System.out.println(x);
+IO.println(x);
x++;
// 3.5
-System.out.println(x);
+IO.println(x);
x--;
// 2.5
-System.out.println(x);
+IO.println(x);
x *= 5;
// 12.5
-System.out.println(x);
+IO.println(x);
x /= 2;
// 6.25
-System.out.println(x);
+IO.println(x);
~}
```
diff --git a/src/floating_point_numbers/square_root.md b/src/floating_point_numbers/square_root.md
index dca62212..82f49565 100644
--- a/src/floating_point_numbers/square_root.md
+++ b/src/floating_point_numbers/square_root.md
@@ -11,7 +11,7 @@ double x = 4;
double y = Math.sqrt(x);
// This will output 2
-System.out.println(y);
+IO.println(y);
~}
```
@@ -24,7 +24,7 @@ double y = 13;
double z = Math.sqrt(9 * x + y);
// This will output 7.615773105863909
-System.out.println(z);
+IO.println(z);
~}
```
@@ -33,6 +33,6 @@ If you try to take the square root of a negative number, the result will be `NaN
```java
~void main() {
// will output NaN
-System.out.println(Math.sqrt(-5.2));
+IO.println(Math.sqrt(-5.2));
~}
```
diff --git a/src/floating_point_numbers/subtraction.md b/src/floating_point_numbers/subtraction.md
index cc89f7bb..4e535206 100644
--- a/src/floating_point_numbers/subtraction.md
+++ b/src/floating_point_numbers/subtraction.md
@@ -5,11 +5,11 @@ You can subtract any two `double`s using the `-` operator.
```java
~void main() {
double x = 5.1;
-// y will be 4.1
+// y will be -4.1
double y = x - 9.2;
-System.out.println(x);
-System.out.println(y);
+IO.println(x);
+IO.println(y);
~}
```
@@ -18,12 +18,12 @@ Because of the previously mentioned inaccuracy, the results of subtractions migh
```java
~void main() {
~double x = 5.1;
-~// y will be 4.1
+~// y will be -4.1
~double y = x - 9.2;
// z will be -4.199999999999999
double z = y - 0.1;
-System.out.println(z);
+IO.println(z);
~}
```
@@ -36,9 +36,9 @@ double y = 4.5;
// z will be 0.5
double z = x - y;
-System.out.println(x);
-System.out.println(y);
-System.out.println(z);
+IO.println(x);
+IO.println(y);
+IO.println(z);
~}
```
diff --git a/src/floating_point_numbers_ii.md b/src/floating_point_numbers_ii.md
new file mode 100644
index 00000000..57ad3ca3
--- /dev/null
+++ b/src/floating_point_numbers_ii.md
@@ -0,0 +1 @@
+# Floating Point Numbers II
diff --git a/src/generic_growable_arrays.md b/src/generic_growable_arrays.md
new file mode 100644
index 00000000..9b5525a8
--- /dev/null
+++ b/src/generic_growable_arrays.md
@@ -0,0 +1 @@
+# Generic Growable Arrays
diff --git a/src/generic_growable_arrays/arraylist.md b/src/generic_growable_arrays/arraylist.md
new file mode 100644
index 00000000..6b95c2f0
--- /dev/null
+++ b/src/generic_growable_arrays/arraylist.md
@@ -0,0 +1 @@
+# ArrayList
diff --git a/src/generic_hash_maps/hash_map b/src/generic_hash_maps/hash_map
new file mode 100644
index 00000000..96e549de
--- /dev/null
+++ b/src/generic_hash_maps/hash_map
@@ -0,0 +1 @@
+# HashMap
diff --git a/src/generics.md b/src/generics.md
new file mode 100644
index 00000000..14ca196f
--- /dev/null
+++ b/src/generics.md
@@ -0,0 +1,17 @@
+# Generics
+
+
+
+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.
+
+Generics help us make these generically useful containers.
+
+```java
+class Box