内部类

首先了解内部类，顾名思义，将类嵌套在另一个类的内部，简单内部类：

public Student{
        private String name;//StbClass也可以使用name
        public StbClass{
                String getClass(){
                    name = "王大侠";
                }
        }
}

StbClass就是内部类。

 

=>使用内部类的原因：

1、内部类可以使用该类定义所在作用域中的数据，包括private修饰符在内的。

2、对同一包的其他类隐藏。

3、当要定义一个回调函数，而且只想编写少量代码来说，使用匿名内部类（后面）比较方便。（Java核心技术）

 

在外部类中初始化内部类，内部类的实例会绑定对应外部类的实例（除了内部类定义在静态方法中）。内部类的对象总有一个隐式引用，指向创建它的外部类对象。若是某个方法如getId中初始化内部类，那么这个内部对象将会绑定在执行该方法的实例上。

public class Student {
        //StbClass stbClass = new StbClass();
	private Integer id;	

	class StbClass{
		public void setId(){
			id = 8;
		}
 	}
	
	public Integer getId(){
		StbClass stbClass = new StbClass();
		stbClass.setId();
		return id;
	}
}

在外部类作用域之外实例化内部类，则需要特殊处理：

Student student = new Student();
Student.StbClass stbClass = student.new StbClass();

上面简写就是：OutClass.InnerClass。不过当StbClass设为私有，就不能再外部类外部实例化该类，只能在外部类内部声明。

 

内部类是一种编译器现象，与虚拟机无关。例如编译成外部类名+“$”符号+内部类名，而虚拟机却不知道。内部类访问外部类的私有数据存在一定的安全风险，即有可能通过附加在外围类所在包中的其他类访问到它们（有机会尝试）。

 

 

=>着重说明局部内部类、匿名内部类和静态内部类（static）。

 

1、局部内部类：

在一个类的方法中定义局部类，不能用public、private来修饰，作用域即在声明该局部类的代码块中。

	public Integer run(){
		class School{
			public void send(){
				id = 9;//访问外部类变量
			}
		}
		School school = new School();
		school.send();
		return id;
	}

School即为局部内部类，可以访问类的私有变量，也可以访问实例化在方法外部定义的简单外部类，不过它的作用域仅限于run方法中，即对外部完全隐藏。

 

局部类还可以访问方法参数，这些参数需要声明为final，所以只能引用：

	public Integer run(final String schoolName){
		class School{
			public void send(){
				id = 9;
				if("".equals(schoolName)){
					System.out.println("有啊");
				}
			}
		}
		School school = new School();
		school.send();
		return id;
	}

 

2、匿名内联类：

只创建一个类的对象，它允许在一个方法体内动态地定义没有命名的类的实现。

	public Integer run(){
		ISchool school = new ISchool() {
			public void send(){
				id = 9;
			}
		};
		return id;
	}

创建一个ISchool接口类的对象，需要实现的send方法在{}内部。

 

 

匿名内部类需继承扩展一个类或者实现一个接口。匿名内部类没有名称，意味着该类没有构造函数，不过可以将构造参数传给父类的构造函数（接口除外）。它的通常格式是：

new 父类名(构造参数)/接口名(){
     匿名内部类方法和数据
}

它比普通实例化对象多了{}。

public interface ISchool {
	public void send();
}
public Integer run(){
	ISchool school = new ISchool() {
                //重写接口方法
		public void send(){
			id = 9;
		}
	};
	school.send();
	return id;
}

public class School {
	private Integer i;
	public School(Integer i) {
		super();
		this.i = i;
	}
	public void send(Integer i){}
}

public Integer run(Integer i){
	School school = new School(i) {
                //扩展
		public void send(Integer a){
			id = a+9;
		}
	};
	school.send(i);
	return id;
}

上面的id返回之和。

上面的代码省去了一些编写接口实现类和子类的代码，也适用于编写少量代码的回调函数。在多线程应用中会大量使用匿名类。

		Thread thread = new Thread(){
			public void run(){
				System.out.println("运行中.");
			}
		};
		thread.start();
		
		Runnable runnable = new Runnable() {
			public void run() {
				System.out.println("运行中..");
			}
		};
		new Thread(runnable).start();

匿名内部类获取静态方法的类名，可以像new Object(){}.getClass().getEnclosingClass();，new Object(){}建立Object的一个匿名子类的一个匿名对象。

 

3、静态内部类 

当使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外部类对象，可以用static修饰，避免引用。

class Student{
     public static class Book{
	......	
     }
}

若在静态方法中使用到内部类，那么它必须声明成静态内部类。声明在接口中的内部类会自动成为static和public型。

 

下面的例子：

一个非静态的嵌套类的构造器，在编译的时候会将一个隐藏的参数作为它的第一个参数，这个参数表示了它的直接外围实例。当你在代码中任何可以让编译器找到合适的外围实例的地方去调用构造器的时候，这个参数就会被隐式地传递进去。但是，上述的过程只适用于普通的构造器调用，也就是不使用反射的情况。

当你使用反射调用构造器时，这个隐藏的参数就需要被显式地传递，这对于Class.newInstance方法是不可能做到的。要传递这个隐藏参数的唯一办法就是使用java.lang.reflect.Constructor。（考虑到从Java程序到class文件的映射的复杂度，请避免使用反射来实例化内部类。）

import java.lang.reflect.Constructor;

public class Outer {
	public static void main(String[] args) throws Exception {
		new Outer().greetWorld();
	}
	private void greetWorld() throws Exception {
		Constructor<Inner> constructor = Inner.class.getConstructor(Outer.class);//反射调用构造器需要注意的地方
		System.out.println(constructor.newInstance(Outer.this));
	}
	public class Inner {
		public String toString() {
			return "Hello world";
		}
	}
}

其实这里Inner实例并不需要一个外围的Outer实例，所以可以将Inner类型声明为静态的（static）。除非你确实是需要一个外围实例，否则你应该优先使用静态成员类（static member class）而不是非静态成员类。

即：

public class Outer {
	public static void main(String[] args) throws Exception {
		new Outer().greetWorld();
	}
	private void greetWorld() throws Exception {
		System.out.println(Inner.class.newInstance());
	}
	public static class Inner {
		public String toString() {
			return "Hello world";
		}
	}
}

结果打印出Hello World。

 

静态内部类（static）、非静态内部类（除了上面的特例）的区别：

（1）在于非静态内部类可以访问定义在外围类的实例变量，而静态内部类则不可以。

（2）非静态内部类完全封装在外围类中。虽然允许从外部代码中引用非静态内部类，不过不要那样做。静态内部类可以被外部代码使用和实例化，只要访问限定符号不是private。如静态内部类Entry（Map$Entry.class），遍历Map对象中的key-value对。在Map之外的上下文中，使用Map.Entry来引用这个类。

（3）静态内部类允许序列化，而非静态内部类不能序列化，因为他们可以访问外部实例变量，那么就意味着还要处理外部类的成员变量。

 

所以将内部类声明成静态的首要原因是别的类可以使用它，第二个原因是允许其序列化。

	public static class Book implements Serializable{
		private static final long serialVersionUID = 1L;
	}