java基础---内部类的使用

内部类，顾名思义，是类内部中的类。然而，在类中定义类也有四中不同的情况，分别称为：成员内部类，静态内部类，局部内部类，匿名内部类

其中成员内部类和匿名内部类较为重要，应用较为广泛，需多加注意

下面就说下这四中内部类以及内部类的调用方法：

1.  成员内部类：在类中，方法外 定义的类，像成员一样被使用 
          可以访问外部类的static东西，但是自己不可以定义static的对东西
            内部类可以访问外部类的私有属性

class Outer {
	int i;
	private int k;

	// 外部类可以调用内部类
	public void f() {
		Inner inner = new Inner();
		inner.g();
		System.out.println(inner.i);
	}

	class Inner {
		int i = 10;
		//内部类可以访问外部类的私有属性
		// static int k; Err
		public void g() {
			int j = 100;
			System.out.println(j + "|" + this.i + "|" + Outer.this.i
					+ Outer.this.k);
		}
	}
}

2. 静态内部类：在一个类中定义的static修饰的成员内部类
            静态内部类中可以定义静态的东西
          静态只能访问静态，实例可以访问所有

class Outer1{
	int i=10;
	static int j;
	public void f() {
		
	}
	//定义一个静态内部类
	static class Inner1{
		int k=20;
		static int g=30;
		public void m() {
			
		}
		public static void n() {
			System.out.println(g);
		}
	}
}

3.局部内部类：定义在类的方法中的类
          在局部内部类中访问局部变量，该局部变量要声明成final的--无法改变
          在局部内部类的方法中调用，当方法被调用时，局部内部类自动被调用

class Outer2{
	int i=0;
	public void f() {
		//局部变量，默认为final的，无法更改
		int k=2;
		//局部内部类
		class Inner2{
			int j;
			public void g() {
				System.out.println(i++ +"|" + k +"|"+ j++);
			}
		}
		new Inner2().g();
	}
}

4. 匿名内部类：他是一个特殊的局部内部类--调用一次就好
    通常是改内部类需要实现一个接口或者继承某个类（抽象类），不起名的一种创建方式

//定义一个接口
interface MyInterface{
	void fun();
}
//定义一个类继承自接口
abstract class MyAbClass implements MyInterface{
	public  abstract  void fun2();
}
//Outer3
class Outer3{
	int i=0;
	public void f() {
		//匿名内部类--注意分号
		MyInterface mi=new MyAbClass() {
			@Override
			public void fun() {
				System.out.println("i="+i);
			}

			@Override
			public void fun2() {
				System.out.println("匿名内部类");
			}
		};
		mi.fun();
		//从大到小--需要强转
		((MyAbClass)mi).fun2();
	}
}

5.内部类的调用

public static void main(String[] args) {
		//成员内部类-- 单行写法
		Outer.Inner in = new Outer().new Inner();
		// 多行写法--繁琐
		Outer outer = new Outer();
		Outer.Inner in2 = outer.new Inner();

		//创建一个静态内部类对象
		Outer1.Inner1 in3=new Outer1.Inner1();
		
		//局部内部类的调用
		new Outer2().f();
		
		//匿名内部类的调用
		new Outer3().f();
	}

我们可以看到内部类有两种调用方法，但第二种调用自我感觉比较绕，所以倾向于第一种调用方法。

欢迎大家提出建议！