graph TD
A[Java Code] -->|Compiled| B(Bytecode)
B --> C{Run}
C -->|bytecode| D[Windows JVM] 
D --> K[Windows Instructions]
C -->|bytecode| E[Unix  JVM]
E --> L[Unix Instructions]
C -->|bytecode| F[Linux  JVM]
F --> M[Linux Instructions]
C -->|bytecode| G[Any other platform  JVM]
G --> N[Linux Instructions]

javac HelloWorld.java

java HelloWorld

int number;
number = 5;
System.out.println(number);//5
number = number   2;
System.out.println(number);//7
number = number   2;
System.out.println(number);//9

TYPE variableName;

int value = 5;

int i = 15;
long longValue = 1000000000000l;
byte b = (byte)254;

float f = 26.012f;
double d = 123.567;
boolean isDone = true;
boolean isGood = false;
char ch = 'a';
char ch2 = ';';

Animal dog = new Animal();

Animal dog1 = new Animal();
dog1 = new Animal();

Animal animal1 = new Animal();
Animal animal2 = new Animal();
animal1 = animal2;

int eight = 010; 
int nine=011;  
int invalid = 089;//COMPILER ERROR! 8 and 9 are invalid in Octal
int sixteen = 0x10; 
int fifteen = 0XF; 
int fourteen = 0xe;
int x = 23,000;
long a = 123456789l; 
long b = 0x9ABCDEFGHL; 
long c = 0123456789L;

float f = 123.456;//COMPILER ERROR! A double value cannot be assigned to a float.

boolean b = true; boolean b=false;
boolean b = TRUE;//COMPILATION ERROR
boolean b = 0; //COMPILER ERROR. This is not C Language

char ch = a;
char a = 97;
char ch1 = 66000; //COMPILER ERROR!

int value = 35;//35 is copied into 35

int squareOfValue = value * value;//value * value = 35 * 35 is stored into squareOfValue

int twiceOfValue = value * 2;

int a1 = 5;
int b1 = 6;
b1 = a1; // value of a1 is copied into b1
a1 = 10; // If we change a1 or b1 after this, it would not change the other variable.. b1 will remain 6

Actor actor1 = new Actor();
actor1.setName("Actor1");
//This creates new reference variable actor1 of type Actor  new Actor() on the heap assigns the new Actor on the heap to reference variable

Actor actor2 = actor1;
actor2.setName("Actor2");
System.out.println(actor1.getName());//Actor2

byte b = 10; //byte b = (int) 10; Example below compiles because compiler introduces an implicit cast.

short n1 = 5;
short n2 = 6;
//short sum = n1   n2;//COMPILER ERROR
short sum = (short)(n1   n2);//Needs an explicit cast

byte b = 5;
b  = 5; //Compiles because of implicit conversion

int value = 100;
long number = value; //Implicit Casting
float f = 100; //Implicit Casting 

long number1 = 25678;
int number2 = (int)number1;//Explicit Casting
//int x = 35.35;//COMPILER ERROR
int x = (int)35.35;//Explicit Casting

int bigValue = 280;
byte small = (byte) bigValue;
System.out.println(small);//output 24. Only 8 bits remain.

//float avg = 36.01;//COMPILER ERROR. Default Double
float avg = (float) 36.01;//Explicit Casting
float avg1 = 36.01f;
float avg2 = 36.01F; //f or F is fine

//byte large = 128; //Literal value bigger than range of variable type causes compilation error
byte large = (byte) 128;//Causes Truncation!

int a = 5;
a  = 5; //similar to a = a   5;
a *= 10;//similar to a = a * 10;
a -= 5;//similar to a = a - 5;
a /= 5;//similar to a = a / 5;

System.out.println(10 % 4);//2
System.out.println(15 % 4);//3

int age = 18;

System.out.println(
age >= 18 ? "Can Vote": "Cannot Vote");//Can Vote

age = 15;

System.out.println(
age >= 18 ? "Can Vote": "Cannot Vote");//Cannot Vote

public class StaticAndMemberVariables {
    public static void main(String[] args) {
Actor actor1 = new Actor();
actor1.name = "ACTOR1";
//Actor.name //Compiler Error

//Below statement can be written as actor1.count  
//But NOT recommended.
Actor.count  ;

Actor actor2 = new Actor();
actor2.name = "ACTOR2";

//Below statement can be written as actor2.count  
//But NOT recommended.
Actor.count  ;

System.out.println(actor1.name);//ACTOR1
System.out.println(actor2.name);//ACTOR2

//Next 3 statements refer to same variable
System.out.println(actor1.count);//2
System.out.println(actor2.count);//2
System.out.println(Actor.count);//2
    }
}

class Actor {
    //RULE 1: Member Variables can be accessed 
    //only through object references
    String name;
    
    //RULE 2:Static Variables can be accessed 
    //through a.Class Name and b.Object Reference
    //It is NOT recommended to use object reference 
    //to refer to static variables.
    static int count;    
}

public class VariablesExample {
    //RULE 1:Static Variable can be used anywhere in the class. 
    static int staticVariable;
    
    //RULE 2:Member Variable can be used in any non-static method. 
    int memberVariable;
    
    void method1() {
		//RULE 3: method1LocalVariable can be used only in method1.
		int method1LocalVariable;

		memberVariable = 5;//RULE 2
		staticVariable = 5;//RULE 1

		//Some Code
		{
		    //RULE 4:blockVariable can be used only in this block.
		    int blockVariable;
		    //Some Code
		}

		//blockVariable = 5;//COMPILER ERROR - RULE 4
    }
    
    void method2() {
		//method1LocalVariable = 5; //COMPILER ERROR - RULE3
    }
    
    static void staticMethod() {
		staticVariable = 5;//RULE 1
		//memberVariable = 5; //COMPILER ERROR - RULE 2
    }
}

package com.in28minutes.variables;

//RULE1:Member/Static variables are alway initialized with 
//default values.Default values for numeric types is 0, 
//floating point types is 0.0, boolean is false, 
//char  is '\u0000' and object reference variable is null.

//RULE2:Local/block variables are NOT initialized by compiler. 

//RULE3    :If local variables are used before initialization, 
//it would result in Compilation Error

public class VariableInitialization {
    public static void main(String[] args) {
		Player player = new Player();

		//score is an int member variable - default 0
		System.out.println(player.score);//0 - RULE1

		//name is a member reference variable - default null
		System.out.println(player.name);//null - RULE1

		int local; //not initialized
		//System.out.println(local);//COMPILER ERROR! RULE3

		String value1;//not initialized
		//System.out.println(value1);//COMPILER ERROR! RULE3

		String value2 = null;//initialized
		System.out.println(value2);//null - NO PROBLEM.
    }
}


class Player{
    String name;
    int score;
}

Integer number = new Integer(55);//int
Integer number2 = new Integer("55");//String

Float number3 = new Float(55.0);//double argument
Float number4 = new Float(55.0f);//float argument
Float number5 = new Float("55.0f");//String

Character c1 = new Character('C');//Only char constructor
//Character c2 = new Character(124);//COMPILER ERROR

Boolean b = new Boolean(true);

//"true" "True" "tRUe" - all String Values give True
//Anything else gives false
Boolean b1 = new Boolean("true");//value stored - true
Boolean b2 = new Boolean("True");//value stored - true
Boolean b3 = new Boolean("False");//value stored - false
Boolean b4 = new Boolean("SomeString");//value stored - false

b = false;

Integer seven = 
    Integer.valueOf("111", 2);//binary 111 is converted to 7

Integer hundred = 
    Integer.valueOf("100");//100 is stored in variable

Integer integer = Integer.valueOf(57);
int primitive = seven.intValue();//57
float primitiveFloat = seven.floatValue();//57.0f

Float floatWrapper = Float.valueOf(57.0f);
int floatToInt = floatWrapper.intValue();//57
float floatToFloat = floatWrapper.floatValue();//57.0f

int sevenPrimitive = 
    Integer.parseInt("111", 2);//binary 111 is converted to 7

int hundredPrimitive = 
    Integer.parseInt("100");//100 is stored in variable

Integer wrapperEight = new Integer(8);
System.out.println(Integer.
toString(wrapperEight));//String Output: 8

System.out.println(Integer
.toString(wrapperEight, 2));//String Output: 1000

System.out.println(Integer
.toHexString(wrapperEight));//String Output:8 
System.out.println(Integer
.toBinaryString(wrapperEight));//String Output:1000
System.out.println(Integer
.toOctalString(wrapperEight));//String Output:10

Integer ten = new Integer(10);
ten  ;//allowed. Java does the work behind the screen for us

Integer nineA = new Integer(9);
Integer nineB = new Integer(9);
System.out.println(nineA == nineB);//false
System.out.println(nineA.equals(nineB));//true

Integer nineC = 9;
Integer nineD = 9;
System.out.println(nineC == nineD);//true
System.out.println(nineC.equals(nineD));//true

String str3 = "value1";
str3.concat("value2");
System.out.println(str3); //value1

String concat = str3.concat("value2");
System.out.println(concat); //value1value2

String str1 = "value"; 

//1. String Literal "value" - created in the "String constant pool"
//2. String Object - created on the heap
String str2 = new String("value");

String str = "abcdefghijk";

//char charAt(int paramInt)
System.out.println(str.charAt(2)); //prints a char - c
System.out.println("ABCDEFGH".length());//8
System.out.println("abcdefghij".toString()); //abcdefghij
System.out.println("ABC".equalsIgnoreCase("abc"));//true

//Get All characters from index paramInt
//String substring(int paramInt)
System.out.println("abcdefghij".substring(3)); //cdefghij

//All characters from index 3 to 6
System.out.println("abcdefghij".substring(3,7)); //defg

//String concat(String paramString)
System.out.println(str.concat("lmn"));//abcdefghijklmn

//String replace(char paramChar1, char paramChar2)
System.out.println("012301230123".replace('0', '4'));//412341234123

//String replace(CharSequence paramCharSequence1, CharSequence paramCharSequence2)
System.out.println("012301230123".replace("01", "45"));//452345234523

System.out.println("ABCDEFGHIJ".toLowerCase()); //abcdefghij

System.out.println("abcdefghij".toUpperCase()); //ABCDEFGHIJ

//trim removes leading and trailings spaces
System.out.println(" abcd  ".trim()); //abcd

System.out.println(5   "Test"   5); //5Test5
System.out.println(5   5   "Test"); //10Test
System.out.println("5"   5   "Test"); //55Test
System.out.println("5"   "5"   "25"); //5525
System.out.println(5   5   "25"); //1025
System.out.println(""   5   5   "25"); //5525
System.out.println(5   (5   "25")); //5525
System.out.println(5   5   25); //35

int i = 25;
int j =   i;//i is incremented to 26, assigned to j
System.out.println(i   " "   j);//26 26

i = 25;
j = i  ;//i value(25) is assigned to j, then incremented to 26
System.out.println(i   " "   j);//26 25

i = 25;
j = --i;//i is decremented to 24, assigned to j
System.out.println(i   " "   j);//24 24

i = 25;
j = i--;//i value(25) is assigned to j, then decremented to 24
System.out.println(i   " "   j);//24 25

int number = 7;

System.out.println(number > 5);//true
System.out.println(number > 7);//false

System.out.println(number >= 7);//true

System.out.println(number < 9);//true
System.out.println(number < 7);//false

System.out.println(number <= 7);//true

System.out.println(number == 7);//true
System.out.println(number == 9);//false

System.out.println(number != 9);//true
System.out.println(number != 7);//false

System.out.println(number = 7);//7

int a = 5;
int b = 5;

System.out.println(a == b);//true

Integer aReference = new Integer(5);
Integer bReference = new Integer(5);

System.out.println(aReference == bReference);//false

bReference = aReference;

//Now both are referring to same object
System.out.println(aReference == bReference);//true

System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false
System.out.println(false && false);//false

System.out.println(true || true);//true
System.out.println(true || false);//true
System.out.println(false || true);//true
System.out.println(false || false);//false

//System.out.println(5 || 6);//COMPILER ERROR

int i = 10;
System.out.println(true ||   i==11);//true
System.out.println(false &&   i==11);//false
System.out.println(i);//i remains 10, as   i expressions are not executed.

int j = 10;
System.out.println(true |   j==11);//true
System.out.println(false &   j==12);//false
System.out.println(j);//j becomes 12, as both   j expressions are executed

System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false

System.out.println(!false);//true
System.out.println(!true);//false

//Declaring an Array
int[] marks;

// Creating an array
marks = new int[5]; // 5 is size of array

int marks2[] = new int[5];//Declaring and creating an array in same line.

System.out.println(marks2[0]);//New Arrays are always initialized with default values - 0

//Index of elements in an array runs from 0 to length - 1
marks[0] = 25;
marks[1] = 30;
marks[2] = 50;
marks[3] = 10;
marks[4] = 5;

System.out.println(marks[2]);//Printing a value from array

//Printing a 1D Array
int marks5[] = { 25, 30, 50, 10, 5 };
System.out.println(marks5); //[I@6db3f829
System.out.println(
    Arrays.toString(marks5));//[25, 30, 50, 10, 5]

int length = marks.length;//Length of an array: Property length

//Enhanced For Loop
for (int mark: marks) {
    System.out.println(mark);
}

//Fill array with a value
Arrays.fill(marks, 100); //All array values will be 100

//String Arrays
String[] daysOfWeek = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

int[][] matrix = { { 1, 2, 3 }, { 4, 5, 6 } };

int[][] matrixA = new int[5][6]; 

//Accessing elements from 2D array:
System.out.println(matrix[0][0]); //1
System.out.println(matrix[1][2]); //6

//Looping a 2D array
for (int[] array: matrix) {
    for (int number: array) {
         System.out.println(number);
    }
}

// Printing a 2D Array
int[][] matrix3 = { { 1, 2, 3 }, { 4, 5, 6 } };
System.out.println(matrix3); //[[I@1d5a0305
System.out.println(

Arrays.toString(matrix3)); 
//[[I@6db3f829, [I@42698403]

System.out.println(Arrays.deepToString(matrix3)); 
//[[1, 2, 3], [4, 5, 6]]

System.out.println(matrix3[0]);//[I@86c347 - matrix3[0] is a 1D Array
System.out.println(Arrays.toString(matrix3[0]));//[1, 2, 3]

//Comparing Arrays
int[] numbers1 = { 1, 2, 3 };
int[] numbers2 = { 4, 5, 6 };

System.out.println(Arrays
.equals(numbers1, numbers2)); //false

int[] numbers3 = { 1, 2, 3 };

System.out.println(Arrays
.equals(numbers1, numbers3)); //true

// Sorting an Array

int rollNos[] = { 12, 5, 7, 9 };
Arrays.sort(rollNos);
System.out.println(Arrays.toString(rollNos));//[5, 7, 9, 12]

Person[] persons = new Person[3];

//By default, an array of 3 reference variables is created.
//The person objects are not created
System.out.println(persons[0]);//null

