innerClass.md

####注意41行,innerclass的创建

class B {
	int k = 900;
	static int f = 180;
}

interface X {
	int l = 658;
}

class A {
	int i=100;
	static int j=200;
//Inner class supoorts Interfaces
//InnerClass Supports Inheritance but only one class and one interface
//Innerclass supports Accespecifiers(private,public,default,protected)
	private	class Inner extends B implements X {
	//Static varibles and methods we cannot declare inside the non-Static innerclass but if u declare final keyword before static varibles and methods we can declare inside the non-Static innerclass
	//Non-Static varibles and methods and Static varibles and methods of outer class we can access Directly from non-Static innerclass
		final static int m = 600;
		void funIn() {
			System.out.println(l);//658
			System.out.println(k);//900
			System.out.println(f);//180
			System.out.println(i);//100
			System.out.println(j);//200
			System.out.println("inside funin");
		}//innerclassmethod
	}//non-static innerclass

	void funOu() {
//here we can create object innerclass directly
		Inner d=new Inner();
		System.out.println(d.m);

	}//Outerclass methods
	public static void main(String[] args) {
		//We cannot create object of innerclass Directly for eg: Inner i=new Inner();
		A.Inner b = new A().new Inner();
		b.funIn();
		A   c = new A();
		c.funOu();
		System.out.println("Hello World!");
	}
}

####LocalInnerclass

• if we declare a class inside the methods is called as localinnerclass.
• localinnerclass will not support private ,protected, static keyword
• localinner class support inheritance and inteface,abstracts..

class A {
	//if we declare inside the methods class is called as localinnerclass.
	void funA() {
		class LocalIn {
	//we cannot create object of localinnerclass out side class main method
			void funIn() {
				System.out.println("inside funIn");
			}
		}//localinnerclass

		LocalIn l = new LocalIn();
		l.funIn();
	}

	public static void main(String[] args) {
		A b = new A();
		b.funA();
		System.out.println("Hello World!");
	}
}

Which is true about a method-local inner class?
A.	It must be marked final.
B.	It can be marked abstract.
C.	It can be marked public.
D.	It can be marked static.
Answer: Option B

Explanation:

Option B is correct because a method-local inner class can be abstract, although it means a subclass of the inner class must be created if the abstract class is to be used (so an abstract method-local inner class is probably not useful).

Option A is incorrect because a method-local inner class does not have to be declared final (although it is legal to do so).

C and D are incorrect because a method-local inner class cannot be made public (remember-you cannot mark any local variables as public), or static.

public class MyOuter
{
    public static class MyInner
    {
        public static void foo() { }
    }
}
which statement, if placed in a class other than MyOuter or MyInner, instantiates an instance of the nested class?
A.	MyOuter.MyInner m = new MyOuter.MyInner();
B.	MyOuter.MyInner mi = new MyInner();
C.
MyOuter m = new MyOuter();
MyOuter.MyInner mi = m.new MyOuter.MyInner();
D.	MyInner mi = new MyOuter.MyInner();
Answer: Option A

Explanation:

MyInner is a static nested class, so it must be instantiated using the fully-scoped name of MyOuter.MyInner.

Option B is incorrect because it doesn't use the enclosing name in the new.

Option C is incorrect because it uses incorrect syntax. When you instantiate a nested class by invoking new on an instance of the enclosing class, you do not use the enclosing name. The difference between Option A and C is that Option C is calling new on an instance of the enclosing class rather than just new by itself.

Option D is incorrect because it doesn't use the enclosing class name in the variable declaration.