public class Intx {
static int i =110;
public static void main(String[] args) {
  int x =0;
  System.out.println(x+"..."+i);
  x =10;
  i =120;
  System.out.println(x+"..."+i);
}
}
其中的i 与x 同样都是局部变量 都一样的可以被调用，可以被直接赋值
1.那么他们定义在外面与里面有什么区别？
2.为什么定义在外面就必须用静态方法修饰？
3.如果外面的i 不用static修饰而改用final 修饰以后为什么直接调用（打印）就会报错？
4.在外部加上final修饰以后的i 有什么用？
5.而里面的x 加上final修饰以后直接调用不会报错？
一共5个问题~~

1. public class Intx {
   
2. static int i =110;
   
3. public static void main(String[] args) {
   
4.    int x =0;
   
5.    System.out.println(x+"..."+i);
   
6.    x =10;
   
7.    <font color="red">int =120;//缺不缺？
   
8. </font>   System.out.println(x+"..."+i);
   
9. }        <font color="red">}//少不少？？
   
10. </font>

复制代码

1. public class Intx {
   
2. static int i =110;
   
3. public static void main(String[] args) {
   
4.    int x =0;
   
5.    System.out.println(x+"..."+i);
   
6.    x =10;
   
7.    int =120;//这样定义不可以吧？
   
8.    System.out.println(x+"..."+i);
   
9. }//少不少大括号啊？
   

复制代码

郭宁 发表于 2012-5-16 18:22

代码已经该回来了，可能当初为了验证问题 修该了代码，上网时间太少，平均3天才到一次网吧，心比较急，谢谢你的细心，能不能方便解答下我的疑惑

1. public class Intx {
   
2.          static int i =110;
   
3.          
   
4.          public static void main(String[] args) {
   
5.            int x =0;
   
6.            System.out.println(x+"..."+i);
   
7.            x =10;
   
8.            i =120;
   
9.            System.out.println(x+"..."+i);
   
10.          }
    
11.          public void fun2(){
    
12.                  System.out.println(x);//这里访问X就会报错，因为X是在main函数里面的局部变量
    
13.                                                 //局部变量的有效范围 限定在他所在的 ｛｝里面
    
14.                  System.out.println(i);// 在这里访问i不会报错因为  没有跑出 i 的有效范围
    
15.          }        
    
16. }
    
17. 给你写两个函数，你硬挨明白 定义在外面 与定义在里面的区别了吧，外面可以被类里面的所有函数访问，函数里面则只能被此函数访问

复制代码

郭宁 发表于 2012-5-16 18:40

谢谢这位朋友的回答，但是你说的这个我知道，我想问的是就在那个里面是否有区别呢？
另外下面几个问题方便回答下嘛？感激不禁{:soso_e121:}
1为什么定义在外面就必须用静态方法修饰？
2如果外面的i 不用static修饰而改用final 修饰以后为什么直接调用（打印）就会报错？
3在外部加上final修饰以后的i 有什么用？
4而里面的x 加上final修饰以后直接调用不会报错？

—__ 发表于 2012-5-16 18:42
为什么定义在外面就必须用静态方法修饰？
如果外面的i 不用static修饰而改用final 修饰以后为什么直接调 ...

因为你在 main 函数里面没有实例化  Intx 对象 自然无法访问 i 了，即便你用 final修饰还是无法访问，因为就没有这个实例。
但你定义成static  在编译的时候 i  就被初始化了，自然可以访问。

问题的关键只在于你访问的 i 有没有被实例化，有没有分配内存空间，跟final无关，final修饰变量只是把它强制成常量来使用。

晕倒，码了半天IE崩溃了~~~~~~~~~~

那么他们定义在外面与里面有什么区别？
作用范围不一样
为什么定义在外面就必须用静态方法修饰？
静态修饰是随内存的加载而进入内存的，可以不用静太修饰
如果外面的i 不用static修饰而改用final 修饰以后为什么直接调用（打印）就会报错？
加final以后的变量不可以再修改
在外部加上final修饰以后的i 有什么用？
表明i是一个常量
而里面的x 加上final修饰以后直接调用不会报错？
如果你修改x的话一定会报错的

郭宁 发表于 2012-5-16 18:51
晕倒，码了半天IE崩溃了~~~~~~~~~~

:L 听了你的话 我压力好大，不过我想IE崩溃跟我没关系吧╮(╯_╰)╭ 不过对于问题 ，我简单了解了 ，谢谢哥们了，也就是说  关键问题在 函数是否被实例化上 是嘛？我回去以后测试一下，先感谢了

1.定义在外面是全局变量，main方法是静态函数只能调用静态的变量以及方法。用final修饰后，则 i 为一个全局常量，不会再改变。里面x加上final则为常量，x =10;就会报好错，不能给一个常量赋值！

我给你说简单点你领会一下吧

你想访问外部的变量，访问的时候这个变量必须存在即被分配了地址空间（这不是废话么）

不用static修饰，访问不到就是应为你在main函数没有实例化 Intx  当然 变量 i  就不会被分配地址空间，肯定访问不到

用static修饰 在编译的时候就会把静态变量分配地址空间，自然就能访问

这个跟final是无关的，final修饰变量只是把变量强制成常量。

蒙武辉 发表于 2012-5-16 18:53
那么他们定义在外面与里面有什么区别？
作用范围不一样
为什么定义在外面就必须用静态方法修饰？

如果外面的i 不用static修饰而改用final 修饰以后为什么直接调用（打印）就会报错？
加final以后的变量不可以再修改// 我是直接打印 也就是 直接调用 并没有赋值过程~~
在外部加上final修饰以后的i 有什么用？
表明i是一个常量//我知道这代表一个常量= =。我的意思是在后面写代码中 i 如何被应用的问题:L
而里面的x 加上final修饰以后直接调用不会报错？
如果你修改x的话一定会报错的//为什么呢？

郭宁 发表于 2012-5-16 18:57
我给你说简单点你领会一下吧

你想访问外部的变量，访问的时候这个变量必须存在即被分配了地址空间（这不是 ...

:) 意思我懂了  我就是回去再写代码验证一下 巩固一下 O(∩_∩)O谢谢:P