//Let's create the new objects
persons[0] = new Person();
persons[1] = new Person();
persons[2] = new Person();

//Creating and initializing person array in one statement
Person[] personsAgain = { new Person(),new Person(),new Person()};

//Another example
Person[][] persons2D = 
    {
		{ new Person(),new Person(),new Person()},
		{ new Person(),new Person()}
    };

//You can Declare, Create and Initialize Array on same line.
int marks3[] = { 25, 30, 50, 10, 5 };

//Leaving additional comma is not a problem. (note that comma after 5)
int marks4[] = { 25, 30, 50, 10, 5, };


int marks[]; //Not Readable
int[] runs; //Not Readable


//int values[5];//Compilation Error!Declaration of an Array should not include size. 

//marks = new int[];//COMPILER ERROR! Size of an array is mandatory to create an array.


//Declaring 2D Array Examples:
int[][] matrix1; //Recommended
int[] matrix2[]; //Legal but not readable. Avoid.

//Access 10th element when array has only length 5
//Runtime Exception: ArrayIndexOutOfBoundsException
//System.out.println(marks[10]);

//Array can contain only values of same type.

//COMPILE ERROR!!
//int marks4[] = {10,15.0}; //10 is int 15.0 is float

//Cross assigment of primitive arrays is ILLEGAL
int[] ints = new int[5];
short[] shorts = new short[5];
//ints = shorts;//COMPILER ERROR
//ints = (int[])shorts;//COMPILER ERROR


//The first dimension of a 2D array is mandatory
matrixA = new int[3][];//FINE
//matrixA = new int[][5];//COMPILER ERROR
//matrixA = new int[][];//COMPILER ERROR

//Each row in a 2D Array can have a different size. This is called a Ragged Array.
matrixA = new int[3][];//FINE
matrixA[0] = new int[3];
matrixA[0] = new int[4];
matrixA[0] = new int[5];

if(true){
    System.out.println("Will be printed");
}

if(false){
    System.out.println("Will NOT be printed");//Not executed
}

//Example 1
int x = 5;

if(x==5){
    System.out.println("x is 5");//executed since x==5 is true
}

//Example 2
x = 6;
if(x==5){
    System.out.println("x is 5");//Not executed since x==5 is false
}

//Example 3
int y = 10;

if(y==10){
    System.out.println("Y is 10");//executed-condn y==10 is true
} else {
    System.out.println("Y is Not 10");
}

//Example 4
y = 11;

if(y==10){
    System.out.println("Y is 10");//NOT executed
} else {
    System.out.println("Y is Not 10");//executed
}

//Example 5
int z = 15;
//Only one condition is executed. Rest of the conditions are skipped.
if(z==10){
    System.out.println("Z is 10");//NOT executed
} else if(z==12){
    System.out.println("Z is 12");//NOT executed
} else if(z==15){
    System.out.println("Z is 15");//executed. 
} else {
    System.out.println("Z is Something Else.");//NOT executed
}

z = 18;
if(z==10){
    System.out.println("Z is 10");//NOT executed
} else if(z==12){
    System.out.println("Z is 12");//NOT executed
} else if(z==15){
    System.out.println("Z is 15");//NOT executed
} else {
    System.out.println("Z is Something Else.");//executed
}

//If else Example: without Blocks
int number = 5;
if(number < 0) 
    number = number   10; //Not executed
    number  ; //This statement is not part of if. Executed.
System.out.println(number);//prints 6

//Puzzle 1
int k = 15;
if (k > 20) {
    System.out.println(1);
} else if (k > 10) {
    System.out.println(2);
} else if (k < 20) {
    System.out.println(3);
} else {
    System.out.println(4);
}

//Output is 2. 
//Once a condition in nested-if-else is true the rest of the code is not executed.  


//Puzzle 2
int l = 15;

if(l<20)
    System.out.println("l<20");
if(l>20)
    System.out.println("l>20");
else
    System.out.println("Who am I?");

Puzzle 3

Puzzles Continued

### Switch Statement
- Choose between a set of options.
- From Java 6, String can be used as the switch argument.

Important Tips
- There is a break statement in every case. If there is no break statement, switch continues to execute other cases.
- There is a case named default.  If none of the cases match default case is executed.

Output of above switch

Since there is no break after case 2, execution falls through to case 3. There is no break in case 3 as well. So, execution falls through to default. 

> Code in switch is executed from a matching case until a break or end of switch statement is encountered.


Switch Statement Example 3 , Few Break's

Program Output 

Case 2 matches. Since there is no code in case 2, execution falls through to case 3, executes the println. Break statement takes execution out of the switch.

Switch Statement Example 4 , Let's Default
- default is executed if none of the case's match. 

Code Output

Switch Statement Example 5 - Default need not be Last 

Output 

#### Switch statement Example 6

>TODO Check this up.. Its supports String. Does it support others as well?

Switch can be used only with char, byte, short, int or enum

number = 10;
switch (number) {
//case number>5://COMPILER ERROR. Cannot have a condition
//case number://COMPILER ERROR. Should be constant.
}    

int count = 0;

while(count < 5){//while this condn is true, loop is executed.
    System.out.print(count);
    count  ;
}
//Output - 01234

count = 5;
while(count < 5){//condn is false. So, code in while is not executed.
    System.out.print(count);
    count  ;
}//Nothing is printed to output

int count = 0;
do{
    System.out.print(count);
    count  ;
}while(count < 5);//while this condn is true, loop is executed.
//output is 01234

count = 5;
do{
    System.out.print(count);
    count  ;
}while(count < 5);
//output is 5

for (int i = 0; i < 10; i  ) {
    System.out.print(i);
}
//Output - 0123456789

for (int i = 0,j = 0; i < 10; i  ,j--) {
    System.out.print(j);
}
//Output - 0123456789

int[] numbers = {1,2,3,4,5};

for(int number:numbers){
    System.out.print(number);
}
//Output - 12345

for (;;) {
    System.out.print("I will be looping for ever..");
}
//Infinite loop => Loop executes until the program is terminated.

for (int i = 0; i < 10; i  ) {
    System.out.print(i);
    if (i == 5) {
         break;
    }
}
//Output - 012345
//Even though the for loop runs from 0 to 10, execution stops at i==5 because of the break statement. ÒBreak statementÓ stops the execution of the loop and takes execution to the first statement after the loop.

int i = 0;
while (i < 10) {
    System.out.print(i);
    if (i == 5) {
break;
    }
    i  ;
}
//Output - 012345

outer:
    for (int j = 0; j < 2; j  ) {
       for (int k = 0; k < 10; k  ) {
             System.out.print(j   ""   k);
             if (k == 5) {
               break outer;//Takes out of loop using j
             }
        }
    }
//Output - 000102030405

for (int i = 0; i < 10; i  ) {
    if (i == 5) {
      continue;
    }
    System.out.print(i);
}

//Output => 012346789

//Note that the output does not contain 5. 
//When i==5 continue is executed. Continue skips rest of the code and goes to next loop iteration. 
//So, the print statement is not executed when i==5.

int i = 0;
while (i < 10) {
    i  ;
    if (i == 5) {
        continue;
    }
    System.out.print(i);
}
//Output - 1234678910

for (int j = 0; j < 2; j  ) {
    for (int k = 0; k < 10; k  ) {
       if (k == 5) {
          continue;//skips to next iteration of k loop
        }
        System.out.print(j   ""   k);
    }
}
//Output - 000102030406070809101112131416171819
//When k==5 the print statement in the loop is skipped due to continue. 
//So 05 and 05 are not printed to the console.

outer:
    for (int j = 0; j < 2; j  ) {
		for (int k = 0; k < 10; k  ) {
    		if (k == 5) {
				continue outer;//skips to next iteration of j loop
    		}
    		System.out.print(j   ""   k);
		}
    }
//Output - 00010203041011121314
//When k==5 is true, continue outer is called. 
//So, when value of k is 5, the loop skips to the next iteration of j. 

    enum Season {
       WINTER, SPRING, SUMMER, FALL
    };

//Enum can be declared outside a class
enum SeasonOutsideClass {
	WINTER, SPRING, SUMMER, FALL
};

public class Enum {
	// Enum can be declared inside a class
	enum Season {
		WINTER, SPRING, SUMMER, FALL
	};

	public static void main(String[] args) {
		/*
		 * //Uncommenting gives compilation error //enum cannot be created in a
		 * method enum InsideMethodNotAllowed { WINTER, SPRING, SUMMER, FALL };
		 */

		// Converting String to Enum
		Season season = Season.valueOf("FALL");

		// Converting Enum to String
		System.out.println(season.name());// FALL

		// Default ordinals of enum
		// By default java assigns ordinals in order
		System.out.println(Season.WINTER.ordinal());// 0
		System.out.println(Season.SPRING.ordinal());// 1
		System.out.println(Season.SUMMER.ordinal());// 2
		System.out.println(Season.FALL.ordinal());// 3

		// Looping an enum => We use method values
		for (Season season1 : Season.values()) {
			System.out.println(season1.name());
			// WINTER SPRING SUMMER FALL (separate lines)
		}

		// Comparing two Enums
		Season season1 = Season.FALL;
		Season season2 = Season.FALL;
		System.out.println(season1 == season2);// true
		System.out.println(season1.equals(season2));// true
	}
}

//Converting String to Enum
Season season = Season.valueOf("FALL");

//Converting Enum to String
System.out.println(season.name());//FALL

//Default ordinals of enum
// By default java assigns ordinals in order
System.out.println(Season.WINTER.ordinal());//0
System.out.println(Season.SPRING.ordinal());//1
System.out.println(Season.SUMMER.ordinal());//2
System.out.println(Season.FALL.ordinal());//3

//Looping an enum => We use method values
for (Season season1: Season.values()) {
    System.out.println(season1.name());
    //WINTER SPRING SUMMER FALL (separate lines)
}

//Comparing two Enums
Season season1 = Season.FALL;
Season season2 = Season.FALL;
System.out.println(season1 == season2);//true
System.out.println(season1.equals(season2));//true

package com.in28minutes.java.beginners.concept.examples.enums;

public class EnumAdvanced {

	// Enum with a variable,method and constructor
	enum SeasonCustomized {
		WINTER(1), SPRING(2), SUMMER(3), FALL(4);

		// variable
		private int code;

		// method
		public int getCode() {
			return code;
		}

		// Constructor-only private or (default)
		// modifiers are allowed
		SeasonCustomized(int code) {
			this.code = code;
		}

		// Getting value of enum from code
		public static SeasonCustomized valueOf(int code) {
			for (SeasonCustomized season : SeasonCustomized.values()) {
				if (season.getCode() == code)
					return season;
			}
			throw new RuntimeException("value not found");// Just for kicks
		}

		// Using switch statement on an enum
		public int getExpectedMaxTemperature() {
			switch (this) {
			case WINTER:
				return 5;
			case SPRING:
			case FALL:
				return 10;
			case SUMMER:
				return 20;
			}
			return -1;// Dummy since Java does not recognize this is possible :)
		}

	};

	public static void main(String[] args) {
		SeasonCustomized season = SeasonCustomized.WINTER;

		/*
		 * //Enum constructor cannot be invoked directly //Below line would
		 * cause COMPILER ERROR SeasonCustomized season2 = new
		 * SeasonCustomized(1);
		 */

		System.out.println(season.getCode());// 1

		System.out.println(season.getExpectedMaxTemperature());// 5

		System.out.println(SeasonCustomized.valueOf(4));// FALL

	}

}

//variable
private int code;

//method
public int getCode() {
    return code;
}

//Constructor-only private or (default) 
//modifiers are allowed
SeasonCustomized(int code) {
    this.code = code;
}

WINTER(1), SPRING(2), SUMMER(3), FALL(4);

/*//Enum constructor cannot be invoked directly
  //Below line would cause COMPILER ERROR
SeasonCustomized season2 = new SeasonCustomized(1);
*/

// Using switch statement on an enum
public int getExpectedMaxTemperature() {
	switch (this) {
	case WINTER:
		return 5;
	case SPRING:
	case FALL:
		return 10;
	case SUMMER:
		return 20;
	}
	return -1;
}

package com.in28minutes.java.beginners.concept.examples.enums;

public class EnumAdvanced2 {

	// Enum with a variable,method and constructor
	enum SeasonCustomized {
		WINTER(1) {
			public int getExpectedMaxTemperature() {
				return 5;
			}
		},
		SPRING(2), SUMMER(3) {
			public int getExpectedMaxTemperature() {
				return 20;
			}
		},
		FALL(4);

		// variable
		private int code;

		// method
		public int getCode() {
			return code;
		}

		// Constructor-only private or (default)
		// modifiers are allowed
		SeasonCustomized(int code) {
			this.code = code;
		}

		public int getExpectedMaxTemperature() {
			return 10;
		}

	};

	public static void main(String[] args) {
		SeasonCustomized season = SeasonCustomized.WINTER;

		System.out.println(season.getExpectedMaxTemperature());// 5

		System.out.println(SeasonCustomized.FALL.getExpectedMaxTemperature());// 10

	}

}

WINTER(1) {
    public int getExpectedMaxTemperature() {
         return 5;
    }
}

String str = "Testing";
System.out.println(str.toString());
System.out.println(str.hashCode());
System.out.println(str.clone());

if(str instanceof Object){
    System.out.println("I extend Object");//Will be printed
}

public class Actor {
    public void act(){
        System.out.println("Act");
    };
}

//IS-A relationship. Hero is-a Actor
public class Hero extends Actor {
    public void fight(){
       System.out.println("fight");
    };
}

Hero hero = new Hero();
//act method inherited from Actor
hero.act();//Act
hero.fight();//fight

//IS-A relationship. Comedian is-a Actor
public class Comedian extends Actor {
    public void performComedy(){
       System.out.println("Comedy");
    };
}

Comedian comedian = new Comedian();
//act method inherited from Actor
comedian.act();//Act
comedian.performComedy();//Comedy

Actor actor1 = new Comedian();
Actor actor2 = new Hero();

//Object is super class of all java classes
Object object = new Hero(); 

class Dog extends Animal, Pet { //COMPILER ERROR
}

class Pet extends Animal {
}

class Dog extends Pet {
}

public class Animal {
    public String shout() {
        return "Don't Know!";
    }
}

class Cat extends Animal {
    public String shout() {
        return "Meow Meow";
    }
}

class Dog extends Animal {
    public String shout() {
        return "BOW BOW";
    }

    public void run(){

    }
}

Animal animal1 = new Animal();
System.out.println(animal1.shout()); //Don't Know!

Animal animal2 = new Dog();//Animal reference used to store Dog object

//Reference variable type => Animal
//Object referred to => Dog
//Dog's bark method is called.
System.out.println(animal2.shout()); //BOW BOW

//Cannot invoke sub class method with super class reference variable.
//animal2.run();//COMPILE ERROR

class SuperClass {
};

class SubClass extends SuperClass {
};

interface Interface {
};

class SuperClassImplementingInteface implements Interface {
};

