内部类小结

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

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

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

 

<span style="white-space:pre">	</span>Inner inner = new Inner();		//Inner这个类用public,private,protected修饰都可以创建

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

 

<span style="white-space:pre">	</span>class Outer{	
		class Inner{
			Inner inner = new Inner();
			Outer outer = new Outer();
		}
	}	

在不同的类中创建内部类

 

<span style="white-space:pre">	</span>Outer.Inner inner = new Outer().new Inner();	//Inner()这个类的能否创建和访问修饰符有关系，不能定义成private

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




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

 

<span style="white-space:pre">	</span>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;
	<span style="white-space:pre">	</span>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");
		}
	}

调用变量注意点：

 

<span style="white-space:pre">	</span>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修饰的内部类。

 

<span style="white-space:pre">	</span>class Outer02{
		static class Inner{
		}
	}

创建内部类的格式和上面的内部类基本相同。不同点:
在另外一个类中创建对象时:
Outer02.Inner inner = new Outer02.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); //非静态字段报错
}
}

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初学者，希望一起学习。