Numerics

Author: bowbahdoe

src/SUMMARY.md

@@ -532,6 +532,7 @@ Make them do one. -->
   - [ZonedDateTime](./time/zoned_date_time.md)
   - [OffsetDateTime](./time/offset_date_time.md)
   - [Date](./time/date.md)
+  - [Challenges](./time/challenges.md)
 - [ArrayList](./array_list.md)
   - [Ubiquity](./array_list/ubiquity.md)
   - [Add an item](./array_list/add_an_item.md)
@@ -593,7 +594,7 @@ Make them do one. -->
 - [Encapsulation](./encapsulation.md)
   - [Implementation Details](./encapsulation/implementation_details.md)
   - [Methods](./encapsulation/methods.md)
-  - [Classes]()(./encapsulation/classes.md)
+  - [Classes](./encapsulation/classes.md)
   - [Implicit Interfaces](./encapsulation/implicit_interfaces.md)
   - [Abstractions](./encapsulation/abstractions.md)
   - [Leaky Abstractions](./encapsulation/leaky_abstractions.md)
@@ -663,15 +664,24 @@ Make them do one. -->
   - [Static Methods]()
   - [Private Static Methods]()
 - [Class Extension](./class_extension.md)
+  - [Extend a Class]()
+  - [Protected Fields]()
+  - [Protected Methods]()
+  - [Relation to Interfaces]()
+  - [Relation to Encapsulation]()
+  - [Final Classes](./class_extension/final_classes.md)
 - [Abstract Classes](./abstract_classes.md)
+  - [Relation to Interfaces]()
+
 
 # Data Types IV
 
-- [Niche Numerics]()
-  - [byte]()
-  - [short]()
-  - [long]()
-  - [Unsigned Operations]()
+- [Niche Numerics](./niche_numerics.md)
+  - [byte](./niche_numerics/byte.md)
+  - [short](./niche_numerics/short.md)
+  - [long](./niche_numerics/long.md)
+  - [Unsigned Operations](./niche_numerics/unsigned_operations.md)
+  - [float](./niche_numerics/float.md)
 
 # Code Structure VIII
 

src/class_extension.md

@@ -1 +1,2 @@
 # Class Extension
+

src/class_extension/final_classes

@@ -0,0 +1 @@
+# Final Classes

src/class_extension/final_classes.md

@@ -0,0 +1 @@
+# Final Classes

src/niche_numerics.md

@@ -0,0 +1,19 @@
+# Niche Numerics
+
+For a surprisingly wide range of programs `int` and `double`
+(along with their boxed counterparts `Integer` and `Double`)
+are the only numeric types you will need.
+
+Every now and then, however, you will want something more exotic[^wording].
+
+```java
+~void main() {
+byte b = 123;
+
+System.out.println(b);
+~}
+```
+
+[^wording]: The reason I am calling these "exotic" and "niche" has nothing to do with how
+useful they are. If you want a `byte` then a `byte` is what you want. Its just that most
+of the time (in my experience) you can get by with a little help from your `int`s.

src/niche_numerics/byte.md

@@ -0,0 +1,64 @@
+# byte
+
+A `byte` represents a signed value between `-128`
+and `127`.
+
+```java
+~void main() {
+byte a = 127;
+System.out.println(a);
+byte b = -128;
+System.out.println(b);
+~}
+```
+
+Operations like `+` and `*` on a `byte` will "promote" the result an `int`
+and you will need to cast the result. Going from an `int` to a `byte`
+is a narrowing conversion.
+
+```java
+~void main() {
+byte a = 5;
+byte b = 6;
+// Need to cast the result to a (byte) again
+byte c = (byte) (a * b);
+System.out.println(c);
+~}
+```
+
+Conversely, going from a `byte` to an `int` is a widening conversion and you won't
+need a cast.
+
+```java
+~void main() {
+byte a = 5;
+int a2 = a; // Widening conversion
+System.out.println(a2);
+~}
+```
+
+
+And if you have need of a potentially nullable `byte`, `Byte` with a capital `B` is the boxed version.
+
+```java
+~void main() {
+// Can't have a null "byte"
+// byte b = null; 
+
+// But you can have a null "Byte"
+Byte b = null;
+System.out.println(b);
+~}
+```
+
+You will most often want a `byte` when you are trying to save space in memory.
+
+```java,no_run
+// This array of 4 bytes
+byte[] bytes = { 1, 2, 3, 4 };
+// Will take up as much space as this
+// array with 1 int
+int[] oneInt = { 1 };
+```
+
+

src/niche_numerics/float.md