class SubClass2 extends SuperClassImplementingInteface {
};

class SomeOtherClass {
};

SubClass subClass = new SubClass();
Object subClassObj = new SubClass();

SubClass2 subClass2 = new SubClass2();
SomeOtherClass someOtherClass = new SomeOtherClass();

//We can run instanceof operator on the different instances created earlier.
System.out.println(subClass instanceof SubClass);//true
System.out.println(subClass instanceof SuperClass);//true
System.out.println(subClassObj instanceof SuperClass);//true

System.out.println(subClass2 instanceof SuperClassImplementingInteface);//true

//instanceof can be used with interfaces as well. 
//Since Super Class implements the interface, below code prints true.
System.out.println(subClass2 
instanceof Interface);//true

//If the type compared is unrelated to the object, a compilation error occurs.
//System.out.println(subClass 
//    instanceof SomeOtherClass);//Compiler Error

//Object referred by subClassObj(SubClass)- NOT of type SomeOtherClass
System.out.println(subClassObj instanceof SomeOtherClass);//false

package com.in28minutes;

public class CricketScorer {
    //Instance Variables - constitute the state of an object
    private int score;

    //Behavior - all the methods that are part of the class
    //An object of this type has behavior based on the 
    //methods four, six and getScore
    public void four(){
score = score   4;
    }
    
    public void six(){
score = score   6;
    }
    
    public int getScore() {
return score;
    }
    
    public static void main(String[] args) {
CricketScorer scorer = new CricketScorer();
scorer.six();
//State of scorer is (score => 6)
scorer.four();
//State of scorer is (score => 10)
System.out.println(scorer.getScore());
    }
}

scorer.six();
//State of scorer is (score => 6)

scorer.four();
//State of scorer is (score => 10)

class Animal {

    public Animal(String name, String type) {
      this.name = name;
      this.type = type;
    }

    String name;
    String type;

}



Animal animal = new Animal("Tommy", "Dog");

//Output does not show the content of animal (what name? and what type?).
System.out.println(animal);//com.in28minutes.Animal@f7e6a96

To show the content of the animal object, we can override the default implementation of toString method provided by Object class.

//Adding toString to Animal class
class Animal {
    
    public Animal(String name, String type) {
        this.name = name;
        this.type = type;
    }

    String name;
    String type;

    public String toString() {
        return "Animal [name="   name   ", type="   type   "]";
    }

}

Animal animal = new Animal("Tommy","Dog");

//Output now shows the content of the animal object. 
System.out.println(animal);//Animal [name=Tommy, type=Dog]

class Client {
    private int id;

    public Client(int id) {
      this.id = id;
    }

    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result   id;
      return result;
    }
}

// == comparison operator checks if the object references are pointing to the same object. 
// It does NOT look at the content of the object.
Client client1 = new Client(25);
Client client2 = new Client(25);
Client client3 = client1;

//client1 and client2 are pointing to different client objects.
System.out.println(client1 == client2);//false

//client3 and client1 refer to the same client objects.
System.out.println(client1 == client3);//true

//similar output to ==
System.out.println(client1.equals(client2));//false
System.out.println(client1.equals(client3));//true

//overriding equals method
class Client {
    private int id;

    public Client(int id) {
      this.id = id;
    }

    @Override
    public boolean equals(Object obj) {
      Client other = (Client) obj;
      if (id != other.id)
          return false;
      return true;
    }
}

Client client1 = new Client(25);
Client client2 = new Client(25);
Client client3 = client1;

//both id's are 25
System.out.println(client1.equals(client2));//true

//both id's are 25
System.out.println(client1.equals(client3));//true

//Client class
@Override
public boolean equals(Object obj) {
    if (this == obj)
return true;
    if (obj == null)
return false;
    if (getClass() != obj.getClass())
return false;
    Client other = (Client) obj;
    if (id != other.id)
return false;
    return true;
}

//Client class
@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result   id;
    return result;
}

public abstract class AbstractClassExample {
    public static void main(String[] args) {
      //An abstract class cannot be instantiated
      //Below line gives compilation error if uncommented
      //AbstractClassExample ex = new AbstractClassExample();
    }
}

//Abstract class can contain instance and static variables

public abstract class AbstractClassExample {
    
    //Abstract class can contain instance and static variables
    public int publicVariable;
    private int privateVariable;
    static int staticVariable;

}

//An Abstract method does not contain body.
//Abstract Class can contain 0 or more abstract methods
//Abstract method does not have a body
abstract void abstractMethod1();
abstract void abstractMethod2();

//Abstract method can be declared only in Abstract Class. 
class NormalClass{
    abstract void abstractMethod();//COMPILER ERROR
}

// Abstract class can contain fully defined non-abstract methods. 
public abstract class AbstractClassExample {
    
    //Abstract class can contain instance and static variables
    public int publicVariable;
    private int privateVariable;
    static int staticVariable;
    
    //Abstract Class can contain 0 or more abstract methods
    //Abstract method does not have a body
    abstract void abstractMethod1();
    abstract void abstractMethod2();
    
    //Abstract Class can contain 0 or more non-abstract methods
    public void nonAbstractMethod(){
      System.out.println("Non Abstract Method");
    }    
    
    public static void main(String[] args) {
      //An abstract class cannot be instantiated
      //Below line gives compilation error if uncommented
      //AbstractClassExample ex = new AbstractClassExample();
    }
}

//Extending an abstract class
class SubClass2 extends AbstractClassExample {
    void abstractMethod1() {
      System.out.println("Abstract Method1");
    }

    void abstractMethod2() {
      System.out.println("Abstract Method2");
    }
}

// A concrete sub class should implement all abstract methods.
// Below class gives compilation error if uncommented
/*
class SubClass extends AbstractClassExample {
    
}
*/

//An abstract sub class need not implement all abstract methods.
abstract class AbstractSubClass extends AbstractClassExample {
    void abstractMethod1() {
      System.out.println("Abstract Method1");
    }
    //abstractMethod2 is not defined.
}

public class Animal {
    String name;

    public static void main(String[] args) {
// Compiler provides this class with a default no-argument constructor.
// This allows us to create an instance of Animal class.
Animal animal = new Animal();
    }
}

class Animal {
    String name;

    // This is called a one argument constructor.
    public Animal(String name) {
this.name = name;
    }

    public static void main(String[] args) {
// Since we provided a constructor, compiler does not
// provide a default constructor.
// Animal animal = new Animal();//COMPILER ERROR!

// The only way we can create Animal1 object is by using
Animal animal = new Animal("Tommy");
    }
}

class Animal {
    String name;

    public Animal() {
this.name = "Default Name";
    }

    // This is called a one argument constructor.
    public Animal(String name) {
this.name = name;
    }

    public static void main(String[] args) {
// Since we provided a constructor, compiler does not
// provide a default constructor.
// Animal animal = new Animal();//COMPILER ERROR!

// The only way we can create Animal1 object is by using
Animal animal = new Animal("Tommy");
    }
}

public Animal() {
    super();
    this.name = "Default Name";
}

public Animal() {
    this("Default Name");
}

public Animal() {
    this.name = "Default Name";
    //super(), if called, should always the first statement in a constructor.
    //super(); //COMPILER ERROR
}

public Animal() {
    System.out.println("Creating an Animal");
    //this(string), if called, should always the first statement in a constructor.
    //this("Default Name");//COMPILER ERROR
}

public Animal() {
    //member variable cannot be used in a constructor call
    this(name);//COMPILER ERROR since name is member variable
}

class Animal {
    String name;

    public Animal() {
    }

    public method() {
Animal();// Compiler error
    }
}

class Animal {
    public Animal() {
System.out.println("Animal Constructor");
    }
}

class Dog extends Animal {
    public Dog() {
System.out.println("Dog Constructor");
    }
}

class Labrador extends Dog {
    public Labrador() {
System.out.println("Labrador Constructor");
    }
}

public class ConstructorExamples {
    public static void main(String[] args) {
Labrador labrador = new Labrador();
    }
}
//Output - Animal Constructor
Dog Constructor
Labrador Constructor

class Animal {
    public Animal() {
super();// IMPLICIT CALL
System.out.println("Animal Constructor");
    }
}

class Dog extends Animal {
    public Dog() {
super();// IMPLICIT CALL
System.out.println("Dog Constructor");
    }
}

class Labrador extends Dog {
    public Labrador() {
super();// IMPLICIT CALL
System.out.println("Labrador Constructor");
    }
}

class Animal {
    String name;

    public Animal(String name) {
this.name = name;
System.out.println("Animal Constructor");
    }
}

class Dog extends Animal {
    public Dog() { // COMPILER ERROR! No constructor for Animal()
System.out.println("Dog Constructor");
    }
}

class Animal {
    String name;

    public Animal(String name) {
this.name = name;
System.out.println("Animal Constructor");
    }
}

class Dog extends Animal {// COMPILER ERROR! No constructor for Animal()
}

class Animal {
    String name;

    public Animal() {
    }

    public Animal(String name) {
this.name = name;
System.out.println("Animal Constructor");
    }
}

class Dog extends Animal {
    public Dog() { // COMPILER ERROR! No constructor for Animal()
super("Default Dog Name");
System.out.println("Dog Constructor");
    }
}

class Animal {
    String name;

    public Animal(String name) {
this.name = name;
System.out.println("Animal Constructor with name");
    }
}

class Dog extends Animal {
}

public class ConstructorExamples {
    public static void main(String[] args) {
// Dog dog = new Dog("Terry");//COMPILER ERROR
    }
}

class Dog extends Animal {
    public Dog() {
super("Default Dog Name");
    }
}

class ShoppingCartEntry {
    public float price;
    public int quantity;
}

class ShoppingCart {
    public ShoppingCartEntry[] items;
}

class Order {
    private ShoppingCart cart;
    private float salesTax;

    public Order(ShoppingCart cart, float salesTax) {
this.cart = cart;
this.salesTax = salesTax;
    }

    // This method know the internal details of ShoppingCartEntry and
    // ShoppingCart classes. If there is any change in any of those
    // classes, this method also needs to change.
    public float orderTotalPrice() {
float cartTotalPrice = 0;
for (int i = 0; i < cart.items.length; i  ) {
    cartTotalPrice  = cart.items[i].price
    * cart.items[i].quantity;
}
cartTotalPrice  = cartTotalPrice * salesTax;
return cartTotalPrice;
    }
}

class ShoppingCartEntry
{
    float price;
    int quantity;

    public float getTotalPrice()
    {
return price * quantity;
    }
}

class CartContents
{
    ShoppingCartEntry[] items;

    public float getTotalPrice()
    {
float totalPrice = 0;
for (ShoppingCartEntry item:items)
{
    totalPrice  = item.getTotalPrice();
}
return totalPrice;
    }
}

class Order
{
    private CartContents cart;
    private float salesTax;

    public Order(CartContents cart, float salesTax)
    {
this.cart = cart;
this.salesTax = salesTax;
    }

    public float totalPrice()
    {
return cart.getTotalPrice() * (1.0f   salesTax);
    }
}

class DownloadAndStore{
    void downloadFromInternet(){
    }
    
    void parseData(){
    }
    
    void storeIntoDatabase(){
    }
    
    void doEverything(){
downloadFromInternet();
parseData();
storeIntoDatabase();
    }
}

class InternetDownloader {
    public void downloadFromInternet() {
    }
}

class DataParser {
    public void parseData() {
    }
}

class DatabaseStorer {
    public void storeIntoDatabase() {
    }
}

class DownloadAndStore {
    void doEverything() {
new InternetDownloader().downloadFromInternet();
new DataParser().parseData();
new DatabaseStorer().storeIntoDatabase();
    }
}

public class CricketScorer {
    public int score;
}

public static void main(String[] args) {
CricketScorer scorer = new CricketScorer();
scorer.score = scorer.score   4;
}

public class CricketScorer {
    private int score;

    public int getScore() {
return score;
    }

    public void setScore(int score) {
this.score = score;
    }
}

public static void main(String[] args) {
CricketScorer scorer = new CricketScorer();

int score = scorer.getScore();
scorer.setScore(score   4);
}

public class CricketScorer {
    private int score;
    
    public void four() {
score  = 4;
    }

}

public static void main(String[] args) {
  CricketScorer scorer = new CricketScorer();
  scorer.four();
}

//public abstract are not necessary
public abstract interface Flyable {
    //public abstract are not necessary
    public abstract void fly();
}

public class Aeroplane implements Flyable{
    @Override
    public void fly() {
System.out.println("Aeroplane is flying");
    }
}

public class Bird implements Flyable{
    @Override
    public void fly() {
System.out.println("Bird is flying");
    }
}

Bird bird = new Bird();
bird.fly();//Bird is flying

Aeroplane aeroplane = new Aeroplane();
aeroplane.fly();//Aeroplane is flying

Flyable flyable1 = new Bird();
Flyable flyable2 = new Aeroplane();

interface ExampleInterface1 {
    //By default - public static final. No other modifier allowed
    //value1,value2,value3,value4 all are - public static final
    int value1 = 10;
    public int value2 = 15;
    public static int value3 = 20;
    public static final int value4 = 25;
    //private int value5 = 10;//COMPILER ERROR
}

interface ExampleInterface1 {
    //By default - public abstract. No other modifier allowed
    void method1();//method1 is public and abstract
    //private void method6();//COMPILER ERROR!
    
    /*//Interface cannot have body (definition) of a method
      //This method, uncommented, gives COMPILER ERROR!
    void method5() {
System.out.println("Method5");
    }
     */
}

interface SubInterface1 extends ExampleInterface1{
    void method3();
}

/* //COMPILE ERROR IF UnCommented
   //Interface cannot extend a Class
interface SubInterface2 extends Integer{
    void method3();
}
*/

interface ExampleInterface2 {
    void method2();
}

class SampleImpl implements ExampleInterface1,ExampleInterface2{
    /* A class should implement all the methods in an interface.
       If either of method1 or method2 is commented, it would 
       result in compilation error. 
     */
    public void method2() {
System.out.println("Sample Implementation for Method2");
    }

    public void method1() {
System.out.println("Sample Implementation for Method1");
    }
    
}

class Foo{
    public void doIt(int number){

    }
    public void doIt(String string){

    }
}

class Bar extends Foo{
    public void doIt(float number){

    }
}

public class Animal {
    public String bark() {
return "Don't Know!";
    }
}

class Cat extends Animal {
    public String bark() {
return "Meow Meow";
    }
}

class SuperClass{
    public void publicMethod(){

    }
}

class SubClass{
    //Cannot reduce visibility of SuperClass Method
    //So, only option is public
    public void publicMethod() {

    }    
}

class SuperClass{
    void defaultMethod(){

    }
}

class SubClass{
    //Can be overridden with public,(default) or protected
    //private would give COMPILE ERROR!
    public void defaultMethod(){

    }
    
}

class SuperClass{
    public void publicMethod() throws FileNotFoundException{

    }
}

