learnxinyminutes-docs/java.html.markdown

---

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;
	printf("%d\n", my_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);
	}
	

///////////////////////////////////////
// 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();
			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