07--java内部类总结-优快云博客

本文链接：https://blog.youkuaiyun.com/zhangtianhao7_6/article/details/17264575

java内部类总结：

1. 什么叫内部类？内部类有什么特点。

   1.1 顾名思义，在java中在一个类的内部在定义一个类，这个类叫做内部类。
   1.2 内部类作为外部类的一个成员，并且依附于外部类而存在。
   因此内部类可以自由的访问内部类的成员变量，包括private的。
   1.3 外部类要访问内部类，必须建立内部类的对象。
   1.4 内部类是一个独立的类，在编译后同样会生成一个class字节码文件，名称为“外部类名$内部类名.class”
   1.5 内部类包括成员内部类、静态内部类、局部内部类、匿名内部类。

2. 成员内部类

2.1 内部类在外部类的成员位置上。格式：

	   class Outer{
		class Inner{}
	   }

编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。
此时在外部其它类中可以建立内部类对象，需要通过外部类对象。格式：
外部类名.内部类名变量名 = 外部类对象.内部类对象。

Outer.Inner in = new Outer().new Inner();

   2.2 内部类可以被成员修饰符所修饰，比如：
      2.2.1 private 将内部类在外部类中进行封装。
      2.2.2 static 当内部类被static修饰后，成为静态内部类。
      2.2.3 final 成为最终类，不能被继承了。
      2.2.4 abstract 抽象关键字所修饰，抽象的内部类。
   2.3 成员内部类中不允许有任何静态声明。例如下面的例子将不能通过编译。

	   class Outer{
		class Inner{
		   static int i = 10;
		}
	   }

   2.4 成员内部类的this引用：
      2.4.1 普通的类可以用this引用当前的对象，内部类也是如此。
      2.4.2 内部类引用外部类当前的对象格式：外部类名.this。

	   class Outer{
		int i = 1;
		class Inner{
		   int i = 10;
		   System.out.println(this.i);  // 10
		   System.out.println(Outer.this.i);   // 1
		}
	   }

3. 静态内部类

3.1 在成员内部类的基础加上static关键字修饰。
3.2 静态内部类只能直接访问外部类中的静态成员。例如下面的例子将不能通过编译：

          class Outer{
		int i = 10;
		class Inner{
		   System.out.println(i);
		}
	   }

3.3 在外部其它类中如何访问静态内部类的非静态成员：外部类名.内部类类名().成员

        Outer.Inner().成员

3.4 在外部其它类中，如何直接访问静态内部类的静态成员：外部类名.内部类类名.成员

        Outer.Inner.成员

3.5 内部类中定义了静态成员，该内部类也必须定义为静态的。
3.6 当外部类中的静态方法访问内部类时，内部类也要定义成静态的。

class Outer {
	private static int x = 3;

	static class Inner// 静态内部类
	{
		static void function() {
			System.out.println("innner :" + x);
		}
	}
	static class Inner2 {
		void show() {
			System.out.println("inner2 show");
		}
	}
	public static void method() {
		// Inner.function();
		new Inner2().show();
	}
}

public class InnerClassTest {
	public static void main(String[] args) {
		Outer.method();
		// Outer.Inner.function();
		// new Outer.Inner().function();
		// 直接访问内部类中的成员。
		// Outer.Inner in = new Outer().new Inner();
		// in.function();
	}
}

4. 局部内部类

   4.1 java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。
   4.2 局部内部类只能在定义该内部类的方法内实例化不可以在此方法外对其实例化。它不可被成员修饰符修饰。
   4.3 可以直接访问外部类中的成员，因为还持有外部类的引用。
   4.4 但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
   因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，
   局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！
   例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。
   正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。

class Outer{
	int x = 3;

	void method(final int a){
		final int y = 4;
		class Inner{
			void function()	{
				System.out.println(y);
			}
		}
		new Inner().function();	
	}
}
class  InnerClassDemo3{
	public static void main(String[] args) 	{
		Outer out = new Outer();
		out.method(7);
		out.method(8);
	}
}

5. 匿名内部类

   5.1 匿名内部类的格式： new 父类或者接口(){定义子类的内容}
   5.2 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
   5.3 继承式的匿名内部类：

   class Car{
	public void drive(){
		System.out.println("车跑起来了");
	}
   }
   class Test{
	public static void main(String[] args){
		Car car = new Car(){// 匿名内部类继承了Car类
			public void drive(){  // 覆盖了Car类的方法
				System.out.println("车车跑起来了！");
			}
		};
		car.driver();// 调用内部类的方法。
	}
   }

5.4 接口式的内部类

   interface Car{
	public abstract void drive();
   }
   class Test{
	public static void main(String[] args){
		Car car = new Car(){// 匿名内部类实现了Car接口
			public void drive(){  // 重写了Car接口的方法
				System.out.println("车车跑起来了！");
			}
		};
		car.driver();// 调用内部类的方法。
	}
   }

5.5 参数式的匿名内部类：

   class A{
	void method(B b){}
	}
   }
   class B{
	void function(){
		System.out.println("BBBB");
	}
   }
   class Test{
	public static void main(String[] args){
		A a = new A();
		a.method(new B(){
			void function(){
				System.out.println("TTTTT");
			}
		});
	}
   }