class SubClass{
    //Cannot throw bigger exceptions than Super Class
    public void publicMethod() /*throws IOException*/ {

    }
}

class Animal{
    public void bark(){
System.out.println("Animal Bark");
    }
}

class Dog extends Animal{
    public void bark(){
System.out.println("Dog Bark");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {

Animal[] animals = {new Dog(),new Animal()};

animals[0].bark();//Dog bark
animals[1].bark();//Animal bark
    }

}

public class PublicClass{
    
}

class DefaultClass{
    
}

protected class Error{//COMPILER ERROR
    
}

private class Error{//COMPILER ERROR
    
}

/* No public before class. So this class has default access*/
class DefaultAccessClass {
//Default access is also called package access    
}

package com.in28minutes.classmodifiers.defaultaccess.a;

public class AnotherClassInSamePackage {
    //DefaultAccessClass and AnotherClassInSamePackage 
    //are in same package.
    //So, DefaultAccessClass is visible.
    //An instance of the class can be created.    
    DefaultAccessClass defaultAccess;
}

package com.in28minutes.classmodifiers.defaultaccess.b;

public class ClassInDifferentPackage {
    //Class DefaultAccessClass and Class ClassInDifferentPackage
    //are in different packages (*.a and *.b)
    //So, DefaultAccessClass is not visible to ClassInDifferentPackage
    
    //Below line of code will cause compilation error if uncommented
    //DefaultAccessClass defaultAccess; //COMPILE ERROR!!    
}

ExampleClass example = new ExampleClass();

example.publicVariable = 5;
example.publicMethod();

public class SubClass extends ExampleClass {    
    void subClassMethod(){
publicVariable = 5;
protectedVariable = 5;
    }    
}

package com.in28minutes.membermodifiers.access;

public class ExampleClass {
    int defaultVariable;
    public int publicVariable;
    private int privateVariable;
    protected int protectedVariable;
    
    void defaultMethod(){

    }
    
    public void publicMethod(){

    }
    
    private void privateMethod(){

    }
    
    protected void protectedMethod(){

    }
}

package com.in28minutes.membermodifiers.access;

public class TestClassInSamePackage {
    public static void main(String[] args) {
ExampleClass example = new ExampleClass();

example.publicVariable = 5;
example.publicMethod();

//privateVariable is not visible
//Below Line, uncommented, would give compiler error
//example.privateVariable=5; //COMPILE ERROR
//example.privateMethod();

example.protectedVariable = 5;
example.protectedMethod();

example.defaultVariable = 5;
example.defaultMethod();
    }
}

package com.in28minutes.membermodifiers.access.different;

import com.in28minutes.membermodifiers.access.ExampleClass;

public class TestClassInDifferentPackage {
    public static void main(String[] args) {
ExampleClass example = new ExampleClass();

example.publicVariable = 5;
example.publicMethod();

//privateVariable,privateMethod are not visible
//Below Lines, uncommented, would give compiler error
//example.privateVariable=5; //COMPILE ERROR
//example.privateMethod();//COMPILE ERROR

//protectedVariable,protectedMethod are not visible
//Below Lines, uncommented, would give compiler error
//example.protectedVariable = 5; //COMPILE ERROR
//example.protectedMethod();//COMPILE ERROR

//defaultVariable,defaultMethod are not visible
//Below Lines, uncommented, would give compiler error
//example.defaultVariable = 5;//COMPILE ERROR
//example.defaultMethod();//COMPILE ERROR
    }
}

package com.in28minutes.membermodifiers.access;

public class SubClassInSamePackage extends ExampleClass {
    
    void subClassMethod(){
publicVariable = 5;
publicMethod();

//privateVariable is not visible to SubClass
//Below Line, uncommented, would give compiler error
//privateVariable=5; //COMPILE ERROR
//privateMethod();

protectedVariable = 5;
protectedMethod();

defaultVariable = 5;
defaultMethod();
    }    
}

package com.in28minutes.membermodifiers.access.different;

import com.in28minutes.membermodifiers.access.ExampleClass;

public class SubClassInDifferentPackage extends ExampleClass {
    
    void subClassMethod(){
publicVariable = 5;
publicMethod();

//privateVariable is not visible to SubClass
//Below Line, uncommented, would give compiler error
//privateVariable=5; //COMPILE ERROR
//privateMethod();

protectedVariable = 5;
protectedMethod();

//privateVariable is not visible to SubClass
//Below Line, uncommented, would give compiler error
//defaultVariable = 5; //COMPILE ERROR
//defaultMethod();
    }    
}

final public class FinalClass {
}

/*
class ExtendingFinalClass extends FinalClass{ //COMPILER ERROR
    
}
*/

public class FinalMemberModifiersExample {
    final void finalMethod(){
    }
}

class SubClass extends FinalMemberModifiersExample {
    //final method cannot be over-riddent
    //Below method, uncommented, causes compilation Error
    /*
    final void finalMethod(){

    }
    */
}

final int finalValue = 5;
//finalValue = 10; //COMPILER ERROR

void testMethod(final int finalArgument){
    //final argument cannot be modified
    //Below line, uncommented, causes compilation Error
    //finalArgument = 5;//COMPILER ERROR
}

public class Cricketer {
    private static int count;

    public Cricketer() {
count  ;
    }

    static int getCount() {
return count;
    }

    public static void main(String[] args) {

Cricketer cricketer1 = new Cricketer();
Cricketer cricketer2 = new Cricketer();
Cricketer cricketer3 = new Cricketer();
Cricketer cricketer4 = new Cricketer();

System.out.println(Cricketer.getCount());//4
    }
}

public class StaticModifierExamples {
    private static int staticVariable;
    private int instanceVariable;

    public static void staticMethod() {
//instance variables are not accessible in static methods
//instanceVariable = 10; //COMPILER ERROR

//Also, this Keyword is not accessible. this refers to object.
//static methods are class methods

//static variables are accessible in static methods
staticVariable = 10;
    }

    public void instanceMethod() {
//static and instance variables are accessible in instance methods
instanceVariable = 10;
staticVariable = 10;
    }

    public static void main(String[] args) {
//static int i =5; //COMPILER ERROR
StaticModifierExamples example = new StaticModifierExamples();

//instance variables and methods are only accessible through object references
example.instanceVariable = 10;
example.instanceMethod();
//StaticModifierExamples.instanceVariable = 10;//COMPILER ERROR
//StaticModifierExamples.instanceMethod();//COMPILER ERROR

//static variables and methods are accessible through object references and Class Name.
example.staticVariable = 10;
example.staticMethod();
StaticModifierExamples.staticVariable = 10;
StaticModifierExamples.staticMethod();

    }
}

    public static void staticMethod() {
//instance variables are not accessible in static methods
//instanceVariable = 10; //COMPILER ERROR

//Also, this Keyword is not accessible. this refers to object.
//static methods are class methods

//static variables are accessible in static methods
staticVariable = 10;
    }

    public void instanceMethod() {
instanceVariable = 10;
staticVariable = 10;
    }

example.instanceVariable = 10;
example.instanceMethod();
//StaticModifierExamples.instanceVariable = 10;//COMPILER ERROR
//StaticModifierExamples.instanceMethod();//COMPILER ERROR

example.staticVariable = 10;
example.staticMethod();
StaticModifierExamples.staticVariable = 10;
StaticModifierExamples.staticMethod();

class Animal{
    static void StaticMethod(){
System.out.println("Animal Static Method");
    }
}

class Dog extends Animal{
    static void StaticMethod(){
System.out.println("Dog Static Method");
    }
}

Animal animal = new Dog();
animal.StaticMethod();//Animal Static Method

public static void main(String[] args) {
    //static int i =5; //COMPILER ERROR
}

/* Comments Anywhere*/
package com.in28minutes.classcontent;
class DefaultClass1{
	
}
/* Comments Anywhere*/
class DefaultClass2{
	
}
/* Comments Anywhere*/
public class PublicClass1 {
}

/* Cannot have another Public Class. 
public class PublicClass2 {
}
*/

class OuterClass {

    public class InnerClass {
    }

    public static class StaticNestedClass {
    }

    public void exampleMethod() {
class MethodLocalInnerClass {
};
    }

}

class OuterClass {
    private int outerClassInstanceVariable;

    public class InnerClass {
private int innerClassVariable;

public int getInnerClassVariable() {
    return innerClassVariable;
}

public void setInnerClassVariable(
int innerClassVariable) {
    this.innerClassVariable = innerClassVariable;
}

public void privateVariablesOfOuterClassAreAvailable() {
    outerClassInstanceVariable = 5; // we can access the value
    System.out.println("Inner class ref is "   this); 
    
    //Accessing outer class reference variable
    System.out.println("Outer class ref is "   OuterClass.this);
}
    }

    public void createInnerClass(){
//Just use the inner class name to create it
InnerClass inner = new InnerClass();
    }
    
}

public class InnerClassExamples {
    public static void main(String[] args) {

// COMPILER ERROR! You cannot create an inner class on its own.
// InnerClass innerClass = new InnerClass();
OuterClass example = new OuterClass();

// To create an Inner Class you need an instance of Outer Class
OuterClass.InnerClass innerClass = example.new InnerClass();

    }
}

// InnerClass innerClass = new InnerClass(); //Compiler Error

OuterClass example = new OuterClass();
OuterClass.InnerClass innerClass = example.new InnerClass();

public void createInnerClass(){
    //Just use the inner class name to create it
    InnerClass inner = new InnerClass();
}

public void privateVariablesOfOuterClassAreAvailable() {
    outerClassInstanceVariable = 5; // we can access the value
    System.out.println("Inner class ref is "   this); 
    
    //Accessing outer class reference variable
    System.out.println("Outer class ref is "   OuterClass.this);
}

class OuterClass {
    private int outerClassInstanceVariable;

    public static class StaticNestedClass {
private int staticNestedClassVariable;

public int getStaticNestedClassVariable() {
    return staticNestedClassVariable;
}

public void setStaticNestedClassVariable(
int staticNestedClassVariable) {
    this.staticNestedClassVariable = staticNestedClassVariable;
}

public void privateVariablesOfOuterClassAreNOTAvailable() {
    // outerClassInstanceVariable = 5; //COMPILE ERROR
}
    }

}

public class InnerClassExamples {
    public static void main(String[] args) {
// Static Nested Class can be created without needing to create its
// parent. Without creating NestedClassesExample, we created
// StaticNestedClass
OuterClass.StaticNestedClass staticNestedClass1 = new OuterClass.StaticNestedClass();
staticNestedClass1.setStaticNestedClassVariable(5);

OuterClass.StaticNestedClass staticNestedClass2 = new OuterClass.StaticNestedClass();
staticNestedClass2.setStaticNestedClassVariable(10);

// Static Nested Class member variables are not static. They can have
// different values.
System.out.println(staticNestedClass1
.getStaticNestedClassVariable()); //5
System.out.println(staticNestedClass2
.getStaticNestedClassVariable()); //10
    }
} 

OuterClass.StaticNestedClass staticNestedClass1 = new OuterClass.StaticNestedClass();

System.out.println(staticNestedClass1
.getStaticNestedClassVariable()); //5
System.out.println(staticNestedClass2
.getStaticNestedClassVariable()); //10

public void privateVariablesOfOuterClassAreNOTAvailable() {
    // outerClassInstanceVariable = 5; //COMPILE ERROR
}

class OuterClass {
    private int outerClassInstanceVariable;

    public void exampleMethod() {
int localVariable;
final int finalVariable = 5;
class MethodLocalInnerClass {
    public void method() {
//Can access class instance variables
System.out
.println(outerClassInstanceVariable);

//Cannot access method's non-final local variables
//localVariable = 5;//Compiler Error
System.out.println(finalVariable);//Final variable is fine..
    }
}

//MethodLocalInnerClass can be instantiated only in this method
MethodLocalInnerClass m1 = new MethodLocalInnerClass();
m1.method();
    }

    //MethodLocalInnerClass can be instantiated only in the method where it is declared
    //MethodLocalInnerClass m1 = new MethodLocalInnerClass();//COMPILER ERROR

}

//Can access class instance variables
System.out.println(outerClassInstanceVariable);

//Cannot access method's non-final local variables
//localVariable = 5;//Compiler Error
System.out.println(finalVariable);//Final variable is fine..

    //int(type) followed ... (three dot's) is syntax of a variable argument. 
    public int sum(int... numbers) {
//inside the method a variable argument is similar to an array.
//number can be treated as if it is declared as int[] numbers;
int sum = 0;
for (int number: numbers) {
    sum  = number;
}
return sum;
    }

