为什么“非静态的内部类中的成员不能定义成静态的”？

xiaozhimin1978 2006-12-24 09:15:57

如题，谢谢!

...全文

1046 20 打赏收藏转发到动态举报

写回复

用AI写文章

20 条回复

切换为时间正序

请发表友善的回复…

发表回复

xiaozhimin1978 2006-12-28

打赏
举报

//在外部实例以外，建立内部类实例的方式，绝不推荐使用

是的，我也不赞成在其经地方创建某个内部类的实例，如果建立的内部类又要被其它不相关的类访问的话，还不如干脆定义成外部类算了

shine333 2006-12-27

打赏
举报

不是对static而是对非静态内部类

不同外部实例的内部类，似乎可以认为属于两个类型
public class Test {

public static void main(String[] args) throws Exception {
Test t1 = new Test();
A a1 = t.new A(); //在外部实例以外，建立内部类实例的方式，绝不推荐使用
}

class A {

}
}

xiaozhimin1978 2006-12-27

打赏
举报

第一种理解方法我是没有想到的，是不是我对 static 的理解不够？

shine333 2006-12-27

打赏
举报

恩

CD2 2006-12-27

打赏
举报

终于明白了！

xiaoyetao08 2006-12-26

打赏
举报

得
都在装Ｂ

xiaozhimin1978 2006-12-26

打赏
举报

请问 shine333(enihs)：

你在一楼举的例子的是不是我后来理解的意思？

shine333 2006-12-26

打赏
举报

这是一种简单理解问题的方式，但是归根结底，和内部类引用局部变量/参数必须final一样，还是由编译原理决定的

xiaozhimin1978 2006-12-26

打赏
举报

一楼的意思是不是说，在“非静态内部内中定义了静态内部成员”的前提下，会产生两种不同的理解方式：

1、仅仅是在同一个外部类对象中的不同内部类对象(outer1.inner1.innerx = out1.inner2.innerx, out2.inner1.innerx = out2.inner2.innerx)才共享它们的静态成员，不同的外部类对象的静态成员不共享(outer1.inner1.innerx != outer2.inner1.innerx，outer1.inner2.innerx != outer2.inner2.innerx)

2、所有有内部类对象都共享它们的静态成员，这样所有的 innerx 都共享了，也就不会不相等了

？？？？？？？

yaray 2006-12-25

打赏
举报

被static修饰的对象在相同JVM中只有唯一实例,表现出来就是其他对象共享此对象(共用相同的对象).

shine333 2006-12-25

打赏
举报

> 表示它可以脱离外部类的对象而单独创建
non-static的内部类不可能脱离外部实例而存在。
就上面的例子而言，对于outer1.inner1和outer1.inner2而言，它们访问outerX(或者完整的写法Outer.this.outerX)都是同一个即outer1.outerX，而outer2.inner1和outer2.inner2访问的就是他们对应的外部实例的outer2.outerX

> 静态的内部类只不过是多加了一个 package 的深度而已
静态内部类和非静态内部类不是一个概念

xiaozhimin1978 2006-12-25

打赏
举报

不是很明白一楼所说的，为什么

outer1.inner1.innerX != outer2.inner1.innerX
和
outer1.inner1.innerX = outer2.inner1.innerX

就我的理解，因为在 java 的内部类中可以访问外部内的非静态成员，因此非静态的内部类对象在创建之前必须先创建它的外部类对象，并且一个内部类的对象和它的外部类对象是相关联的。在程序的任意地方，创建内部类对象必须：
Outer outerObj = new Outer();
Inner innerObj = outerObj.new Inner();

但是如果内部类加上了 static 之后，表示它可以脱离外部类的对象而单独创建。从这个角度看，静态的内部类只不过是多加了一个 package 的深度而已。这样看来，一楼所说的 innerX 应该和一般的类成员没什么区别啊。难道说 static innerX 会多次分配空间？

我的理解而已，

gongyali2005 2006-12-25

打赏
举报

静态方法可以在没有产生类对像的时候使用！
非静态方法必须产生类对像才可以使用！

shine333 2006-12-25

打赏
举报

静态内部类基本上就可以参照你的理解。
但是非静态内部类就绝不能这样了

shine333 2006-12-25

打赏
举报

大哥,你要看清,他说的是为什么非静态内部类的成员为什么能是静态的

i.e:
class Outer {
class Inner {
int innerX; // OK
static int innerY; // NG
}
}

没人说内部类Inner的修饰符不能是static的

lixiaoxue85 2006-12-25

打赏
举报

1楼太牛

xiaozhimin1978 2006-12-25

打赏
举报

“> 表示它可以脱离外部类的对象而单独创建
non-static的内部类不可能脱离外部实例而存在。”

我的完整的话是：如果内部类加上了 static 之后，表示它可以脱离外部类的对象而单独创建。意思就是静态内部类是可以脱离外部类对象而存在的

“就上面的例子而言，对于outer1.inner1和outer1.inner2而言，它们访问outerX(或者完整的写法Outer.this.outerX)都是同一个即outer1.outerX，而outer2.inner1和outer2.inner2访问的就是他们对应的外部实例的outer2.outerX”

这个意思我明白

“> 静态的内部类只不过是多加了一个 package 的深度而已
静态内部类和非静态内部类不是一个概念”

我的意思是说，如果不考虑访问权限(public, default, protected 和 private)的话，静态的内部类和一般别的类没有什么不同了，只不过它的包的深度加了一层。比如外部类是 org.myorg.Outer，则这个外部类的一个内部类就变成了 org.myorg.Outer.Inner。如果从这个角度看，这个 org.myorg.Outer.Inner 内的成员为什么不可以是静态的呢

kingofworl 2006-12-24

打赏
举报

厉害

千里冰封820 2006-12-24

打赏
举报

楼上正解,牛

shine333 2006-12-24

打赏
举报

因为这会产生歧义。

比如

class Outer {
int outerX;
Inner inner1 = new Inner();
Inner inner2 = new Inner();
class Inner {
int innerX;
}
}

Outer outer1 = new Outer();
Outer outer2 = new Outer();

假如innerX是static的，那么这个static的含义是
1：仅是同一outer实例下的不同inner实例共享：
outer1.inner1.innerX=outer1.inner2.innerX，And
outer2.inner1.innerX=outer2.inner2.innerX，But
outer1.inner1.innerX!=outer2.inner1.innerX，Hence
outer1.inner2.innerX!=outer2.inner2.innerX

2: 所有outer实例的inner实例都共享：
outer1.inner1.innerX=outer1.inner2.innerX，And
outer2.inner1.innerX=outer2.inner2.innerX，And
outer1.inner1.innerX=outer2.inner1.innerX，Hence
outer1.inner2.innerX=outer2.inner2.innerX