Fixed codebox formatting of src/boxed_primitives

src/boxed_primitives/boolean.md

@@ -1,12 +1,12 @@
 # Boolean
 
-
 The type to use for a `boolean` that might be null is `Boolean`.
 
-```java
-~void main() {
-Boolean b = null;
-System.out.println(b);
-b = true;
-System.out.println(true);
-~}
+```java, no_run
+void main() {
+    Boolean b = null;
+    System.out.println(b);
+    b = true;
+    System.out.println(true);
+}
+```

src/boxed_primitives/boxing_conversion.md

@@ -4,14 +4,14 @@ If you try to assign to a boxed type like `Integer` from some
 code that gives you the unboxed version like `int`, then Java will
 automatically do that conversion.[^obvious]
 
-```java
-~void main() {
-int x = 5;
-Integer y = x;
+```java, no_run
+void main() {
+    int x = 5;
+    Integer y = x;
 
-System.out.println(x);
-System.out.println(y);
-~}
+    System.out.println(x);
+    System.out.println(y);
+}
 ```
 
 [^obvious]: This might feel obvious, but this is one of the few places in Java where the type of something "magically" changes. `int` and `Integer`, `char` and `Character`, etc. *are* different types.

src/boxed_primitives/character.md

@@ -2,10 +2,11 @@
 
 The type to use for a `char` that might be null is `Character`.
 
-```java
-~void main() {
-Character c = null;
-System.out.println(c);
-c = '%';
-System.out.println(c);
-~}
+```java, no_run
+void main() {
+    Character c = null;
+    System.out.println(c);
+    c = '%';
+    System.out.println(c);
+}
+```

src/boxed_primitives/double.md

@@ -2,10 +2,11 @@
 
 The type to use for a `double` that might be null is `Double`.
 
-```java
-~void main() {
-Double d = null;
-System.out.println(d);
-d = 3.14;
-System.out.println(d);
-~}
+```java, no_run
+void main() {
+    Double d = null;
+    System.out.println(d);
+    d = 3.14;
+    System.out.println(d);
+}
+```

src/boxed_primitives/integer.md

@@ -2,11 +2,11 @@
 
 The type to use for an `int` that might be null is `Integer`.
 
-```java
-~void main() {
-Integer i = null;
-System.out.println(i);
-i = 5;
-System.out.println(i);
+```java, no_run
+void main() {
+    Integer i = null;
+    System.out.println(i);
+    i = 5;
+    System.out.println(i);
 ~}
 ```

src/boxed_primitives/unboxing_conversion.md

@@ -5,36 +5,36 @@ the normal type is expected, it will be implicitly "unboxed."
 
 This means you can use `Integer`s directly in math expressions.
 
-```java
-~void main() {
-Integer x = 5;
-int y = 3;
-int z = x * y;
-
-System.out.println(z);
-~}
+```java, no_run
+void main() {
+    Integer x = 5;
+    int y = 3;
+    int z = x * y;
+
+    System.out.println(z);
+}
 ```
 
 As well as `Boolean`s in logical expressions.
 
-```java
-~void main() {
-Boolean hasHat = true;
-if (hasHat) {
-    System.out.println("You have a hat!");
+```java, no_run
+void main() {
+    Boolean hasHat = true;
+    if (hasHat) {
+        System.out.println("You have a hat!");
+    }
 }
-~}
 ```
 
 And so on for `Double`, `Character`, etc.
 
 But if you use one of these types like this and they happen to be `null` you will
 get a `NullPointerException`.
 
-```java,panics
-~void main() {
-Integer x = null;
-// Bool
-int y = x;
-~}
+```java, panics
+void main() {
+    Integer x = null;
+    // Bool
+    int y = x;
+}
 ```