Java内部类总结

内部类简介
 
Java 允许将一个类的定义放在另一个类的定义内部，这就是内部类。

内部类是一种非常有用的特性，因为它允许你把一些逻辑相关的类组织在一起，并控制位于内部的类的可视性。

内部类一般有如下四种：

• 成员内部类
• 局部内部类
• 匿名内部类
• 静态内部类

接下来我们依次来看一下这四种内部类的用法。

 
一、成员内部类
 
成员内部类是最普通的内部类，它的定义为位于另一个类的内部，如下

package InnerClass;

/**
 * 成员内部类的使用
 * @author xudaxia0610
 */

public class Outer {
	
	private int num = 1;
	public static String str = "abc";
	
	public void outerFun() {
		System.out.println("我是外部类，现在调用内部类的方法 innerFun()");
		Inner inner = new Inner();
		inner.innerFun();
	}
	
	
	//内部类
	class Inner{
		public void innerFun() {
			System.out.println("我是内部类");
			System.out.println(num);
			System.out.println(str);
		}
	}
	
    public static void main(String[] args) {
 		Outer outer = new Outer();
		outer.outerFun();
	}

}

控制台

我是外部类，现在调用内部类的方法 innerFun()
我是内部类
1
abc

Outer 称为外部类，类 Inner 称为类 Outer 的成员内部类。

成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括 private 成员和静态成员，正如我代码中所展示的那样）。

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。

package InnerClass;

/**
 * 成员内部类的使用
 * @author xudaxia0610
 */

public class Outer {
	
	private int num = 1;
	public static String str = "abc";
	
	public void outerFun() {
		System.out.println("我是外部类，现在调用内部类的方法 innerFun()");
		Inner inner = new Inner();
		inner.innerFun();
	}
	
	
	//内部类
	class Inner{
		
		private int num = 2;
		private String str = "cba";
		
		public void innerFun() {
			System.out.println("我是内部类");
			System.out.println(num);
			System.out.println(str);
		}
	}
	
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.outerFun();
	}

}

控制台

我是外部类，现在调用内部类的方法 innerFun()
我是内部类
2
cba

在这种命名冲突的情况下，如果要访问外部类的同名成员，需要以下面的形式进行访问：

• 外部类.this.成员变量，比如 Outer.this.num
• 外部类.this.成员方法

我们还要注意到外部类与成员内部类是存在这样一个关系的，尽管成员内部类可以无条件的访问外部类的所有变量和方法，但是反过来，外部类要想访问内部类的成员，必须先要创建出一个内部类的对象，然后由这个引用去访问，正如我代码中 outerFun() 方法中所做的那样。

上面所说的是在外部类的成员方法内访问内部类的成员的方式。那么在静态方法中或者是外部类之外呢？

在给出代码之前，我们需要明确一点，成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。

注意我加粗的地方，注意这是成员内部类，等我们看到静态内部类的时候会发现不需要有这个限制。

下面来看看在静态方法中如何访问内部类。

步骤一般如下：

• 先创建出一个外部类的对象：Outer outer = new Outer();
• 之后由这个外部类对象的引用去创建内部类对象：Outer.Inner inner = outer.new Inner();

public static void main(String[] args) {
		Outer outer = new Outer();
		Outer.Inner inner = outer.new Inner();
		inner.innerFun();
}

内部类（对于成员内部类和静态内部类而言）可以拥有 private 访问权限、protected 访问权限、public 访问权限及包访问权限。

比如上面的例子.

• 如果成员内部类 Inner 用 private 修饰，则只能在外部类的内部访问
• 如果用 public 修饰，则任何地方都能访问
• 如果用 protected 修饰，则只能在同一个包下或者继承外部类的情况下访问
• 如果是默认访问权限，则只能在同一个包下访问

这一点和外部类有一点不一样，外部类只能被 public 和默认访问两种权限修饰。

可以这么理解，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

 
二、局部内部类
 
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

还要注意一点：局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。

package InnerClass;

/**
 * 局部内部类
 * @author xudaxia0610
 */
class People{
	
	public People() {
	}
}

public class Outer2 {
	
	public People fun() {
		//局部内部类
		class Inner2 extends People{
		    String sex = "男";
		}
		
		return new Inner2();
	}

}

 
三、匿名内部类
 

举个常用的例子，实例化可排序的容器的时候，我们传入自定义的比较器，直接在构造函数中定义这个比较器。

package InnerClass;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * 匿名内部类
 * @author xudaxia0610
 */
public class People {
	
	private int age;
	
	public static void main(String[] args) {
		TreeSet<People> set = new TreeSet<>(new Comparator<People>() {

			@Override
			public int compare(People o1, People o2) {
				return o1.age - o2.age;
			}
		});
	}

}

同局部内部类一样，匿名内部类也是不能有访问修饰符和 static 修饰符的。

匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

 
四、静态内部类
 
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字 static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非 static 成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非 static 成员就会产生矛盾，因为外部类的非 static 成员必须依附于具体的对象。

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
    }
}
 
class Outter {
    public Outter() {
         
    }
     
    static class Inner {
        public Inner() {
             
        }
    }
}

注意到在 main 方法中，我们在创建静态内部类对象之前并没有事先创建外部类对象。

 
为什么要使用内部类？
 

我们来看看《Thinking in Java》里面是怎么说的。

使用内部类最吸引人的原因是：
 
每个内部类都能独立的继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
如果没有内部类提供的、可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了 “多重继承” 。

简单的概括一下，就是内部类在一定程度上弥补了 Java 不支持多重继承的问题。