    public static void main(String[] args) {
VariableArgumentExamples example = new VariableArgumentExamples();
//3 Arguments
System.out.println(example.sum(1, 4, 5));//10
//4 Arguments
System.out.println(example.sum(1, 4, 5, 20));//30
//0 Arguments
System.out.println(example.sum());//0
    }

public int sum(int... numbers) {

    public int sum(int... numbers) {
int sum = 0;
for (int number: numbers) {
    sum  = number;
}
return sum;
    }

    public int sum(int... numbers, float value) {//COMPILER ERROR
    }

    class Animal {
void bark() {
    System.out.println("Bark");
}
void bark(Animal... animals) {
    for (Animal animal: animals) {
animal.bark();
    }
}
    }

    public static void main(String[] args) {
String str = null;
str.toString();
    }

Exception in thread "main" java.lang.NullPointerException at
com.in28minutes.exceptionhandling.ExceptionHandlingExample1.main(ExceptionHandlingExample1.java:6)

    public static void main(String[] args) {
method1();
    }

    private static void method1() {
method2();
    }

    private static void method2() {
String str = null;
str.toString();
    }
//Output - Exception in thread "main" java.lang.NullPointerException at
com.in28minutes.exceptionhandling.ExceptionHandlingExample1.method2(ExceptionHandlingExample1.java:15)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.method1(ExceptionHandlingExample1.java:10)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.main(ExceptionHandlingExample1.java:6)

    public static void main(String[] args) {
method1();
System.out.println("Line after Exception - Main");
    }

    private static void method1() {
method2();
System.out.println("Line after Exception - Method 1");
    }

    private static void method2() {
String str = null;
str.toString();
System.out.println("Line after Exception - Method 2");
    }
//Output - Exception in thread "main" java.lang.NullPointerException
at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.method2(ExceptionHandlingExample1.java:18)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.method1(ExceptionHandlingExample1.java:12)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.main(ExceptionHandlingExample1.java:7)

    public static void main(String[] args) {
method1();
System.out.println("Line after Exception - Main");
    }

    private static void method1() {
method2();
System.out.println("Line after Exception - Method 1");
    }

    private static void method2() {
try {
    String str = null;
    str.toString();
    System.out.println("Line after Exception - Method 2");
} catch (Exception e) {
    // NOT PRINTING EXCEPTION TRACE- BAD PRACTICE
    System.out.println("Exception Handled - Method 2");
}
    }

Exception Handled - Method 2
Line after Exception - Method 1
Line after Exception - Main

package com.in28minutes.exceptionhandling;

class Connection {
    void open() {
System.out.println("Connection Opened");
    }

    void close() {
System.out.println("Connection Closed");
    }
}

public class ExceptionHandlingExample1 {

    // Exception Handling Example 1
    // Let's add a try catch block in method2
    public static void main(String[] args) {
method1();
System.out.println("Line after Exception - Main");
    }

    private static void method1() {
method2();
System.out.println("Line after Exception - Method 1");
    }

    private static void method2() {
try {
    Connection connection = new Connection();
    connection.open();

    // LOGIC
    String str = null;
    str.toString();

    connection.close();
} catch (Exception e) {
    // NOT PRINTING EXCEPTION TRACE- BAD PRACTICE
    System.out.println("Exception Handled - Method 2");
}
    }
}

Connection Opened
Exception Handled - Method 2
Line after Exception - Method 1
Line after Exception - Main

    private static void method2() {
Connection connection = new Connection();
connection.open();
try {
    // LOGIC
    String str = null;
    str.toString();

} catch (Exception e) {
    // NOT PRINTING EXCEPTION TRACE - BAD PRACTICE
    System.out.println("Exception Handled - Method 2");
} finally {
    connection.close();
}
    }

Connection Opened
Exception Handled - Method 2
Connection Closed
Line after Exception - Method 1
Line after Exception - Main

private static void method2() {
Connection connection = new Connection();
connection.open();
try {
    // LOGIC    
    String str = null;
    str.toString();
    return;
} catch (Exception e) {
    // NOT PRINTING EXCEPTION TRACE - BAD PRACTICE
    System.out.println("Exception Handled - Method 2");
    return;
} finally {
    connection.close();
}
    }

private static void method2() {
Connection connection = new Connection();
connection.open();
try {
    // LOGIC
    String str = null;
    str.toString();
} finally {
    connection.close();
}
    }

Connection Opened
Connection Closed
Exception in thread "main" java.lang.NullPointerException at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.method2(ExceptionHandlingExample1.java:33) at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.method1(ExceptionHandlingExample1.java:22) at com.in28minutes.exceptionhandling.ExceptionHandlingExample1.main(ExceptionHandlingExample1.java:17)

    private static void method2() {
Connection connection = new Connection();
connection.open();
try {
    // LOGIC
    String str = null;
    str.toString();
}//COMPILER ERROR!!
    }

//Pre-defined Java Classes
class Error extends Throwable{}
class Exception extends Throwable{}
class RuntimeException extends Exception{}

//Programmer defined classes
class CheckedException1 extends Exception{}
class CheckedException2 extends CheckedException1{}

class UnCheckedException extends RuntimeException{}
class UnCheckedException2 extends UnCheckedException{}

class Amount {
    public Amount(String currency, int amount) {
this.currency = currency;
this.amount = amount;
    }

    String currency;// Should be an Enum
    int amount;// Should ideally use BigDecimal
}

// AmountAdder class has method addAmounts which is throwing a RuntimeException
class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2) {
if (!amount1.currency.equals(amount2.currency)) {
    throw new RuntimeException("Currencies don't match");
}
return new Amount(amount1.currency, amount1.amount   amount2.amount);
    }
}

public class ExceptionHandlingExample2 {

    public static void main(String[] args) {
AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR", 5));
    }

}

Exception in thread "main" java.lang.RuntimeException: Currencies don't match
at com.in28minutes.exceptionhandling.AmountAdder.addAmounts(ExceptionHandlingExample2.java:17)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample2.main(ExceptionHandlingExample2.java:28)

class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2) {
if (!amount1.currency.equals(amount2.currency)) {
    throw new Exception("Currencies don't match");// COMPILER ERROR!// Unhandled exception type Exception
}
return new Amount(amount1.currency, amount1.amount   amount2.amount);
    }
}

class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2) throws Exception {
if (!amount1.currency.equals(amount2.currency)) {
    throw new Exception("Currencies don't match");
}
return new Amount(amount1.currency, amount1.amount   amount2.amount);
    }
}

    public static void main(String[] args) throws Exception {
AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR", 5));
    }

Exception in thread "main" java.lang.Exception: Currencies don't match
at com.in28minutes.exceptionhandling.AmountAdder.addAmounts(ExceptionHandlingExample2.java:17)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample2.main(ExceptionHandlingExample2.java:28)

public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR",5));
} catch (Exception e) {
    System.out.println("Exception Handled in Main");
}
    }

Exception Handled in Main

class CurrenciesDoNotMatchException extends Exception{
}

class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2)
    throws CurrenciesDoNotMatchException {
if (!amount1.currency.equals(amount2.currency)) {
    throw new CurrenciesDoNotMatchException();
}
return new Amount(amount1.currency, amount1.amount   amount2.amount);
    }
}

public class ExceptionHandlingExample2 {
    public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR",
    5));
} catch (CurrenciesDoNotMatchException e) {
    System.out.println("Exception Handled in Main"   e.getClass());
}
    }
}

Exception Handled in Mainclass com.in28minutes.exceptionhandling.CurrenciesDoNotMatchException

public class ExceptionHandlingExample2 {
    public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR",5));
} catch (Exception e) {
    System.out.println("Exception Handled in Main"   e.getClass());
}
    }
}

Exception Handled in Mainclass com.in28minutes.exceptionhandling.CurrenciesDoNotMatchException

class CurrenciesDoNotMatchException extends RuntimeException{
}

Exception Handled in Mainclass com.in28minutes.exceptionhandling.CurrenciesDoNotMatchException

public class ExceptionHandlingExample2 {
    public static void main(String[] args) {
AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR", 5));
    }
}

Exception in thread "main" com.in28minutes.exceptionhandling.CurrenciesDoNotMatchException at com.in28minutes.exceptionhandling.AmountAdder.addAmounts(ExceptionHandlingExample2.java:21)
at com.in28minutes.exceptionhandling.ExceptionHandlingExample2.main(ExceptionHandlingExample2.java:30)

public class ExceptionHandlingExample2 {
    public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR",
    5));
} catch (CurrenciesDoNotMatchException e) {
    System.out.println("Handled CurrenciesDoNotMatchException");
} catch (Exception e) {
    System.out.println("Handled Exception");
}
    }
}

Handled CurrenciesDoNotMatchException

    public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR",
    5));
} catch (Exception e) { // COMPILER ERROR!!
    System.out.println("Handled Exception");
} catch (CurrenciesDoNotMatchException e) {
    System.out.println("Handled CurrenciesDoNotMatchException");
}
    }

    public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("RUPEE",
    5));
    String string = null;
    string.toString();
} catch (CurrenciesDoNotMatchException e) {
    System.out.println("Handled CurrenciesDoNotMatchException");
}
    }

	//Output : Exception in thread "main" java.lang.NullPointerException at com.in28minutes.exceptionhandling.ExceptionHandlingExample2.main(ExceptionHandlingExample2.java:34)

    public static void main(String[] args) {
try {
    AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("RUPEE",
    5));
    String string = null;
    string.toString();
} catch (CurrenciesDoNotMatchException e) {
    System.out.println("Handled CurrenciesDoNotMatchException");
    e.printStackTrace();
}
    }

//Console console = new Console(); //COMPILER ERROR
Console console = System.console();

console.printf("Enter a Line of Text");

String text = console.readLine();
console.printf("Enter a Password");

char[] password = console.readPassword();

console.format("\nEntered Text is %s", text);

System.out.printf("%d", 5);//5
System.out.printf("My name is %s", "Rithu");//My name is Rithu
System.out.printf("%s is %d Years old", "Rithu", 5);//Rithu is 5 Years old

//Prints 12 using minimum 5 character spaces.
System.out.printf("|]|", 12); //prints |   12| 

//Prints 1234 using minimum 5 character spaces.
System.out.printf("|]|", 1234); //prints | 1234|
//In above example 5 is called width specifier.

//Left Justification can be done by using -
System.out.printf("|%-5d|", 12); //prints |12   |

//Using 0 pads the number with 0's
System.out.printf("d", 12); //prints 00012

//Using , format the number using comma's
System.out.printf("%,d", 12345); //prints 12,345

//Using ( prints negative numbers between ( and )
System.out.printf("%(d", -12345); //prints (12345)
System.out.printf("%(d", 12345); //prints 12345

//Using   prints   or - before the number
System.out.printf("% d", -12345); //prints -12345
System.out.printf("% d", 12345); //prints  12345

System.out.printf("%5.2f", 1234.5678); //prints 1234.57

System.out.printf("]","Test");
//Throws java.util.IllegalFormatConversionException

//To change the order of printing and passing of arguments, argument index can be used
System.out.printf("%3$.1f %2$s %1$d", 123, "Test", 123.4); //prints 123.4 Test 123

//format method has the same behavior as printf method 
System.out.format("%5.2f", 1234.5678);//prints 1234.57

StringBuffer stringbuffer = new StringBuffer("12345");
stringbuffer.append("6789");
System.out.println(stringbuffer); //123456789
//All StringBuffer methods modify the value of the object.

StringBuilder sb = new StringBuilder("0123456789");

//StringBuilder delete(int startIndex, int endIndexPlusOne)
System.out.println(sb.delete(3, 7));//012789

StringBuilder sb1 = new StringBuilder("abcdefgh");

//StringBuilder insert(int indext, String whatToInsert)
System.out.println(sb1.insert(3, "ABCD"));//abcABCDdefgh

StringBuilder sb2 = new StringBuilder("abcdefgh");
//StringBuilder reverse()
System.out.println(sb2.reverse());//hgfedcba

StringBuilder sb3 = new StringBuilder("abcdefgh");
System.out.println(sb3.reverse().delete(5, 6).insert(3, "---"));//hgf---edba

//Creating Date Object
Date now = new Date();
System.out.println(now.getTime());

Date date = new Date();

//Increase time by 6 hrs
date.setTime(date.getTime()   6 * 60 * 60 * 1000);
System.out.println(date);

//Decrease time by 6 hrs
date = new Date();
date.setTime(date.getTime() - 6 * 60 * 60 * 1000);
System.out.println(date);

//Formatting Dates
System.out.println(DateFormat.getInstance().format(
date));//10/16/12 5:18 AM

System.out.println(DateFormat.getDateInstance(
DateFormat.FULL, new Locale("it", "IT"))
.format(date));//martedÒ 16 ottobre 2012

System.out.println(DateFormat.getDateInstance(
DateFormat.FULL, Locale.ITALIAN)
.format(date));//martedÒ 16 ottobre 2012

//This uses default locale US
System.out.println(DateFormat.getDateInstance(
DateFormat.FULL).format(date));//Tuesday, October 16, 2012

System.out.println(DateFormat.getDateInstance()
.format(date));//Oct 16, 2012
System.out.println(DateFormat.getDateInstance(
DateFormat.SHORT).format(date));//10/16/12
System.out.println(DateFormat.getDateInstance(
DateFormat.MEDIUM).format(date));//Oct 16, 2012

System.out.println(DateFormat.getDateInstance(
DateFormat.LONG).format(date));//October 16, 2012

System.out.println(new SimpleDateFormat("yy-MM-dd")
.format(date));//12-10-16
System.out
.println(new SimpleDateFormat("yy-MMM-dd")
.format(date));//12-Oct-16
System.out.println(new SimpleDateFormat(
"yyyy-MM-dd").format(date));//2012-10-16

//Parse Dates using DateFormat
Date date2 = DateFormat.getDateInstance(
DateFormat.SHORT).parse("10/16/12");
System.out.println(date2);//Tue Oct 16 00:00:00 GMT 05:30 2012

//Creating Dates using SimpleDateFormat
Date date1 = new SimpleDateFormat("yy-MM-dd")
.parse("12-10-16");
System.out.println(date1);//Tue Oct 16 00:00:00 GMT 05:30 2012

Locale defaultLocale = Locale.getDefault();

System.out.println(defaultLocale
.getDisplayCountry());//United States
System.out.println(defaultLocale
.getDisplayLanguage());//English

//Calendar calendar = new Calendar(); //COMPILER ERROR
Calendar calendar = Calendar.getInstance();

calendar.set(Calendar.DATE, 24);
calendar.set(Calendar.MONTH, 8);//8 - September
calendar.set(Calendar.YEAR, 2010);

System.out.println(calendar.get(Calendar.YEAR));//2010
System.out.println(calendar.get(Calendar.MONTH));//8
System.out.println(calendar.get(Calendar.DATE));//24
System.out.println(calendar.get(Calendar.WEEK_OF_MONTH));//4
System.out.println(calendar.get(Calendar.WEEK_OF_YEAR));//39
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//267
System.out.println(calendar.getFirstDayOfWeek());//1 -> Calendar.SUNDAY

calendar.add(Calendar.DATE, 5);
System.out.println(calendar.getTime());//Wed Sep 29 2010
calendar.add(Calendar.MONTH, 1);
System.out.println(calendar.getTime());//Fri Oct 29 2010
calendar.add(Calendar.YEAR, 2);
System.out.println(calendar.getTime());//Mon Oct 29 2012

calendar.roll(Calendar.MONTH, 5);
System.out.println(calendar.getTime());//Mon Mar 29 2012

Calendar gregorianCalendar = new GregorianCalendar(
2011, 7, 15);

System.out.println(DateFormat.getInstance().format(
calendar.getTime()));//3/29/12 11:39 AM

System.out.println(NumberFormat.getInstance().format(321.24f));//321.24

System.out.println(NumberFormat.getInstance(new Locale("nl")).format(4032.3f));//4.032,3

System.out.println(NumberFormat.getInstance(Locale.GERMANY).format(4032.3f));//4.032,3

System.out.println(NumberFormat.getCurrencyInstance().format(40324.31f));//$40,324.31

Formatting a Currency using Netherlands locale
System.out.println(NumberFormat.getCurrencyInstance(new Locale("nl")).format(40324.31f));//? 40.324,31

NumberFormat numberFormat = NumberFormat.getInstance();
System.out.println(numberFormat.getMaximumFractionDigits());//3
numberFormat.setMaximumFractionDigits(5);
System.out.println(numberFormat.format(321.24532f));//321.24533

System.out.println(numberFormat.parse("9876.56"));//9876.56

numberFormat.setParseIntegerOnly(true);
System.out.println(numberFormat.parse("9876.56"));//9876

interface Collection<E> extends Iterable<E>
{
  boolean add(E paramE);
  boolean remove(Object paramObject);

  int size();
  boolean isEmpty();
  void clear();

  boolean contains(Object paramObject);
  boolean containsAll(Collection<?> paramCollection);
  
  boolean addAll(Collection<? extends E> paramCollection);
  boolean removeAll(Collection<?> paramCollection);
  boolean retainAll(Collection<?> paramCollection);
  

  Iterator<E> iterator();

  //A NUMBER OF OTHER METHODS AS WELL..
}

interface List<E> extends Collection<E>
{
  boolean addAll(int paramInt, Collection<? extends E> paramCollection);

