java 在内部类返回_Java内部类

内部类

定义在另一个类中的类称之为内部类，典型的应用是外部类将有一个方法，它返回一个内部类的引用。

public classTest {public static voidmain(String[] args){

Outer o= newOuter();

Outer.Inner i= o.showInner(); //OuterName.InnerName表示内部对象类型

System.out.println(i.getName());

}

}classOuter{classInner{privateString name;

Inner(){

name= "sakura";

}publicString getName() {returnname;

}

}

Inner showInner(){return new Inner(); //外部类的方法，返回一个内部对象的引用

}

}

内部类有外部类所有成员的访问权限。 事实上，某个外部类对象创建了一个内部类对象是，该内部类对象会秘密捕获一个指向外部类对象的引用，在访问外部类成员时，将用那个引用访问。

1)在外部创建内部类对象时声明内部类对象类型为      //OuterClassName.InnerClassName

2)在外部创建内部类对象需要引用外部类对象，构造语法为      //OuterObjectName.new InnerClassName(parameters)

3)生成外部类对象的引用：外部类名称紧跟圆点紧跟this      //OuterClassName.this

public classTest {public static voidmain(String[] args){

Outer o= newOuter();

Outer.Inner i= o.new Inner(); //1)和2)

}

}classOuter{private String name = "sakura";

Outer(){

}publicString getName() {returnname;

}public classInner{

Inner(){

System.out.println(Outer.this.getName()); //3)

}

}

}

局部内部类

1)局部内部类不能用public 或private 访问说明符进行声明。它的作用域被限定在声明这个局部类的块中。

2)局部内部类对外界完全隐藏，只有所在方法可以知道它的存在。

3)它们不仅能够访问包含它们的外部类， 还可以访问局部变量。不过， 在jdk8之前，那些局部变量必须事实上为final。

public classOuterClass

{private String str = "OutStr";public voidOuterMethod(String str1)

{

System.out.println("OuterMethod");class InnerClass //局部内部类

{publicInnerClass() {}public voidInnerMethod()

{

System.out.println("InnerMethod");

}public voidInnerShow()

{

System.out.println(str);

System.out.println(str1);

InnerMethod();

}

}

InnerClass inner= newInnerClass();

inner.InnerMethod();

inner.InnerShow();

}public static voidmain(String[] args)

{

OuterClass test= newOuterClass();

test.OuterMethod(test.str);

}

}

匿名内部类

1)匿名类有两种实现方式：

继承一个类，重写其方法。

实现一个接口(可以是多个)，实现其方法。

newSuperType(construction parameters)

{

innerclassmethods and data

}newInterfaceType

{

methods and data

}

匿名内部类实现接口

public class Test {

public Contents contents(){

return new Contents(){ //匿名内部类，实现接口

int i = 0;

public int value(){return i;}

};

}

public static void main(String[] args){

Test t = new Test();

Contents c = t.contents();

}

}

interface Contents{

int value();

}

匿名内部类继承父类

public classTest {public Wrapping wrappering(intx){return new Wrapping(x){ //匿名内部类,继承父类

public intvalue(){return super.value();

}

};

}public static voidmain(String[] args){

Test t= newTest();

Wrapping w= t.wrappering(10);

}

}classWrapping{private inti;public Wrapping(int x){ i=x;}public int value(){returni;}

}

2)匿名内部类没有构造器，但可以有构造体

public classTest {publicContents contents(){return new Contents(){ //匿名内部类

inti;

{//构造体

i = 0;

System.out.printf("i:" +i);

}public int value(){returni;}

};

}public static voidmain(String[] args){

Test t= newTest();

Contents c=t.contents();

}

}interfaceContents{intvalue();

}

静态内部类

1)有时候， 使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象。为此，可以将内部类声明为static(静态内部类), 以便取消产生的引用。

2)静态内部类不能访问非静态的外部类对象；创建静态内部类对象不需要通过外部类对象。

3)静态内部类可以有静态域和方法。

public classTest {public static voidmain(String[] args){

Outer o= newOuter();

Outer.Inner i= new Outer.Inner(); //直接通过类名创建，对比于 o.new Inner();

}

}classOuter{private String name = "sakura";

Outer(){

}publicString getName() {returnname;

}public static classInner{static int id = 20151003; //静态域ok

static String show_id(){ //静态方法ok

return ""+id;

}

Inner(){//System.out.println(Outer.this.getName()); 报错，无法访问外部类成员

}

}

}

继承内部类

classwithinner{

withinner(){

}classinner{

}

}public class Test extendswithinner.inner{

Test(withinner w){

w.super(); //外部类引用.super()

}public static voidmain(String[] args) {

Test t= new Test(newwithinner());

}

}

每个内部类都能独自得实现一个接口，不管它的外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。