Java的内部类(成员内部类,私有内部类,静态内部类,局部内部类,匿名内部类)

一.内部类基础

• 在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。

1.成员内部类

• 内部类定义在外部类的成员位置
• 特点:
  • 具有类的特性: 继承父类,实现接口,修饰符…
  • 成员的特点: 可以用成员修饰符(能够修饰成员的成员修饰符)修饰…public,static.final
  • 系统中$代表内部类
  • 注意:
    • 在成员内部类中不能定义静态的内容,除了final修饰过的常量
    • 在内部类中可以直接使用外部类中的成员,包括私有的
    • 外部类中使用内部类中的内容,需要通过内部类的对象使用
• 使用:
  • 其他类中使用内部类中的内容,通过对象,内部类对象要依赖于外部类对象

public class Outer {
	int a = 3;
	//成员内部类
	class Inner {
		int a = 33;

		public void test() {
			int a = 333;
			System.out.println(a);
			System.out.println(this.a);
			Outer out = new Outer();
			System.out.println(out.a);
		}
	}
}

• 测试:

public class Test {
	public static void main(String[] args) {
		//成员内部类
		Outer out = new Outer();
		Outer.Inner in = out.new Inner();
		in.test();
		//也可以直接创建对象
		Outer.Inner in1 = new Outer().new Inner();
		in1.test();

2.私有内部类

• 私有内部类中的内容只能在外部类通过对象使用

public class Outer02{
	private int a=1;
	//私有内部类
	private class Inner{
		private String name="李四";
		private void inner(){
			System.out.println(a)
		}
	}
	public void outer(){
		System.out.println("外部类中的成员方法");
		Inner inner=new Inner();
		System.out.println(inner.name);
		inner.inner();
	}
}

3.静态内部类

• 可以定义静态的内容
• 内部类中静态内容中,可以直接使用内部外部的静态内容,通过内部类对象使用内部类的成员,外部类对象使用外部类的成员
• 内部类中成员内容中,可以直接使用内部外部的静态内容,可以直接使用内部类中的成员,通过外部类对象使用外部类的成员,因为内部类是静态的
• 外部类中通过类名使用内部类中的静态内容,通过内部类对象使用内部类中的成员
• 静态内部类是依赖于外部类的,而不是外部类的对象

public class Outer03{
	static int a=5;
	int b=10;
	//静态内部类
	static class Inner{
		static int c=15;
		int d=20;
		//静态内部类中的静态方法
		static void inner(){
			System.out.println(c);
			System.out.println(new Inner().d);
			System.out.println(a);
			System.out.println(new Outer03().b);
		}
		//静态类中得到成员方法
		void Inner01(){
			System.out.println(c);
			System.out.println(d);
			System.out.println(a);
			System.out.println(new Outer03().b);
		}
	}
	// 外部类中的成员方法
	void outer() {
		//调用静态内部类中的静态变量
		System.out.println(Inner.c);
		//调动静态内部类中的成员变量
		System.out.println(new Inner().d);
	}
}

• 其他类中测试:

public class Test {
	public static void main(String[] args) {
		//静态内部类
		System.out.println(Outer03.Inner.c);
		System.out.println(new Outer03.Inner().d);
		
	}
}

4.局部内部类

• 方法中定义内部类
• 不能使用public,static,default,protected,private…修饰
• 只能在其定义的方法中通过对象使用
• 局部内部类中使用方法的参数,要求这个参数必须被final修饰,1.7及之前版本必须显示定义,1.8及之后可以省略

public class Outer04 {
	private int a=1;
	public static void main(String[] args) {
		//局部变量
		//final int a=5;
		//局部内部类
		final class Inner{
			private String name="haha";
			
			public void inner(){
				//int a=20;
				//System.out.println(a);
			}
		}
		Inner in=new Inner();
		in.inner();
		System.out.println(in.name);
		
		
	}
	
	void test(final int x){
		//x=1;
		
		class Inner{
			void inner(){
				System.out.println(x);
			}
		}
	}
}

5.匿名内部类

• 类体是存在的,只不过这个类体没有名字
• 作用:为了简化自身没有具体作用的实现类

//匿名内部类
public class Outer04 {
	public static void main(String[] args) {

		/*1.匿名的实现类对象,只能在当前使用一次,用完就销毁
		  new Learn() {
		  
		  @Override public void learn() { System.out.println("躺着学"); }
		  }.learn();
		 */

		/*2.接口多态,引用接收
		Learn l = new Learn() {

			@Override
			public void learn() {
				System.out.println("想怎么学怎么学");
			}
		};
		l.learn();
		*/

		//3.作为方法的参数引用
		test(new Learn() {

			@Override
			public void learn() {
				System.out.println("想怎么学怎么学");
			}
		});
	}

	static void test(Learn l) {
		l.learn();
	}
}

//接口
interface Learn {
	void learn();
}