黑马程序员-java内部类总结

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

内部类指在一个外部类的内部再定义一个类。

内部类可以用成员修饰符修饰，如static、public、friendly、protected和private。而外部顶级类（即类名和文件名相同的）也只能使用public和friendly。

1、成员内部类

1）成员内部类，就是作为外部类的成员，可以直接访问外部类的所有成员变量和方法，包括private的。因为内部类中持有一个外部类的引用，格式：OuterClass.this ；

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

当内部类定义在外部类的成员位置上，且非私有，可以在外部其他类中直接建立内部类对象。

格式： OuterClass.InnerClass in=new OuterClass.new InnerClass();

3）注意，成员内部类中不能含有静态变量和方法。原因请见下面的“嵌套内部类”部分。

例1：

class  TestDemo
{
	public static void main(String[] args) 
	{
		Outer.Inner in1=new Outer().new Inner();//得到内部类的一种方式
		in1.function();
		Outer.Inner in2=new Outer().getInner();
		in2.function();
	}
}
class Outer
{
	private int x=3;
	class Inner
	{
		void function()
		{
			System.out.println("Inner:"+x);   //内部类可以访问外部类所有成员，包括私有的。
		}
	}
	/*在外部类作用范围之外得到内部类对象的另一种方式，那就是利用其外部类的方法创建并返回。
	个人推荐这种方式，尤其当内部类的构造函数无参数时*/
	public Inner getInner()   
	{
		return new Inner();
	}
}

输出结果：

Inner:3
Inner:3

2、嵌套内部类

嵌套内部类，就是用static修饰的内部类。

1）当内部类被static修饰后，就具备static的特性，只能直接访问外部类中的static成员。出现了访问局限。

2）

在外部其他类，直接访问static内部类中的非静态成员的格式：new OuterClass.InnerClass().function();

在外部其他类，直接访问static内部类中的静态成员的格式：Outer.Inner.function();

3）当内部类中定义了静态成员，则该内部类必须是嵌套类的，而嵌套类中的成员不必都是静态的；当外部类中的静态方法访问内部类时，内部类也必须是嵌套类。

例2：

class  TestDemo
{
	public static void main(String[] args) 
	{
		new Outer.Inner().function1();  //在外部其他类，直接访问static内部类中的非静态成员
		Outer.Inner.function2();        //在外部其他类，直接访问static内部类中的静态成员
	}
}
class Outer
{
	private int x=3;
	private static int y=4;
	static class Inner
	{
		void function1()
		{
			//System.out.println("Inner.x:"+x);   //出错，嵌套内部类只能访问外部类中的静态成员。
			System.out.println("Inner.y="+y);
		}
		static void function2()
		{
			System.out.println("Inner.static");
		}
	}
}

输出结果：

Inner.y=4
Inner.static

3、局部内部类

局部内部类，是指内部类定义在方法和作用域内。

1）局部内部类仍可以访问外部成员；

2）内部类以及其内部成员前面不能加private、static等修饰符。因为它们是用于修饰成员的，而此时内部类已经变成了局部变量；

3）局部内部类只能访问被final修饰的局部变量。                                                                                                                                                                                                                         例3：

class  TestDemo
{
	public static void main(String[] args) 
	{
		Outer out=new Outer();
		out.method(1);
	}
}
class Outer
{
	private int x=3;
	
	void method(final int a)
	{
		int b=4;
		class Inner
		{
			void function()
			{
				//System.out.println("b="+b); //错误，局部内部类只能访问被final修饰的局部变量
				System.out.println("a="+a);   
				System.out.println("x="+x);   //局部内部类仍可以访问外部成员
			}
		}
		new Inner().function();
	}
}

输出结果：

a=1
x=3

4、匿名内部类

1）匿名内部类其实就是内部类的简写格式；

2）定义匿名内部类的前提：内部类必须是继承一个类或实现一个接口。换句话说，这个类或者接口要先定义；

3）匿名内部类的格式：new 父类\接口(){定义子类的内容};

4）其实匿名内部类就是一个匿名子类对象；

5）匿名内部类中定义的方法最好不超过3个；

6）匿名内部类是不能加修饰符的。

例4：

