黑马程序员技术交流社区

标题: 练习题问题 [打印本页]
作者: 孙飞    时间: 2012-6-28 21:38
标题: 练习题问题
本帖最后由 feigecal 于 2012-6-29 07:47 编辑

class data
{
        private static final data mInstance = new data();
        private static int mx = 0;
        private data()
        {
                System.out.println("mx=" + mx);
                mx = getVersion();
        }
        public static data getInstance()
        {
                return mInstance;
        }
        public int getVersion()
        {
                int v = 0;
                if (v == 0)
                {
                        v = 7;
                        
                }
                return v;
        }
        public int getmx()
        {
                return mx;
        }
}

class Test2
{
        public static void main(String args[])
        {
                System.out.println(data.getInstance().getmx());
        }
}

为什么最后mx的值不是7？运行详细过程？如果把private static final data mInstance = new data();中的final去掉，能不能加上一个setInstance方法给mInstance赋一个值，用那个get方法输出？如果可以怎么写？如果不行，为什么？
作者: 薄炳鑫    时间: 2012-6-28 22:10
本帖最后由 薄炳鑫 于 2012-6-28 22:18 编辑

你这是用的单例模式的思想所以是不能对对象进行修改的。
private data()
        {
                System.out.println("mx=" + mx);
                mx = getVersion();
                System.out.println("+++++++");//这里确定你上面的一句getVersion（）执行了。效果如图：

        }
当把mx前面的静态去了以后：执行结果就会和你想的一样了如下图：
作者: 周刚    时间: 2012-6-28 22:12
不能
因为如果要写setInstance(mInstance m)就势必要在Test2方法中new 一个mInstance实例作为参数传进去，
而事实上data类采用的是单例模式，外部不能创建mInstance实例。
作者: 常佳杰    时间: 2012-6-28 22:44
哥们看看这个解释,
package com.heima.changjiajie;

public class Test13 {
                public static void main(String args[])
                {
                            System.out.println(data.getVersion());//这儿也能证明返回的是7
                            //System.out.println(data.getInstance());
                        System.out.println(data.getInstance().getmx());//data.getInstance().getmx()这个方法
                                                                      //先是执行了getInstance，再就是getmx()了，没实例化对象所以没掉用构造函数，就没执行private data(),getversion()等，所以return的是mx的初始值...
                }
        }
        class data
        {
                private static final data mInstance = new data();
                private static int mx = 0;
                private data()
                {
                        System.out.println("mx=" + mx);
                        mx = getVersion();
                       //System.out.println(mx);//这儿打印的也是7
                }
                public static data getInstance()
                {
                        return mInstance;
                }
                public static int getVersion()//加个static用来证明是不是返回的是多少，主函数里调用这个方法..
                {
                        int v = 0;
                        if (v == 0)
                        {
                                v = 7;
                        }
                       // System.out.println(v);//这儿打印的是7，也就证明返回的也就是7了，
                                        return v;
                }
                public int getmx()
                {
                        return mx;
                }
        }

       
       
       
作者: 孙飞    时间: 2012-6-28 23:46
常佳杰 发表于 2012-6-28 22:44
哥们看看这个解释,
package com.heima.changjiajie;

如果没调用 构造函数怎么会执行构造函数中的语句System.out.println("mx=" + mx);呢？
作者: 孙飞    时间: 2012-6-29 00:04
想了半天我感觉是这样的，不知道对不？首先类加载的时候，运行第一句的初始化，new一个对象也就是private static final data mInstance = new data();这句。因为new了一个对象，所以构造函数运行，执行System.out.println("mx=" + mx);输出"mx"=0。然后构造函数中的mx = getVersion();调用下面的方法，返回了7.然后运行第二名 private static int mx = 0;又给mx赋值了0.所以最后输出的是0。
但如果是这样的话，静态初始化不是优先于构造函数执行吗？为什么第一句运行后不是运行第二个静态初始化，而是运行构造函数呢？不太明白



