Java内部类笔记

定义：将一个类的定义放在另一个类的定义的内部，叫做内部类。

内部类的使用场景一：

 

public class Out {
   class In{
	   private int i = 5;
   }
   public void say(){
	   In in = new In();
	   System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
   }
   public static void main(String[] args){
	   Out out = new Out();
	   out.say();
   }
   /**
    * Console:5
    */
}

在上面的代码中，为了方便将main方法定义在Out类中，但是实际应用中main方法往往不在Out类中定义。而在该方法中使用了out对象的say()方法，该方法内部使用了In的一个对象。

 

同样的。我们可以利用外部类来得到一个内部类。如下：

 

public class Out {
   class In{
	   private int i = 5;
	   public int i2 = 6;
   }
   public void say(){
	   In in = new In();
	   System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
   }
   public In getIn(){
	   return new In();
   }
   public static void main(String[] args){
	   Out out = new Out();
	   out.say();
	   In in = out.getIn();
	   System.out.println(in.i2);
   }
   /**
    * Console:5
              6 
    */
}

如果将上面的代码的最后一句改为System.out.println(in.i);也是可以正确运行的。所以这里有一个问题是，既然i是一个私有的成员变量，为什么可以被main访问呢？这里的main方法定义在Out类内部，前面说到在Out类是可以访问内部类的私有属性的。我们将main方法定义在外部：

 

 

public class Out {
   class In{
	   private int i = 5;
	   public int i2 = 6;
   }
   public void say(){
	   In in = new In();
	   System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
   }
   public In getIn(){
	   return new In();
   }
}

public class Main {
	public static void main(String[] args){
		   Out out = new Out();
		   out.say();
		   In in = out.getIn();//这里报错。
		   System.out.println(in.i2);
	   }
}

出现了一个错误：In cannot be resolved to a type。

 

加入import Out.In提示：The import Out cannot be resolved

所以新的问题是：

如何在外部类的外部实例化一个内部类？

按照前面说的，如果在Out类定义一个方法getIn()便可以返回一个内部类的实例。但是如果将main方法定义在外部，同样会出现In类无法解析的错误。

先说明一个问题，为什么要实例化内部类？当生成一个内部类的对象的时候，该对象于制造它的外围类的对象之间就有了一种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊的条件，这与C++的嵌套类不同，在C++中只是单纯的名字隐藏机制，与外围对象没有联系，也没有隐含的访问权。（来自《Java编程思想》）

实例化的代码可以参考：

 

public class Out {
   class In{
	   private int i = 5;
	   public int i2 = 6;
	   public void say2(){
		   System.out.println("this is from In!");
	   }
   }
   public void say(){
	   In in = new In();
	   System.out.println(in.i);//外部类是可以访问内部类的私有成员变量的
   }
   public In getIn(){
	   return new In();
   }
}

public class Main {
	public static void main(String[] args){
		   Out out = new Out();
		   Out.In in = out.new In();//注意Out.In 和out.new语法
		   in.say2();
	   }
}

上面的代码说明的是，在创建某个内部类的对象的时候，必须在new表达式中提供对其他外部类对象的引用。这时候需要使用.new语法。（百度百科说，内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。这将在我们下文的通过反射机制实现内部类得到体现。内部类虽然是一个独立的类，但是在一般的构造时却需要外部类的介入。）

 

现在有了新的问题，既然外部类可以调用内部类，那么内部类可以调用外部类吗？答案是可以的。

代码太长，就简要地说，语法上是在需要调用外部类的内部类方法中，使用以下的语句：

public Out getOut(){
		   return Out.this;
	   }

this指向的是内部类还是外部类？外部类。

 

除了以上的种种，内部类还有一个好处，那就是当内部类实现了某一个接口（或者继承了某一个抽象类）的时候，可以做到完全不可见，也不可用，这样能够很方便地隐藏实现的细节。比如

 

public interface interfaceForInner {
    public void say1();
    public void say2();
}

public class Out {
   public String out_str = "this is from Out!";
   class In implements interfaceForInner{
	public void say1() {
		System.out.println("this is from in.say1!");
	}
	public void say2() {
		System.out.println("this is from in.say2!");
	}
   }
   public In getIn(){
	   return new In();
   }
}

public class Main {
	public static void main(String[] args){
		   Out out = new Out();
		   Out.In in = out.getIn();
		   in.say1();
		   in.say2();
	   }
}

此外，内部类还可以在外部类的方法中定义。不过这样子一来，该内部类便只是方法的一部分，而不是外部类的一部分。在该方法的外部是不能够访问该内部类的。

 

 

public class Out {
   public int value(){
	   class In{
		   public int i = 15;
	   }
	   In in = new In();
	   return in.i;
   }
   class Inn{
	   public int i = 155;
   }
   public static void main(String[] args){
	   Out out = new Out();
	   out.value();
	   //In in = new In();//报错
	   Inn inn = new Inn();//不报错
   }
}

 

