java 根据地址区分省市区 java按地址传递

在Java

//:   按值传递与按址传递测试类  Test1.java
public       class    Test1 {
        public       static       void    main(String[] args) {
        User t =    new    User();
        t.setUserId(0);
        t.setUsername(   "0"   );
        t.setPassword(   "0"   );
        System.   out   .println(   "User=>Bef     Id:"   +t.getUserId()+   "\tname:"   +t.getUsername()+   "\tpassword:"   +t.getPassword());
        change (t);
        System.   out   .println(   "User=>Aft     Id:"   +t.getUserId()+   "\tname:"   +t.getUsername()+   "\tpassword:"   +t.getPassword());
     }
        public       static       void    change(User t){
           //    在此，    t   引用的地址没有改变      
        t.setUsername(   "00"   );   // t   的属性引用的地址改变了      
        t.setPassword(   "00"   );
     }
}   /* Output:
User=>Bef
User=>Aft   Id:0    name:00     password:00
*///:~   结论：按址传递      
//:   按值传递与按址传递测试类    Test2.java
public       class    Test2 {
        public       static       void    main(String[] args) {
           int    t = 0;
        System.   out   .println(   "int=>Bef     t:"   +t);
        change (t);
        System.   out   .println(   "int=>Aft     t:"   +t);        
     }
        public       static       void    change(   int    t){
           //    在此，    t   引用的地址没有改变      
        t   =   1;    //    在此，    t   引用的地址改变了      
     }
}   /* Output:
int=>Bef
int=>Aft    t:0
*///:~   结论：按址传递      
//:   按值传递与按址传递测试类    Test3.java
public       class    Test3 {
        public       static       void    main(String[] args) {
        Integer t = 0;
        System.   out   .println(   "Integer=>Bef    t:"   +t);
        change (t);
        System.   out   .println(   "Integer=>Aft    t:"   +t);        
     }
        public       static       void    change(Integer t){
           //    在此，    t   引用的地址没有改变      
        t   =   1;    //    在此，    t   引用的地址改变了      
     }
}   /* Output:
Integer=>Bef
integer=>Aft   t:0
*///:~   结论：按址传递      
//:   按值传递与按址传递测试类    Test4.java
public       class    Test4 {
        public       static       void    main(String[] args) {
        String t =    "0"   ;
        System.   out   .println(   "String=>Bef  t:"   +t);
        change (t);
        System.   out   .println(   "String =>Aft    t:"   +t);        
     }
        public       static       void    change(String t){
//    在此，    t   引用的地址没有改变      
        t   =   "00"   ;   //    在此，    t   引用的地址改变了      
     }
}   /* Output:
String=>Bef
String=>Aft    t:0

*///:~ 结论：按址传递

    最终结论： 在 Java 中，为类的方法传递参数时，本身的传递机制是按址传递。那么，为什么打印的结果会不一样呢？主要是由赋值符号“ = ”造成的，众所周知，在 Java 中，一切都是对象，所以即便是个数字、字符，或者字符串，都被称为是对象。在 Java 中，规定的赋值（“ = ”）机制是按址传递，即将对象的地址赋给引用（即把对象的地址赋给“ = ”左侧的变量），所以每出现一次赋值语句，左侧变量的地址都会发生改变。既然这样，那么为什么在 Test2 、 3 、 4 中最后打印 t 的值时却没有改变呢？这就是程序本身的迷惑性造成的，其实 change 方法内部的 t 与该方法外的 t 不是一个引用，如果把 change 参数的 t 改为其他名字你就明白了，这就是故意用来迷惑不成熟的程序员的。在传递参数时，首先要新生成参数列表中的虚参变量，然后将传递的实参的对象地址赋给虚参，这样就完成了 Java

       因此，当在一个方法内部改变方法外面的某个对象的值时，一定要注意“ = ”的迷惑性（“ =

       总之一句话，在 Java 中传的都是地址，不是值 ！