Documentation updated

Author: AtomicScience

doc/About JavOC/Serialization/Constant Pool.md

@@ -1,6 +1,6 @@
 # Constant pool entries serialization
 
-## Structrue of serialized entry
+## Structure of serialized entry
 For debug purposes, it is very convenient to have a way to represent a constant pool entry in a *human-readable form*.
 
 However, since most of entries contain links to other entries, that link to other constants as well... It becomes tricker to handle and represent.

doc/Class Loading and structure/Class File Format.md

@@ -44,7 +44,7 @@ Each `.class` value starts with special 'magic value' - a sequence of 4 bytes, t
 
 ### Minor and major versions
 <img align="right" src="../Diagrams/Class%20Loading%20and%20structure/Versions.png" alt="drawing" width="200"/>
-Each class was compiled to be used with a specific version of Java. It was quite complex back in old versions of Java, but today everything is pretty straightforward - JVM can run classes of its version and classes with *older* versions. In other words, JVMs are **backwards compatible**
+Each class was compiled to be used with a specific version of Java. It was quite complex back in old versions of Java, but today everything is pretty straightforward - JVM can run classes of its version and classes with <em>older</em> versions. In other words, JVMs are <b>backwards compatible</b>
 
 To store version of the Java that compiled the file, Major and Minor fields exist
 

doc/Class Loading and structure/Java class file structure by example.md

@@ -1,5 +1,5 @@
 # Java class file structure by example
-As you already know from "Class File Format" document, Java classes have a relatively complex structure. And the best way to study it - compile something and see these beatiful files in the wild!
+As you already know from [Class File Format](Class%20File%20Format.md) document, Java classes have a relatively complex structure. And the best way to study it - compile something and see these beatiful files in the wild!
 
 For such a purpose, you can use `javac` and `javad` command line tools - official compiler and disassembler, that are included into every Java Development Kit.
 
@@ -11,21 +11,21 @@ For the beginning, let's compile a simple class.
 
 Something like **this**:
 ```java
-class Main {}
+class SimplestClass {}
 ```
 <details>
   <summary>Disassembler output</summary>
 
 
-	Classfile /tmp/1059625032030680147/classes/Main.class
+	Classfile /tmp/1059625032030680147/classes/SimplestClass.class
 		Last modified Aug 7, 2020; size 237 bytes
 	  	SHA-256 checksum <>
-		Compiled from "Main.java"
-	class Main
+		Compiled from "SimplestClass.java"
+	class SimplestClass
 		minor version: 0
 		major version: 58
 		flags: (0x0020) ACC_SUPER
-		this_class: #7                          // Main
+		this_class: #7                          // SimplestClass
 		super_class: #2                         // java/lang/Object
 		interfaces: 0, fields: 0, methods: 1, attributes: 1
 
@@ -36,38 +36,81 @@ class Main {}
 	   #4 = Utf8               java/lang/Object
 	   #5 = Utf8               <init>
 	   #6 = Utf8               ()V
-	   #7 = Class              #8             // Main
-	   #8 = Utf8               Main
+	   #7 = Class              #8             // SimplestClass
+	   #8 = Utf8               SimplestClass
 	   #9 = Utf8               Code
 	  #10 = Utf8               LineNumberTable
 	  #11 = Utf8               LocalVariableTable
 	  #12 = Utf8               this
-	  #13 = Utf8               LMain;
+	  #13 = Utf8               LSimplestClass;
 	  #14 = Utf8               SourceFile
-	  #15 = Utf8               Main.java
+	  #15 = Utf8               SimplestClass.java
 
 	{
-	  Main();
+	  SimplestClass();
 	    descriptor: ()V
 	    flags: (0x0000)
 
 	    Code:
 
 	      stack=1, locals=1, args_size=1
-	        start local 0           s// Main this
+	        start local 0           s// SimplestClass this
 	         0: aload_0
 	         1: invokespecial #1    // Method java/lang/Object."<init>":()V
 	         4: return
-	        end local 0 // Main this
+	        end local 0 // SimplestClass this
 
 	      LineNumberTable:
 
 	      LocalVariableTable:
 
 	        Start  Length  Slot  Name   Signature
-	            0       5     0  this   LMain;
+	            0       5     0  this   LSimplestClass;
 
 	}
-	SourceFile: "Main.java"
+	SourceFile: "SimplestClass.java"
+</details>
 
-</details>
+Okay, hold on. We have compiled the simplest class we could have, right? Where all of this code came from?
+
+Well, if you are familiar with Java, you surely know, that Java compilers actually add something to your code. Things like default constructor, implicit inheritance from `java.lang.Object`...
+
+Long story short, that's how our class *actually* looks after compilation:
+
+```java
+class SimplestClass extends java.lang.Object {
+    public void <init> { // That's our default constructor
+        java.lang.Object.<init>(); // Calling a constructor from Object
+        return;
+    }
+}
+```
+
+Obviously, this code won't compile! But that's how our class really looks under the hood.
+
+That explains everything. But let's dive into each line of decomiler's output and see what it really does!
+## `javap` output teardown
+
+`javap` output starts with some information about class file - creation date, size, etc. :
+```java
+Classfile /tmp/1059625032030680147/classes/SimplestClass.class
+	Last modified Aug 7, 2020; size 237 bytes
+  	SHA-256 checksum <>
+	Compiled from "SimplestClass.java"
+```
+
+After that, the class file name goes:
+```java
+class SimplestClass
+```
+
+And the major and minor versions of the JDK that compiled the file. Looking up the version of the Java in the special [table](/doc/Reference/Java%20major%20versions.md), we gain a resulting version of Java - **15**!
+```java
+minor version: 0
+major version: 59
+```
+
+Class flags:
+```java
+flags: (0x0020) ACC_SUPER
+```

doc/Reference/Java major versions.md

@@ -0,0 +1,20 @@
+# Java major versions
+| Version       | Decimal | Hex      |
+| :------------ | :------ | :------- |
+| JDK 1.1       | 45      | 0x2D     |
+| JDK 1.2       | 46      | 0x2E     |
+| JDK 1.3       | 47      | 0x2F     |
+| JDK 1.4       | 48      | 0x30     |
+| Java SE 5     | 49      | 0x31     |
+| **Java SE 6** | **50**  | **0x32** |
+| Java SE 7     | 51      | 0x33     |
+| Java SE 8     | 52      | 0x34     |
+| Java SE 9     | 53      | 0x35     |
+| Java SE 10    | 54      | 0x36     |
+| Java SE 11    | 55      | 0x37     |
+| Java SE 12    | 56      | 0x38     |
+| Java SE 13    | 57      | 0x39     |
+| Java SE 14    | 58      | 0x3A     |
+| Java SE 15    | 59      | 0x3B     |
+| Java SE 16    | 60      | 0x3C     |
+| Java SE 17    | 61      | 0x3D     |