作者: 赵庆礼    时间: 2012-6-29 00:13
class data
{
private static final data mInstance = new data();  //去掉final之后也是不可以对mInstance赋值的
    private static int mx = 0;   //如果把static去掉会得到你想要的结果，参考截图：第二个执行结果为去掉static之后的情况
    private data()
    {
        mx = getVersion();   //java编译时是逐行编译，当编译该行代码的时候getVersion（）并没有返回值，mx还是默认的值0，所以打印的结果是0  。
                                        //但是，在执行main函数的时候getVersion（）函数会被执行，打印的结果为v=7，下图可以说明该情况。
        System.out.println("data()中：mx = " + mx);
    }
    public static data getInstance()
    {
        return mInstance;
    }
    public int getVersion()
    {
        int v = 0;
        if (v == 0)
        {
   v = 7;      
        }
  System.out.println("执行时：v = "+v);
        return v;
    }
    public int getmx()
    {
        return mx;
    }
}
class TestDataDemo
{
    public static void main(String args[])
    {
        System.out.println("main中：mx = "+data.getInstance().getmx());
    }
}
如图

作者: 常佳杰    时间: 2012-6-29 00:13
调用
public int getmx()
                {
                        return mx;
                }
方法时，return的是mx，mx的值是初始值0，所以返回的是0
输出的也就是0了
作者: 常佳杰    时间: 2012-6-29 00:14
想了半天就只有这种可能了..
按流程应该是..
作者: rslheima    时间: 2012-6-29 02:22
本帖最后由 rslheima 于 2012-6-29 02:23 编辑

首先要了解类的初始化顺序：（参考 http://www.cnblogs.com/jackyrong/archive/2008/08/12/1266161.html）根据我自己的理解：
(1)data.getInstance().getmx()
              |---mInstance = new data()  会初始化一个构造函数 new data()，  但在这之前会先初始化静态变量，(按顺序)
                                                                                                                                                           |--private static （final ）data mInstance  = new data();  
                                                                                                                                                           |                                                                  |--调用getVersion使得mx为7
                                                                                                                                                           |-- private static int mx =0;//这里又重新给mx赋值为0了

(2)之后调用getmx() ，这时mx等于0，所以返回了0



作者: 孙飞    时间: 2012-6-29 07:42
rslheima 发表于 2012-6-29 02:22
首先要了解类的初始化顺序：（参考 http://www.cnblogs.com/jackyrong/archive/2008/08/12/1266161.html）
...

我感觉 也是这样的运行
作者: 孙飞    时间: 2012-6-29 07:43
常佳杰 发表于 2012-6-29 00:14
想了半天就只有这种可能了..
按流程应该是..

我想应该是十楼说的那样
作者: 刘蕴学    时间: 2012-6-29 14:48
本帖最后由 刘蕴学 于 2012-6-29 15:34 编辑
  1. class data
  2. {
  3.                
  4.         private static final data mInstance = new data();
  5.         
  6.         private static int mx;
  7.         
  8.         //这么初始化比较安全
  9.         static
  10.         {
  11.                 mx = getInstance().getVersion();
  12.         }
  13.         
  14.         public static data getInstance()
  15.         {
  16.                 return mInstance;
  17.         }
  18.         
  19.         public int getVersion()
  20.         {
  21.                 int v = 0;
  22.                 if (v == 0)
  23.                 {
  24.                         v = 7;
  25.                         
  26.                 }
  27.                 return v;
  28.         }
  29.         
  30.         public int getmx()
  31.         {
  32.                 return mx;
  33.         }
  34. }

  36. class Test21
  37. {
  38.         public static void main(String args[])
  39.         {
  40.                 System.out.println(data.getInstance().getmx());
  41.         }
  42. }
复制代码
把我都整乱了。。。。10楼的解释确实木有问题，不过我还是建议你不在构造方法里初始化静态变量，写静态块吧
作者: 黑马罗坚    时间: 2012-6-29 16:02
成员属性初始化分为显示初始化和隐士初始化  private static final data mInstance = new data();
                private static int mx =0;  首先执行   private static final data mInstance =null;   private static int max=0;  这是影视初始化  相当于写代码是写的
private static final data mInstance；  private static int mx;   接下来显示初始化  把new data();的结果返回给minstance 在这之前mx已经隐士初始化了所以不会出现找不到mx的情况  minstance把 mx赋值了7   接下来mix的显示初始化又把mx赋值了0  在调用getInstance返回对象 调用对象的getMax打印 现在max=0 所以结果是mx=0   0
作者: 黑马罗坚    时间: 2012-6-29 16:18
执行流程  首先 定义声明了的静态变量 private static final data mInstance;        private static int mx;  接着把new data()结果赋值给  中途把7赋值给mx 因为mx被声明了所以不会报错 mx=7 接下来把mx显示赋值  把0赋值给mx所以mx 的值为0  调用getInstance  返回对象 调用getMx 打印所以结果为mx=0   0



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2