java的内部类问题
2009-11-11 20:59:58 来源:WEB开发网核心提示: class Outer{ PRivate int index=100; public class Inner {private int index=50; void print() {int index=30;System.out.println(index);System.out.println(this.inde
class Outer
{
PRivate int index=100;
public class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
Inner getInner()
{
return new Inner();
}
}
public class Testprint
{
public static void main(String[] arguments)
{
Outer out=new Outer();
out.print();
Outer.Inner inner1=out.getInner();
inner1.print();
}
}
这是个简单的例子,只是我会从这个例子中总结出一些我的经验,关于java和C#的
类中类可以看作是类的一个非静态的方法,你可以返回这种方法, Inner getInner()
{
return new Inner();
}
如果你在类外访问类中类的时候,可以这么作
在java和C#中类的变量既字段一旦声明赋初值后就不能更改了,
class Outer
{
private int index=100;
index=400;
}
这么写是错的,要想对值修改可以在构造函数中,比如
class Outer
{
private int index;
public Outer()
{
this.index=400;
}
还有一个需要注意的问题就是类的字段要访问修饰符号,但方法的是局部变量就不需要:
void print()
{
private int index=30;
System.out.println(index);
}
这么写是错的,这叫画蛇添足,应该:
void print()
{
private int index=30;
System.out.println(index);
}
类中的方法是可以相互访问的,但是非静态的方法不可以访问静态的方法,静态的方法不可以访问非静态的方法
public class Outer
{
private int index=100;
public class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
Inner getInner()
{
return new Inner();
}
public static void main(String[] arguments)
{
Outer out=new Outer();
out.print();
Outer.Inner inner1=out.getInner();
inner1.print();
Inner inner=new Inner();
inner.print();
}
}
这样写会出现一个错误
non-static variable this cannot be referenced from a static context
就是说this指针不能访问静态的方法main()
关于这个示例还有一点就是类中类可以任意的访问它的父类,因为类中类保存了它的父类的this指针!
如果类的访问修饰符没写,就是默认的,默认的类在包体内部是可以相互访问的,但是在包外是不能访问的哦!
class Testprint
{
public static void main(String[] arguments)
{
Outer out=new Outer();
Outer.Inner inner2=out.new Inner();
}
}
对于类中类的定义也可以采取这种方式定义,不过要先定义外部类,然后定义这个类的内部类
{
PRivate int index=100;
public class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
Inner getInner()
{
return new Inner();
}
}
public class Testprint
{
public static void main(String[] arguments)
{
Outer out=new Outer();
out.print();
Outer.Inner inner1=out.getInner();
inner1.print();
}
}
这是个简单的例子,只是我会从这个例子中总结出一些我的经验,关于java和C#的
类中类可以看作是类的一个非静态的方法,你可以返回这种方法, Inner getInner()
{
return new Inner();
}
如果你在类外访问类中类的时候,可以这么作
在java和C#中类的变量既字段一旦声明赋初值后就不能更改了,
class Outer
{
private int index=100;
index=400;
}
这么写是错的,要想对值修改可以在构造函数中,比如
class Outer
{
private int index;
public Outer()
{
this.index=400;
}
还有一个需要注意的问题就是类的字段要访问修饰符号,但方法的是局部变量就不需要:
void print()
{
private int index=30;
System.out.println(index);
}
这么写是错的,这叫画蛇添足,应该:
void print()
{
private int index=30;
System.out.println(index);
}
类中的方法是可以相互访问的,但是非静态的方法不可以访问静态的方法,静态的方法不可以访问非静态的方法
public class Outer
{
private int index=100;
public class Inner
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
void print()
{
Inner inner=new Inner();
inner.print();
}
Inner getInner()
{
return new Inner();
}
public static void main(String[] arguments)
{
Outer out=new Outer();
out.print();
Outer.Inner inner1=out.getInner();
inner1.print();
Inner inner=new Inner();
inner.print();
}
}
这样写会出现一个错误
non-static variable this cannot be referenced from a static context
就是说this指针不能访问静态的方法main()
关于这个示例还有一点就是类中类可以任意的访问它的父类,因为类中类保存了它的父类的this指针!
如果类的访问修饰符没写,就是默认的,默认的类在包体内部是可以相互访问的,但是在包外是不能访问的哦!
class Testprint
{
public static void main(String[] arguments)
{
Outer out=new Outer();
Outer.Inner inner2=out.new Inner();
}
}
对于类中类的定义也可以采取这种方式定义,不过要先定义外部类,然后定义这个类的内部类
更多精彩
赞助商链接