@@ -0,0 +1,63 @@
+# float
+
+What `int` is to `long`, `float` is to `double`. Even the type name `double` implicitly means "double the size of a float." So if you want something half the size of a `double` you can use a `float`. 
+
+To write a float in a program you need to write `f` at the end of the floating
+point literal.
+
+```java
+~void main() {
+float f = 3.5f;
+System.out.println(f);
+~}
+```
+
+This is because Java sees floating point literals without a trailing `f` as representing a `double`.
+
+```java,does_not_compile
+~void main() {
+float f = 3.5;
+System.out.println(f);
+~}
+```
+
+Conversions from a `double` to a `float` are narrowing and require an explicit cast.
+Conversions from a `float` to a `double` are widening and do not require a cast.
+
+```java
+~void main() {
+double a = 6.5;
+// Need a cast
+float b = (float) a;
+System.out.println(b);
+
+float c = 9.5f;
+// Do not need a cast
+double d = c;
+System.out.println(d);
+~}
+```
+
+And if you have need of a potentially nullable `float`, `Float` with a capital `F` is the boxed version.
+
+```java
+~void main() {
+// Can't have a null "float"
+// float f = null; 
+
+// But you can have a null "Float"
+Float f = null;
+System.out.println(f);
+~}
+```
+
+You will really only want a `float` when you are trying to save space in memory.
+Otherwise its best to just use a `double`.
+
+```java,no_run
+// This array of 2 floats
+float[] floats = { 1.0f, 2.0f };
+// Will take up as much space as this
+// array with 1 double
+double[] oneDouble = { 1.0 };
+```

src/niche_numerics/long.md

@@ -0,0 +1,74 @@
+# long
+
+If an `int` is not big enough for your needs, a `long` is twice as big as an `int`
+and can represent numbers from `-2^63` to `2^63 - 1`.
+
+You can make a `long` from an integer literal, but integer literals do not
+normally allow for numbers that an `int` cannot store. 
+
+```java,does_not_compile
+~void main() {
+// Smaller numbers work without issue
+long smallNumber = 5;
+System.out.println(smallNumber);
+// This is too big for an int
+long bigNumber = 55555555555;
+System.out.println(bigNumber);
+~}
+```
+
+For those cases you need to add an `L` to the end of the literal.[^lforlong]
+
+```java
+~void main() {
+long smallNumber = 5;
+System.out.println(smallNumber);
+// But with an L at the end, its not too big for a long
+long bigNumber = 55555555555L;
+System.out.println(bigNumber);
+~}
+```
+
+All operations with a `long` will result in a `long`. Conversions to `int` and
+other "smaller" integer types will be narrowing and require a cast.
+
+```java
+~void main() {
+long a = 5;
+int b = 3;
+// a long times an int will result in a long
+long c = a * b;
+System.out.println(c);
+~}
+```
+
+And if you have need of a potentially nullable `long`, `Long` with a capital `L` is the boxed version.
+
+```java
+~void main() {
+// Can't have a null "long"
+// long l = null; 
+
+// But you can have a null "Long"
+Long l = null;
+System.out.println(l);
+~}
+```
+
+The reason you will likely end up using `int` more than `long` is that `int`
+works more with other parts of Java. Like array indexing - you can't
+get an item in an array with a `long`, you need an `int` for that.
+
+```java,does_not_compile
+~void main() {
+String[] sadRobots = { "2B", "9S", "A2" };
+long index = 2;
+// Longs can't be used as indexes
+String sadRobot = sadRobots[index];
+~}
+```
+
+But there is nothing wrong with a `long`. If you need to represent a number that is potentially bigger than an `int` then it is useful.
+
+
+[^lforlong]: "L is for long" would be a total cop-out in a children's picture book.

src/niche_numerics/short.md

@@ -0,0 +1,87 @@
+# short
+
+A `short` represents a signed value between `-32768`
+and `32767`. Representing a `short` takes twice as much memory as representing
+a `byte` and half as much memory as representing an `int`.
+
+```java
+~void main() {
+short a = 32767;
+System.out.println(a);
+byte b = -32768;
+System.out.println(b);
+~}
+```
+
+Operations like `+` and `*` on a `short` will "promote" the result an `int`
+and you will need to cast the result. Going from an `int` to a `short`
+is a narrowing conversion.
+
+```java
+~void main() {
+short a = 5;
+short b = 6;
+// Need to cast the result to a (byte) again
+short c = (short) (a * b);
+System.out.println(c);
+~}
+```
+
+Conversely, going from a `short` to an `int` is a widening conversion and you won't
+need a cast.
+
+```java
+~void main() {
+short a = 5;
+int a2 = a; // Widening conversion
+System.out.println(a2);
+~}
+```
+
+
+And if you have need of a potentially nullable `short`, `Short` with a capital `S` is the boxed version.
+
+```java
+~void main() {
+// Can't have a null "short"
+// short b = null; 
+
+// But you can have a null "Short"
+Short b = null;
+System.out.println(b);
+~}
+```
+
+
+A `short` also takes up exactly as much space as a `char` and converting between the two
+is allowed, but will still require an explicit cast in both directions.[^neither]
+
+```java
+~void main() {
+short s = 50;
+char c = (char) s;
+s = (short) c;
+System.out.println(c);
+~}
+```
+
+You will most often want a `short` when you are trying to save space in memory but
+need to represent numbers beyond what a `byte` can represent.[^rare]
+
+```java,no_run
+// This array of 2 shorts
+short[] shorts = { 1, 2 };
+
+// Will take up as much space as this
+// array with 1 int
+int[] oneInt = { 1 };
+
+// And as much space as this array with 4 bytes
+byte[] bytes = { 1, 2, 3, 4 };
+```
+
+
+[^neither]: These are neither narrowing or widening conversions. Java just makes you put
+the cast. One way to view this is that when you go from a `short` to a `char` you've transformed a "number" into a "character." So while no information is lost, what the information "represents" has changed.
+
+[^rare]: As you might suspect, this is more rare than the situations where you would want a `byte`.