  E get(int paramInt);
  E set(int paramInt, E paramE);

  void add(int paramInt, E paramE);
  E remove(int paramInt);

  int indexOf(Object paramObject);
  int lastIndexOf(Object paramObject);

  ListIterator<E> listIterator();
  ListIterator<E> listIterator(int paramInt);
  List<E> subList(int paramInt1, int paramInt2);
}

  V put(K paramK, V paramV);

  V get(Object paramObject);

interface Map<K, V>
{
  int size();
  boolean isEmpty();

  boolean containsKey(Object paramObject);
  boolean containsValue(Object paramObject);

  V get(Object paramObject);
  V put(K paramK, V paramV);
  V remove(Object paramObject);

  void putAll(Map<? extends K, ? extends V> paramMap);
  void clear();

  Set<K> keySet();
  Collection<V> values();
  Set<Entry<K, V>> entrySet();

  boolean equals(Object paramObject);
  int hashCode();

  public static abstract interface Entry<K, V>
  {
    K getKey();
    V getValue();
    V setValue(V paramV);
    boolean equals(Object paramObject);
    int hashCode();
  }
}

// Unique things only - Does not allow duplication.
// If obj1.equals(obj2) then only one of them can be in the Set.
interface Set<E> extends Collection<E>
{
}

public interface SortedSet<E> extends Set<E> {
    
    SortedSet<E> subSet(E fromElement, E toElement);
    SortedSet<E> headSet(E toElement);
    SortedSet<E> tailSet(E fromElement);
    
    E first();
    E last();

    Comparator<? super E> comparator();
}

public interface SortedMap<K, V> extends Map<K, V> {
    Comparator<? super K> comparator();

    SortedMap<K, V> subMap(K fromKey, K toKey);

    SortedMap<K, V> headMap(K toKey);

    SortedMap<K, V> tailMap(K fromKey);

    K firstKey();

    K lastKey();
}

interface Queue<E> extends Collection<E>
{
  boolean offer(E paramE);
  E remove();
  E poll();
  E element();
  E peek();
}

public interface Iterator<E> {
    boolean hasNext();

    E next();
}

List<Integer> integers = new ArrayList<Integer>();

integers.add(5);//new Integer(5)

List<String> arraylist = new ArrayList<String>();

//adds at the end of list
arraylist.add("Sachin");//[Sachin]

//adds at the end of list
arraylist.add("Dravid");//[Sachin, Dravid]

//adds at the index 0
arraylist.add(0, "Ganguly");//[Ganguly, Sachin, Dravid]

//List allows duplicates - Sachin is present in the list twice
arraylist.add("Sachin");//[ Ganguly, Sachin, Dravid, Sachin]

System.out.println(arraylist.size());//4
System.out.println(arraylist.contains("Dravid"));//true

Iterator<String> arraylistIterator = arraylist
.iterator();
while (arraylistIterator.hasNext()) {
    String str = arraylistIterator.next();
    System.out.println(str);//Prints the 4 names in the list on separate lines.
}

//example1 - value is present
System.out.println(arraylist.indexOf("Dravid"));//2
//example2 - value is not present
System.out.println(arraylist.indexOf("Bradman"));//-1

System.out.println(arraylist.get(1));//Sachin

//Using the object as parameter
//Dravid is removed from the list
arraylist.remove("Dravid");//[Ganguly, Sachin, Sachin]

//Using index as argument. 
//Object at index 1 (Sachin) is removed
arraylist.remove(1);//[Ganguly, Sachin]

List<String> numbers = new ArrayList<String>();
numbers.add("one");
numbers.add("two");
numbers.add("three");
numbers.add("four");
System.out.println(numbers);//[one, two, three, four]

//Strings - By Default - are sorted alphabetically
Collections.sort(numbers);

System.out.println(numbers);//[four, one, three, two]

class Cricketer{
    int runs;
    String name;

    public Cricketer(String name, int runs) {
super();
this.name = name;
this.runs = runs;
    }

    @Override
    public String toString() {
return name   " "   runs;
    }
}

List<Cricketer> cricketers = new ArrayList<Cricketer>();
cricketers.add(new Cricketer("Bradman", 9996));
cricketers.add(new Cricketer("Sachin", 14000));
cricketers.add(new Cricketer("Dravid", 12000));
cricketers.add(new Cricketer("Ponting", 11000));
System.out.println(cricketers);
//[Bradman 9996, Sachin 14000, Dravid 12000, Ponting 11000]

//Cricketer class does not implement Comparable Interface 
//Collections.sort(cricketers); //COMPILER ERROR

class Cricketer implements Comparable<Cricketer> {
    //OTHER CODE/PROGRAM same as previous

    //compareTo takes an argument of the same type of the class
    //compareTo returns -1 if this < that
    //   1 if this > that
    //   0 if this = that
    @Override
    public int compareTo(Cricketer that) {
if (this.runs > that.runs) {
    return 1;
}
if (this.runs < that.runs) {
    return -1;
}
return 0;
    }

}

Collections.sort(cricketers);
System.out.println(cricketers);
//[Bradman 9996, Ponting 11000, Dravid 12000, Sachin 14000]

class DescendingSorter implements Comparator<Cricketer> {

    //compareTo returns -1 if cricketer1 < cricketer2
    //   1 if cricketer1 > cricketer2
    //   0 if cricketer1 = cricketer2

    //Since we want to sort in descending order, 
    //we should return -1 when runs are more
    @Override
    public int compare(Cricketer cricketer1,
    Cricketer cricketer2) {
if (cricketer1.runs > cricketer2.runs) {
    return -1;
}
if (cricketer1.runs < cricketer2.runs) {
    return 1;
}
return 0;
    }

}

Collections
.sort(cricketers, new DescendingSorter());

System.out.println(cricketers);
//[Sachin 14000, Dravid 12000, Ponting 11000, Bradman 9996]

List<String> numbers1 = new ArrayList<String>();
numbers1.add("one");
numbers1.add("two");
numbers1.add("three");
numbers1.add("four");
String[] numbers1Array = new String[numbers1.size()];
numbers1Array = numbers1.toArray(numbers1Array);
System.out.println(Arrays.toString(numbers1Array));
//prints [one, two, three, four]

Object[] numbers1ObjArray = numbers1.toArray();
System.out.println(Arrays
.toString(numbers1ObjArray));
//[one, two, three, four]

String values[] = { "value1", "value2", "value3" };
List<String> valuesList = Arrays.asList(values);
System.out.println(valuesList);//[value1, value2, value3]

Set<String> hashset = new HashSet<String>();

hashset.add("Sachin");
System.out.println(hashset);//[Sachin]

hashset.add("Dravid");
System.out.println(hashset);//[Sachin, Dravid]

hashset.add("Sachin");//returns false since element is not added
System.out.println(hashset);//[Sachin, Dravid]

Set<String> treeSet = new TreeSet<String>();

treeSet.add("Sachin");
System.out.println(treeSet);//[Sachin]

//Alphabetical order
treeSet.add("Dravid");
System.out.println(treeSet);//[Dravid, Sachin]

treeSet.add("Ganguly");
System.out.println(treeSet);//[Dravid, Ganguly, Sachin]

//Sachin is Duplicate. So will not be added. returns false.
treeSet.add("Sachin");//returns false since element is not added
System.out.println(treeSet);//[Dravid, Ganguly, Sachin]

TreeSet<Integer> numbersTreeSet = new TreeSet<Integer>();
numbersTreeSet.add(55);
numbersTreeSet.add(25);
numbersTreeSet.add(35);
numbersTreeSet.add(5);
numbersTreeSet.add(45);

//Find the highest number which is lower than 25
System.out.println(numbersTreeSet.lower(25));//5

//Find the highest number which is lower than or equal to 25
System.out.println(numbersTreeSet.floor(25));//25

//Find the lowest number higher than 25
System.out.println(numbersTreeSet.higher(25));//35

//Find the lowest number higher than or equal to 25
System.out.println(numbersTreeSet.ceiling(25));//25

TreeSet<Integer> exampleTreeSet = new TreeSet<Integer>();
exampleTreeSet.add(55);
exampleTreeSet.add(25);
exampleTreeSet.add(105);
exampleTreeSet.add(35);
exampleTreeSet.add(5);

System.out.println(exampleTreeSet);//[5, 25, 35, 55, 105]

//Get sub set with values >=25 and <55
SortedSet<Integer> subTreeSet = exampleTreeSet
.subSet(25, 55);
System.out.println(subTreeSet);//[25, 35]

//Get sub set with values <55
SortedSet<Integer> headTreeSet = exampleTreeSet
.headSet(55);
System.out.println(headTreeSet);//[5, 25, 35]

//Get sub set with values >=35
SortedSet<Integer> tailTreeSet = exampleTreeSet
.tailSet(35);
System.out.println(tailTreeSet);//[35, 55, 105]
//In the sub set, Lower limit inclusive - 35 included.

//Get sub set with value >=25 and <=55 (both inclusive parameters - true)
SortedSet<Integer> subTreeSetIncl = exampleTreeSet
.subSet(25, true, 55, true);
System.out.println(subTreeSetIncl);//[25, 35, 55]

//Get sub set with value >25 and <55 (both inclusive parameters - false)
SortedSet<Integer> subTreeSetNotIncl = exampleTreeSet
.subSet(25, false, 55, false);
System.out.println(subTreeSetNotIncl);//[35]

//Get sub set with values <=55. Inclusive set to true.
SortedSet<Integer> headTreeSetIncl = exampleTreeSet
.headSet(55, true);
System.out.println(headTreeSetIncl);//[5, 25, 35, 55]

//Get sub set with values >35. Inclusive set to false.
SortedSet<Integer> tailTreeSetNotIncl = exampleTreeSet
.tailSet(35, false);
System.out.println(tailTreeSetNotIncl);//[55, 105]

System.out.println(exampleTreeSet);//[5, 25, 35, 55, 105]
System.out.println(subTreeSet);//[25, 35]
System.out.println(headTreeSet);//[5, 25, 35]
System.out.println(tailTreeSet);//[35, 55, 105]

exampleTreeSet.add(30);

System.out.println(exampleTreeSet);//[5, 25, 30, 35, 55, 105]
System.out.println(subTreeSet);//[25, 30, 35]
System.out.println(headTreeSet);//[5, 30, 25, 35]
System.out.println(tailTreeSet);//[35, 55, 105]

//Let's now add 65 to the set
exampleTreeSet.add(65);

System.out.println(exampleTreeSet);//[5, 25, 30, 35, 55, 65, 105]
System.out.println(subTreeSet);//[25, 30, 35]
System.out.println(headTreeSet);//[5, 30, 25, 35]
System.out.println(tailTreeSet);//[35, 55, 65, 105]

TreeSet<Integer> treeSetOrig = new TreeSet<Integer>();
treeSetOrig.add(55);
treeSetOrig.add(25);
treeSetOrig.add(35);
treeSetOrig.add(5);

System.out.println(treeSetOrig);//[5, 25, 35, 55]
//descendingSet method returns the tree set in reverse order
TreeSet<Integer> treeSetDesc = (TreeSet<Integer>) treeSetOrig
.descendingSet();
System.out.println(treeSetDesc);//[55, 35, 25, 5]

System.out.println(treeSetOrig);//[5, 25, 35, 55]
System.out.println(treeSetOrig.pollFirst());//5
System.out.println(treeSetOrig);//[25, 35, 55]
//In above example element 5 is removed from the set and also removed from the tree set.

System.out.println(treeSetOrig);//[25, 35, 55]
System.out.println(treeSetOrig.pollLast());//55
System.out.println(treeSetOrig);//[25, 35]

Map<String, Cricketer> hashmap = new HashMap<String, Cricketer>();
hashmap.put("sachin",
new Cricketer("Sachin", 14000));
hashmap.put("dravid",
new Cricketer("Dravid", 12000));
hashmap.put("ponting", new Cricketer("Ponting",
11500));
hashmap.put("bradman", new Cricketer("Bradman",
9996));

System.out.println(hashmap.get("ponting"));//Ponting 11500

//if key is not found, returns null.
System.out.println(hashmap.get("lara"));//null

//In the example below, an entry with key "ponting" is already present. 
//Runs are updated to 11800.
hashmap.put("ponting", new Cricketer("Ponting",
11800));

//gets the recently updated value
System.out.println(hashmap.get("ponting"));//Ponting 11800

Map<String, Cricketer> treemap = new TreeMap<String, Cricketer>();
treemap.put("sachin",
new Cricketer("Sachin", 14000));
System.out.println(treemap);
//{sachin=Sachin 14000}

treemap.put("dravid",
new Cricketer("Dravid", 12000));
System.out.println(treemap);
//{dravid=Dravid 12000, sachin=Sachin 14000}

treemap.put("ponting", new Cricketer("Ponting",
11500));
System.out.println(treemap);
//{dravid=Dravid 12000, ponting=Ponting 11500, sachin=Sachin 14000}

treemap.put("bradman", new Cricketer("Bradman",
9996));
System.out.println(treemap);
//{bradman=Bradman 9996, dravid=Dravid 12000, ponting=Ponting 11500, sachin=Sachin 14000}

TreeMap<Integer, Cricketer> numbersTreeMap = new TreeMap<Integer, Cricketer>();
numbersTreeMap.put(55, new Cricketer("Sachin",
14000));
numbersTreeMap.put(25, new Cricketer("Dravid",
12000));
numbersTreeMap.put(35, new Cricketer("Ponting",
12000));
numbersTreeMap.put(5,
new Cricketer("Bradman", 9996));
numbersTreeMap
.put(45, new Cricketer("Lara", 10000));

//Find the highest key which is lower than 25
System.out.println(numbersTreeMap.lowerKey(25));//5

//Find the highest key which is lower than or equal to 25
System.out.println(numbersTreeMap.floorKey(25));//25

//Find the lowest key higher than 25
System.out.println(numbersTreeMap.higherKey(25));//35

//Find the lowest key higher than or equal to 25
System.out.println(numbersTreeMap.ceilingKey(25));//25

TreeMap<Integer, Cricketer> exampleTreeMap = new TreeMap<Integer, Cricketer>();
exampleTreeMap.put(55, new Cricketer("Sachin",
14000));
exampleTreeMap.put(25, new Cricketer("Dravid",
12000));
exampleTreeMap.put(5,
new Cricketer("Bradman", 9996));
exampleTreeMap
.put(45, new Cricketer("Lara", 10000));

//Lower limit (5) inclusive, Uppper Limit(25) NOT inclusive
System.out.println(exampleTreeMap.subMap(5, 25));//{5=Bradman 9996}

System.out.println(exampleTreeMap.headMap(30));
//{5=Bradman 9996, 25=Dravid 12000}

System.out.println(exampleTreeMap.tailMap(25));
//{25=Dravid 12000, 45=Lara 10000, 55=Sachin 14000}

