【Java】内部类

1.概述

嵌套在类里面的类

2.分类

1. 成员内部类
   定义在类成员位置的类
   创建对象必须依赖于外部类

public class Face {
		String type; // 脸型
		class Nose { // 鼻子为脸的内部类，离开脸他就失去了意义
//			static int i;     在成员内部类里面定义不了静态成员
			String type;
			void huXi() {}
		}
	}

2. 局部内部类
   定义在方法内的类
   局部内部类不能创建对象，其若想访问他所在方法内的变量，那个变量必须是final修饰的
   局部内部类只在该方法内部可见，方法内部类可以定义在方法中的任何位置。

public class LocaltionClass {
		void m(final int i) {
			int j = 10;
			class JBNBClass {
				void m1() {
					System.out.println(i);
				}
			}
		}
	}

3. 静态内部类
   在成员内部类基础上加static修饰，可以创建以及访问外部静态成员
   他不能访问外部类的非静态成员
   要创建静态内部类对象的时候，也不需要外部类对象，直接可以通过：new OuterClass.InnerClass()，来创建

public static class StaticClass {
		static final int j = 0;
		static class A {
			void m() {
				System.out.println(j);
			}
		}
	}

4. 匿名内部类
   不给类名的内部类
   直接定义一个类
   该类通常实现了某个接口或者抽象

public class NoNameClass {
		// 有一个方法 需要传入一个引用类型
		void m(A nn) {
		}
		public static void main(String[] args) {
		NoNameClass  nnc =new NoNameClass();
			nnc.m(new A(){
				public void print() {
				System.out.println("打印A");
			}
			});
		}
	}
	
	interface A {
		void print();
	}

3.特点及用法

1. 内部类直接在类的内部进行声明，其访问权限约定与外部类一致
2. 内部类自动拥有对其外部类所有成员的访问权
   如果内部类和外部类成员同名，则需要通过OuterClass.this.memberName来访问外部成员
   在局部方法中调用局部类的方法，可以直接创建对象并调用

public void test() { 
                Inner in = new Inner(); 
                in.innerMsg(); 
} 

3. 必须使用外部类对象来创建内部类对象，而不是直接new一个

//格式为：外部对象名.new 内部类构造方法
Outer outer = new Outer();
Outer.Inner iner = outer.new Inner();

4. 访问内部类自己的成员i，也可以写成 this.i++;
   访问外部类的成员 i，Outer.this.i++;
5. 内部类可以实现接口
6. 内部类之间相互可见，但并非内部类之间方法都可见

4.代码示例

局部类和内部类

//@author:林寒_

public class MyClass {
	//method方法传入IA接口实例对象
	public static void method(IA ia) {
		//输出:in method
		System.out.println("in method");
		//调用ia对象的接口方法ma()
		ia.ma();
	}
}

interface IA{
	void ma();
}

public class TestInnerClass {
	public static void main(String[] args) {
		//1.直接调用MyClass的静态方法method,在参数中创建匿名内部类，实例化接口，并重写ma方法
		//下处调用该方法输出：
		//in method
		//ma in annoymous inner class
		MyClass.method(new IA() {
			public void ma() {
				System.out.println("ma in annoymous inner class");
			}
		});
		
		//此处创建局部内部类，继承IA接口，并重写其抽象方法ma
		class MyMaClass implements IA{
			public void ma() {
				System.out.println("ma in local inner class");
			}
		}
		//再次调用MyClass的静态方法method,在参数中传入刚创建的内部类
		//2.输出相应语句
		//in method
		//in local inner class
		MyClass.method(new MyMaClass());
	}
}