为什么Non-static class 内不能有static data static method static class?

Question

看看这个例子:     
class TestConstructor{
          static int i;//class variable
                     int j;//instance variable
              TestConstructor(int i,int j){
                     this.i=i;
                     this.j=j;
              }//constructor
        static void StaticFun(){
                      System.out.println("i is"+i);
                      i++;
                    //j++;
               }//static function或class function
        public void InstanceFun(){
                      System.out.println("i is"+i+";j is"+j);
                      i++;
                      j++;//这里可以的!
               }
}
class TestInitial{
        public static void main(String[] args){
           TestConstructor tc=new TestConstructor(1,2);//初始化i,j
           tc.StaticFun();
           tc.InstanceFun();
           
       }
}

Answer 1

哥们，你使用/调用静态字段的手法有问题，应该是用<类名>.<静态字段>
比如你class TestConstructor的构造函数中应该是TestConstructor.i=i;
StaticFun中应该是
System.out.println("i is "+TestConstructor.i);
TestConstructor.i++;
InstanceFun()中应该是
System.out.println("i is "+TestConstructor.i+";j is "+j);
TestConstructor.i++;
j++
你好好看看书吧！呵呵～～

Answer 2

楼主的可以问题这样解释：
因为无论如何每个类都会存储一些关于类的RTTI信息，比如类名什么的
静态方法和字段都是和RTTI存储方法一样的，应为，对于所有的类实例静态的东西都只有一份
而对于静态方法，是因为上面提到的存储RTTI的地方只有一些关于静态方法的引用，所以和静态字段都是一样存储的

Answer 3

public class TestConstructor {    public static final int param = 0;//static final variable    public static int count = 0;//static variable    private int c;//variable    private InnerClass innerC = null;//just for demo and i make it null    private StaticInnerClass sInnerC = null;    //Get&Set Here...
    public TestConstructor() {
    }    public TestConstructor(int c) {
        this.c = c; //donot initialize static variable here
    }    protected class InnerClass {
        int value;
        InnerClass(int value) {
            this.value = value;
        }
    }    protected static class StaticInnerClass {
        int value;
        StaticInnerClass(int value) {
            this.value = value;
        }
    }    public static void main(String[] args) {
        StaticInnerClass demoClass1 = new StaticInnerClass(1);        TestConstructor demoClass2 = new TestConstructor();        InnerClass demoClass3 = demoClass2.new InnerClass(1);        System.out.println(TestConstructor.count + ":" + TestConstructor.param);        System.out.println(demoClass2.c + ":" + demoClass2.innerC + ":" + demoClass2.sInnerC);
    }
}

Answer 4

另外在仔细看了楼主的贴子和标题后，我仍然不知道他再说什么
花费了几分钟写了一个例子，希望有所帮助，略去了所有不必要的代码
另外，由于main()在这个类中，所以它可以访问私有变量（所以我可以省去Get^^）
不过这不是一个良好的编程习惯

Answer 5

楼主不出来，只能揣摩他的意思了
是不是想了解java类的内存形式，呵呵

Answer 6

我的意思就是想知道为什么non-static class 为什么不能有static method ？
不能有static method 是不是和不能有static data一样的原因？
原因又何在？
谢谢各位的积极参与,感激ing..
继续讨论一下吧，应该对大家都有帮助的。

Answer 7

主要问题是non-static class是什么意思，有这种说法吗？

Answer 8

什么叫non-static class？？看不懂你在说什么？

Answer 9

不好意思，我也至今没看过non-static class，楼主贴个代码

Answer 10

错了，是non-static inner class!

Answer 11

哦，这个好解释：
解释1/跟你Wapper类（外覆类）用法有关，就好像路径不对一样；
解释2/因为inner类非静态，所以必须有他的一个实例，而通过实例调用就没必要用静态了吧
你看看，有没有参考价值～～
欢迎联系我，QQ：21445102（多数时间不在）mail：[email protected]

Answer 12

还是有可能有这个需要的。无论static field还是static method逻辑上也都是说得通的。memory model对此并无影响。因为，一个inner class完全可以转化为一个拥有host class指针的静态nested class。至于为什么java不支持呢？
我想，原因可能是这个东西的需求不大，实现起来又需要额外的工作量，所以权衡利弊，sun认为不值得吧。也或许，跟java class的动态加载机制有关？static member对non-static inner class可能会有些不利的影响？
没有仔细研读过java spec，不好下结论。

Answer 13

在java中，如果把一个类的定义放到另一个类的定义中，里面的类被称作嵌套类(nested class)。如果需要的话，一个嵌套类可以在它的内部有它自己的另一个嵌套类。而
    你定义的嵌套类实际就是一个封闭在类中的成员，这点与其他的成员一样。一个嵌套类可以同其他类的成员一样有一个访问属性，并且按同样的方式由这个属性决定从封装类的外部的可访问能力。
public class Outside
{
    //Nested class
    public class Inside
    {
        //Details of Inside class
    }
    //More members of Outside class 
}
    这里的类Inside嵌套在类Outside中。类Inside声明为Outside类的一个公有成员，所以它可以从Outside的外面访问。显而易见，一个嵌套类应该与包含它的类有一些特殊的联系。任意的将一个类嵌到另一个类是不明智的。这里的Outside被称作顶层类(top-level class)。顶层类是一个包含嵌套类而它自己没有被嵌套到其他类中的类。
    这里的嵌套类只在一个Outside型对象范围内才有意义，这是因为Inside没有声明为Outside类的静态成员。在建立一个Outside型对象之前，你不能建立任何的Inside对象。然而，在你声明一个包含嵌套类的类对象时，不需要建立嵌套类的对象，当然，被类的构造函数建立的对象除外。例如，假设我们用下列语句建立一个对象：
Outside outer = new Outside();
    没有建立嵌套类的对象Inside。如果你现在希望建立一个嵌套类的对象，你就必须使用一个作为限定词的类的名字引用嵌套类。例如，已经声明了一个Outside类的对象，我们可以用下列语句建立一个Inside型的对象：
Outside.Inside inner = outer.new Inside();
    这里我们已经建立了一个嵌套类的对象，它于与我们前面建立的outer对象相关联。我们正是在outer对象范围内建立一个Inside型的对象。
    在Outside的非静态成员方法中，你可以使用Inside类名，而不需要任何限定，它将由编译器使用this变量自动加以限制。所以我们可以在对象Outside的方法内建立新的Inside对象：
Inside inner = new Inside();
    它等价于：
this.Insie inner = this.new Inside();
    所有的这些说明静态方法不能建立一个非静态嵌套的类对象。因为Inside类不是Outside类的静态成员，如果在Outside对象的范围内没有已存在的Inside对象，则引用一个不存在的对象将是错误的。由于Inside不是Outside类的一个静态数据成员，如果Outside类中的一个静态方法试图直接地建立一个Inside
型的对象，而开始并不存在一个Outside的对象，这种尝试在一个对象的合法范围外建立对象的操作将是非法的。
    还有因为类Insider不是一个Outside类的静态成员，所以它不能依次返回它自己包含的任何静态数据成员，当然也不能调用它自己包含的任何静态方法。由于Inside本身不是静态的，所以它不能用静态成员来从当一个自由稳定的类(而静态方法当然也可以看作静态成员)，这存在着逻辑上的矛盾。