TreeMap<Integer, Cricketer> treeMapOrig = new TreeMap<Integer, Cricketer>();
treeMapOrig.put(55, new Cricketer("Sachin", 14000));
treeMapOrig.put(25, new Cricketer("Dravid", 12000));
treeMapOrig.put(5, new Cricketer("Bradman", 9996));
treeMapOrig.put(45, new Cricketer("Lara", 10000));

System.out.println(treeMapOrig);
//{5=Bradman 9996, 25=Dravid 12000, 45=Lara 10000, 55=Sachin 14000}

NavigableMap<Integer, Cricketer> treeMapDesc = treeMapOrig
.descendingMap();
System.out.println(treeMapDesc);
//{55=Sachin 14000, 45=Lara 10000, 25=Dravid 12000, 5=Bradman 9996}

System.out.println(treeMapOrig);
//{5=Bradman 9996, 25=Dravid 12000, 45=Lara 10000, 55=Sachin 14000}
System.out.println(treeMapOrig.pollFirstEntry());//5=Bradman 9996
System.out.println(treeMapOrig);
//{25=Dravid 12000, 45=Lara 10000, 55=Sachin 14000}
//In above example element 5 is removed from the set and also removed from the tree set.

System.out.println(treeMapOrig);
//{25=Dravid 12000, 45=Lara 10000, 55=Sachin 14000}
System.out.println(treeMapOrig.pollLastEntry());//55=Sachin 14000
System.out.println(treeMapOrig);
//{25=Dravid 12000, 45=Lara 10000}

//Using default constructor - uses natural ordering of numbers
//Smaller numbers have higher priority
PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();

priorityQueue.offer(24);
priorityQueue.offer(15);
priorityQueue.offer(9);
priorityQueue.offer(45);

System.out.println(priorityQueue);//[9, 24, 15, 45]

//peek method get the element with highest priority.
System.out.println(priorityQueue.peek());//9
//peek method does not change the queue
System.out.println(priorityQueue);//[9, 24, 15, 45]

//poll method gets the element with highest priority.
System.out.println(priorityQueue.poll());//9
//peek method removes the highest priority element from the queue.
System.out.println(priorityQueue);//[24, 15, 45]

//This comparator gives high priority to the biggest number.
Comparator reverseComparator = new Comparator<Integer>() {
    public int compare(Integer paramT1,
    Integer paramT2) {
return paramT2 - paramT1;
    }

};

PriorityQueue<Integer> priorityQueueDesc = new PriorityQueue<Integer>(
20, reverseComparator);

priorityQueueDesc.offer(24);
priorityQueueDesc.offer(15);
priorityQueueDesc.offer(9);
priorityQueueDesc.offer(45);

//45 is the largest element. Our custom comparator gives priority to highest number.
System.out.println(priorityQueueDesc.peek());//45

static int binarySearch(List, key) //Can be used only on sorted list
static int binarySearch(List, key, Comparator)
static void reverse(List)//Reverse the order of elements in a List.
static Comparator reverseOrder();
//Return a Comparator that sorts the reverse of the collection current sort sequence. 
static void sort(List)
static void sort(List, Comparator)

class MyList {
    private List<String> values;

    void add(String value) {
values.add(value);
    }

    void remove(String value) {
values.remove(value);
    }
}

MyList myList = new MyList();
myList.add("Value 1");
myList.add("Value 2");

class MyListGeneric<T> {
    private List<T> values;

    void add(T value) {
values.add(value);
    }

    void remove(T value) {
values.remove(value);
    }

    T get(int index) {
return values.get(index);
    }
}

class MyListGeneric<T>

MyListGeneric<String> myListString = new MyListGeneric<String>();
myListString.add("Value 1");
myListString.add("Value 2");

MyListGeneric<Integer> myListInteger = new MyListGeneric<Integer>();
myListInteger.add(1);
myListInteger.add(2);

class MyListRestricted<T extends Number> {
    private List<T> values;

    void add(T value) {
values.add(value);
    }

    void remove(T value) {
values.remove(value);
    }

    T get(int index) {
return values.get(index);
    }
}

MyListRestricted<Integer> restrictedListInteger = new MyListRestricted<Integer>();
restrictedListInteger.add(1);
restrictedListInteger.add(2);

//MyListRestricted<String> restrictedStringList = 
//new MyListRestricted<String>();//COMPILER ERROR

    static <X extends Number> X doSomething(X number){
X result = number;
//do something with result
return result;
    }

Integer i = 5;
Integer k = doSomething(i);

class Animal {
}

class Dog extends Animal {
}

Animal[] animalsArray = { new Animal(), new Dog() };
Dog[] dogsArray = { new Dog(), new Dog() };

List<Animal> animalsList = Arrays.asList(animalsArray); 
List<Dog> dogsList = Arrays.asList(dogsArray); 

    static void doSomethingArray(Animal[] animals) {
//do Something with Animals
    }

    static void doSomethingList(List<Animal> animals) {
//do Something with Animals
    }

doSomethingArray(animalsArray);
doSomethingArray(dogsArray);

doSomethingList(animalsList);
//List<Dog> not compatible with List<Animal>
//doSomethingList(dogsList);//COMPILER ERROR

    static void doSomethingListModified(List<? extends Animal> animals) {
//Adding an element into  a list declared with ? is prohibited.

//animals.add(new Animal());//COMPILER ERROR!
//animals.add(new Dog());//COMPILER ERROR!
    }

doSomethingListModified(animalsList);
doSomethingListModified(dogsList);

    static void doSomethingListModifiedSuper(List<? super Dog> animals) {
//Adding an element into  a list declared with ? is prohibited.
//animals.add(new Animal());//COMPILER ERROR!
//animals.add(new Dog());//COMPILER ERROR!
    }

doSomethingListModifiedSuper(animalsList);    
doSomethingListModifiedSuper(dogsList);

    static void doSomethingListInterface(List<? extends Serializable> animals) {
//Adding an element into  a list declared with ? is prohibited.

//animals.add(new Animal());//COMPILER ERROR!
//animals.add(new Dog());//COMPILER ERROR!
    }

List<? extends Animal> listAnimals = new ArrayList<Dog>(); //COMPILES
//List<?> genericList = new ArrayList<? extends Animal>(); //COMPILER ERROR

    static void addElement(ArrayList something){
something.add(new String("String"));
    }

ArrayList<Integer> numbers = new ArrayList<Integer>();
numbers.add(5);
numbers.add(6);
addElement(numbers);

//com/rithus/generics/GenericsExamples.java uses unchecked or unsafe operations.
//Recompile with -Xlint:unchecked for details.

javac -Xlint:unchecked com/rithus/generics/GenericsExamples.java
//com/rithus/generics/GenericsExamples.java:21: warning: [unchecked] 
//unchecked call to add(E) as a member of the raw type java.util.ArrayList
//something.add(new String("String"));
//     ^

File file = new File("FileName.txt");

System.out.println(file.exists());

System.out.println(file.createNewFile());

System.out.println(file.getAbsolutePath());
System.out.println(file.isFile());//true
System.out.println(file.isDirectory());//false

File fileWithNewName = new File("NewFileName.txt");
file.renameTo(fileWithNewName);
//There is no method file.renameTo("NewFileName.txt");

File directory = new File("src/com/rithus");

System.out.println(directory.getAbsolutePath());
System.out.println(directory.isDirectory());//true

File fileInDir = new File(directory,"NewFileInDirectory.txt");

System.out.println(fileInDir.createNewFile()); //true - First Time

System.out.println(Arrays.toString(directory.list()));

File newDirectory = new File("newfolder");
System.out.println(newDirectory.mkdir());//true - First Time

File notExistingDirectory = new File("notexisting");
File newFile = new File(notExistingDirectory,"newFile");

//Will throw Exception if uncommented: No such file or directory
//newFile.createNewFile();

System.out.println(newDirectory.mkdir());//true - First Time

//FileWriter helps to write stuff into the file
FileWriter fileWriter = new FileWriter(file);
fileWriter.write("How are you doing?");
//Always flush before close. Writing to file uses Buffering.
fileWriter.flush();
fileWriter.close();

FileWriter fileWriter2 = new FileWriter("FileName.txt");
fileWriter2.write("How are you doing Buddy?");
//Always flush before close. Writing to file uses Buffering.
fileWriter2.flush();
fileWriter2.close();

FileReader fileReader = new FileReader(file);
char[] temp = new char[25];

//fileReader reads entire file and stores it into temp
System.out.println(fileReader.read(temp));//18 - No of characters Read from file

System.out.println(Arrays.toString(temp));//output below
//[H, o, w,  , a, r, e,  , y, o, u,  , d, o, i, n, g, ?, , , , , ,]

fileReader.close();//Always close anything you opened:)

FileReader fileReader2 = new FileReader("FileName.txt");
System.out.println(fileReader2.read(temp));//24
System.out.println(Arrays.toString(temp));//output below

