Primitive types and Wrapper Classes

There are eight primitive types in Java. Since Java still has these primitive types, hence it cannot be said that 
Java is PURE OBJECT ORIENTED LANGUEAGE. Hence Java is said to be OBJECT ORIENTED but NOT PURE OBJECT ORIENTED
LANGUAGE.

The eight primitive types are:
(Source: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html)
char
byte
short
int
long
float
double
boolean

Whereas the following are the datatypes in Java:
String (Please note that in String S is capital)
char
byte
short
int
long
float
double
boolean

Every primitive type has its own wrapper class and their respective important methods used while 
implementing Comparator or Comparable interface are:


Character -> compare(char x, char y) , compareTo(Character anotherCharacter) "compareTo compares Character objects" 
Byte -> compareTo(Byte anotherByte) "Byte wrapper class does not have compare method"
Short -> compare(short x, short y) , compareTo(Short anotherShort)
Integer -> compare(int x, int y) , compareTo(Integer anotherInteger)
Long -> compare(long x, long y) , compareTo(Long anotherLong)
Float -> compare(float f1, float f2) , compareTo(Float anotherFloat)
Double -> compare(double d1, double d2) , compareTo(Double anotherDouble)  
Boolean -> compare(boolean x, boolean y) , compareTo(Boolean b)
String -> compareTo(String anotherString) , compareToIgnoreCase(String str)  "In String, both compare and
compareTo methods have String objects"

IMP: All the wrapper classes have compareTo() method. Only Byte and String does not have compare() method

Please NOTE: 
1) (VERY IMP) If we declare or initialize a string with small "s", it will give compilation ERROR.
String in Java is always defined and declared with capital "S"
2) As learned in the above mentioned IMP methods, compareTo() method always uses Object(also in case of Byte
Wrapper class), whereas compare() method always uses primitive data type(Byte wrapper class does not have
compare() method)
3) compare(T o1, T o2) method of Comparator<T> interface has both arguments as Objects
(Source: http://docs.oracle.com/javase/7/docs/api/java/util/Comparator.html)
compareTo(T o) method of Comparable<T> interface has arguments as Object
That means while overriding compare() and compareTo() methods we have to use ojects as arguments since
these methods are overridden from respective Comparator<T> and Comparable<T> interfaces



ANOTHER IMP CONCEPT IN JAVA: When is "return null;" valid ?
Answer: 
1. Valid: "return null;" is valid only for complex datatypes and complex datastructures such as Wrapper Classes, 
Object, List, Arrays etc.
2. Invalid: "return null;" is invalid for Primitive datatypes such as int,double,char.

The following program clearly displays 2 things.
1. 'return null' is invalid for primitive datatypes.
2. 'string' does not exist. But 'String' wrapper class exist. This means that 'string' is not primitive datatype in Java.



package forTesting;

import java.util.List;

public class CheckingNullForAllReturnTypes {
public static void main(String[] args) {
	System.out.println(returnList());  
	System.out.println(returnDouble());
	System.out.println(returndoubleArray());
	System.out.println(returnDoubleArray());
	System.out.println(returnObject());
	System.out.println(returnString());
	System.out.println(returndouble()); // VERY IMP: CANNOT RETURN NULL for Primitive Datatypes
}

public static List<Integer> returnList(){ // CAN RETURN NULL for return type of complex datatype
	return null;	
}
public static Double returnDouble(){  // CAN RETURN NULL for return type of Wrapper Classes
	return null;
}
public static double[] returndoubleArray(){   // CAN RETURN NULL for complex DS such as array of primitive datatype
	return null;
}
public static Double[] returnDoubleArray(){     // CAN RETURN NULL for complex DS such as array of Wrapper datatype
	return null;
}
public static Object returnObject(){
	return null;                            // CAN RETURN NULL for return type of complex datatype such as Object
}
public static String returnString(){
	return null;                        // CAN RETURN NULL for complex DS such as String, since there is no such thing called 'string'
										// The primitive datatype of String is 'char' and NOT 'string'
}

public static double returndouble(){    
	return null;                            // CANNOT RETURN NULL for Primitive Datatype 
}
/*ANOTHER IMPORTANT THING:
 * public static string returnstring(){ // Throws ERROR, since there is no such thing called as 'string'
	// since 'string' is not Primitive datatype. 'String' exists which is Wrapper class
	// and not 'string'. The primitive type of 'String' can be said to be 'char'.
	// Also the primitive type of 'Character' wrapper class is also 'char'
return null;
}*/
}

/*
 * 
Output:
null
null
null
null
null
null
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Type mismatch: cannot convert from null to double

	at forTesting.CheckingNullForAllReturnTypes.returndouble(CheckingNullForAllReturnTypes.java:36)
	at forTesting.CheckingNullForAllReturnTypes.main(CheckingNullForAllReturnTypes.java:13)
*/