More reflection

Author: bowbahdoe

src/SUMMARY.md

@@ -603,10 +603,12 @@ Make them do one. -->
 - [Reflection](./reflection.md)
   - [Class Objects](./reflection/class_objects.md)
   - [Get all Fields](./reflection/get_all_fields.md)
-  - [Get a Field]()
-  - [Set a Field]()
-  - [Get a Method]()
-  - [Call a Method]()
+  - [Get a Field](./reflection/get_a_field.md)
+  - [Read from a Field](./reflection/read_from_a_field.md)
+  - [Write to a Field](./reflection/write_to_a_field.md)
+  - [Get all Methods](./reflection/get_all_methods.md)
+  - [Get a Method](./reflection/get_a_method.md)
+  - [Invoke a Method](./reflection/invoke_a_method.md)
   - [Get a Constructor]()
 
 - [Annotations](./annotations.md)

src/reflection/get_a_field.md

@@ -0,0 +1,47 @@
+# Get a Field
+
+You can retrieve a single field by its name using `getField`. If there
+is no field with that name it will throw a `NoSuchFieldException`.
+
+```java
+import java.lang.reflect.Field;
+
+class Main {
+    void main() throws NoSuchFieldException {
+        Class<Drink> drinkClass = Drink.class;
+
+        Field nameField = drinkClass.getField("name");
+        System.out.println(nameField);
+    }
+}
+
+class Drink {
+    public String name;
+    public boolean caffeinated;
+}
+```
+
+And if you need to access a field that might be non-public you can use `getDeclaredField`.
+
+```java,panics
+import java.lang.reflect.Field;
+
+class Main {
+    void main() throws NoSuchFieldException {
+        Class<Soup> soupClass = Soup.class;
+
+        Field hasVeggiesField = soupClass.getDeclaredField("hasVeggies");
+        System.out.println(hasVeggiesField);
+        
+        // Will fail. getField won't see hasVeggies
+        soupClass.getField("hasVeggies");
+    }
+}
+
+class Soup {
+    public String name;
+    boolean isChicken;
+    private boolean hasVeggies;
+}
+```
+

src/reflection/get_a_method.md

@@ -0,0 +1 @@
+# Get a Method

src/reflection/get_all_methods.md

@@ -0,0 +1 @@
+# Get all Methods

src/reflection/get_methods.md

@@ -0,0 +1 @@
+# Get Methods

src/reflection/invoke_a_method.md

@@ -0,0 +1 @@
+# Invoke a Method

src/reflection/read_from_a_field.md

@@ -0,0 +1,40 @@
+# Read from a Field
+
+Once you have a `Field` object you can use its `get` method to read the value of that field
+from an object. This will throw an `IllegalAccessException` if you try to read a field you
+are not allowed to.[^permission]
+
+```java
+import java.lang.reflect.Field;
+
+class Main {
+    void main() throws IllegalAccessException {
+        Class<Drink> drinkClass = Drink.class;
+
+        Field nameField;
+        try {
+            nameField = drinkClass.getField("name");
+        } catch (NoSuchFieldException e) {
+            throw new RuntimeException(e); // Should have this field
+        }
+
+        var soda = new Drink("Soda", true);
+        var water = new Drink("Water", false);
+
+        System.out.println(nameField.get(soda));
+        System.out.println(nameField.get(water));
+    }
+}
+
+class Drink {
+    public String name;
+    public boolean caffeinated;
+
+    Drink(String name, boolean caffeinated) {
+        this.name = name;
+        this.caffeinated = caffeinated;
+    }
+}
+```
+
+[^permission]: The rules for this go a bit beyond "you cannot read private fields."

src/reflection/write_to_a_field.md

@@ -0,0 +1,75 @@
+# Write to a Field
+
+Similarly, you can write to a field using the `.set` method on a `Field` object.
+This will also throw `IllegalAccessException` if its not something you are allowed to do.
+
+```java
+import java.lang.reflect.Field;
+
+class Main {
+    void main() throws IllegalAccessException {
+        Class<Drink> drinkClass = Drink.class;
+
+        Field caffeinatedField;
+        try {
+            caffeinatedField = drinkClass.getField("caffeinated");
+        } catch (NoSuchFieldException e) {
+            throw new RuntimeException(e);
+        }
+
+        var water = new Drink("Water", false);
+
+        // You can put drugs in anything you set your mind to, kids
+        caffeinatedField.set(water, true);
+
+        System.out.println(caffeinatedField.get(water));
+    }
+}
+
+class Drink {
+    public String name;
+    public boolean caffeinated;
+
+    Drink(String name, boolean caffeinated) {
+        this.name = name;
+        this.caffeinated = caffeinated;
+    }
+}
+```
+
+If you try to set a field to the wrong type of value - like setting a `boolean` field to have a `String` value -
+you will get an `IllegalArgumentException`. Unlike `NoSuchFieldException` and `IllegalAccessException` this is an
+unchecked exception, so you do not need to explicitly account for it.
+
+```java
+import java.lang.reflect.Field;
+
+class Main {
+    void main() throws IllegalAccessException {
+        Class<Drink> drinkClass = Drink.class;
+
+        Field caffeinatedField;
+        try {
+            caffeinatedField = drinkClass.getField("caffeinated");
+        } catch (NoSuchFieldException e) {
+            throw new RuntimeException(e);
+        }
+
+        var soda = new Drink("Soda", true);
+
+        caffeinatedField.set(soda, "yes, very much so");
+
+        System.out.println(caffeinatedField.get(soda));
+    }
+}
+
+class Drink {
+    public String name;
+    public boolean caffeinated;
+
+    Drink(String name, boolean caffeinated) {
+        this.name = name;
+        this.caffeinated = caffeinated;
+    }
+}
+```