FileWriter fileWriter3 = new FileWriter("BufferedFileName.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter3); 

bufferedWriter.write("How are you doing Buddy?");
bufferedWriter.newLine();
bufferedWriter.write("I'm Doing Fine");
//Always flush before close. Writing to file uses Buffering.
bufferedWriter.flush();
bufferedWriter.close();
fileWriter3.close();

FileReader fileReader3 = new FileReader("BufferedFileName.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader3);

String line;
//readLine returns null when reading the file is completed.
while((line=bufferedReader.readLine()) != null){
    System.out.println(line);
}

PrintWriter printWriter = new PrintWriter("PrintWriterFileName.txt");

//writes "My Name" to the file
printWriter.format("s", "My Name");

printWriter.println(); //New Line
printWriter.println("Some Text");

//writes "Formatted Number: 4.50000" to the file
printWriter.printf("Formatted Number: %5.5f", 4.5);
printWriter.flush();//Always flush a writer
printWriter.close();

FileReader fileReader4 = new FileReader("PrintWriterFileName.txt");
BufferedReader bufferedReader2 = new BufferedReader(fileReader4);

String line2;
//readLine returns null when reading the file is completed.
while((line2=bufferedReader2.readLine()) != null){
    System.out.println(line2);
}

class Rectangle implements Serializable {
    public Rectangle(int length, int breadth) {
this.length = length;
this.breadth = breadth;
area = length * breadth;
    }

    int length;
    int breadth;
    int area;
}

FileOutputStream fileStream = new FileOutputStream("Rectangle.ser");
ObjectOutputStream objectStream = new ObjectOutputStream(fileStream);
objectStream.writeObject(new Rectangle(5, 6));
objectStream.close();

FileInputStream fileInputStream = new FileInputStream("Rectangle.ser");
ObjectInputStream objectInputStream = new ObjectInputStream(
fileInputStream);
Rectangle rectangle = (Rectangle) objectInputStream.readObject();
objectInputStream.close();
System.out.println(rectangle.length);// 5
System.out.println(rectangle.breadth);// 6
System.out.println(rectangle.area);// 30

//Modified Rectangle class

class Rectangle implements Serializable {
    public Rectangle(int length, int breadth) {
this.length = length;
this.breadth = breadth;
area = length * breadth;
    }

    int length;
    int breadth;
    transient int area;
}

System.out.println(rectangle.length);// 5
System.out.println(rectangle.breadth);// 6
System.out.println(rectangle.area);// 0

    private void readObject(ObjectInputStream is) throws IOException,
    ClassNotFoundException {
// Do whatever java does usually when de-serialization is called
is.defaultReadObject();
// In addition, calculate area also
area = this.length * this.breadth;
    }

System.out.println(rectangle.length);// 5
System.out.println(rectangle.breadth);// 6
System.out.println(rectangle.area);// 30

    private void writeObject(ObjectOutputStream os) throws IOException {
//Do whatever java does usually when serialization is called
os.defaultWriteObject();
    }

System.out.println(rectangle.length);//5
System.out.println(rectangle.breadth);//6
System.out.println(rectangle.area);//30

class House implements Serializable {
    public House(int number) {
super();
this.number = number;
    }


    Wall wall;
    int number;
}

class Wall{
    int length;
    int breadth;
    int color;
}

public class SerializationExamples2 {
    public static void main(String[] args)
    throws IOException {

FileOutputStream fileStream = new FileOutputStream(
"House.ser");
ObjectOutputStream objectStream = new ObjectOutputStream(
fileStream);
House house = new House(10);
house.wall = new Wall();
//Exception in thread "main" java.io.NotSerializableException: 
//com.in28minutes.serialization.Wall
objectStream.writeObject(house);
objectStream.close();
    }
}

//Output:
//Exception in thread "main" java.io.NotSerializableException: com.in28minutes.serialization.Wall
//    at java.io.ObjectOutputStream.writeObject0(Unknown Source)
//    at java.io.ObjectOutputStream.defaultWriteFields(Unknown Source)

class House implements Serializable {
    public House(int number) {
super();
this.number = number;
    }

    transient Wall wall;
    int number;
}

class Wall implements Serializable {
    int length;
    int breadth;
    int color;
}

class Actor {
    String name;

    public Actor(String name) {
super();
this.name = name;
    }

    Actor() {
name = "Default";
    }
}

class Hero extends Actor implements Serializable {
    String danceType;

    public Hero(String name, String danceType) {
super(name);
this.danceType = danceType;
    }

    Hero() {
danceType = "Default";
    }
}

FileOutputStream fileStream = new FileOutputStream("Hero.ser");
ObjectOutputStream objectStream = new ObjectOutputStream(fileStream);

Hero hero = new Hero("Hero1", "Ganganam");

// Before -> DanceType:Ganganam Name:Hero1
System.out.println("Before -> DanceType:"   hero.danceType   " Name:"
  hero.name);

objectStream.writeObject(hero);
objectStream.close();

FileInputStream fileInputStream = new FileInputStream("Hero.ser");
ObjectInputStream objectInputStream = new ObjectInputStream(
fileInputStream);
hero = (Hero) objectInputStream.readObject();
objectInputStream.close();

// After -> DanceType:Ganganam Name:Default
System.out.println("After -> DanceType:"   hero.danceType   " Name:"
  hero.name);

ThreadExamples example = new ThreadExamples();
example.downloadAndStoreBattingStatistics();
example.downloadAndStoreBowlingStatistics();
example.downloadAndStoreFieldingStatistics();

example.mergeAndAnalyze();

class BattingStatisticsThread extends Thread {
    //run method without parameters
    public void run() {
for (int i = 0; i < 1000; i  )
    System.out
    .println("Running Batting Statistics Thread "
      i);
    }
}

class BowlingStatisticsThread implements Runnable {
    //run method without parameters
    public void run() {
for (int i = 0; i < 1000; i  )
    System.out
    .println("Running Bowling Statistics Thread "
      i);
    }
}

BattingStatisticsThread battingThread1 = new BattingStatisticsThread();
battingThread1.start();

BowlingStatisticsThread battingInterfaceImpl = new BowlingStatisticsThread();
Thread battingThread2 = new Thread(
battingInterfaceImpl);
battingThread2.start();

public class ThreadExamples {
    public static void main(String[] args) {
class BattingStatisticsThread extends Thread {
    // run method without parameters
    public void run() {
for (int i = 0; i < 1000; i  )
    System.out.println("Running Batting Statistics Thread "   i);
    }
}

class BowlingStatisticsThread implements Runnable {
    // run method without parameters
    public void run() {
for (int i = 0; i < 1000; i  )
    System.out.println("Running Bowling Statistics Thread "   i);
    }
}

BattingStatisticsThread battingThread1 = new BattingStatisticsThread();
battingThread1.start();

BowlingStatisticsThread battingInterfaceImpl = new BowlingStatisticsThread();
Thread battingThread2 = new Thread(battingInterfaceImpl);
battingThread2.start();

    }

}

Running Batting Statistics Thread 0
Running Batting Statistics Thread 1
..
..
Running Batting Statistics Thread 10
Running Bowling Statistics Thread 0
..
..
Running Bowling Statistics Thread 948
Running Bowling Statistics Thread 949
Running Batting Statistics Thread 11
Running Batting Statistics Thread 12
..
..
Running Batting Statistics Thread 383
Running Batting Statistics Thread 384
Running Bowling Statistics Thread 950
Running Bowling Statistics Thread 951
..
Running Bowling Statistics Thread 998
Running Bowling Statistics Thread 999
Running Batting Statistics Thread 385
..
Running Batting Statistics Thread 998
Running Batting Statistics Thread 999 

class SpreadSheet {
    int cell1, cell2, cell3;

    int setandGetSum(int a1, int a2, int a3) {
cell1 = a1;
sleepForSomeTime();
cell2 = a2;
sleepForSomeTime();
cell3 = a3;
sleepForSomeTime();
return cell1   cell2   cell3;
    }

    void sleepForSomeTime() {
try {
    Thread.sleep(10 * (int) (Math.random() * 100));
} catch (InterruptedException e) {
    e.printStackTrace();
}
    }
}

public static void main(String[] args) {
    SpreadSheet spreadSheet = new SpreadSheet();
    for (int i = 0; i < 4; i  ) {
System.out.print(spreadSheet.setandGetSum(i, i * 2, i * 3)   " ");
    }
}
//Output - 0 6 12 18

public class ThreadExampleSynchronized implements Runnable {

    SpreadSheet spreadSheet = new SpreadSheet();

    public void run() {
for (int i = 0; i < 4; i  ) {
    System.out.print(
    spreadSheet.setandGetSum(i,i * 2, i * 3)
      " ");
}
    }

    public static void main(String[] args) {
ThreadExampleSynchronized r = new ThreadExampleSynchronized();
Thread one = new Thread(r);
Thread two = new Thread(r);
one.start();
two.start();
    }
}

FIRST RUN    : 0 1 6 9 12 15 18 18
SECOND RUN    : 0 3 6 6 12 15 18 18
THIRD RUN    : 0 3 6 9 12 15 18 18

int setandGetSum(int a1, int a2, int a3) {
    cell1 = a1;
    sleepForSomeTime();
    cell2 = a2;
    sleepForSomeTime();
    cell3 = a3;
    sleepForSomeTime();
    return cell1   cell2   cell3;
}

synchronized int setandGetSum(int a1, int a2, int a3) {
    cell1 = a1;
    sleepForSomeTime();
    cell2 = a2;
    sleepForSomeTime();
    cell3 = a3;
    sleepForSomeTime();
    return cell1   cell2   cell3;
}

    synchronized void synchronizedExample1() {
//All code goes here..
    }

    void synchronizedExample2() {
synchronized (this){
//All code goes here..
}
    }

    synchronized static int getCount(){
return count;
    }

    static int getCount2(){
synchronized (SynchronizedSyntaxExample.class) {
    return count;
}
    }

LINE 1: BattingStatisticsThread battingThread1 = new BattingStatisticsThread();
LINE 2: battingThread1.start();

LINE 3: BowlingStatisticsThread battingInterfaceImpl = new BowlingStatisticsThread();
LINE 4: Thread battingThread2 = new Thread(battingInterfaceImpl);
LINE 5:battingThread2.start();
//Output - Running Batting Statistics Thread 0
Running Batting Statistics Thread 1
..
..
Running Batting Statistics Thread 10
Running Bowling Statistics Thread 0
..
..
Running Bowling Statistics Thread 948
Running Bowling Statistics Thread 949
Running Batting Statistics Thread 11
Running Batting Statistics Thread 12
..
..
Running Batting Statistics Thread 383
Running Batting Statistics Thread 384
Running Bowling Statistics Thread 950
Running Bowling Statistics Thread 951
..
Running Bowling Statistics Thread 998
Running Bowling Statistics Thread 999
Running Batting Statistics Thread 385
..
Running Batting Statistics Thread 998
Running Batting Statistics Thread 999 

class ThreadExample extends Thread {
    public void run() {
for (int i = 0; i < 1000; i  )
    System.out
    .println( this.getName()   " Running "
      i);
    }
}

ThreadExample thread1 = new ThreadExample();
thread1.setPriority(8);

ThreadExample thread2 = new ThreadExample();
ThreadExample thread3 = new ThreadExample();
ThreadExample thread4 = new ThreadExample();

thread3.start();
thread2.start();
thread3.join();//wait for thread 3 to complete
System.out.println("Thread3 is completed.");
thread4.start();

thread4.join(2000);

class Resource {
}

class SomeOperation {
    Resource resource1 = new Resource();
    Resource resource2 = new Resource();

    void method1() throws InterruptedException {
synchronized (resource1) {
    Thread.sleep(1000);
    //code using resource1
    synchronized (resource2) {
//code using resource2
    }
}
    }

    void method2() throws InterruptedException {
System.out.println(Thread.currentThread().getName()
  "is in method2");
synchronized (resource2) {
    //code using resource2
    Thread.sleep(1000);
    synchronized (resource1) {
//code using resource1
    }
}
    }

}

public class ThreadDeadlock implements Runnable {

    SomeOperation operation = new SomeOperation();

    @Override
    public void run() {
try {
    operation.method1();
    operation.method2();
} catch (InterruptedException e) {
    e.printStackTrace();
}
    }

    public static void main(String[] args) {
ThreadDeadlock r = new ThreadDeadlock();
Thread one = new Thread(r);
Thread two = new Thread(r);
one.start();
two.start();
    }
}

class SomeOperation {
    Resource resource1 = new Resource();
    Resource resource2 = new Resource();

    void method1() throws InterruptedException {
synchronized (resource1) {
    System.out.println("Method1 - got resource1");
    Thread.sleep(1000);
    //code using resource1
    System.out.println("Method1 - waiting for resource2");
    synchronized (resource2) {
System.out.println("Method1 - got resource2");
//code using resource2
    }
}
    }

    void method2() throws InterruptedException {
synchronized (resource2) {
    System.out.println("Method2 - got resource2");
    //code using resource2
    Thread.sleep(1000);
    System.out.println("Method2 - waiting for resource1");
    synchronized (resource1) {
System.out.println("Method2 - got resource1");
//code using resource1
    }
}
    }

}

Method1 - got resource1
Method1 - waiting for resource2
Method1 - got resource2
Method1 - got resource1
Method2 - got resource2
Method1 - waiting for resource2
Method2 - waiting for resource1
HANGSÉÉÉÉÉÉÉÉ

class Calculator extends Thread {
    long sumUptoMillion;
    long sumUptoTenMillion;
    public void run() {
calculateSumUptoMillion();
calculateSumUptoTenMillion();
    }
    
    private void calculateSumUptoMillion() {
for (int i = 0; i < 1000000; i  ) {
    sumUptoMillion  = i;
}
    }
    private void calculateSumUptoTenMillion() {
for (int i = 0; i < 10000000; i  ) {
    sumUptoTenMillion  = i;
}
    }
}

public class ThreadWaitAndNotify {
    public static void main(String[] args) {
Calculator thread = new Calculator();
thread.start();
System.out.println(thread.sumUptoMillion);
    }
}

0

package com.in28minutes.threads;

class Calculator extends Thread {
    long sumUptoMillion;
    long sumUptoTenMillion;

    public void run() {
synchronized (this) {
    calculateSumUptoMillion();
    notify();
}
calculateSumUptoTenMillion();
    }

    private void calculateSumUptoMillion() {
for (int i = 0; i < 1000000; i  ) {
    sumUptoMillion  = i;
}
System.out.println("Million done");
    }

    private void calculateSumUptoTenMillion() {
for (int i = 0; i < 10000000; i  ) {
    sumUptoTenMillion  = i;
}
System.out.println("Ten Million done");
    }
}

public class ThreadWaitAndNotify {
    public static void main(String[] args) throws InterruptedException {
Calculator thread = new Calculator();
synchronized(thread){
    thread.start();
    thread.wait();
}
System.out.println(thread.sumUptoMillion);
    }
}

Million done
499999500000
Ten Million done

synchronized(thread){
    thread.start();
    thread.wait();
}

synchronized (this) {
calculateSumUptoMillion();
notify();
    }

thread.notifyAll();

private int computerSimpleInterest(int principal,float interest,int years){
    assert(principal>0);
    return 100;
}

private int computeCompoundInterest(int principal,float interest,int years){
    //condition is always boolean
    //second parameter can be anything that converts to a String.
    assert(principal>0): "principal is "   principal;
    return 100;
}

public static void main(String[] args) {
    AssertExamples examples = new AssertExamples();
    System.out.println(examples.computerSimpleInterest(-1000,1.0f,5));
}

void method(){
    Calendar calendar = new GregorianCalendar(2000,10,30);
    System.out.println(calendar);
}

public class InitializerExamples {
    static int count;
    int i;

    static{
//This is a static initializers. Run only when Class is first loaded.
//Only static variables can be accessed
System.out.println("Static Initializer");
//i = 6;//COMPILER ERROR
System.out.println("Count when Static Initializer is run is "   count);
    }

    public static void main(String[] args) {
InitializerExamples example = new InitializerExamples();
InitializerExamples example2 = new InitializerExamples();
InitializerExamples example3 = new InitializerExamples();
    }
}

Static Initializer
Count when Static Initializer is run is 0

public class InitializerExamples {
    static int count;
    int i;
    {
//This is an instance initializers. Run every time an object is created.
//static and instance variables can be accessed
System.out.println("Instance Initializer");
i = 6;
count = count   1;
System.out.println("Count when Instance Initializer is run is "   count);
    }

    public static void main(String[] args) {
InitializerExamples example = new InitializerExamples();
InitializerExamples example1 = new InitializerExamples();
InitializerExamples example2 = new InitializerExamples();
    }

}

Instance Initializer
Count when Instance Initializer is run is 1
Instance Initializer
Count when Instance Initializer is run is 2
Instance Initializer
Count when Instance Initializer is run is 3

public class JavaBeansStandards {    

private String name;
private boolean good;

public String getName() {
    return name;
}

public boolean isGood() {
    return good;
}

public void setName(String name) {
    this.name = name;
}

public void setGood(boolean isGood) {
    this.good = isGood;
}

public void addSomeListener(MyListener listener){
}

public void removeSomeListener(MyListener listener){
}

}

private String name;
private boolean good;

public String getName() {
    return name;
}

public boolean isGood() {
    return good;
}

public void setName(String name) {
    this.name = name;
}
public void setGood(boolean isGood) {
    this.good = isGood;
}

public void addSomeListener(MyListener listener){
}

public void removeSomeListener(MyListener listener){
}

private static void regex(String regex, String string) {
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(string);
    List<String> matches = new ArrayList<String>();
    while (m.find()) {
matches.add(m.start()   "<"   m.group()   ">");
    }
    System.out.println(matches);
}

regex("12", "122345612");

[0<12>, 7<12>]

regex("12", "122345612");//[0<12>, 7<12>]

System.out.println("\\");//prints \ (only one slash)

regex("\\s", "12 1234 123 ");//[2< >, 7< >, 11< >]

regex("\\d", "12 12");//[0<1>, 1<2>, 3<1>, 4<2>]

regex("\\w", "ab 12 _");//[0<a>, 1<b>, 3<1>, 4<2>, 6<_>]

regex("[a-d1-4]", "azbkdm 15AB");//[0<a>, 2<b>, 4<d>, 7<1>]
regex("[a-dA-D]", "abyzCD");//[0<a>, 1<b>, 4<C>, 5<D>]

regex("a ", "aaabaayza");//[0<aaa>, 4<aa>, 8<a>]

regex("[a-z] ", "abcZ2xyzN1yza");//[0<abc>, 5<xyz>, 10<yza>]
//0123456789012

regex("a b ", "aabcacaabbbcbb");//[0<aab>, 6<aabbb>]

regex("a b*c ", "abcdacdabdbc");//[0<abc>, 4<ac>]

regex("a b*c?", "adabdabcdabccd");//[0<a>, 2<ab>, 5<abc>, 9<abc>]

regex("[^a] ", "bcadefazyx");//[0<bc>, 3<def>, 7<zyx>]

regex("[^abcd] a", "efgazyazyzb");//[0<efga>, 4<zya>]

regex("a.c", "abca ca!cabbc");//[0<abc>, 3<a c>, 6<a!c>]

regex("a ", "aaaaab");//[0<aaaaa>]

regex("a ?", "aaaaab");//[0<a>, 1<a>, 2<a>, 3<a>, 4<a>]

regex("\\.\\.\\.", "...a....b...c");//[0<...>, 4<...>, 9<...>]

private static void regexUsingScanner(String regex,
String string) {
    Scanner s = new Scanner(string);
    List<String> matches = new ArrayList<String>();

    String token;
    while ((token = s.findInLine(regex)) != null) {
matches.add(token);
    }
    ;
    System.out.println(matches);
}

regexUsingScanner("a ?", "aaaaab");//[a, a, a, a, a]

private static void tokenize(String string,String regex) {
    String[] tokens = string.split(regex);
    System.out.println(Arrays.toString(tokens));
}

tokenize("ac;bd;def;e",";");//[ac, bd, def, e]

private static void tokenizeUsingScanner(String string,String regex) {
    Scanner scanner = new Scanner(string);
    scanner.useDelimiter(regex);
    List<String> matches = new ArrayList<String>();
    while(scanner.hasNext()){
matches.add(scanner.next());
    }
    System.out.println(matches);
}

tokenizeUsingScanner("ac;bd;def;e",";");//[ac, bd, def, e]

private static void lookForDifferentThingsUsingScanner(
String string) {
    Scanner scanner = new Scanner(string);
    while(scanner.hasNext()){
if(scanner.hasNextBoolean()){
    System.out.println("Found Boolean:"   scanner.nextBoolean());
} else if(scanner.hasNextInt()){
    System.out.println("Found Integer:"   scanner.nextInt());
} else {
    System.out.println("Different thing:"   scanner.next());
}
    }
}

lookForDifferentThingsUsingScanner("true false 12 3 abc true 154");

//Found Boolean:true
//Found Boolean:false
//Found Integer:12
//Found Integer:3
//Different thing:abc
//Found Boolean:true
//Found Integer:154