Java基础——面向对象（六）内部类

一、概述

一个类嵌套在另一个类当中。编译后生成文件：类$内部类.class。

class Outer
{
    class Inner
    {
    }
}

特点：

1.内部类可以直接访问外部类中的成员。

2.外部类要访问内部类，必须建立内部类的对象。

什么时候使用？

一般用于类的设计。分析事物时，发现该实物描述中还有事物，而且这个事物还在访问被描述事物的内容。

二、修饰符与使用

1.内部类可以使用修饰符

static：此时内部类是静态的，相当于一个外部类。注意：当内部类有静态成员，内部类必须是静态的。

2.使用格式

//外部访问
class Demo{
    public static void main(String[] args){
        //如果是public
        Outer.Inner in = new Outer().new Inner();
        //如果是static
        Outer.Inner in = new Outer.Inner();
    }
}
//内部访问
class Outer{
    class Inner{ }
    void Method(){
        Inner in = new Inner();
    }
}

三、实现细节

class Outer
{
	int num = 3;
	class Inner
	{
		int num = 4;
		void show()
		{
			int num = 5;
            //注意这里Inner.this或者Outer.this表示的num不同
			System.out.println(Outer.this.num);
		}
	}
	void method()
	{
		new Inner().show();
	}
}


class InnerClassDemo2 
{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}

思考：为什么内部类能直接访问外部类中的成员呢？

那是因为内部类持有了外部类的成员。外部类名.this

四、局部内部类——方法中的类

class Outer
{
	int num = 3;
	Object method()
	{
		final int x = 9;
		class Inner
		{
			public String toString()
			{
				return "show ..."+x;//调用只能被final修饰的变量-》规则
			}
		}
		Object in = new Inner();
		return in;//0x0045
//		in.show();
	}
}
class InnerClassDemo3 
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		Object obj = out.method();
		System.out.println(obj);

	}
}

上面的出规则：局部内部类只能调用final修饰的局部变量。

原因：方法执行完会被弹栈，但是申请到的对象还在主程序。

五、匿名内部类——内部类的简写格式

规则：内部类必须继承或者实现一个外部类或者接口。

abstract class Demo
{
	abstract void show();
}

class Outer
{
	int num = 4;
	/*
	class Inner extends Demo
	{
		void show()
		{
			System.out.println("show ..."+num);
		}
	}
	*/
	public void method()
	{
		//new Inner().show();
		new Demo()//匿名内部类。
		{
			void show()
			{
				System.out.println("show ........"+num);
			}
		}.show();
	}
}

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

子类内容：需要全部实现

六、应用

	public void method()
	{
//		Inner in = new Inner();
//		in.show1();
//		in.show2();
		

		Inter in = new Inter()
		{
			public void show1()
			{
				
			}
			public void show2()
			{
			
			}
			
		};
		in.show1();
		in.show2();
	}

使用场景一：当函数参数是接口类型时，且接口中的方法不超过三个。可以使用匿名内部类作为实际参数进行传递。

//使用场景之一
interface Inter(){
    public void show1();
    public void show2();
}
class InnerClassDemo5 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
		show(new Inter()
		{
			public void show1(){}
			public void show2(){}
		});
	}

注意：main里面需要的都是静态的