java内部类的作用分析

          提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。

Java中的内部类共分为四种：

　　静态内部类    static inner class (also called nested class)

　　成员内部类    member inner class

　　局部内部类    local inner class

　　匿名内部类    anonymous inner class

        注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

内部类的作用：

    1、隐藏你不想让别人知道的操作，也即封装性。

    2、一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！

内部类的功能在于，每个内部类都能独立的继承一个接口的实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多重继承的解决方案变得完整，并且内部类允许继承多个非接口类型(类或抽象类)。通过内部类分别继承一个基类，外部类创建内部类的对象，并使用内部类的方法，变相地实现了多继承。

下面从以下几个方面来介绍：

public interface Contents {
 int value();
}
public interface Destination {
 String readLabel();
}
public class Goods {
 private class Content implements Contents {
  private int i = 11;
  public int value() {
   return i;
  }
 }
 protected class GDestination implements Destination {
  private String label;
  private GDestination(String whereTo) {
   label = whereTo;
  }
  public String readLabel() {
   return label;
  }
 }
 public Destination dest(String s) {
  return new GDestination(s);
 }
 public Contents cont() {
  return new Content();
 }
}
class TestGoods {
 public static void main(String[] args) {
  Goods p = new Goods();
  Contents c = p.cont();
  Destination d = p.dest("Beijing");
 }
}

        这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作，也即封装性。

同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：

public class Goods {
	private int valueRate = 2;
	private class Content implements Contents {
		private int i = 11 * valueRate;
		public int value() {
			return i;
		}
	}
	protected class GDestination implements Destination {
		private String label;
		private GDestination(String whereTo) {
			label = whereTo;
		}
		public String readLabel() {
			return label;
		}
	}
	public Destination dest(String s) {
		return new GDestination(s);
	}
	public Contents cont() {
		return new Content();
	}
}

        在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：

outerClass.this

有了它，我们就不怕这种屏蔽的情况了。

public class OutClassTest {
    private int num ;
    public OutClassTest(){
  
    }
 
    public OutClassTest(int num){
        this.num = num;
    }
 
    private class Inner{
        public OutClassTest getTest2(){
            return OutClassTest.this;
        }
  
        public OutClassTest newTest2(){
            return new OutClassTest();
        }
    }
 
    public static void main(String [] args){
        OutClassTest outClass = new OutClassTest(5);
        OutClassTest.Inner innerClass = outClass.new Inner();
        OutClassTest test2 = innerClass.getTest2();
        OutClassTest test3 = innerClass.newTest2();
        System.out.println(test2.num);
        System.out.println(test3.num);
    }
}------输出-------------------
5
0

 

静态内部类

和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

　　注意：只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。

　　           生成静态内部类对象的方式为：

　　          OuterClass.InnerClass inner = new OuterClass.InnerClass();

局部内部类

是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。

 

public class Outer {
	private int s = 100;
	private int out_i = 1;
	public void f(final int k) {
		final int s = 200;
		int i = 1;
		final int j = 10;
		// 定义在方法内部
		class Inner {
			int s = 300;// 可以定义与外部类同名的变量
			// static int m = 20;//不可以定义静态变量
			Inner(int k) {
				inner_f(k);
			}
			int inner_i = 100;
			void inner_f(int k) {
				// 如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
				System.out.println(out_i);
				// 可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
				System.out.println(j);
				// 如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
				System.out.println(s);
				// 用this.变量名访问的也是内部类变量
				System.out.println(this.s);
				// 用外部类名.this.内部类变量名访问的是外部类变量
				System.out.println(Outer.this.s);
			}
		}
		new Inner(k);
	}
	public static void main(String[] args) {
		// 访问局部内部类必须先有外部类对象
		Outer out = new Outer();
		out.f(3);
	}
}

 

        与局部变量类似，局部内部类前面是不可以加权限控制符的，也不能用static修饰。但是可以用final修饰，用来确保这个变量的值不会发生改变。所以如果局部类要访问带修饰的局部变量，只能访问用final修饰的局部变量。但是局部类可以访问外部类的所有成员，包括成员变量。

匿名内部类

java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：

new interfacename(){......}; 或 new superclassname(){......};

下面接着前面继续举例子：

public class Goods3 {
	public Contents cont() {
		return new Contents() {
			private int i = 11;
			public int value() {
				return i;
			}
		};
	}
}

 

public class Goods3 {
	public Contents cont() {
		return new Contents() {
			private int i = 11;
			public int value() {
				return i;
			}
		};
	}
}

       这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。

在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：

frame.addWindowListener(new WindowAdapter(){
	public void windowClosing(WindowEvent e){
	   System.exit(0);
	}
}); 

        有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：

如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。

将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。

在这个匿名内部类中使用初始化代码块。

为什么需要内部类？

java内部类有什么好处？为什么需要内部类？

首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

不过你可能要质疑，更改一下方法的不就行了吗？

的确，以此作为设计内部类的理由，实在没有说服力。

真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。