class  TestDemo
{
	public static void main(String[] args) 
	{
		Outer out=new Outer();
		out.method();
	}
}
class Outer
{
	private int x=3;
	
	void method()
	{
		new Abs()
		{
			public void show()
			{
				System.out.println("x="+x);
			}	
		}.show();
		//调用接口中没有的方法也是可以的
		new Abs()
		{
			public void show()
			{
				System.out.println("x="+x);
			}
			public void abs()
			{
				System.out.println("abs");
			}
		}.abs();
		//当用父类\接口型引用变量指向匿名内部类时
		Abs d=new Abs()
		{
			public void show()
			{
				System.out.println("x="+x);
			}
			public void abs()
			{
				System.out.println("abs");
			}
		};
		d.show();
		//d.abs();           //错误，根据java多态性可知
	}
}
interface Abs
{
	void show();
}

输出结果：

x=3
abs
x=3

5、内部类的作用

1）内部类可以很好的隐藏。因为内部类可以用private、protected等修饰；

2）内部类拥有外部类的所有成员的访问权限；

3）可以实现多重继承；

4）可以避免修改接口而实现同一个类中两种同名方法的调用。

下面针对各点作用举例说明，

例5：实现隐藏

class  TestDemo
{
	public static void main(String[] args) 
	{
		Outer out=new Outer();
		Abs a=out.getAbs();
		a.show();
	}
}
class Outer
{
	private class Inner implements Abs  //内部类私有化
	{
		private int i=1;
		public void show()
		{
			System.out.println(i);
		}
	}
	public Abs getAbs()               //返回值为内部类实现的接口类型
	{
		return new Inner();
	}
}
interface Abs
{
	void show();
}

输出结果：

1

此例中，内部类Inner被private修饰，它实现了接口Abs。在main中，通过getAbs()获得了内部类的对象，但是我们甚至连内部类的名字都没看到。因此内部类的第一个作用：隐藏不想让别人知道的操作，即封装性。

例6：可以访问外部类的所有成员

参见例1。

例7：可以实现多重继承

class  TestDemo
{
	public static void main(String[] args) 
	{
		Outer out=new Outer();
		System.out.println("name="+out.getName());
		System.out.println("age="+out.getAge());
	}
}
class Outer
{
	private class Inner1 extends A  
	{
		public int getAge()
		{
			return super.getAge();
		}
	}
	private class Inner2 extends B
	{
		public String getName()
		{
			return super.getName();
		}
	}
	public int getAge()               
	{
		return new Inner1().getAge();
	}
	public String getName()
	{
		return new Inner2().getName();
	}
}
class A
{
	public int getAge()
	{
		return 11;
	}
}
class B
{
	public String getName()
	{
		return "Zhangsan";
	}
}

输出结果：

name=Zhangsan
age=11

通过内部类Inner1和Inner2分别继承了类A和B，我们类Outer就拥有了类A和B的成员变量和方法，也就是间接地实现了多继承。

例8：避免修改接口而实现同一个类中两种同名方法的调用

class Outer {} extends A implements B
class A
{
	public int getAge()
	{
		return 11;
	}
}
interface B
{
	public int getAge();
}

如上所示，此时Outer类中，有两个同名的getAge()方法。既不能区别，重写时也不知道到底重写了哪一个。

而通过内部类即可解决这个问题：

class  TestDemo
{
	public static void main(String[] args) 
	{
		Outer out=new Outer();
		System.out.println("A.age="+out.getAge());
		System.out.println("B.age="+out.getInner().getAge());	
	}
}
class Outer extends A
{
	private class Inner implements B
	{
		public int getAge()
		{
			return 20;
		}
	}
	public B getInner()
	{
		return new Inner();
	}
} 
class A
{
	public int getAge()
	{
		return 11;
	}
}
interface B
{
	public int getAge();
}

延伸阅读：

1）为什么内部类可以访问外部类的所有成员，包括私有的？

2）为什么在外部类的作用范围内可以任意创建内部类对象，即使内部类是私有的？即内部类对包围它的外部类可见。

3）为什么局部内部类只能访问被final修饰的局部变量？

4）为什么嵌套内部类（静态内部类）不能访问外部类的静态成员？

要了解到这些特点背后的机制，请参阅【解惑】领略Java内部类的“内部”这篇文章。

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com