Welcome to Rithus.com. You one stop destination for all C,C++, .Net and Java videos and tutorials. We thank Koushik for this tutorial series. http://www.youtube.com/user/koushks.

There are two types of nested classes in Java : Inner class and Static Nested Class. Lets look at them in detail with examples.

1. Consider the class below:

   public class NestedClass {
   	private int outerClassVariable;
   
   	public static class StaticNestedClass {
   		private int staticNestedClassVariable;
   
   		public int getStaticNestedClassVariable() {
   			return staticNestedClassVariable;
   		}
   
   		public void setStaticNestedClassVariable
   				(int staticNestedClassVariable) {
   			this.staticNestedClassVariable 
   					= staticNestedClassVariable;
   		}
   
   		public void privateVariablesOfOuterClassAreNOTAvailable() {
   			// outerClassVariable = 5; //COMPILE ERROR
   		}
   	}
   
   	public class InnerClass {
   		private int innerClassVariable;
   
   		public int getInnerClassVariable() {
   			return innerClassVariable;
   		}
   
   		public void setInnerClassVariable(int innerClassVariable) {
   			this.innerClassVariable = innerClassVariable;
   		}
   
   		public void privateVariablesOfOuterClassAreAvailable() {
   			outerClassVariable = 5; // we can access the value
   		}
   	}
   
   

2. The above example clearly shows what can/cannot be done in each type of Nested Class.
3. Consider the JUnit Test below. This show what can/cannot be done with a Static Nested Class.

   	@Test
   	public void staticClass() {
   		// Static Nested Class can be created 
   		// without needing to create its parent. 
   		// Without creating NestedClassesExample, 
   		// we created StaticNestedClass
   		NestedClass.StaticNestedClass staticNestedClass1 = 
   				new NestedClass.StaticNestedClass();
   		
   		staticNestedClass1.setStaticNestedClassVariable(5);
   
   		NestedClass.StaticNestedClass staticNestedClass2 = 
   				new NestedClass.StaticNestedClass();
   		staticNestedClass2.setStaticNestedClassVariable(10);
   
   		// Static Nested Class member variables are not static. 
   		// They can have different values.
   		assertEquals(5, staticNestedClass1.
   						getStaticNestedClassVariable());
   		assertEquals(10, staticNestedClass2.
   						getStaticNestedClassVariable());
   	}
   
   

4. Below Junit shows the features of an Inner Class.

   	@Test
   	public void innerClass() {
   		// COMPILER ERROR! 
   		//You cannot create an inner class on its own.
   		// InnerClass innerClass = new InnerClass();
   		NestedClass example = new NestedClass();
   
   		// To create an Inner Class 
   		// you need an instance of Outer Class
   		NestedClass.InnerClass innerClass = 
   				example.new InnerClass();
   
   		assertEquals(0, 
   			innerClass.getInnerClassVariable());
   	}
   

Lets look at a Java example of method hiding.

1. SuperClass declares a method named methodToHide.

   	class SuperClass{
   		public int methodToHide(){
   			return -1;
   		}
   	}
   

2. Lets create a sub class extending previous class with a method with same signature but returning different value.

   	class SubClass extends SuperClass{
   		public int methodToHide(){
   			return 1;
   		}
   	}
   

3. Lets write a Junit. We crete a SubClass instance and call methodToHide. The value returned is from the sub class method. So, the sub class method is effectively hiding the super class method. This is “Method Hiding”.

   	@Test
   	public void methodHidingBasicExample(){
   		SubClass subClass = new SubClass();
   		
   		//Method from super class is hidden 
   		//by the method in sub class
   		assertEquals(1, subClass.methodToHide());		
   	}
   
   

A copy constructor accepts an instance of the same class as parameter and sets appropriate values. Lets look at an example.

1. Consider the Student class below. The second constructor “Student(Student student)” is a copy constructor.

   	class Student {
   		// should ideally be private
   		String name;
   		// should ideally be private
   		int marks;
   
   		// Typical Constructor
   		Student(String name, int marks) {
   			this.name = name;
   			this.marks = marks;
   		}
   
   		// Copy Constructor - constructor 
   		// which receives the same type
   		// as current class as argument
   		Student(Student student) {
   			name = student.name;
   			marks = student.marks;
   		}
   	}
   

2. Lets write a Junit to test the copy constructor.

   	@Test
   	public void copyConstructorTest() {
   		Student student = 
   					new Student("Ramya", 100);
   
   		// uses copy constructor
   		Student studentCopy = 
   					new Student(student); 
   
   		assertEquals("Ramya", studentCopy.name);
   		assertEquals(100, studentCopy.marks);
   	}
   

Constructor chaining is a concept in oops where a constructor invokes a super class constructor and so on. Lets look at an example.

1. Lets create a class called SuperClass.

   	class SuperClass{
   		//ideally should be private
   		String name;
   		public SuperClass(String name){
   			this.name = name;
   		}
   	}
   
   

2. Consider a sub class of previously created class. The constructor calls super(name). This is called constructor chaining.

   	class SubClass extends SuperClass{
   		//ideally should be private
   		int value;
   		public SubClass(String name,int value){
   			super(name);//Constructot Chaining.
   			this.value = value;
   		}
   	}
   
   

3. Lets write a small test to verify behavior.

   	@Test
   	public void constuctorChaining(){
   		SubClass subClass = new SubClass("SAMPLE",10);
   		assertEquals("SAMPLE",subClass.name);
   		assertEquals(10,subClass.value);
   	}
   

Welcome to Rithus.com. You one stop destination for all C,C++, .Net and Java videos and tutorials. We thank Koushik for this tutorial series. http://www.youtube.com/user/koushks.

Welcome to Rithus.com. You one stop destination for all C,C++, .Net and Java videos and tutorials. We thank Koushik for this tutorial series. http://www.youtube.com/user/koushks.

Welcome to Rithus.com. You one stop destination for all C,C++, .Net and Java videos and tutorials. We thank Koushik for this tutorial series. http://www.youtube.com/user/koushks.

Welcome to Rithus.com. You one stop destination for all C,C++, .Net and Java videos and tutorials.

Welcome to Rithus.com. You one stop destination for all C,C++, .Net and Java videos and tutorials. We thank Koushik for this tutorial series. http://www.youtube.com/user/koushks.

1. Consider the example Student class below:

   	class Student {
   		String name;
   	}
   

2. Below test uses default constuctor provided by Java.Name is assigned null value since we did not initialize name.

   	@Test
   	public void defaultConstructor() {
   		Student student = new Student();
   		assertNull(student.name);
   	}
   

3. Lets add an one argument constructor to a new student class.

   	class StudentWithOneArgumentConstructor {
   		String name;// Should ideally be private;
   
   		public StudentWithOneArgumentConstructor
   								(String name) {
   			this.name = name;
   		}
   	}
   

4. The default constructor does not work anymore.

   
   /* COMPILE ERROR! Default Constructor 
    * no longer works!
    * As soon as we create one constructor, 
    * Java expects us to provide all others
    * 
    *	StudentWithOneArgumentConstructor student = 
    * 				new StudentWithOneArgumentConstructor();
    */ 
   

5. However, we can create objects using the one argument constructor.

   		StudentWithOneArgumentConstructor student =
   				new StudentWithOneArgumentConstructor("Tom");
   		 assertEquals("Tom",student.name); 
   

Lets look at a collection, which ensures that the elements are always sorted.

1. In a SortedSet Collection, elements are always sorted. Look at the example below.

   	@Test
   	public void sortedCollection(){
   		/*KNOWN ISSUE : Cannot contain Duplicates*/
   		Set<String> sortedSet = new TreeSet<String>();
   		sortedSet.add("Zebra");
   		
   		sortedSet.add("Elephant");
   		assertArrayEquals(
   			new String[]{"Elephant","Zebra"},
   			sortedSet.toArray());
   		
   		sortedSet.add("Giraffe");
   		assertArrayEquals(
   			new String[]{"Elephant","Giraffe","Zebra"},
   			sortedSet.toArray());
   		
   		sortedSet.add("Bear");
   		assertArrayEquals(
   			new String[]{"Bear","Elephant",
   									"Giraffe","Zebra"},
   			sortedSet.toArray());
   	}
   

BigDecimal scale indicates number of digits after decimal. Lets look at a couple of examples.

1. BigDecimal is created with No digits after decimal. Its scale is 0.

   		BigDecimal firstAmount = 
   						new BigDecimal("55");
   		
   		assertEquals(0, firstAmount.scale());
   

2. BigDecimal created with 2 digits after decimal. Its scale is 2

   		BigDecimal secondAmount = 
   						new BigDecimal("12.00");
   		
   		assertEquals(2, secondAmount.scale());
   

3. Scale of result of addition is that of larger of two operands. (uses BigDecimal’s declared above).

   		BigDecimal additionResult = 
   				firstAmount.add(secondAmount);
   		
   		assertEquals(2, additionResult.scale());
   

4. Its safe to specify scale and rounding when dividing BigDecimal values. Otherwise, an exception might be thrown.

		BigDecimal firstAmount = 
					new BigDecimal("55");
		BigDecimal secondAmount = 
					new BigDecimal("12");

		//Scale - 4
		BigDecimal divisionResult = 
				firstAmount.divide(secondAmount, 
				4, BigDecimal.ROUND_UP); 

In this example, lets look at a few options available to round BigDecimal values.

1. Example 1 : ROUND_UP

   		assertEquals(new BigDecimal("59.56"),
   						new BigDecimal("59.551").
   						setScale(2, BigDecimal.ROUND_UP));
   

2. Example 2 : ROUND_DOWN

   
   		// Any fraction is truncated
   		assertEquals(new BigDecimal("59.55"),
   						new BigDecimal("59.559").
   						setScale(2, BigDecimal.ROUND_DOWN));
   

3. Example 3 : ROUND_HALF_UP

   		// Fraction >=.5 is rounded up. others truncated
   		assertEquals(new BigDecimal("59.56"),
   					new BigDecimal("59.555").
   					setScale(2, BigDecimal.ROUND_HALF_UP));
   		assertEquals(new BigDecimal("59.55"),
   					new BigDecimal("59.5549").
   					setScale(2, BigDecimal.ROUND_HALF_UP));
   
   

4. Example 4 : ROUND_HALF_DOWN

   		//fraction <=.5 is truncated. others rounded up.
   		assertEquals(new BigDecimal("59.55"),
   					new BigDecimal("59.555").
   					setScale(2, BigDecimal.ROUND_HALF_DOWN));
   		assertEquals(new BigDecimal("59.56"),
   					new BigDecimal("59.5551").
   					setScale(2,	BigDecimal.ROUND_HALF_DOWN));
   

Dividing BigDecimal’s is tricky business. Lets take a quick look at how to get good at it.

1. Dividing BigDecimal’s without using the scale might result in ArithmeticException if the result is Non-terminating.

   BigDecimal never truncates a result unless its requested to.

   	@Test(expected = ArithmeticException.class)
   	public void bigDecimalDivisionException() {
   		BigDecimal firstAmount = 
   						new BigDecimal("55");
   		BigDecimal secondAmount = 
   						new BigDecimal("12");
   
   		// java.lang.ArithmeticException: 
   		// Non-terminating decimal expansion;
   		// no exact representable decimal result.
   		BigDecimal divisionResult = 
   					firstAmount.divide(secondAmount);
   	}
   

2. Safest way to divide BigDecimals is to specify scale and rounding parameter as shown in the example below.

   	@Test
   	public void bigDecimalDivide() {
   		BigDecimal firstAmount = 
   					new BigDecimal("55");
   		BigDecimal secondAmount = 
   					new BigDecimal("12");
   
   		//Scale 4
   		BigDecimal divisionResult = 
   					firstAmount.divide(secondAmount, 
   							4, BigDecimal.ROUND_UP);
   		
   		assertEquals(new BigDecimal("4.5834"), divisionResult);
   	}
   
   

3. There are varied kind of Rounding parameters available with BigDecimal. Couple of examples below.

   		BigDecimal divisionResultScale2Roundup = 
   						firstAmount.divide(secondAmount, 
   						2, BigDecimal.ROUND_UP);
   
   		BigDecimal divisionResultScale2Rounddown = 
   						firstAmount.divide(secondAmount, 
   						2, BigDecimal.ROUND_DOWN);
   
   		assertEquals(new BigDecimal("4.59"), 
   						divisionResultScale2Roundup);
   		
   		assertEquals(new BigDecimal("4.58"), 
   						divisionResultScale2Rounddown);
   

Adding BigDecimals can be done using the add method. Lets look at a quick example.

1. The scale of the result is the maximum of the scales of the operands.

   	@Test
   	public void bigDecimalsAddition() {
   		BigDecimal firstAmount = new BigDecimal("2.300");// 3
   		BigDecimal secondAmount = new BigDecimal("2.45");// 2
   
   		BigDecimal sum = firstAmount.add(secondAmount);
   		BigDecimal sumScale2 = sum.setScale(2);
   
   		assertEquals(new BigDecimal("4.75"), sumScale2);
   		assertEquals(new BigDecimal("4.750"), sum);
   	}
   
   

Lets take a quick look at the Options available to Compare BigDecimal objects.

1. Equals method is not the best bet to compare BigDecimals. The below comparison uses assertFalse.

   		assertFalse(new BigDecimal("2.3").
   						equals(new BigDecimal("2.30")));
   
   

2. Best way to compare BigDecimal’s is to use compareTo function. All possible result values of the compareTo are shown in the code below.

   		assertEquals(0, 
   				new BigDecimal("2.3").compareTo(
   				new BigDecimal("2.30")));
   		
   		assertEquals(1,
   				new BigDecimal("2.31").compareTo(
   				new BigDecimal("2.30")));
   		
   		assertEquals(-1,
   				new BigDecimal("2.29").compareTo(
   				new BigDecimal("2.3")));
   

Lets take a quick look at the two options available in Java to concatenate Strings.

1. Example 1 : Uses + operator to concatenate Strings.

   	@Test
   	public void concatenateStrings() {
   		String string1 = "Sachin ";
   		String string2 = "Tendulkar";
   		String concatenatedString = string1 
   									+ string2;
   		assertEquals("Sachin Tendulkar", 
   						concatenatedString);
   	}
   

2. Example 2 : Uses String function Concat.

   	@Test
   	public void concatenateStringsApproach2() {
   		String string1 = "Sachin ";
   		String string2 = "Tendulkar";
   		String concatenatedString = 
   						string1.concat(string2);
   		assertEquals("Sachin Tendulkar", 
   						concatenatedString);
   	}
   
   

Quick example to remove last character from a String
1. Use substring function to get the first length – 1 characters of the string.

   	@Test
   	public void removeLastCharacterFromString() {
   		String str = "COOLSTUFF";
   		// Replace O with empty string ""
   		String strWithLastCharacterRemoved = 
   				str.substring(0, str.length() - 1);
   		assertEquals("COOLSTUF", 
   					strWithLastCharacterRemoved);
   	}
   
   

1. Example 1 : Convert String to Character object

   	@Test
   	public void stringToCharacter() {
   		String oneCharacterString = "A";
   		char char1 = oneCharacterString.charAt(0);
   		Character character = Character.valueOf(char1);
   		assertEquals(new Character('A'), character);
   	}
   

2. Example 2 : Convert String to Char

   	@Test
   	public void stringToChar() {
   		String oneCharacterString = "A";
   		char character = oneCharacterString.charAt(0);
   		assertEquals('A', character);
   	}
   

3. Example 3 : Convert String to Double

   	@Test
   	public void stringToDouble() {
   		String doubleAsString = "25.25";
   
   		// If you want a Wrapper number - this is the best way
   		Double numberWrapper = Double.valueOf(doubleAsString);
   		assertEquals(25.25, numberWrapper.doubleValue(), 0.00);
   
   		// If you want a primitive int - this is the best way
   		double numberPrimitive = Double.parseDouble(doubleAsString);
   		assertEquals(25.25, numberPrimitive, 0.00);
   	}
   
   

4. Example 4 : Convert String to integer

   	@Test
   	public void stringToInt() {
   		String intAsString = "25";
   		// If you want a primitive int - this is the best way
   		int numberPrimitive = Integer.parseInt(intAsString);
   		assertEquals(25, numberPrimitive);
   	}
   

Quick Example to Convert a String to Date and/or Calendar.

1. Simplest way is to use SimpleDateFormat to create a date and then use calendar.setTime to set the date into calendar. Source code below.

   	@Test
   	public void stringToDate() throws ParseException {
   		String dateString = "August 15, 2011";
   
   		//Create a date
   		Date date = 
   			new SimpleDateFormat("MMMM d, yyyy", 
   									Locale.ENGLISH)
   				.parse(dateString);
   		
   		//Create a calendar and set teim
   		Calendar calendar = new GregorianCalendar();
   		calendar.setTime(date);
   
   		assertEquals(15, 
   					calendar.get(Calendar.DATE));
   		
   		assertEquals(Calendar.AUGUST, 
   					calendar.get(Calendar.MONTH));
   		
   		assertEquals(2011, 
   					calendar.get(Calendar.YEAR));
   	}
   

Lets take a quick peek at various methods available in Java to search a string.

1. Lets quickly create a String to search in.

   		String string = "Sachin Tendulkar";
   					  // 0123456789012345
   

2. First Method to search a string is contains.

   		// Search for a sequence of characters
   		assertTrue(string.contains("in"));
   		assertFalse(string.contains("notin"));
   

3. Get index of the first character that matches the search sequence using indexOf.

   		// Get index of character sequence
   		assertEquals(2, string.indexOf("ch"));
   		// -1 Not found
   		assertEquals(-1, string.indexOf("notin"));
   

4. Search for the last occurance of a character sequence using lastIndexOf.

   		// If you want to search for last character
   		assertEquals(14, string.lastIndexOf("a"));
   

Lets look at couple of quick examples of Replace All on a String using a Regular Expression (Regex).

1. First example :

   	@Test
   	public void stringReplaceAllRegex() {
   		String string = 
   				"Replace all numbers 6 in 7 string 8";
   
   		//Regex matches all numeric characters
   		String regularExpression = "[0-9]";
   
   		String stringToReplaceWith = "X";
   
   		assertEquals("Replace all numbers X in X string X",
   				string.replaceAll(
   					regularExpression, 
   					stringToReplaceWith));
   	}
   

2. Example 2 : Difference between String Replace and Replace All.

   	@Test
   	public void stringReplaceAndReplaceAllDifference() {
   		String string = 
   			"Replace all 5 numbers 6 in 7 string 8";
   
   		// Regex matches all numeric characters
   		String regularExpression = "[0-9]";
   
   		String stringToReplaceWith = "X";
   
   		// Replace all looks for regular expression
   		assertEquals(
   			"Replace all X numbers X in X string X",
   			string.replaceAll(regularExpression, 
   								stringToReplaceWith));
   
   		// Replace looks for the actual string. 
   		// Since "[0-9]" is not found,
   		// it does not replace anything
   		assertEquals(
   			"Replace all 5 numbers 6 in 7 string 8",
   			string.replace(regularExpression, 
   								stringToReplaceWith));
   
   	}
   
   

Lets look at couple of quick examples : Replacing String in a String and Replacing Character in a String.

1. Example 1: Replacing String in a String

   	@Test
   	public void stringReplace() {
   		String string = "Gavaskar is India's best Batsman";
   		String stringToReplace = "Gavaskar";
   		String stringToReplaceWith = "Sachin";
   
   		assertEquals("Sachin is India's best Batsman",
   				string.replace(stringToReplace, 
   								stringToReplaceWith));
   	}
   

2. Example 2 : Replace Character in a String

   	@Test
   	public void replaceCharacterInString() {
   		String string = "TESTING";
   		char charToReplace = 'T';
   		char charToReplaceWith = '$';
   
   		assertEquals("$ES$ING",
   					string.replace(charToReplace, 
   							charToReplaceWith));
   	}
   

Quick Example of how to Split Strings in Java.

1. We make use of the split method available on a String object. Source code below.

   	@Test
   	public void splitStrings() {
   		String stringToSplit = "1,2,3,4";
   		String seperator = ",";
   
   		String[] splits = stringToSplit.split(seperator);
   
   		int noOfSplitFragments = 4;
   		
   		assertEquals(noOfSplitFragments, splits.length);
   
   		assertArrayEquals(
   					new String[] { "1", "2", "3", "4" }, 
   					splits);
   	}