public class J_Test {
        String m_kobe = "1";
        String[] m_king = {"2"};
        public static void main(String[] args) {
                J_Test app = new J_Test();
                app.mb_operate(app.m_kobe, app.m_king);
                System.out.println(app.m_kobe+app.m_king[0]);
        }
        static void mb_operate(String m_kobe, String[] king) {
                //System.out.println(m_kobe);
                m_kobe = new String("3");
        //        System.out.println(king[0]);
                king[0] = new String("4");
        }
}

为什么结果是14

public class J_Test {
        String m_kobe = "1";
        String[] m_king = {"2"};
        public static void main(String[] args) {
                J_Test app = new J_Test();
                app.mb_operate(app.m_kobe, app.m_king);
                System.out.println(app.m_kobe+app.m_king[0]);
        }
        static void mb_operate(String m_kobe, String[] king) {
                king[0] = new String("4");                m_kobe = new String("3");
        }
}

我觉得当m_kobe(1)和m_king(2)作为参数分别投到mb_operate中时，
1、m_king 作为数组(也就是king)它的第一个字符串(king[0])被赋值为4；
2、而m_king作为字符串是不可能被赋值为3的，这体现了字符串的一大特性：一旦被赋值，就不可改变了(不可改变性)；
结果为 14。

1. public class J_Test {
   
2.            String m_kobe = "1";//全局变量
   
3.            String[] m_king = {"2"};
   
4.           public static void main(String[] args) {
   
5.                        J_Test app = new J_Test();//实例化J_Test的一个实例app
   
6.                      
   
7.                       app.mb_operate(app.m_kobe, app.m_king);//调用静态方法mb_operate,
   
8.                       System.out.println(app.m_kobe+app.m_king[0]);
   
9.            }
   
10.          //当形参为对象或数组时为引用传递, 你可以在调用前和调用后分别打印一下m_king和king看其值是否一样
    
11.          static void mb_operate(String m_kobe, String[] king) {
    
12.          
    
13.                m_kobe = new String("3");//<font color="red">m_kobe="3";这个m_kobe是局部变量,其值不影响外部同名变量</font>
    
14.                       //        System.out.println(king[0]);
    
15.                              king[0] = new String("4");//<font color="red">注意这里的改变同样影响m_king[0]的值，因为他们指向同样地址,亦即为同一变量。</font>
    
16.                   }
    
17. }

复制代码

关于第十行的方法，当形参为对象或数组时为引用传递, 你可以在调用前和调用后分别打印一下m_king和king看其值是否一样

看不懂啊

兄兄，
你这个问题，差点把我难道，哈哈

还是被我看破了。

这个程序，首先在执行的时候。
执行的是static   修饰的方法啊。

所以程序运行后，首先，执行的是：

1. static void mb_operate(String m_kobe, String[] king) {
   
2.                 //System.out.println(m_kobe);
   
3.                 m_kobe = new String("3");
   
4.         //        System.out.println(king[0]);
   
5.                 king[0] = new String("4");
   
6.         }

复制代码

这个时候m_kobe = new String("3");新指定了一个地址值，是被传递过来的局部变量。
跟class下的m_kobe不是同一个！！！  其实我也不知道这个是全局变量，嘿嘿，
我只是改了个值  String m_kobe = "P";  放到了main方法下，分解输出看值
发现，p根本就没有出现过，说明没有调用他，这种情况下，只有全局变量这个大哥在的时候，小弟才黯然收场。
king[0] = new String("4"); 是正常的赋值行为。

然后程序由上往下执行代码。全局常量：m_kobe = “1”
app.m_king[0]  是新的数组，
所以他们进行字符串连接的时候会是14

-0-  囧啊，我看了半天。对了，这是我分解你的代码：

1. class Test9 {
   
2.         String m_kobe = "1"; //原来丫的全局变量，我也才知道。嘿嘿。
   
3.         // m_kobe = "p";   //赋值失败。   2个赋值证明丫是全局大哥大。
   
4.         String[] m_king = {"2"};
   
5.         public static void main(String[] args) {
   
6. 
   
7.                         String m_kobe = "2";//局部变量，
   
8.                                 m_kobe = "3";//成功赋值   
   
9.                         Test9 app = new Test9();
   
10.                         app.mb_operate(app.m_kobe, app.m_king);
    
11. 
    
12.                         System.out.println(app.m_kobe);//1
    
13. 
    
14.                         System.out.println(app.m_king[0]);//4
    
15.                        
    
16.                         System.out.println(app.m_kobe+app.m_king[0]);//14
    
17.         }
    
18.         static void mb_operate(String m_kobe, String[] king) {
    
19.                         //System.out.println(m_kobe);
    
20.                         m_kobe = new String("3");
    
21.                         System.out.println(m_kobe+"----");//3----
    
22.         //        System.out.println(king[0]);
    
23.                         king[0] = new String("4");
    
24.         }
    
25. }

复制代码

额，这段代码我直勾勾的盯了二十分钟，终于明白了是为什么了，记得刘意老师讲过String 是一个特殊的引用类型，在参数传递的时候，把他当做基本类型，而大家应该知道，基本类型在做参数传递的时候其本身是不会变的，所以m_kobe不管做任何操作，其本身就是1，而对于下面那个字符串的数组来说，是对数组中的某个索引位置进行赋值，所以就会变成4，这样来看最后结果就是14，如果输出中这样写的话会更清楚：System.out.println(app.m_kobe+":"+app.m_kingp[0]);