From 29cbff176857653422555650c983afef4a28ae1f Mon Sep 17 00:00:00 2001
From: Zachary Ferguson <zfergus2@users.noreply.github.com>
Date: Tue, 6 Oct 2015 18:16:33 -0400
Subject: [java/en] Edits and additions

Included an example of printf
Discussed final variable
initialization
Gave a floating point division example
Discussed boolean
operators
Defined the abstract and final class and compared them.
Added
some clarifying remarks to comments.
---
 java.html.markdown | 90 ++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 71 insertions(+), 19 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 928eb39f..5e580f33 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Jakukyo Friel", "http://weakish.github.io"]
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
 filename: LearnJava.java
 ---
 
@@ -31,7 +32,7 @@ import java.security.*;
 // the file.
 public class LearnJava {
 
-    // A program must have a main method as an entry point.
+    // In order to run a java program, it must have a main method as an entry point.
     public static void main (String[] args) {
 
         // Use System.out.println() to print lines.
@@ -45,6 +46,8 @@ public class LearnJava {
         System.out.print("Hello ");
         System.out.print("World");
 
+        // Use System.out.printf() for easy formatted printing.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
 
         ///////////////////////////////////////
         // Types & Variables
@@ -73,7 +76,7 @@ public class LearnJava {
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
         float fooFloat = 234.5f;
-        // f is used to denote that this variable value is of type float;
+        // f or F is used to denote that this variable value is of type float;
         // otherwise it is treated as double.
 
         // Double - Double-precision 64-bit IEEE 754 Floating Point
@@ -86,9 +89,12 @@ 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;
-
+        // but they can be initialized later.
+        final double E;
+        E = 2.71828;
+        
         // Strings
         String fooString = "My String Is Here!";
 
@@ -146,6 +152,7 @@ public class LearnJava {
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
         System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
+        System.out.println("1/2 = " + (i1 / (i2*1.0))); // => 0.5
 
         // Modulo
         System.out.println("11%3 = "+(11 % 3)); // => 2
@@ -158,12 +165,17 @@ public class LearnJava {
         System.out.println("2 <= 2? " + (2 <= 2)); // => true
         System.out.println("2 >= 2? " + (2 >= 2)); // => true
 
+        // Boolean operators
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
         // Bitwise operators!
         /*
         ~      Unary bitwise complement
         <<     Signed left shift
-        >>     Signed right shift
-        >>>    Unsigned right shift
+        >>     Signed/Arithmetic right shift
+        >>>    Unsigned/Logical right shift
         &      Bitwise AND
         ^      Bitwise exclusive OR
         |      Bitwise inclusive OR
@@ -216,9 +228,8 @@ public class LearnJava {
         System.out.println("fooDoWhile Value: " + fooDoWhile);
 
         // For Loop
-        int fooFor;
         // for loop structure => for(<start_statement>; <conditional>; <step>)
-        for (fooFor = 0; fooFor < 10; fooFor++) {
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
             System.out.println(fooFor);
             // Iterated 10 times, fooFor 0->9
         }
@@ -310,7 +321,8 @@ public class LearnJava {
 } // End LearnJava class
 
 
-// You can include other, non-public outer-level classes in a .java file
+// You can include other, non-public outer-level classes in a .java file, 
+// but it is good practice. Instead split classes into separate files.
 
 
 // Class Declaration Syntax:
@@ -330,6 +342,8 @@ class Bicycle {
     // Constructors are a way of creating classes
     // This is a constructor
     public Bicycle() {
+        // You can also call another constructor: 
+        // this(1, 50, 5, "Bontrager");
         gear = 1;
         cadence = 50;
         speed = 5;
@@ -351,7 +365,7 @@ class Bicycle {
     // Java classes often implement getters and setters for their fields
 
     // Method declaration syntax:
-    // <scope> <return type> <method name>(<args>)
+    // <access modifier> <return type> <method name>(<args>)
     public int getCadence() {
         return cadence;
     }
@@ -382,7 +396,7 @@ class Bicycle {
     }
 
     //Method to display the attribute values of this Object.
-    @Override
+    @Override // Inherited from the Object class.
     public String toString() {
         return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
             " name: " + name;
@@ -417,26 +431,26 @@ class PennyFarthing extends Bicycle {
 
 // Example - Food:
 public interface Edible {
-	public void eat(); // Any class that implements this interface, must
+    public void eat(); // Any class that implements this interface, must
                        // implement this method.
 }
 
 public interface Digestible {
-	public void digest();
+    public void digest();
 }
 
 
 // We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
     @Override
-	public void eat() {
-		// ...
-	}
+    public void eat() {
+        // ...
+    }
 
     @Override
-	public void digest() {
-		// ...
-	}
+    public void digest() {
+        // ...
+    }
 }
 
 // In Java, you can extend only one class, but you can implement many
@@ -451,6 +465,44 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 	public void InterfaceTwoMethod() {
 	}
 }
+
+// There are also two special types of classes, abstract and final.
+
+// Marking a class as abstract means that it contains abstract methods that must
+// be defined in a child class. Similar to interfaces, abstract classes cannot 
+// be instantiated, but instead must be extended and the abstract methods 
+// defined. Different from interfaces, abstract classes can contain a mixture of
+// concrete and abstract methods.
+public abstract class Mammal()
+{
+    // Abstract classes can contain concrete methods.
+    public boolean hasHair()
+    {
+        return true;
+    }
+    
+    // Final methods, like, final classes cannot be overridden by a child class.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+
+    // Abstract methods are methods required to be overridden in a child class.
+    public abstract String getBinomialNomenclature();
+}
+
+// Final classes are classes that cannot be inherited from and are therefore a
+// final child. In a way, final classes are the opposite of abstract classes 
+// because abstract classes must be extended, but final classes cannot be 
+// extended.
+public final class SaberToothedCat extends Mammal
+{
+    public String getBinomialNomenclature()
+    {
+        return "Smilodon fatalis";
+    }
+}
+
 ```
 
 ## Further Reading
-- 
cgit v1.2.3


From 93d7d801d8cd40417d88e67a248dd232d75cdd34 Mon Sep 17 00:00:00 2001
From: Zachary Ferguson <zfergus2@users.noreply.github.com>
Date: Tue, 6 Oct 2015 18:28:57 -0400
Subject: [java/en] Merged definitions of abstract and added final

Merged definitions of abstract and added a definition of final classes.
---
 java.html.markdown | 54 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 23 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 34da903a..39878c8f 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -513,14 +513,9 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 	}
 }
 
-<<<<<<< HEAD
 // There are also two special types of classes, abstract and final.
 
-// Marking a class as abstract means that it contains abstract methods that must
-// be defined in a child class. Similar to interfaces, abstract classes cannot 
-// be instantiated, but instead must be extended and the abstract methods 
-// defined. Different from interfaces, abstract classes can contain a mixture of
-// concrete and abstract methods.
+
 public abstract class Mammal()
 {
     // Abstract classes can contain concrete methods.
@@ -539,17 +534,6 @@ public abstract class Mammal()
     public abstract String getBinomialNomenclature();
 }
 
-// Final classes are classes that cannot be inherited from and are therefore a
-// final child. In a way, final classes are the opposite of abstract classes 
-// because abstract classes must be extended, but final classes cannot be 
-// extended.
-public final class SaberToothedCat extends Mammal
-{
-    public String getBinomialNomenclature()
-    {
-        return "Smilodon fatalis";
-    }
-=======
 
 // Abstract Classes 
 // Abstract Class declaration syntax
@@ -558,10 +542,13 @@ public final class SaberToothedCat extends Mammal
 //     // Method declarations
 // }
 
-// Methods can't have bodies in an interface, unless the method is
-// static. Also variables are NOT final by default, unlike an interface.
-// Also abstract classes CAN have the "main" method.
-// Abstract classes solve these problems.
+// Marking a class as abstract means that it contains abstract methods that must
+// be defined in a child class. Similar to interfaces, abstract classes cannot 
+// be instantiated, but instead must be extended and the abstract methods 
+// defined. Different from interfaces, abstract classes can contain a mixture of
+// concrete and abstract methods. Methods in an interface cannot have a body, 
+// unless the method is static, and variables are final by default, unlike an
+// abstract class. Also abstract classes CAN have the "main" method.
 
 public abstract class Animal 
 {
@@ -578,7 +565,7 @@ public abstract class Animal
 	// No need to initialize, however in an interface 
 	// a variable is implicitly final and hence has
 	// to be initialized.
-	private int age;
+	protected int age;
 
 	public void printAge()
 	{
@@ -615,7 +602,28 @@ class Dog extends Animal
 		pluto.eat();
 		pluto.printAge();
 	}
->>>>>>> adambard/master
+}
+
+// Final Classes 
+// Final Class declaration syntax
+// <access-level> final <final-class-name> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Final classes are classes that cannot be inherited from and are therefore a
+// final child. In a way, final classes are the opposite of abstract classes 
+// because abstract classes must be extended, but final classes cannot be 
+// extended.
+public final class SaberToothedCat extends Animal
+{
+	// Note still have to override the abstract methods in the
+	// abstract class.
+	@Override
+	public void makeSound()
+	{
+		System.out.println("Roar");
+	}
 }
 
 ```
-- 
cgit v1.2.3


From 01685afb8429f1b9756e97d6116ab7cbf24ce6c0 Mon Sep 17 00:00:00 2001
From: Zachary Ferguson <zfergus2@users.noreply.github.com>
Date: Tue, 6 Oct 2015 18:31:11 -0400
Subject: [java/en] removed excess abstract class

removed excess abstract class
---
 java.html.markdown | 22 ----------------------
 1 file changed, 22 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 39878c8f..6bfa6633 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -513,28 +513,6 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 	}
 }
 
-// There are also two special types of classes, abstract and final.
-
-
-public abstract class Mammal()
-{
-    // Abstract classes can contain concrete methods.
-    public boolean hasHair()
-    {
-        return true;
-    }
-    
-    // Final methods, like, final classes cannot be overridden by a child class.
-    public final boolean isWarmBlooded()
-    {
-        return true;
-    }
-
-    // Abstract methods are methods required to be overridden in a child class.
-    public abstract String getBinomialNomenclature();
-}
-
-
 // Abstract Classes 
 // Abstract Class declaration syntax
 // <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
-- 
cgit v1.2.3


From 420e04a5909ae309683201c9fb272ed3dc142283 Mon Sep 17 00:00:00 2001
From: Zachary Ferguson <zfergus2@users.noreply.github.com>
Date: Tue, 6 Oct 2015 19:07:24 -0400
Subject: [java/en] Final Methods

Explained Final Methods
---
 java.html.markdown | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 6bfa6633..9ab257a4 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -406,7 +406,7 @@ class Bicycle {
         this.name = name;
     }
 
-    // Function Syntax:
+    // Method Syntax:
     // <public/private/protected> <return type> <function name>(<args>)
 
     // Java classes often implement getters and setters for their fields
@@ -604,6 +604,19 @@ public final class SaberToothedCat extends Animal
 	}
 }
 
+// Final Methods
+public abstract class Mammal()
+{
+	// Final Method Syntax:
+    // <access modifier> final <return type> <function name>(<args>)
+	
+    // Final methods, like, final classes cannot be overridden by a child class,
+	// and are therefore the final implementation of the method.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+}
 ```
 
 ## Further Reading
-- 
cgit v1.2.3


From cea7db46eb1365c42d2e56a84af0ee2e3a750569 Mon Sep 17 00:00:00 2001
From: Zachary Ferguson <zfergus2@users.noreply.github.com>
Date: Tue, 6 Oct 2015 19:09:13 -0400
Subject: [java/en] Fixed Whitespace

Converted tabs to 4 spaces for consistency.
---
 java.html.markdown | 126 ++++++++++++++++++++++++++---------------------------
 1 file changed, 63 insertions(+), 63 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 9ab257a4..5c230501 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -343,9 +343,9 @@ public class LearnJava {
         
         private static final Set<String> COUNTRIES = new HashSet<String>();
         static {
-	       validCodes.add("DENMARK");
-	       validCodes.add("SWEDEN");
-	       validCodes.add("FINLAND");
+           validCodes.add("DENMARK");
+           validCodes.add("SWEDEN");
+           validCodes.add("FINLAND");
         }
         
         // But there's a nifty way to achive the same thing in an
@@ -505,12 +505,12 @@ public class Fruit implements Edible, Digestible {
 public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     InterfaceTwo {
     @Override
-	public void InterfaceOneMethod() {
-	}
+    public void InterfaceOneMethod() {
+    }
 
     @Override
-	public void InterfaceTwoMethod() {
-	}
+    public void InterfaceTwoMethod() {
+    }
 }
 
 // Abstract Classes 
@@ -530,56 +530,56 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 
 public abstract class Animal 
 {
-	public abstract void makeSound();
-
-	// Method can have a body
-	public void eat()
-	{
-		System.out.println("I am an animal and I am Eating.");  
-		// Note: We can access private variable here.
-		age = 30;
-	}
-
-	// No need to initialize, however in an interface 
-	// a variable is implicitly final and hence has
-	// to be initialized.
-	protected int age;
-
-	public void printAge()
-	{
-		System.out.println(age);  
-	}
-
-	// Abstract classes can have main function.
-	public static void main(String[] args)
-	{
-		System.out.println("I am abstract");
-	}
+    public abstract void makeSound();
+
+    // Method can have a body
+    public void eat()
+    {
+        System.out.println("I am an animal and I am Eating.");  
+        // Note: We can access private variable here.
+        age = 30;
+    }
+
+    // No need to initialize, however in an interface 
+    // a variable is implicitly final and hence has
+    // to be initialized.
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Abstract classes can have main function.
+    public static void main(String[] args)
+    {
+        System.out.println("I am abstract");
+    }
 }
 
 class Dog extends Animal
 {
-	// Note still have to override the abstract methods in the
-	// abstract class.
-	@Override
-	public void makeSound()
-	{
-		System.out.println("Bark");
-		// age = 30;	==> ERROR!	age is private to Animal
-	}
-
-	// NOTE: You will get an error if you used the 
-	// @Override annotation here, since java doesn't allow
-	// overriding of static methods.
-	// What is happening here is called METHOD HIDING.
-	// Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
-	public static void main(String[] args)
-	{
-		Dog pluto = new Dog();
-		pluto.makeSound();
-		pluto.eat();
-		pluto.printAge();
-	}
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Bark");
+        // age = 30;	==> ERROR!	age is private to Animal
+    }
+
+    // NOTE: You will get an error if you used the 
+    // @Override annotation here, since java doesn't allow
+    // overriding of static methods.
+    // What is happening here is called METHOD HIDING.
+    // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
 }
 
 // Final Classes 
@@ -595,23 +595,23 @@ class Dog extends Animal
 // extended.
 public final class SaberToothedCat extends Animal
 {
-	// Note still have to override the abstract methods in the
-	// abstract class.
-	@Override
-	public void makeSound()
-	{
-		System.out.println("Roar");
-	}
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Roar");
+    }
 }
 
 // Final Methods
 public abstract class Mammal()
 {
-	// Final Method Syntax:
+    // Final Method Syntax:
     // <access modifier> final <return type> <function name>(<args>)
-	
+
     // Final methods, like, final classes cannot be overridden by a child class,
-	// and are therefore the final implementation of the method.
+    // and are therefore the final implementation of the method.
     public final boolean isWarmBlooded()
     {
         return true;
-- 
cgit v1.2.3


From ec125fb6e793f54645a6ee592e4b5dec85f22cc5 Mon Sep 17 00:00:00 2001
From: Cameron Schermerhorn <cameron.schermerhorn@its.ny.gov>
Date: Wed, 7 Oct 2015 08:53:09 -0400
Subject: Add example for switching Strings

+ Added switch structure to demonstrate how to switch Strings
+ Added name to contributor list
---
 java.html.markdown | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 478ec683..a862d294 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Jakukyo Friel", "http://weakish.github.io"]
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
 filename: LearnJava.java
 ---
 
@@ -275,6 +276,23 @@ public class LearnJava {
                      break;
         }
         System.out.println("Switch Case Result: " + monthString);
+        
+        //Starting in Java 7 and above, switching Strings works like this:
+        String myAnswer = "maybe";
+        switch(myAnswer){
+            case "yes":
+                System.out.prinln("You answered yes.");
+                break;
+            case "no":
+                System.out.println("You answered no.");
+                break;
+            case "maybe":
+                System.out.println("You answered maybe.");
+                break;
+            default:
+                Sustem.out.println("You answered " + myAnswer);
+                break;
+        }
 
         // Conditional Shorthand
         // You can use the '?' operator for quick assignments or logic forks.
-- 
cgit v1.2.3


From 18b1c0c4d600284a06e28b59ab1978f777ebcc77 Mon Sep 17 00:00:00 2001
From: Cameron Schermerhorn <cameron.schermerhorn@its.ny.gov>
Date: Wed, 7 Oct 2015 08:56:29 -0400
Subject: Edit string switch addition

+ fix typos:
     line 284: fix prinln to println
     line 293: fix sustem to system
---
 java.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index a862d294..e567b049 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -281,7 +281,7 @@ public class LearnJava {
         String myAnswer = "maybe";
         switch(myAnswer){
             case "yes":
-                System.out.prinln("You answered yes.");
+                System.out.println("You answered yes.");
                 break;
             case "no":
                 System.out.println("You answered no.");
@@ -290,7 +290,7 @@ public class LearnJava {
                 System.out.println("You answered maybe.");
                 break;
             default:
-                Sustem.out.println("You answered " + myAnswer);
+                System.out.println("You answered " + myAnswer);
                 break;
         }
 
-- 
cgit v1.2.3


From 960ee4a1856db8eadb96277bb2422edfa8f2a81c Mon Sep 17 00:00:00 2001
From: Gabriel Halley <gabhalley@gmail.com>
Date: Wed, 7 Oct 2015 23:11:24 -0400
Subject: removing whitespace all over

---
 java.html.markdown | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 478ec683..fc7948d6 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -47,9 +47,9 @@ public class LearnJava {
 
 
         ///////////////////////////////////////
-        // Variables 
+        // Variables
         ///////////////////////////////////////
-        
+
         /*
         *  Variable Declaration
         */
@@ -325,29 +325,29 @@ public class LearnJava {
 
         // toString returns this Object's string representation.
         System.out.println("trek info: " + trek.toString());
-        
+
         // Double Brace Initialization
         // The Java Language has no syntax for how to create static Collections
         // in an easy way. Usually you end up in the following way:
-        
+
         private static final Set<String> COUNTRIES = new HashSet<String>();
         static {
 	       validCodes.add("DENMARK");
 	       validCodes.add("SWEDEN");
 	       validCodes.add("FINLAND");
         }
-        
+
         // But there's a nifty way to achive the same thing in an
         // easier way, by using something that is called Double Brace
         // Initialization.
-        
+
         private static final Set<String> COUNTRIES = HashSet<String>() {{
             add("DENMARK");
             add("SWEDEN");
-            add("FINLAND");            
+            add("FINLAND");
         }}
-        
-        // The first brace is creating an new AnonymousInnerClass and the 
+
+        // The first brace is creating an new AnonymousInnerClass and the
         // second one declares and instance initializer block. This block
         // is called with the anonymous inner class is created.
         // This does not only work for Collections, it works for all
@@ -500,7 +500,7 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 }
 
 
-// Abstract Classes 
+// Abstract Classes
 // Abstract Class declaration syntax
 // <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
 //     // Constants and variables
@@ -512,26 +512,26 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 // Also abstract classes CAN have the "main" method.
 // Abstract classes solve these problems.
 
-public abstract class Animal 
+public abstract class Animal
 {
 	public abstract void makeSound();
 
 	// Method can have a body
 	public void eat()
 	{
-		System.out.println("I am an animal and I am Eating.");  
+		System.out.println("I am an animal and I am Eating.");
 		// Note: We can access private variable here.
 		age = 30;
 	}
 
-	// No need to initialize, however in an interface 
+	// No need to initialize, however in an interface
 	// a variable is implicitly final and hence has
 	// to be initialized.
 	private int age;
 
 	public void printAge()
 	{
-		System.out.println(age);  
+		System.out.println(age);
 	}
 
 	// Abstract classes can have main function.
@@ -552,7 +552,7 @@ class Dog extends Animal
 		// age = 30;	==> ERROR!	age is private to Animal
 	}
 
-	// NOTE: You will get an error if you used the 
+	// NOTE: You will get an error if you used the
 	// @Override annotation here, since java doesn't allow
 	// overriding of static methods.
 	// What is happening here is called METHOD HIDING.
-- 
cgit v1.2.3


From 7aca9100a042f3813d383f979f8c32a95ecc4bbb Mon Sep 17 00:00:00 2001
From: Zachary Ferguson <zfergus2@users.noreply.github.com>
Date: Thu, 8 Oct 2015 00:00:37 -0400
Subject: [java/en] Fixed repitions

---
 java.html.markdown | 59 ++----------------------------------------------------
 1 file changed, 2 insertions(+), 57 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 61478968..ba602d2e 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -513,12 +513,8 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     }
 }
 
-<<<<<<< HEAD
-// Abstract Classes 
-=======
-
 // Abstract Classes
->>>>>>> adambard/master
+
 // Abstract Class declaration syntax
 // <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
 //     // Constants and variables
@@ -535,7 +531,6 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 
 public abstract class Animal
 {
-<<<<<<< HEAD
     public abstract void makeSound();
 
     // Method can have a body
@@ -561,38 +556,10 @@ public abstract class Animal
     {
         System.out.println("I am abstract");
     }
-=======
-	public abstract void makeSound();
-
-	// Method can have a body
-	public void eat()
-	{
-		System.out.println("I am an animal and I am Eating.");
-		// Note: We can access private variable here.
-		age = 30;
-	}
-
-	// No need to initialize, however in an interface
-	// a variable is implicitly final and hence has
-	// to be initialized.
-	private int age;
-
-	public void printAge()
-	{
-		System.out.println(age);
-	}
-
-	// Abstract classes can have main function.
-	public static void main(String[] args)
-	{
-		System.out.println("I am abstract");
-	}
->>>>>>> adambard/master
 }
 
 class Dog extends Animal
 {
-<<<<<<< HEAD
     // Note still have to override the abstract methods in the
     // abstract class.
     @Override
@@ -614,32 +581,10 @@ class Dog extends Animal
         pluto.eat();
         pluto.printAge();
     }
-=======
-	// Note still have to override the abstract methods in the
-	// abstract class.
-	@Override
-	public void makeSound()
-	{
-		System.out.println("Bark");
-		// age = 30;	==> ERROR!	age is private to Animal
-	}
-
-	// NOTE: You will get an error if you used the
-	// @Override annotation here, since java doesn't allow
-	// overriding of static methods.
-	// What is happening here is called METHOD HIDING.
-	// Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
-	public static void main(String[] args)
-	{
-		Dog pluto = new Dog();
-		pluto.makeSound();
-		pluto.eat();
-		pluto.printAge();
-	}
->>>>>>> adambard/master
 }
 
 // Final Classes 
+
 // Final Class declaration syntax
 // <access-level> final <final-class-name> {
 //     // Constants and variables
-- 
cgit v1.2.3


From 6d3f52b7f01409818853de6148abf1d8fe57fab0 Mon Sep 17 00:00:00 2001
From: "Todd M. Guerra" <toddguerra@gmail.com>
Date: Thu, 8 Oct 2015 11:53:19 -0400
Subject: Fix some grammar, spelling and indentation

Just some quick cleanup to make the code correctly formatted in parts
and fixed some typos.
---
 java.html.markdown | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index fc7948d6..e020885c 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -337,7 +337,7 @@ public class LearnJava {
 	       validCodes.add("FINLAND");
         }
 
-        // But there's a nifty way to achive the same thing in an
+        // But there's a nifty way to achieve the same thing in an
         // easier way, by using something that is called Double Brace
         // Initialization.
 
@@ -347,9 +347,9 @@ public class LearnJava {
             add("FINLAND");
         }}
 
-        // The first brace is creating an new AnonymousInnerClass and the
-        // second one declares and instance initializer block. This block
-        // is called with the anonymous inner class is created.
+        // The first brace is creating a new AnonymousInnerClass and the
+        // second one declares an instance initializer block. This block
+        // is called when the anonymous inner class is created.
         // This does not only work for Collections, it works for all
         // non-final classes.
 
@@ -476,14 +476,14 @@ public interface Digestible {
 // We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
     @Override
-	public void eat() {
-		// ...
-	}
+  	public void eat() {
+  		// awesome code goes here
+  	}
 
     @Override
-	public void digest() {
-		// ...
-	}
+  	public void digest() {
+  		// awesome code goes here
+  	}
 }
 
 // In Java, you can extend only one class, but you can implement many
@@ -491,12 +491,14 @@ public class Fruit implements Edible, Digestible {
 public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     InterfaceTwo {
     @Override
-	public void InterfaceOneMethod() {
-	}
+  	public void InterfaceOneMethod() {
+      // awesome code goes here
+  	}
 
     @Override
-	public void InterfaceTwoMethod() {
-	}
+  	public void InterfaceTwoMethod() {
+      // awesome code goes here
+  	}
 }
 
 
-- 
cgit v1.2.3


From bf7d33037f64ea9f80f106a37929e3fdf20bd24d Mon Sep 17 00:00:00 2001
From: Cameron Schermerhorn <cameron.schermerhorn@its.ny.gov>
Date: Fri, 9 Oct 2015 08:14:11 -0400
Subject: Add space to comment prior to switch string

+ Add space to comment (after //) prior to switch on string example
---
 java.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index e567b049..eb8b23e9 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -277,7 +277,7 @@ public class LearnJava {
         }
         System.out.println("Switch Case Result: " + monthString);
         
-        //Starting in Java 7 and above, switching Strings works like this:
+        // Starting in Java 7 and above, switching Strings works like this:
         String myAnswer = "maybe";
         switch(myAnswer){
             case "yes":
-- 
cgit v1.2.3


From 1caa042526ec529a8140a244a7416148f8270507 Mon Sep 17 00:00:00 2001
From: "Todd M. Guerra" <toddguerra@gmail.com>
Date: Fri, 9 Oct 2015 11:19:17 -0400
Subject: Fix conflicts from merge with master

---
 java.html.markdown | 45 +++++++++++++--------------------------------
 1 file changed, 13 insertions(+), 32 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index bb0b0d38..67e5494e 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -114,7 +114,7 @@ public class LearnJava {
         // but they can be initialized later.
         final double E;
         E = 2.71828;
-        
+
         // Strings
         String fooString = "My String Is Here!";
 
@@ -368,7 +368,7 @@ public class LearnJava {
 } // End LearnJava class
 
 
-// You can include other, non-public outer-level classes in a .java file, 
+// You can include other, non-public outer-level classes in a .java file,
 // but it is good practice. Instead split classes into separate files.
 
 
@@ -389,7 +389,7 @@ class Bicycle {
     // Constructors are a way of creating classes
     // This is a constructor
     public Bicycle() {
-        // You can also call another constructor: 
+        // You can also call another constructor:
         // this(1, 50, 5, "Bontrager");
         gear = 1;
         cadence = 50;
@@ -489,17 +489,8 @@ public interface Digestible {
 
 // We can now create a class that implements both of these interfaces.
 public class Fruit implements Edible, Digestible {
+  
     @Override
-<<<<<<< HEAD
-  	public void eat() {
-  		// awesome code goes here
-  	}
-
-    @Override
-  	public void digest() {
-  		// awesome code goes here
-  	}
-=======
     public void eat() {
         // ...
     }
@@ -508,31 +499,21 @@ public class Fruit implements Edible, Digestible {
     public void digest() {
         // ...
     }
->>>>>>> adambard/master
 }
 
 // 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
-<<<<<<< HEAD
-  	public void InterfaceOneMethod() {
-      // awesome code goes here
-  	}
 
     @Override
-  	public void InterfaceTwoMethod() {
-      // awesome code goes here
-  	}
-=======
     public void InterfaceOneMethod() {
     }
 
     @Override
     public void InterfaceTwoMethod() {
     }
->>>>>>> adambard/master
+
 }
 
 // Abstract Classes
@@ -544,10 +525,10 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 // }
 
 // Marking a class as abstract means that it contains abstract methods that must
-// be defined in a child class. Similar to interfaces, abstract classes cannot 
-// be instantiated, but instead must be extended and the abstract methods 
+// be defined in a child class. Similar to interfaces, abstract classes cannot
+// be instantiated, but instead must be extended and the abstract methods
 // defined. Different from interfaces, abstract classes can contain a mixture of
-// concrete and abstract methods. Methods in an interface cannot have a body, 
+// concrete and abstract methods. Methods in an interface cannot have a body,
 // unless the method is static, and variables are final by default, unlike an
 // abstract class. Also abstract classes CAN have the "main" method.
 
@@ -563,7 +544,7 @@ public abstract class Animal
         age = 30;
     }
 
-    // No need to initialize, however in an interface 
+    // No need to initialize, however in an interface
     // a variable is implicitly final and hence has
     // to be initialized.
     protected int age;
@@ -591,7 +572,7 @@ class Dog extends Animal
         // age = 30;	==> ERROR!	age is private to Animal
     }
 
-    // NOTE: You will get an error if you used the 
+    // NOTE: You will get an error if you used the
     // @Override annotation here, since java doesn't allow
     // overriding of static methods.
     // What is happening here is called METHOD HIDING.
@@ -605,7 +586,7 @@ class Dog extends Animal
     }
 }
 
-// Final Classes 
+// Final Classes
 
 // Final Class declaration syntax
 // <access-level> final <final-class-name> {
@@ -614,8 +595,8 @@ class Dog extends Animal
 // }
 
 // Final classes are classes that cannot be inherited from and are therefore a
-// final child. In a way, final classes are the opposite of abstract classes 
-// because abstract classes must be extended, but final classes cannot be 
+// final child. In a way, final classes are the opposite of abstract classes
+// because abstract classes must be extended, but final classes cannot be
 // extended.
 public final class SaberToothedCat extends Animal
 {
-- 
cgit v1.2.3


From 35e89f86fe21eb2a1246357184628595f8edca5d Mon Sep 17 00:00:00 2001
From: Cameron Schermerhorn <cameron.schermerhorn@its.ny.gov>
Date: Fri, 9 Oct 2015 13:31:48 -0400
Subject: Resolve merge conflict with master

+ added name back to contributor list
---
 java.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 58c19f11..3b289a6d 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -6,7 +6,7 @@ contributors:
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
-	- ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
 filename: LearnJava.java
 ---
 
-- 
cgit v1.2.3


From 8cb9e5395b2a21fe8e86455f5a5729a60435524c Mon Sep 17 00:00:00 2001
From: Robert Rose <bertra97@gmail.com>
Date: Mon, 12 Oct 2015 17:19:35 -0400
Subject: Updated Java tutorial with BigInteger and BigDecimal.

---
 java.html.markdown | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 67e5494e..55daa5bb 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -95,11 +95,13 @@ public class LearnJava {
         // Note: Java has no unsigned types.
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
         // f or F is used to denote that this variable value is of type float;
         // otherwise it is treated as double.
 
         // Double - Double-precision 64-bit IEEE 754 Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
         // Boolean - true & false
@@ -115,6 +117,34 @@ public class LearnJava {
         final double E;
         E = 2.71828;
 
+
+        // BigInteger - Immutable arbitrary-precision integers
+        //
+        // BigInteger is a data type that allows programmers to manipulate
+        // integers longer than 64-bits. Integers are stored as an array of
+        // of bytes and are manipulated using functions built into BigInteger
+        //
+        // BigInteger can be initialized using an array of bytes or a string.
+        
+        BigInteger fooBigInteger = new BigDecimal(fooByteArray);
+
+
+        // BigDecimal - Immutable, arbitrary-precision signed decimal number
+        //
+        // A BigDecimal takes two parts: an arbitrary precision integer 
+        // unscaled value and a 32-bit integer scale
+        //
+        // BigDecimal allows the programmer complete control over decimal
+        // rounding. It is recommended to use BigDecimal with currency values
+        // and where exact decimal percision is required.
+        //
+        // BigDecimal can be initialized with an int, long, double or String
+        // or by initializing the unscaled value (BigInteger) and scale (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+
+
         // Strings
         String fooString = "My String Is Here!";
 
-- 
cgit v1.2.3


From 4010f3727b377f1aa012c5f4195e58e11cae3be4 Mon Sep 17 00:00:00 2001
From: Robert Rose <bertra97@gmail.com>
Date: Mon, 12 Oct 2015 17:48:08 -0400
Subject: Added contributor credit.

---
 java.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 55daa5bb..b43c3a72 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Rob Rose", "https://github.com/RobRoseKnows"]
 filename: LearnJava.java
 ---
 
-- 
cgit v1.2.3


From a811ee38e44ca5d25eaa385cd7a2de93a9d67056 Mon Sep 17 00:00:00 2001
From: Robert Rose <bertra97@gmail.com>
Date: Mon, 12 Oct 2015 17:49:47 -0400
Subject: Removed credit

---
 java.html.markdown | 1 -
 1 file changed, 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index b43c3a72..55daa5bb 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -6,7 +6,6 @@ contributors:
     - ["Madison Dickson", "http://github.com/mix3d"]
     - ["Simon Morgan", "http://sjm.io/"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
-    - ["Rob Rose", "https://github.com/RobRoseKnows"]
 filename: LearnJava.java
 ---
 
-- 
cgit v1.2.3


From 26696b764b83ae34bb809405ecf5cfba615aad6a Mon Sep 17 00:00:00 2001
From: Robert Rose <bertra97@gmail.com>
Date: Mon, 12 Oct 2015 17:52:09 -0400
Subject: Revert "Updated Java tutorial with BigInteger and BigDecimal."

This reverts commit 8cb9e5395b2a21fe8e86455f5a5729a60435524c.
---
 java.html.markdown | 30 ------------------------------
 1 file changed, 30 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 55daa5bb..67e5494e 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -95,13 +95,11 @@ public class LearnJava {
         // Note: Java has no unsigned types.
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
-        // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
         // f or F is used to denote that this variable value is of type float;
         // otherwise it is treated as double.
 
         // Double - Double-precision 64-bit IEEE 754 Floating Point
-        // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
         // Boolean - true & false
@@ -117,34 +115,6 @@ public class LearnJava {
         final double E;
         E = 2.71828;
 
-
-        // BigInteger - Immutable arbitrary-precision integers
-        //
-        // BigInteger is a data type that allows programmers to manipulate
-        // integers longer than 64-bits. Integers are stored as an array of
-        // of bytes and are manipulated using functions built into BigInteger
-        //
-        // BigInteger can be initialized using an array of bytes or a string.
-        
-        BigInteger fooBigInteger = new BigDecimal(fooByteArray);
-
-
-        // BigDecimal - Immutable, arbitrary-precision signed decimal number
-        //
-        // A BigDecimal takes two parts: an arbitrary precision integer 
-        // unscaled value and a 32-bit integer scale
-        //
-        // BigDecimal allows the programmer complete control over decimal
-        // rounding. It is recommended to use BigDecimal with currency values
-        // and where exact decimal percision is required.
-        //
-        // BigDecimal can be initialized with an int, long, double or String
-        // or by initializing the unscaled value (BigInteger) and scale (int).
-
-        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
-
-
-
         // Strings
         String fooString = "My String Is Here!";
 
-- 
cgit v1.2.3


From a504713d000567919196fed9f2be44e91ba722fe Mon Sep 17 00:00:00 2001
From: Robert Rose <bertra97@gmail.com>
Date: Mon, 12 Oct 2015 17:52:21 -0400
Subject: Updated Java tutorial with BigInteger and BigDecimal

---
 java.html.markdown | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 67e5494e..55daa5bb 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -95,11 +95,13 @@ public class LearnJava {
         // Note: Java has no unsigned types.
 
         // Float - Single-precision 32-bit IEEE 754 Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
         // f or F is used to denote that this variable value is of type float;
         // otherwise it is treated as double.
 
         // Double - Double-precision 64-bit IEEE 754 Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
         // Boolean - true & false
@@ -115,6 +117,34 @@ public class LearnJava {
         final double E;
         E = 2.71828;
 
+
+        // BigInteger - Immutable arbitrary-precision integers
+        //
+        // BigInteger is a data type that allows programmers to manipulate
+        // integers longer than 64-bits. Integers are stored as an array of
+        // of bytes and are manipulated using functions built into BigInteger
+        //
+        // BigInteger can be initialized using an array of bytes or a string.
+        
+        BigInteger fooBigInteger = new BigDecimal(fooByteArray);
+
+
+        // BigDecimal - Immutable, arbitrary-precision signed decimal number
+        //
+        // A BigDecimal takes two parts: an arbitrary precision integer 
+        // unscaled value and a 32-bit integer scale
+        //
+        // BigDecimal allows the programmer complete control over decimal
+        // rounding. It is recommended to use BigDecimal with currency values
+        // and where exact decimal percision is required.
+        //
+        // BigDecimal can be initialized with an int, long, double or String
+        // or by initializing the unscaled value (BigInteger) and scale (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+
+
         // Strings
         String fooString = "My String Is Here!";
 
-- 
cgit v1.2.3


From 50a0bbf33f19ea33c38f4b025c771e57bdfe937b Mon Sep 17 00:00:00 2001
From: Raphael Nascimento <raphaelbn10@gmail.com>
Date: Wed, 14 Oct 2015 22:12:06 -0300
Subject: [java/en] Enum Type

Short overview about enum type.
---
 java.html.markdown | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 35ec57d8..bc119eb1 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -7,6 +7,7 @@ contributors:
     - ["Simon Morgan", "http://sjm.io/"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
     - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Raphael Nascimento", "http://github.com/raphaelbn"]
 filename: LearnJava.java
 ---
 
@@ -670,6 +671,68 @@ public abstract class Mammal()
         return true;
     }
 }
+
+
+// Enum Type
+//
+// An enum type is a special data type that enables for a variable to be a set of predefined constants. The        // variable must be equal to one of the values that have been predefined for it.
+// Because they are constants, the names of an enum type's fields are in uppercase letters.
+// In the Java programming language, you define an enum type by using the enum keyword. For example, you would 
+// specify a days-of-the-week enum type as:
+
+public enum Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY 
+}
+
+// We can use our enum Day like that:
+
+public class EnumTest {
+    
+    // Variable Enum
+    Day day;
+    
+    public EnumTest(Day day) {
+        this.day = day;
+    }
+    
+    public void tellItLikeItIs() {
+        switch (day) {
+            case MONDAY:
+                System.out.println("Mondays are bad.");
+                break;
+                    
+            case FRIDAY:
+                System.out.println("Fridays are better.");
+                break;
+                         
+            case SATURDAY: 
+            case SUNDAY:
+                System.out.println("Weekends are best.");
+                break;
+                        
+            default:
+                System.out.println("Midweek days are so-so.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        EnumTest firstDay = new EnumTest(Day.MONDAY);
+        firstDay.tellItLikeItIs();
+        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+        thirdDay.tellItLikeItIs();
+    }
+}
+
+// The output is:
+// Mondays are bad.
+// Midweek days are so-so.
+
+// Enum types are much more powerful than we show above. 
+// The enum body can include methods and other fields.
+// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
 ```
 
 ## Further Reading
-- 
cgit v1.2.3


From 5a8a68988b7c153cf16f37c307954d7070fc9b81 Mon Sep 17 00:00:00 2001
From: Raphael Nascimento <raphaelbn10@gmail.com>
Date: Thu, 15 Oct 2015 15:59:22 -0300
Subject:  [java/en] Enum Type

Outputs in line.
---
 java.html.markdown | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index bc119eb1..8544ecfc 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -719,16 +719,12 @@ public class EnumTest {
     
     public static void main(String[] args) {
         EnumTest firstDay = new EnumTest(Day.MONDAY);
-        firstDay.tellItLikeItIs();
+        firstDay.tellItLikeItIs(); // => Mondays are bad.
         EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
-        thirdDay.tellItLikeItIs();
+        thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
     }
 }
 
-// The output is:
-// Mondays are bad.
-// Midweek days are so-so.
-
 // Enum types are much more powerful than we show above. 
 // The enum body can include methods and other fields.
 // You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
-- 
cgit v1.2.3


From ef9331fa31ab84e5a04ee024ac490b24a6b5c4dc Mon Sep 17 00:00:00 2001
From: Raphael Nascimento <raphaelbn10@gmail.com>
Date: Wed, 21 Oct 2015 09:03:12 -0300
Subject:  [java/en] Enum Type

---
 java.html.markdown | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 8544ecfc..86b0578e 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -7,7 +7,7 @@ contributors:
     - ["Simon Morgan", "http://sjm.io/"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
     - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
-    - ["Raphael Nascimento", "http://github.com/raphaelbn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
 filename: LearnJava.java
 ---
 
@@ -138,7 +138,7 @@ public class LearnJava {
         //
         // BigDecimal allows the programmer complete control over decimal
         // rounding. It is recommended to use BigDecimal with currency values
-        // and where exact decimal percision is required.
+        // and where exact decimal precision is required.
         //
         // BigDecimal can be initialized with an int, long, double or String
         // or by initializing the unscaled value (BigInteger) and scale (int).
@@ -185,8 +185,12 @@ public class LearnJava {
         // 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.
+        // Maps - A set of objects that map keys to values. Map is
+	//        an interface and therefore cannot be instantiated.
+	//        The type of keys and values contained in a Map must
+	//        be specified upon instantiation of the implementing
+        //        class. Each key may map to only one corresponding value,
+        //        and each key may appear only once (no duplicates).
         // 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
@@ -251,7 +255,7 @@ public class LearnJava {
 
         // If statements are c-like
         int j = 10;
-        if (j == 10){
+        if (j == 10) {
             System.out.println("I get printed");
         } else if (j > 10) {
             System.out.println("I don't");
@@ -286,7 +290,18 @@ public class LearnJava {
             // Iterated 10 times, fooFor 0->9
         }
         System.out.println("fooFor Value: " + fooFor);
-
+        
+        // Nested For Loop Exit with Label
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // breaks out of outer loop instead of only the inner one
+            }
+          }
+        }
+        
         // For Each Loop
         // The for loop is also able to iterate over arrays as well as objects
         // that implement the Iterable interface.
@@ -321,7 +336,7 @@ public class LearnJava {
         
         // Starting in Java 7 and above, switching Strings works like this:
         String myAnswer = "maybe";
-        switch(myAnswer){
+        switch(myAnswer) {
             case "yes":
                 System.out.println("You answered yes.");
                 break;
-- 
cgit v1.2.3


From 03ef96b2f11133701a3db64b9133f634a9709e94 Mon Sep 17 00:00:00 2001
From: Raphael Nascimento <raphaelbn10@gmail.com>
Date: Thu, 29 Oct 2015 12:46:59 -0300
Subject: [java/en] Enum Type

---
 java.html.markdown | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 86b0578e..1813f81c 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -186,9 +186,9 @@ public class LearnJava {
         //               operations perform as could be expected for a
         //               doubly-linked list.
         // Maps - A set of objects that map keys to values. Map is
-	//        an interface and therefore cannot be instantiated.
-	//        The type of keys and values contained in a Map must
-	//        be specified upon instantiation of the implementing
+        //        an interface and therefore cannot be instantiated.
+        //        The type of keys and values contained in a Map must
+        //        be specified upon instantiation of the implementing
         //        class. Each key may map to only one corresponding value,
         //        and each key may appear only once (no duplicates).
         // HashMaps - This class uses a hashtable to implement the Map
@@ -450,6 +450,17 @@ class Bicycle {
     protected int gear; // Protected: Accessible from the class and subclasses
     String name; // default: Only accessible from within this package
 
+    static String className; // Static class variable
+
+    // Static block 
+    // Java has no implementation of static constructors, but
+    // has a static block that can be used to initialize class variables 
+    // (static variables). 
+    // This block will be called when the class is loaded.
+    static {
+        className = "Bicycle";
+    }
+
     // Constructors are a way of creating classes
     // This is a constructor
     public Bicycle() {
@@ -767,7 +778,7 @@ The links provided here below are just to get an understanding of the topic, fee
 
 * [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
 
-* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
 
 **Online Practice and Tutorials**
 
-- 
cgit v1.2.3


From 34c7c6acb22c934f879a353f3ba92b38b602f7fc Mon Sep 17 00:00:00 2001
From: Andy <andrewgallasch@gmail.com>
Date: Sat, 31 Oct 2015 16:57:22 +1030
Subject: Fixed typo at BigInteger assignment

---
 java.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 1813f81c..901e2dad 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -128,7 +128,7 @@ public class LearnJava {
         //
         // BigInteger can be initialized using an array of bytes or a string.
         
-        BigInteger fooBigInteger = new BigDecimal(fooByteArray);
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
 
 
         // BigDecimal - Immutable, arbitrary-precision signed decimal number
-- 
cgit v1.2.3


From f7af2da9dbb504377c2ff7c2f29a55b9f363a4c1 Mon Sep 17 00:00:00 2001
From: Andy <andrewgallasch@gmail.com>
Date: Sat, 31 Oct 2015 18:31:51 +1030
Subject: Added BigDecimal float constructor caveat

---
 java.html.markdown | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 1813f81c..d7d0199b 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -144,7 +144,12 @@ public class LearnJava {
         // or by initializing the unscaled value (BigInteger) and scale (int).
 
         BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
-
+        
+        // Be wary of the constructor that takes a float or double as
+        // the inaccuracy of the float/double will be copied in BigDecimal.
+        // Prefer the String constructor when you need an exact value.
+        
+        BigDecimal tenCents = new BigDecimal("0.1");
 
 
         // Strings
-- 
cgit v1.2.3


From 4593c65543eec73688acf999c4bab002116909b0 Mon Sep 17 00:00:00 2001
From: Andy <andrewgallasch@gmail.com>
Date: Sat, 31 Oct 2015 19:39:26 +1030
Subject: Improved int division comment and code

---
 java.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 1813f81c..966aee15 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -207,8 +207,8 @@ public class LearnJava {
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
-        System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
-        System.out.println("1/2 = " + (i1 / (i2*1.0))); // => 0.5
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
 
         // Modulo
         System.out.println("11%3 = "+(11 % 3)); // => 2
-- 
cgit v1.2.3


From 231b60b7c0c21e2f76a3dfc0939abe1b7efbfad3 Mon Sep 17 00:00:00 2001
From: Andy <andrewgallasch@gmail.com>
Date: Sat, 31 Oct 2015 20:05:05 +1030
Subject: Added missing new in HashSet instantiation

---
 java.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index 966aee15..2836f601 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -416,7 +416,7 @@ public class LearnJava {
         // easier way, by using something that is called Double Brace
         // Initialization.
 
-        private static final Set<String> COUNTRIES = HashSet<String>() {{
+        private static final Set<String> COUNTRIES = new HashSet<String>() {{
             add("DENMARK");
             add("SWEDEN");
             add("FINLAND");
-- 
cgit v1.2.3


From 093c3e656242e84682da7910e8d56db62c08ca10 Mon Sep 17 00:00:00 2001
From: Andy <andrewgallasch@gmail.com>
Date: Sat, 31 Oct 2015 20:52:07 +1030
Subject: Formatted enum comments

---
 java.html.markdown | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'java.html.markdown')

diff --git a/java.html.markdown b/java.html.markdown
index e1efc375..84978ecc 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -706,10 +706,12 @@ public abstract class Mammal()
 
 // Enum Type
 //
-// An enum type is a special data type that enables for a variable to be a set of predefined constants. The        // variable must be equal to one of the values that have been predefined for it.
-// Because they are constants, the names of an enum type's fields are in uppercase letters.
-// In the Java programming language, you define an enum type by using the enum keyword. For example, you would 
-// specify a days-of-the-week enum type as:
+// An enum type is a special data type that enables for a variable to be a set
+// of predefined constants. The variable must be equal to one of the values that
+// have been predefined for it. Because they are constants, the names of an enum
+// type's fields are in uppercase letters. In the Java programming language, you
+// define an enum type by using the enum keyword. For example, you would specify
+// a days-of-the-week enum type as:
 
 public enum Day {
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
-- 
cgit v1.2.3