More challenges

Author: bowbahdoe

src/SUMMARY.md

@@ -552,6 +552,7 @@ Have a project that is just klarna but the your goal is "never write this progra
   - [Package-Private Constructors](./packages/package_private_constructors.md)
   - [Subpackages](./packages/subpackages.md)
   - [Reverse Domain Name Notation](./packages/reverse_domain_name_notation.md)
+  - [Challenges](./packages/challenges.md)
 
 # Data Types IV
 
@@ -564,6 +565,7 @@ Have a project that is just klarna but the your goal is "never write this progra
   - [Check for Equality](./records/check_for_equality.md)
   - [Return Multiple Values](./records/return_multiple_values.md)
   - [Shorthand](./records/shorthand.md)
+  - [Challenges](./records/challenges.md)
 
 - [Integers II](./integers_ii.md)
   - [Integer from a String](./integers_ii/integer_from_a_string.md)

src/encapsulation/implicit_interfaces.md

@@ -15,6 +15,6 @@ Then back within Java there are things which form "an interface"
 which may or may not use the `interface` keyword. The static methods available on a class,
 the constructors that are public, the set of classes that come with a library, etc.
 
-I think a more general concept "the implicit interface." Everything you can observe about a thing forms its "implicit interface."[^implicit]
+I think a more general concept is "the implicit interface." Everything you can observe about a thing forms its "implicit interface."[^implicit]
 
 [^implicit]: I call it "implicit" because there is no place where you write down "all the properties of a thing" that is not the thing itself. And by thing I mean field, method, class, group of classes, package names - everything.

src/integers_ii/integer_from_a_string.md

@@ -2,7 +2,7 @@
 
 If you have a `String` which contains text that can be interpreted
 as an integer you can convert it to an `int` using the `parseInt`
-static method on `Integer`.
+static method on `Integer`.[^already]
 
 ```java
 ~void main() {
@@ -41,3 +41,5 @@ try {
 ~}
 ```
 
+[^already]: You should actually already know this. I just never explained explicitly that parseInt was a static method or showed that you could catch _only_ the `NumberFormatException`. In my defense, `IO.readln`
+at one point came far later in the book.

src/multi_file_programs/challenges.md

@@ -1 +1,105 @@
 # 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
+
+Put this code in a file named `Pickle.java`
+
+```java
+class Pickle {
+    boolean dill;
+}
+```
+
+Put this code in a file named `Ramen.java`
+
+```java
+class Ramen {
+    void mixWith(Pickle pickle) {
+        IO.println("This is gross.");
+        if (pickle.dill) {
+            IO.println("Extra super gross.");
+        }
+    }
+}
+```
+
+And finally put this code in `Main.java`
+
+```java
+class Main {
+    void main() {
+        var pickle = new Pickle();
+        pickle.dill = true;
+
+        var ramen = new Ramen();
+
+        ramen.mixWith(pickle);
+    }
+}
+```
+
+Then run the entire program from your terminal by using `java Main.java`
+in the directory where you made these files.
+
+## Challenge 2
+
+Move `Ramen.java`, `Pickle.java`, and `Main.java` into a folder named `src`.
+
+Make sure you can still run the program by typing `java src/Main.java`.
+
+## Challenge 3
+
+The following code uses an anonymous main class. Make it instead use a named class.
+
+```java,editable
+int dogs = 99;
+
+void main() {
+    while (dogs > 0) {
+        IO.println(dogs + " dogs on the floor.");
+        IO.println("Wake one up, take it for a walk");
+        dogs--;
+    }
+    IO.println("No more dogs on the floor.");
+}
+```
+
+## Challenge 4
+
+
+Combine the following programs while keeping them in separate files.
+This will require you to give names to both classes as well as
+parameterize the "dogs on the floor" program in some way.
+
+```java
+int dogs = 99;
+
+void main() {
+    while (dogs > 0) {
+        IO.println(dogs + " dogs on the floor.");
+        IO.println("Wake one up, take it for a walk");
+        dogs--;
+    }
+    IO.println("No more dogs on the floor.");
+}
+```
+
+
+```java
+void main() {
+    while (true) {
+        try {
+            int dogs = Integer.parseInt(IO.readln("How many dogs are on the floor? "));
+            IO.println("TODO"); // Call the first program here somehow.
+        } catch (RuntimeException e) {
+            IO.println("Goodbye!");
+        }
+    }
+    
+}
+```

src/packages/challenges.md

@@ -0,0 +1,34 @@
+# 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 all the code you have written so far and put into one project.
+
+To do this put everything under one `src` folder just in different packages.
+You will need to convert any usages of the anonymous main class into
+named classes, but other than that it should be doable.
+
+If you have already been doing that, just start making use of packages.
+They are, first and foremost, an organizational tool. Use them to organize
+your code as you see fit.
+
+## Challenge 2.
+
+In the packages above have all the growable array implementations you were
+asked to make in one package named `collections`. Import these collections
+wherever you want to use them with `import collections.GrowableIntArray;`
+or similar declarations.
+
+This will require marking the classes and many of the methods within `public`.
+
+## Challenge 3.
+
+Read through [the list of packages that come with Java](https://docs.oracle.com/en/java/javase/24/docs/api/java.base/module-summary.html). You don't need to understand everything you are looking at; just
+browse and try to find at least one class that interests you.
+
+Import that class and try to use it.

src/records/challenges.md

@@ -0,0 +1,105 @@
+# 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.
+
+Replace the usage of a normal class in the following code with a record.
+
+```java,editable
+import java.util.Arrays;
+
+class InventoryItem {
+    String name;
+
+    InventoryItem(String name) {
+        this.name = name;
+    }
+}
+
+class Main {
+    void main() {
+        var item1 = new InventoryItem("sword");
+        var item2 = new InventoryItem("shield");
+        var item3 = new InventoryItem("armor");
+
+        InventoryItem[] items = {
+            item1,
+            item2,
+            item3
+        };
+
+        IO.println(Arrays.toString(items));
+    }
+}
+```
+
+## Challenge 2.
+
+Make an instance of the `Tien` record and print it out.
+
+```java,editable
+enum TienMove {
+    DODON_RAY,
+    TRI_BEAM,
+    EXPLODE
+}
+
+record Chiaotzu(
+    Move memorableMove
+) {}
+
+record Tien(
+    Chiaotzu onlyFriend,
+    Move firstMove,
+    Move secondMove
+) {}
+
+class Main {
+    void main() {
+        Tien tien;
+        // CODE HERE
+        IO.println(tien);
+    }
+}
+```
+
+## Challenge 3.
+
+What will this program output when run? 
+
+1. `true` then `true`
+2. `true` then `false`
+3. `false` then `true`
+4. `false` then `false`
+
+Write down your guess and then try running it.
+
+```java
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+
+record Location(int x, int y) {}
+
+class Main {
+    void main() {
+        var p1 = new Position(7, 1);
+        var p2 = new Position(7, 1);
+        IO.println(p1.equals(p2));
+
+        var l1 = new Location(8, 3);
+        var l2 = new Location(8, 3);
+        IO.println(l1.equals(l2));
+    }
+}
+```