《Java编程思想》学习笔记3——内部类

1.java中，可以将一个类的定义放在另一个类的内部，这种叫做内部类。

内部类允许编程人员将逻辑上相关的类组织在一起，并且控制内部类对其他类的可见性。

2.在外部类的非静态方法中创建内部类的对象语法：

外部类类名.内部类类名 对象名 = 外部类对象.new 内部类类名();

如：

public class Outter{
	class inner{
}
}
Outter out = new Outter();
Outter.Inner inner = out.new Inner();

注意：非静态的内部类必须要有外部类对象之后才能创建，因为外部类对象持有内部类的引用，如果内部类是静态的，则不需要外部类对象引用内部类对象。

3.内部类对外部类对象的引用：

外部类中所有的元素对内部类都是可见的，内部类持有对外部类对象引用的语法：外部类名称.this。如：

public class Outter{
	void f(){
System.out.println(“Outter f() method”);
}
	class Inner{
	public Outter outer(){
		return Outter.this;
}
}
	public Inner inner(){
		return new Inner();
}
}

4.方法内部类：

除了最常见的最为成员变量的内部类以外，内部类还可以定义在方法中，如：

public class Outter{
	public Inner getInner(){
		class Inner{
			public void f(){
	System.out.println(“Method inner class”);
}
}
return new Inner();
}
public void fout(){
	Inner inner = getInner();
	inner.f();
}
}

5.匿名内部类：

Java中匿名内部类的应用十分广泛，所谓的匿名内部类就是指所创建的内部类没有类名称，也就是不知道内部类的具体类型，如：

public class Outter{
	public Inner getInner(){
		return new Inner(){
			private String name = “inner”;
			public String getName(){
	return name;
}
};
}
}

上面的return newInner{……};就是一个匿名内部类，这个匿名内部类继承了Inner类，即其基类是Inner，但是其具体类型不清楚，该匿名内部类等效于下面的内部类写法：

public class Outter{
	class MyInner implement Inner{
		private String name = “Inner class”;
		public String getName(){
			return name;
}
}
public Inner getInner(){
	return new MyInner();
}
}

注意：匿名内部类是实现了new关键字之后的接口或继承了类，只是没有具体的类名称。

6.匿名内部类传递final参数：

如果在创建匿名内部类，需要外部类传递参数时，参数必须是final类型的，否则，编译时会报错。如：

public class Outter{
	public Inner getInner(final String name){
		return new Inner(){
			public name getName(){
				return name;
}
};
}
}

注意：如果外部类传递的参数在内部类中使用，则必须是final类型，如果没有在内部类中使用(如，仅在基类中使用)，则可以不用是final类型的。

7.静态内部类：

静态内部类又称为嵌套类，静态内部类和普通内部类的区别：

(1).对于非静态的内部类来说，内部类和外部类必须保持对象引用，内部类可以访问外部类的任何元素.

(2).静态内部类不需要和外部类保持对象引用，静态内部类只能访问外部类的静态元素。

8.为什么要使用内部类：

使用内部类主要有以下两个原因：

(1).解决java中类不能多继承的问题：

Java中的继承是单继承，在某些情况下接口的多继承可以解决大部分类似C++中多继承的问题，但是如果一个类需要继承两个父类而不是接口，在java中是没法实现这种功能的，内部类可以帮助我们部分解决这种问题，如：

abrstact class A{
	abstract public void f();
}
abstract class B{
abstract public void g();
}
public class D extends A{
	public void f(){}
	public B makeB(){
		return new B(){
			public void g(){};
}
}
}

这样既继承了A类，有在makeB方法中使用匿名内部类继承了B类。

(2).闭包方法问题：

在面向对象中有个术语叫闭包，所谓闭包是指一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。Java中不支持闭包，但是java的内部类可以看作是对闭包的一种解决方案，因为外部类的所有元素对于普通的内部类来说都是可见的，并且内部类还包含一个指向外部类的对象引用，因此在作用域内，内部类有权操作外部类的所有成员包括private成员。如：

interface Incrementable  {  
	void increment();  
}  

class Callee1 implements Incrementable  {  
private int i=0;  
public void increment()  {  
i++;  
System.out.println(i);  
}  
}  

class MyIncrement  {  
void increment()  {  
System.out.println("other increment");  
}  
static void f(MyIncrement mi)  {  
		mi.increment();  
}  
}  

class Callee2 extends MyIncrement  {  
private int i=0;  
private void incr()  {  
i++;  
System.out.println(i);  
}  
//闭包内部类
private class Closure implements Incrementable {  
public void increment() {  
incr();  
}  
}  
//回调函数
Incrementable getCallbackReference()  { 
//新建内部类   
return new Closure(); 
}  
}  

class Caller {  
private Incrementable callbackRefference;  
Caller(Incrementable cbh)  {  
callbackRefference = cbh;  
}  
void go() {  
//调用increment()方法
callbackRefference.increment(); 
}  
}  

public class Callbacks  {  
public static void main(String [] args) {  
Callee1 c1=new Callee1();  
Callee2 c2=new Callee2();  
MyIncrement.f(c2);  
Caller caller1 =new Caller(c1);  
//将内部类中的Closure赋给Caller  
Caller caller2=new Caller(c2.getCallbackReference());
caller1.go();  
caller1.go();  
caller2.go();  
caller2.go();  
}  
}

输出：
other increment
1
2
1
2
Callee2 通过使用内名内部类提供了一个访问自身increment方法的钩子，
通过getCallbackReference()方法获取内部类对象的引用，进而通过内部类的increment方法调用外部类的回调方法，这就是java中用于实现回调方法的闭包。