Nested classes

Author: turingfly

Java-8/src/advancedClassDesign/AnonymousInnerClass.java

@@ -0,0 +1,50 @@
+package advancedClassDesign;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 2, 2017 10:21:31 PM
+ *
+ *         An anonymous inner class is a local inner class that does not have a
+ *         name. It is declared and instantiated all in on statement using the
+ *         new keyword. Anonymous inner classes are required to extend an
+ *         existing class or implement an existing interface.
+ *         
+ *         You can define them right where they are needed,
+ *         even if that is an argument to another method.
+ */
+public class AnonymousInnerClass {
+	// abstract class
+	abstract class SaleTodayOnly {
+		abstract int dollarOff();
+	}
+
+	public int admission(int basePrice) {
+		SaleTodayOnly sale = new SaleTodayOnly() {
+
+			@Override
+			int dollarOff() {
+				// TODO Auto-generated method stub
+				return 3;
+			}
+		};
+		return basePrice - sale.dollarOff();
+	}
+	
+	// interface
+	interface SaleTodayOnly2 {
+		int dollarOff();
+	}
+	public int admission2(int basePrice) {
+		SaleTodayOnly2 sale = new SaleTodayOnly2() {
+			
+			// interface requires public mehtods
+			@Override
+			public int dollarOff() {
+				// TODO Auto-generated method stub
+				return 0;
+			}
+		};
+		return basePrice - sale.dollarOff();
+	}
+}

Java-8/src/advancedClassDesign/LocalInnerClass.java

@@ -0,0 +1,34 @@
+package advancedClassDesign;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 2, 2017 9:54:47 PM 
+ * 		   Local inner class is a nested class defined within a method.
+ * 
+ *         Properties: 
+ *         1. They do not have an access specifier 
+ *         2. They cannot be declared static and cannot declare static fields or methods 
+ *         3. They have access to all fields and methods of the enclosing class 
+ *         4. They do not have access to local variables of a method unless those
+ *         variables are final or effectively final(only set in the line in which it is declared).
+ */
+public class LocalInnerClass {
+	private int length = 5;
+
+	public void calculate() {
+		final int width = 20;
+		class Inner {
+			public void multily() {
+				System.out.println(length * width);
+			}
+		}
+		Inner inner = new Inner();
+		inner.multily();
+	}
+
+	public static void main(String[] args) {
+		LocalInnerClass outer = new LocalInnerClass();
+		outer.calculate();
+	}
+}

Java-8/src/advancedClassDesign/MemberInnerClass.java

@@ -0,0 +1,58 @@
+package advancedClassDesign;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 2, 2017 9:18:54 PM
+ *
+ *         Member Inner Classes: It is defined at the member level of a
+ *         class(the same level as the methods, instance variables, and
+ *         constructors).
+ * 
+ *         Properties: 
+ *         1. Can be declared public, protected, default and private
+ *         2. Can extend any class and implement interfaces 
+ *         3. Can be abstract or final 
+ *         4. Cannot declare static fields or methods 
+ *         5. Can access
+ *         members of the outer class including private members
+ * 
+ */
+public class MemberInnerClass {
+	private String greeting = "Outer";
+
+	protected class Inner {
+		public int repeat = 3;
+		private String greeting = "Inner";
+
+		public void go() {
+			for (int i = 0; i < repeat; i++)
+				System.out.println(greeting);
+		}
+		
+		public void sameName() {
+			System.out.println(greeting); // Inner
+			System.out.println(this.greeting); // Inner
+			System.out.println(MemberInnerClass.this.greeting); // Outer
+		}
+	}
+
+	public void callInner() {
+		Inner inner = new Inner();
+		inner.go();
+	}
+
+	public static void main(String[] args) {
+		MemberInnerClass outer = new MemberInnerClass();
+		outer.callInner();
+		/**
+		 * another way to instantiate inner We need an instance of Outer in
+		 * order to create Inner. We can't just call new Inner() because Java
+		 * won't know which instance of Outer it is associated.
+		 */
+		MemberInnerClass outer2 = new MemberInnerClass();
+		Inner inner = outer2.new Inner();
+		inner.go();
+		inner.sameName();
+	}
+}

Java-8/src/advancedClassDesign/StaticNestedClass.java

@@ -0,0 +1,27 @@
+package advancedClassDesign;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 2, 2017 10:50:49 PM 
+ * 		   A static nested class is a static
+ *         class defined at the member level. It can be instantiated without an
+ *         object of the enclosing class, so it can't access the instance
+ *         variables without an explicit object of the enclosing class. 
+ *         1. The nesting creates a name space because the enclosing class name must be
+ *         used to refer to it 
+ *         2. It can be made private or use one of the other
+ *         access modifiers to encapsulate it. 
+ *         3. The enclosing class can refer
+ *         to the fields and methods of the static nested class.
+ */
+public class StaticNestedClass {
+	static class Nested {
+		private int price = 6;
+	}
+
+	public static void main(String[] args) {
+		Nested nested = new Nested();
+		System.out.println(nested.price);
+	}
+}