内部类小结

解释：定义在另一个类中的类就是内部类。

public class Outer{
	class Inner(){		//定义在Outer里面的类
	}
}

一般内部类的创建格式:
在这个外部类中可以直接new内部类对象

Inner inner = new Inner();		//Inner这个类用public,private,protected修饰都可以创建

在这个内部类中可以直接new创建内部类或者外部类对象。

class Outer{	
	class Inner{
		Inner inner = new Inner();
		Outer outer = new Outer();
	}
}	

在不同的类中创建内部类

Outer.Inner inner = new Outer().new Inner();	//Inner()这个类的能否创建和访问修饰符有关系，不能定义成private

一般在使用内部类的过程中，都会定义成private，这样外部就不能创建这个对象。




访问权限：
内部类中可以访问外部类的所有字段和方法。

public class OuterDemo01 {
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
		inner.methodInA();
	}
}


class Outer {
	private int a = 1;
	public int b = 2;
	protected int c = 3;
	static int d = 4;
	final int e = 5;


	class Inner {
		public void methodInA() {
			System.out.println("" + a + b + c + d + e);
			methodOutA();
			methodOutB();
			methodOutC();
			methodOutD();
		}
	}


	private void methodOutA() {
		System.out.println("Outer Private Method");
	}


	protected void methodOutB() {
		System.out.println("Outer protected Method");
	}


	final void methodOutC() {
		System.out.println("Outer default final Method");
	}


	public static void methodOutD() {
		System.out.println("Outer public static Method");
	}
}

调用变量注意点：

public class OuterDemo02 {
	public static void main(String[] args) {
		Outer01.Inner inner = new Outer01().new Inner();
		inner.methodB(3);
	}
}


class Outer01 {
	public int n = 1;
	private int m = 2;


	private void methodA() {
		System.out.println("Outer MethodA");
	}


	class Inner {
		public int n = 2;


		private void methodA() {
			System.out.println("Inner MethodA");
		}


		public void methodB(int n) {
			System.out.println("m" + m + "n" + n + this.n + Outer01.this.n);
			methodA(); 							// 调用Inner类的methodA方法
			Outer01.this.methodA(); 		// 调用Outer类的methodA方法
			Outer01.methodB(5);
			methodC();							//调用外部类中的methodC方法
		}
	}


	private static void methodB(int a){
		System.out.println("Outer methodB a:" + a);
	}


	private void methodC() {
		System.out.println("Outer C");
	}
}

最小作用域最强原则
在可见的不同作用域里重名的变量时,优先采用作用域最小的。(插入)
分析：
1、对于不相同名称的变量或者方法，直接使用即可,如上m和methodC()方法。
2、当外部类的成员变量.内部类的成员变量.和内部类的局部变量有相同名称时。当使用这个名称变量时，由于最小作用域最强原则，会优先调用内部类中的局部变量，但是如果想调用内部类中的全局变量，需要使用this.变量名调用，如果需要访问外部类中的全局变量，需要使用外部类名.this.变量名。
3、对于内中同名的方法，内部类调用自己的方法时，可以直接写函数名调用，调用外部类的方法时,需要使用外部类名.this.方法名。
4、同名方法或者变量用static修饰时，调用外部变量时，直接用外部类名.方法或者属性。




静态内部类：
用static修饰的内部类。

class Outer02{
	static class Inner{
	}
}

创建内部类的格式和上面的内部类基本相同。不同点:
在另外一个类中创建对象时:



访问权限：
由于内部类用了static修饰，所以只能访问外部类中的用static修饰的属性和方法。

public class OuterDemo03 {
	public static void main(String[] args) {
		Outer02.Inner inner = new Outer02.Inner();
		inner.methodA(1);
	}
}


class Outer02{
	static int m = 10;
	int n = 4;
	static class Inner{
		static int m = 5;
		void methodA(int m){
			methodB();							//访问外部类的静态方法
			System.out.println(m + "" + Inner.m + Outer02.m);		//访问外部类的静态字段2
			//System.out.println(n);				<span style="white-space:pre">	</span>//非静态字段报错
		}
	}
			
	private static void methodB() {
		System.out.println("static methodB Outer");
	}
}

1、对于不同名静态的变量或者方法时候，可以在内部类中直接调用。
2、当外部类的成员变量.内部类的成员变量.和内部类的局部变量有相同名称时。当使用这个名称变量时，如果想调用内部类中的static全局变量，需要使用内部类名.变量名调用，如果是非static变量，用this.变量名，如果需要访问外部类中的static变量，需要使用外部类名.变量名。
3、对于内中同名的方法，内部类调用自己的方法时，可以直接写函数名调用，调用外部类的方法时,需要使用外部类名.方法名。


局部内部类：
定义在方法中的类。

class Outer04{
	public void methodA() {
		final int a = 12;
		class Inner{
			private void methodC() {
				System.out.println(a);		//调用内部类中的成员
			}
		}


	}
}

具备内部类注意的地方：
1、局部类在所在类的方法外不能创建对象，调用躲在内的方法时才有可能创建。
2、局部类调用所在的内部类中的成员变量时，只能调用被final修饰的。


匿名内部类：
将局部内部类的使用再深入一步。假如只创建这个类的一个对象，就不必命名了。这种类被称为匿名内部类。
new SuperType(){ new InterfaceType(){
//实现方法 实现方法
//或者添加新的成员
} }

一直听老师说的是用的比较多，毕竟现在学的少，不是很懂，匿名内部类还是用的比较多的，之后的学习是安卓。




如果有错误，欢迎指正，java初学者，希望一起学习。