内部类有另外一种实现机制的方式，那就是——匿名内部类。比如：

 

public interface In {
   public int value();
}

public class Out {
   public In getIn(){
	   return new In(){
		   private int i = 11;
		   public int value(){
			   return i;
		   }
	   };
   }
   public static void main(String[] args){
	   Out out = new Out();
	   In in = out.getIn();//这里涉及了多态，new In(){}是一个实现接口的类。而不是一个接口。
	   System.out.println(in.value());
	   //In inn = new In();//报错。因为接口不可以实例化。
   }
}

因为是匿名的，所以无法在外部实例化。

 

上面的代码其实等价于在外部类定义一个内部类比如MyIn；然后该内部类实现了接口In，然后getIn方法返回了new MyIn();。

现在又有了新的问题：外部类和内部类因为关系联系在一起，如果我不需要内部类对象和外围类对象之间有联系，该怎么办呢？答案是将内部类声明为static，这叫做嵌套类。static关键字是指，被定义的东西仅于类层面的定义者有联系，而与对象层面的定义者实例无联系。普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象（注意，是对象），但当内部类是static的时候，意味着：

1）要创建嵌套类的对象，并不需要外围类的对象

2）不能从嵌套类的对象中访问非静态的外围类的对象。

嵌套类与普通的内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是嵌套类可以包含所有这些东西。（《Java编程思想》）

 

public class Out{
	static class In{
		public int value = 1;
	}
	public static In getIn(){
		return new In();
	}
}

public class Main {
   public static void main(String [] args){
	   Out out = new Out();
	   //Out.In in = out.new In();//这里报错。
	   Out.In in = Out.getIn();
	   System.out.println(in.value);
   }
}

作为一个独立的类，还需要实现被继承的功能。如果实例化一样，如果要继承一个外部类的内部类，需要以以下的形式：

 

public class InheritInner extends Out.In{}

现在考虑另一个机制：多态。若有一个子类继承了父类Out.它是否拥有父类的内部类呢？且看实例分析：

 

public class Out{
	class In{
		public int value = 1;
		public int getValue(){
			return value_out;
		}
	}
	public int value_out = 1;
}

public class Out2 extends Out{
    public int value_out = 2;
}

public class Main {
   public static void main(String [] args){
	   Out2 out2 = new Out2();
	   Out2.In in = out2.new In();
	   System.out.println(in.getValue());
   }
}

编译的时候并没有报错。运行结果是1，内部类定义于Out类中，则与Out类的对象之间有了联系。Out2类实例化的时候也是先实例化了Out类的一个对象。

 

那么，子类若拥有同名的类，是否能够将其覆盖呢？其实在Java里，这样的两个内部类是完全独立的两个实体，各自在自己的命名空间里。内部类在编译的时候也会产生一个.class文件，它们的名字是外围类的名字加上“$”再加上自己的名字，所以尽管在子类和父类中同名的内部类，其实也被编译为拥有不同的命名空间的类。

如果内部类是匿名的，编译器会简单地产生一个数字作为其标识符。如果内部类是嵌套在别的内部类之中，只需直接将它们的名字加上其外围类标志与"$"的后面。

如下例子：

 

public class Out{
	class In{
		public int value = 1;
		public int getValue(){
			return value_out;
		}
		class Inn{
			public int value = 8;
		}
	}
	public int value_out = 1;
}

编译之后的文件为：若Out2有内部类In，则还有一个Out2$In.class文件
最后是通过反射机制实例化内部类的尝试。

 

 

public class Out{
	class In{
		public int value = 1;
		public int getValue(){
			return value_out;
		}
	}
	public int value_out = 1;
}

public class Main {
   public static void main(String [] args){
	   Out.In in = null;
	try {
		in = (Out.In)Class.forName("Out$In").newInstance();
	} catch (InstantiationException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IllegalAccessException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	   System.out.println(in.value);
   }
}

上面程序报错：java.lang.InstantiationException: Out$In
at java.lang.Class.newInstance0(Class.java:357)
at java.lang.Class.newInstance(Class.java:325)
at Main.main(Main.java:6)
Exception in thread "main" java.lang.NullPointerException
at Main.main(Main.java:17)

 

内部类是与外部类在对象层次联系在一起的，如果没有实例化外部类不可以实例化内部类。所以我们将内部类定义为static提升到类层面。运行成功，代码如下：

 

public class Out{
	static class In{
		public int value = 1;
		public int getValue(){
			return value_out;
		}
	}
	public static int value_out = 1;//注意static调用到value_out,所以这里应该设为静态变量。
}

以上为今天学习内部类的笔记。学习书籍为《Java编程思想》，参考了百度百科和一些博客，代码为自己写的。肯定有所遗漏和错误的地方，请帮忙指出！谢谢！