Merge pull request #59 from Jakehp/master

java addition

1 files changed, 319 insertions, 0 deletions

diff --git a/java.html.markdown b/java.html.markdown
new file mode 100644
index 00000000..e14f356d
--- /dev/null
+++ b/java.html.markdown
@@ -0,0 +1,319 @@
+---
+
+language: java
+
+author: Jake Prather
+
+author_url: http://github.com/JakeHP
+
+---
+
+Java is a general-purpose, concurrent, class-based, object-oriented computer programming language.
+Read more here: https://en.wikipedia.org/wiki/Java_(programming_language)
+
+```java
+///////////////////////////////////////
+// General
+///////////////////////////////////////
+	// Single-line comments start with //
+	/*
+	Multi-line comments look like this.
+	*/
+	
+	// Import Packages
+	import java.util.ArrayList;
+	import package.path.here;
+	// Import all "sub-packages"
+	import java.lang.Math.*;
+	
+	// Your program's entry point is a function called main
+	public class Main
+	{
+		public static void main (String[] args) throws java.lang.Exception
+		{
+			//stuff here
+		}
+	}
+	
+	// Printing, and forcing a new line on next print = println()
+	System.out.println("Hello World");
+	System.out.println("Integer: "+10+"Double: "+3.14+ "Boolean: "+true);
+	// Printing, without forcing a new line on next print = print()
+	System.out.print("Hello World");
+	System.out.print("Integer: "+10+"Double: "+3.14+ "Boolean: "+true);
+
+///////////////////////////////////////
+// Types
+///////////////////////////////////////
+
+	// Byte - 8-bit signed two's complement integer (-128 <= byte <= 127)
+	byte foo = 100;
+	
+	// Short - 16-bit signed two's complement integer (-32,768 <= short <= 32,767)
+	short bar = 10000;
+	
+	//Integer - 32-bit signed two's complement integer (-2,147,483,648 <= int <= 2,147,483,647)
+	int foo = 1;
+	
+	//Long - 64-bit signed two's complement integer (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+	long bar = 100000L;
+	
+	//Float - Single-precision 32-bit IEEE 754 Floating Point
+	float foo = 234.5f;
+	
+	//Double - Double-precision 64-bit IEEE 754 Floating Point
+	double bar = 123.4;
+	
+	//Boolean - True & False
+	boolean foo = true;
+	boolean bar = false;
+	
+	//Char - A single 16-bit Unicode character
+	char foo = 'A';
+	
+	//Make a variable a constant
+	final int HOURS_I_WORK_PER_WEEK = 9001;
+	
+	//Strings
+	String foo = "Hello World!";
+	// \n is an escaped character that starts a new line
+	String foo = "Hello World!\nLine2!";
+	System.out.println(foo);
+	//Hello World!
+	//Line2!
+	
+	//Arrays
+	//The array size must be decided upon declaration
+	//The format for declaring an array is follows:
+	//<datatype> [] <var name> = new <datatype>[<array size>];
+	int [] array = new int[10];
+	String [] array = new String[1];
+	boolean [] array = new boolean[100];
+	
+	// Indexing an array - Accessing an element
+	array[0];
+	
+	// Arrays are mutable; it's just memory!
+	array[1] = 1;
+	System.out.println(array[1]); // => 1
+	array[1] = 2;
+	System.out.println(array[1]); // => 2
+		
+	//Others to check out
+	//ArrayLists - Like arrays except more functionality is offered, and the size is mutable
+	//LinkedLists
+	//Maps
+	//HashMaps
+
+///////////////////////////////////////
+// Operators
+///////////////////////////////////////
+
+	int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+	
+	// Arithmetic is straightforward
+	i1 + i2; // => 3
+	i2 - i1; // => 1
+	i2 * i1; // => 2
+	i1 / i2; // => 0 (0.5, but truncated towards 0)
+	
+	// Modulo
+	11 % 3; // => 2
+	
+	// Comparison operators
+	3 == 2; // => 0 (false)
+	3 != 2; // => 1 (true)
+	3 > 2; // => 1
+	3 < 2; // => 0
+	2 <= 2; // => 1
+	2 >= 2; // => 1
+	
+	// Bitwise operators!
+	~       Unary bitwise complement
+	<<      Signed left shift
+	>>      Signed right shift
+	>>>     Unsigned right shift
+	&       Bitwise AND
+	^       Bitwise exclusive OR
+	|       Bitwise inclusive OR
+	
+	// Incrementations
+	int i=0;
+	i++; //i = 1. Post-Incrementation
+	++i; //i = 2. Pre-Incrementation
+	i--; //i = 1. Post-Decrementation
+	--i; //i = 0. Pre-Decrementation
+
+///////////////////////////////////////
+// Control Structures
+///////////////////////////////////////
+
+	if (false) {
+		  System.out.println("I never run");
+		} else if (false) {
+		  System.out.println("I am also never run");
+		} else {
+		  System.out.println("I print");
+		}
+	}
+
+	// While loop
+	int i = 0;
+	while(i < 100){
+		System.out.println(i);
+		//Increment the counter
+		i++;
+	}
+	
+	// Do While Loop
+	int i = 0;
+	do{		
+		System.out.println(i);
+		//Increment the counter
+		i++;
+	}while(i < 100);
+	
+	// For Loop
+	int i;
+	//for loop structure => for(<start_statement>;<conditional>;<step>)
+	for(i=0;i<100;i++){
+		System.out.println(i);
+	}
+	
+	// Switch Case
+	int month = 8;
+        String monthString;
+        switch (month) {
+            case 1:  monthString = "January";
+                     break;
+            case 2:  monthString = "February";
+                     break;
+            case 3:  monthString = "March";
+                     break;
+            case 4:  monthString = "April";
+                     break;
+            case 5:  monthString = "May";
+                     break;
+            case 6:  monthString = "June";
+                     break;
+            case 7:  monthString = "July";
+                     break;
+            case 8:  monthString = "August";
+                     break;
+            case 9:  monthString = "September";
+                     break;
+            case 10: monthString = "October";
+                     break;
+            case 11: monthString = "November";
+                     break;
+            case 12: monthString = "December";
+                     break;
+            default: monthString = "Invalid month";
+                     break;
+        }
+        System.out.println(monthString);
+
+///////////////////////////////////////
+// Typecasting
+///////////////////////////////////////
+
+	// Converting data
+	
+	//Convert String To Integer
+	Integer.parseInt("123");//returns an integer version of "123"
+	
+	//Convert Integer To String
+	Integer.toString(123);//returns a string version of 123
+	
+	//For other conversions check out the following classes:
+	//Double
+	//Long
+	//String
+	
+	// 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
+	
+
+///////////////////////////////////////
+// Classes And Functions
+///////////////////////////////////////
+
+	// Classes Syntax shown below.
+	// Function declaration syntax:
+	// <public/private/protected> <return type> <function name>(<args>)
+	// Here is a quick rundown on access level modifiers (public, private, etcetc) http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
+
+	
+	public class Bicycle {
+	        
+	    // Bicycle's Fields/Variables
+	    public int cadence;
+	    public int gear;
+	    public int speed;
+	        
+	    // Constructors are a way of creating classes
+	    // This is a default constructor
+	    public Bicycle(){
+	    	gear = 1;
+	    	cadence = 50;
+	    	startGear = 1;
+	    }
+
+	    // This is a specified constructor (it contains arguments)
+	    public Bicycle(int startCadence, int startSpeed, int startGear) {
+	        gear = startGear;
+	        cadence = startCadence;
+	        speed = startSpeed;
+	    }
+	        
+	    // the Bicycle class has
+	    // four methods
+	    public void setCadence(int newValue) {
+	        cadence = newValue;
+	    }
+	        
+	    public void setGear(int newValue) {
+	        gear = newValue;
+	    }
+	        
+	    public void applyBrake(int decrement) {
+	        speed -= decrement;
+	    }
+	        
+	    public void speedUp(int increment) {
+	        speed += increment;
+	    }
+	        
+	}
+	
+	//Now..Later in the main / driver of your java program
+	public class Main
+	{
+		public static void main (String[] args) throws java.lang.Exception
+		{
+			//Call bicycle's constructor
+			Bicycle trek = new Bicycle();
+			//Manipulate your object
+			trek.speedUp(3);
+			trek.setCadence(100);
+		}
+	}
+
+```
+
+## Further Reading
+
+Other Topics To Research:
+
+	* Inheritance (http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming))
+	
+	* Abstraction (http://en.wikipedia.org/wiki/Abstraction_(computer_science))
+	
+	* Exceptions (http://en.wikipedia.org/wiki/Exception_handling)
+	
+	* Interfaces (http://en.wikipedia.org/wiki/Interfaces_(computer_science))
+	
+	* Generics (http://en.wikipedia.org/wiki/Generics_in_Java)
+	
+	* The links provided are just to get an understanding of the topic, feel free to google and find specific examples