Java内部类

Java内部类

1. 定义普通内部类

package com.sam.innerclass;

public class Parcel1 {
	
	//define inner class
	class Content{		
	}
	
	public void ship() {
		Content c = new Content();
	}
	
	public static void main(String[] args) {
		Parcel1 p = new Parcel1();
		p.ship();
	}

}

 

2. 外部类创造内部类对象

package com.sam.innerclass;

public class Parcel2 {
	
	public void ship() {
		Parcel1 p = new Parcel1();
		
		//OuterClassName.InnerClassName
		Parcel1.Content c = p.new Content();
	}
}

 

3. 给内部类加修饰符

package com.sam.innerclass;

public class Parcel3 {
	
	//define inner class
	private class Content{		
	}
	
	public void ship() {
		Content c = new Content();
	}
}

class TestParcel3{
	Parcel3 p = new Parcel3();
	// Illegal -- can't access private class:
	//! Parcel3.Content = p.new Parcel3();
}

普通的（非内部的）类，不能声明为private或protected；它们只可以被赋予public或者包访问权。

 

4.局部内部类，可定义在方法中。

package com.sam.innerclass;

public class Parcel4 {	
	public void ship() {		
		// Nesting a class within a method.
		class Content{		
		}
	}
}

 

5. 在任意作用域嵌入内部类，已经和其它类一起编译过了

package com.sam.innerclass;

public class Parcel5 {
	public void ship(boolean b) {
		if (b) {
			// Nesting a class within a scope.
			class Content {
			}
		}		
		// Can't use it here, out of scope
		//! Content c = new Content();		
	}
}

 

6. 匿名内部类

公用接口Destination

package com.sam.innerclass;

public interface Destination {
	String readLine();
}

 公用借口Contents

package com.sam.innerclass;

public interface Contents {
	int value();
}

 匿名内部类例子：

package com.sam.innerclass;

public class Parcel6 {
	public Contents ship() {
		return new Contents() {
			@Override
			public int value() {
				return 0;
			}
		};
	}
}

 上述匿名语法是下述形式的简化形式：

class MyContents implements Contents{
	public int value() {		
		return 0;
	}	
}
return new MyContents();

 

7. 带参数构造方法的匿名内部类

 

公共类

package com.sam.innerclass;

public class Wrapping {
	private int i;
	public Wrapping(int x) {
		i = x;
	}
	public int value() {
		return i;
	}
}

 

匿名内部类的构造方法带参数：

package com.sam.innerclass;

public class Parcel7 {
	public Wrapping wrap(int x) {
		return new Wrapping(x) {
			public int value() {
				return super.value()*47;
			}
		};
	}
}

 

8.匿名内部类中访问外部参数引用必须是final的。

package com.sam.innerclass;

public class Parcel8 {
	public Contents ship(final String name) {
		return new Contents() {
			String uname = name;
			public int value() {
				return 0;
			}			
		};
	}
}

 

9. 通过实例初始化，能达到为匿名内部类创建一个构造器的效果。

package com.sam.innerclass;

abstract class Base{
    public Base(int i) {
    }
    public abstract void f();
}

public class AnonymousConstructor {
    public static Base getBase(int i) {
        return new Base(i) {
            public void f() {               
            }           
        };
    }
}

package com.sam.innerclass;

abstract class Base{
	public Base(int i) {
	}
	public abstract void f();
}

public class AnonymousConstructor {
	public static Base getBase(int i) {
		return new Base(i) {
			public void f() {				
			}			
		};
	}
}

 此例中i不要求的final的，因为没有在匿名内部类中直接使用。

 

10. 内部类可以访问外围类的所有对象。

package com.sam.innerclass;

public class Parcel1 {
	int i;
	//using object of outer class
	class Content{	
		int j = i;
	}	
}

 

11.嵌套类

内部类与外部类不再有联系，嵌套类就是内部类加上一个static，内部类中不再有外部类的this对象。

package com.sam.innerclass;

public class Parcel10 {

	static class Content{
		static void ship() {		
		}
	}
}

 

12. 引用外围类的对象

要创建内部类对象，必须先创建外围类对象，因为内部类都回悄悄地连接到外围类对象。

package com.sam.innerclass;

public class Parcel11 {
	class Content {
	}

	public static void main(String[] args) {
		// this is wrong
		// ! Content c = new Content();

		Parcel11 p = new Parcel11();
		Content c = p.new Content();
	}
}

 

13. 从多层嵌套类中访问外部类成员

package com.sam.innerclass;

public class Parcel12 {
	class A {
		class B {
			class C {
			}
		}
	}

	public static void main(String[] args) {
		Parcel12 p = new Parcel12();
		Parcel12.A a = p.new A();
		A.B b = a.new B();
		A.B.C c = b.new C();
		A.B.C c2 = new Parcel12().new A().new B().new C();
	}
}

 

14. 内部类的继承

继承内部类，缺省的构造器不能用，必须在构造器里用外网类引用的super（）方法。

enclosingClassReference.super();

package com.sam.innerclass;
class WithInner {
	class Inner {}
}
public class InheritInner extends WithInner.Inner{
	//! InheritInner() {} //Won't compile
	InheritInner(WithInner wi) {
		wi.super();
	}
}

 

15. 内部类可以被覆盖吗

继承外部类，再覆盖内部类，执行时并没有什么作用，内部类在各自的命名空间里。

package com.sam.innerclass;
class WithInner {
	class Inner {}
}
public class InheritInner extends WithInner{
	class Inner{}
}

 

但当覆盖的内部类明确继承某个内部类时，则有作用。

package com.sam.innerclass;
class WithInner {
	class Inner {}
}
public class InheritInner extends WithInner{
	class Inner extends WithInner.Inner {}
}

 

16. 局部内部类和匿名内部类的区别

初始化时，局部内部类可以有构造方法，匿名内部类因为没有名字，所以没有构造方法。

 

17. 内部类的class文件

Counter.class

LocalInnerClass$2.class

LocalInnerClass$1LocalCounter.class

LocalInnerClass.class

匿名类会产生一个数字加在$后面。

 

18. 为什么需要内部类

答案：可以实现Java的多重继承，每个内部类可以实现一个单独的接口。

 

19. 闭包与回掉

闭包是一个可调用的对象，记录了创建它作用域的一些信息，内部类是面向对象的闭包，内部类可以继承接口，实现方法后返回一个钩子。

 

1. 指明内部类对象的类型：OuterClassName.InnerClassName