—__ 发表于 2012-5-16 18:58
意思我懂了  我就是回去再写代码验证一下 巩固一下 O(∩_∩)O谢谢

不客气~

1.那么他们定义在外面与里面有什么区别？
变量在外面和在里面的区别在于访问权限和作用范围不同
2.为什么定义在外面就必须用静态方法修饰？
变量定义为static，在该类中的任何地方都可以调用该变量，其实此处可以不用定义为static，
3.如果外面的i 不用static修饰而改用final 修饰以后为什么直接调用（打印）就会报错？
用finally修饰后的变量就不能再被修改，而你在内部又对其进行了操作，所以你再调用就报错了，
4.在外部加上final修饰以后的i 有什么用？
你就可以把i看成是一个不可以再该变的常量了
5.而里面的x 加上final修饰以后直接调用不会报错？
你又没修改，当然不会报错了

1.那么他们定义在外面与里面有什么区别？
i定义在外面是Intx类的成员变量，可以被Intx类的其它成员方法所访问，x定义在main方法中只能作用于main方法，不能被main方法以外的方法所访问。
2.为什么定义在外面就必须用静态方法修饰？
因为main方法是static修饰的，被static修饰的方法和成员变量优先于类的对象存在。如果i不用静态方法修饰，那么它必须在新建对象以后，才会存在，而main方法中有访问到i变量，先存在的main方法访问后来才出现的变量，就会报错。
3.如果外面的i 不用static修饰而改用final 修饰以后为什么直接调用（打印）就会报错？
两个方法的原因：1.和上一问一样，被static修饰的成员方法和变量优先于对象存在。
2.被final修饰的变量是常量，而你在main方法中修改了i的值，常量的值是不能被改变的。
4.在外部加上final修饰以后的i 有什么用？
i已经被static修饰，再加上final修饰后，就是一个静态常量。作用就是被调用时，其值不能被修改。
5.而里面的x 加上final修饰以后直接调用不会报错？
里面的x 加上final修饰以后，在main方法中直接调用，并不修改其值就不会报错，如果在main方法外部调用，就会报错。

OK了        

1. 定义在外面就是全局变量，而定义在里面则为局部变量。全局变量的作用域是整个类，局部变量的作用域则是某个方法中，
     定义在外面与里面的作用域不一样
2.因为静态的对象一般都是共享型的，定义在外面就是为了在类中的各个地方能引用它，所以必须定义为静态共享型的
3.因为全局的final变量的值是不能更改的，如果在某个方法中调用它，则不能给其赋值，否则，就会报错
4.外部加上final修饰的i可以保证在整个类的运行过程中，其值不发生变化
5.里面的x加上final不报错是因为它的作用域在局部不能改变，可以为其赋一个初值，但全局域中还是可以改变的