Merge pull request #1111 from drguildo/master

A bunch of small changes to aid clarity, brevity and/or consistency, …

1 files changed, 93 insertions, 104 deletions

diff --git a/java.html.markdown b/java.html.markdown
index 10dd498c..f6bc82c6 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -1,16 +1,16 @@
 ---
-
 language: java
 contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
-    - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
 filename: LearnJava.java
-
 ---
 
-Java is a general-purpose, concurrent, class-based, object-oriented computer programming language.
-[Read more here.](http://docs.oracle.com/javase/tutorial/java/index.html)
+Java is a general-purpose, concurrent, class-based, object-oriented computer
+programming language.
+[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
 
 ```java
 // Single-line comments start with //
@@ -31,17 +31,17 @@ import java.security.*;
 // the file.
 public class LearnJava {
 
-    // A program must have a main method as an entry point
+    // A program must have a main method as an entry point.
     public static void main (String[] args) {
 
-        // Use System.out.println to print lines
+        // Use System.out.println() to print lines.
         System.out.println("Hello World!");
         System.out.println(
             "Integer: " + 10 +
             " Double: " + 3.14 +
             " Boolean: " + true);
 
-        // To print without a newline, use System.out.print
+        // To print without a newline, use System.out.print().
         System.out.print("Hello ");
         System.out.print("World");
 
@@ -69,7 +69,7 @@ public class LearnJava {
         // L is used to denote that this variable value is of type Long;
         // anything without is treated as integer by default.
 
-        // Note: Java has no unsigned types
+        // Note: Java has no unsigned types.
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
         float fooFloat = 234.5f;
@@ -86,7 +86,7 @@ public class LearnJava {
         // Char - A single 16-bit Unicode character
         char fooChar = 'A';
 
-        // final variables can't be reassigned to another object
+        // final variables can't be reassigned to another object.
         final int HOURS_I_WORK_PER_WEEK = 9001;
 
         // Strings
@@ -101,10 +101,10 @@ public class LearnJava {
         System.out.println(bazString);
 
         // Arrays
-        //The array size must be decided upon instantiation
-        //The following formats work for declaring an array
-        //<datatype>[] <var name> = new <datatype>[<array size>];
-        //<datatype> <var name>[] = new <datatype>[<array size>];
+        // The array size must be decided upon instantiation
+        // The following formats work for declaring an array
+        // <datatype>[] <var name> = new <datatype>[<array size>];
+        // <datatype> <var name>[] = new <datatype>[<array size>];
         int[] intArray = new int[10];
         String[] stringArray = new String[1];
         boolean boolArray[] = new boolean[100];
@@ -122,17 +122,17 @@ public class LearnJava {
         System.out.println("intArray @ 1: " + intArray[1]); // => 1
 
         // Others to check out
-        // ArrayLists - Like arrays except more functionality is offered,
-        //             and the size is mutable
+        // ArrayLists - Like arrays except more functionality is offered, and
+        //              the size is mutable.
         // LinkedLists - Implementation of doubly-linked list. All of the
-        //             operations perform as could be expected for
-        //             a doubly-linked list.
-        // Maps - A set of objects that maps keys to values. A map cannot contain
-        //             duplicate keys; each key can map to at most one value.
-        // HashMaps - This class uses a hashtable to implement the Map interface.
-        //             This allows the execution time of basic operations,
-        //             such as get and insert element, to remain constant even
-        //             for large sets. 
+        //               operations perform as could be expected for a
+        //               doubly-linked list.
+        // Maps - A set of objects that maps keys to values. A map cannot
+        //        contain duplicate keys; each key can map to at most one value.
+        // HashMaps - This class uses a hashtable to implement the Map
+        //            interface. This allows the execution time of basic
+        //            operations, such as get and insert element, to remain
+        //            constant even for large sets.
 
         ///////////////////////////////////////
         // Operators
@@ -160,13 +160,13 @@ public class LearnJava {
 
         // Bitwise operators!
         /*
-        ~       Unary bitwise complement
-        <<      Signed left shift
-        >>      Signed right shift
-        >>>     Unsigned right shift
-        &       Bitwise AND
-        ^       Bitwise exclusive OR
-        |       Bitwise inclusive OR
+        ~      Unary bitwise complement
+        <<     Signed left shift
+        >>     Signed right shift
+        >>>    Unsigned right shift
+        &      Bitwise AND
+        ^      Bitwise exclusive OR
+        |      Bitwise inclusive OR
         */
 
         // Incrementations
@@ -175,10 +175,10 @@ public class LearnJava {
         // The ++ and -- operators increment and decrement by 1 respectively.
         // If they are placed before the variable, they increment then return;
         // after the variable they return then increment.
-        System.out.println(i++); //i = 1, prints 0 (post-increment)
-        System.out.println(++i); //i = 2, prints 2 (pre-increment)
-        System.out.println(i--); //i = 1, prints 2 (post-decrement)
-        System.out.println(--i); //i = 0, prints 0 (pre-decrement)
+        System.out.println(i++); // i = 1, prints 0 (post-increment)
+        System.out.println(++i); // i = 2, prints 2 (pre-increment)
+        System.out.println(i--); // i = 1, prints 2 (post-decrement)
+        System.out.println(--i); // i = 0, prints 0 (pre-decrement)
 
         ///////////////////////////////////////
         // Control Structures
@@ -197,73 +197,68 @@ public class LearnJava {
 
         // While loop
         int fooWhile = 0;
-        while(fooWhile < 100)
-        {
-            //System.out.println(fooWhile);
-            //Increment the counter
-            //Iterated 100 times, fooWhile 0,1,2...99
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Increment the counter
+            // Iterated 100 times, fooWhile 0,1,2...99
             fooWhile++;
         }
         System.out.println("fooWhile Value: " + fooWhile);
 
         // Do While Loop
         int fooDoWhile = 0;
-        do
-        {
-            //System.out.println(fooDoWhile);
-            //Increment the counter
-            //Iterated 99 times, fooDoWhile 0->99
+        do {
+            System.out.println(fooDoWhile);
+            // Increment the counter
+            // Iterated 99 times, fooDoWhile 0->99
             fooDoWhile++;
-        }while(fooDoWhile < 100);
+        } while(fooDoWhile < 100);
         System.out.println("fooDoWhile Value: " + fooDoWhile);
 
         // For Loop
         int fooFor;
-        //for loop structure => for(<start_statement>; <conditional>; <step>)
-        for(fooFor=0; fooFor<10; fooFor++){
-            //System.out.println(fooFor);
-            //Iterated 10 times, fooFor 0->9
+        // for loop structure => for(<start_statement>; <conditional>; <step>)
+        for (fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iterated 10 times, fooFor 0->9
         }
         System.out.println("fooFor Value: " + fooFor);
 
         // For Each Loop
         // An automatic iteration through an array or list of objects.
-        int[] fooList = {1,2,3,4,5,6,7,8,9};
-        //for each loop structure => for(<object> : <array_object>)
-        //reads as: for each object in the array
-        //note: the object type must match the array.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // for each loop structure => for (<object> : <array_object>)
+        // reads as: for each object in the array
+        // note: the object type must match the array.
 
-        for( int bar : fooList ){
-            //System.out.println(bar);
+        for (int bar : fooList) {
+            System.out.println(bar);
             //Iterates 9 times and prints 1-9 on new lines
         }
 
         // Switch Case
         // A switch works with the byte, short, char, and int data types.
-        // It also works with enumerated types (discussed in Enum Types),
-        // the String class, and a few special classes that wrap
-        // primitive types: Character, Byte, Short, and Integer.
+        // It also works with enumerated types (discussed in Enum Types), the
+        // String class, and a few special classes that wrap primitive types:
+        // Character, Byte, Short, and Integer.
         int month = 3;
         String monthString;
-        switch (month){
-            case 1:
-                    monthString = "January";
-                    break;
-            case 2:
-                    monthString = "February";
+        switch (month) {
+            case 1: monthString = "January";
                     break;
-            case 3:
-                    monthString = "March";
+            case 2: monthString = "February";
                     break;
-            default:
-                    monthString = "Some other month";
+            case 3: monthString = "March";
                     break;
+            default: monthString = "Some other month";
+                     break;
         }
         System.out.println("Switch Case Result: " + monthString);
 
         // Conditional Shorthand
         // You can use the '?' operator for quick assignments or logic forks.
-        // Reads as "If (statement) is true, use <first value>, otherwise, use <second value>"
+        // Reads as "If (statement) is true, use <first value>, otherwise, use
+        // <second value>"
         int foo = 5;
         String bar = (foo < 10) ? "A" : "B";
         System.out.println(bar); // Prints A, because the statement is true
@@ -287,9 +282,8 @@ public class LearnJava {
         // String
 
         // Typecasting
-        // You can also cast java objects, there's a lot of details and
-        // deals with some more intermediate concepts.
-        // Feel free to check it out here:
+        // You can also cast Java objects, there's a lot of details and deals
+        // with some more intermediate concepts. Feel free to check it out here:
         // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
 
 
@@ -319,9 +313,9 @@ public class LearnJava {
 
 
 // Class Declaration Syntax:
-// <public/private/protected> class <class name>{
-//    //data fields, constructors, functions all inside.
-//    //functions are called as methods in Java.
+// <public/private/protected> class <class name> {
+//    // data fields, constructors, functions all inside.
+//    // functions are called as methods in Java.
 // }
 
 class Bicycle {
@@ -342,7 +336,8 @@ class Bicycle {
     }
 
     // This is a constructor that takes arguments
-    public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
+    public Bicycle(int startCadence, int startSpeed, int startGear,
+        String name) {
         this.gear = startGear;
         this.cadence = startCadence;
         this.speed = startSpeed;
@@ -388,10 +383,8 @@ class Bicycle {
     //Method to display the attribute values of this Object.
     @Override
     public String toString() {
-        return "gear: " + gear +
-                " cadence: " + cadence +
-                " speed: " + speed +
-                " name: " + name;
+        return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+            " name: " + name;
     }
 } // end class Bicycle
 
@@ -405,26 +398,26 @@ class PennyFarthing extends Bicycle {
         super(startCadence, startSpeed, 0, "PennyFarthing");
     }
 
-    // You should mark a method you're overriding with an @annotation
-    // To learn more about what annotations are and their purpose
-    // check this out: http://docs.oracle.com/javase/tutorial/java/annotations/
+    // You should mark a method you're overriding with an @annotation.
+    // To learn more about what annotations are and their purpose check this
+    // out: http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
     public void setGear(int gear) {
         gear = 0;
     }
-
 }
 
-//Interfaces
-//Interface declaration syntax
-//<access-level> interface <interface-name> extends <super-interfaces> {
-//		//Constants
-//		//Method declarations
-//}
+// Interfaces
+// Interface declaration syntax
+// <access-level> interface <interface-name> extends <super-interfaces> {
+//     // Constants
+//     // Method declarations
+// }
 
-//Example - Food:
+// Example - Food:
 public interface Edible {
-	public void eat(); //Any class that implements this interface, must implement this method
+	public void eat(); // Any class that implements this interface, must
+                       // implement this method.
 }
 
 public interface Digestible {
@@ -432,33 +425,31 @@ public interface Digestible {
 }
 
 
-//We can now create a class that implements both of these interfaces
+// We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
     @Override
 	public void eat() {
-		//...
+		// ...
 	}
 
     @Override
 	public void digest() {
-		//... 
+		// ...
 	}
 }
 
-//In java, you can extend only one class, but you can implement many interfaces.
-//For example:
-public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
+// In Java, you can extend only one class, but you can implement many
+// interfaces. For example:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+    InterfaceTwo {
     @Override
 	public void InterfaceOneMethod() {
-
 	}
 
     @Override
 	public void InterfaceTwoMethod() {
-
 	}
 }
-
 ```
 
 ## Further Reading
@@ -500,5 +491,3 @@ The links provided here below are just to get an understanding of the topic, fee
 * [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
 
 * [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
-
-