本文共 3713 字，大约阅读时间需要 12 分钟。

public class Test2 {    public static void setValue(String str){        str = "ss";    }    public static void setValue(Man str){        str = new Man("test");    }    public static class Man{        private String name;        public String getName() {            return name;        }        public void setName(String name) {            this.name = name;        }        public Man(String name) {            this.name = name;        }        @Override        public String toString() {            return "Man{" +                    "name='" + name + '\'' +                    '}';        }    }    public static void main(String[] args) {        String str = "s";        setValue(str);        System.out.println(str);        Man man = null;        setValue(man);        System.out.println(man);    }}

如上面代码实践，结果输出 

snull

原因是方法在执行的时候有栈帧的概念，入栈的时候只是压栈方法参数是传入参数的副本。

JVM高级特性

此时区分数据类型：基本类型和引用类型

基本类型：值存放在局部变量表中，无论如何修改只会修改当前栈帧的值，方法执行结束对方法外不会做任何改变；此时需要改变外层的变量，必须返回主动赋值。

引用数据类型：指针存放在局部变量表中，调用方法的时候，副本引用压栈，赋值仅改变副本的引用。但是如果直接改变副本引用的值，修改了引用地址的对象，此时方法以外的引用此地址对象当然被修改。（两个引用，同一个地址，任何修改行为2个引用同时生效）

比如

public static void setValue(StringBuilder str){        str = new StringBuilder("sss");    }        public static void setValue2(StringBuilder str){        str.append("sss");    }    public static void main(String[] args) {        StringBuilder str = new StringBuilder();        setValue(str);        System.out.println(str.toString()); //输出空字符串        setValue2(str);        System.out.println(str.toString()); //输出sss    }

关于String，本质是final类型char数组，不可修改，只能赋值，在做参数传入方法修改时，其实是新建对象，必须返回重新对外面的变量赋值才会对外面的String引用生效。

看String源码的任意一个方法即可明白

/**     * Returns a string resulting from replacing all occurrences of     * {@code oldChar} in this string with {@code newChar}.     * 
     * If the character {@code oldChar} does not occur in the     * character sequence represented by this {@code String} object,     * then a reference to this {@code String} object is returned.     * Otherwise, a {@code String} object is returned that     * represents a character sequence identical to the character sequence     * represented by this {@code String} object, except that every     * occurrence of {@code oldChar} is replaced by an occurrence     * of {@code newChar}.     * 
     * Examples:     * 
   
    
     * "mesquite in your cellar".replace('e', 'o')     *         returns "mosquito in your collar"     * "the war of baronets".replace('r', 'y')     *         returns "the way of bayonets"     * "sparring with a purple porpoise".replace('p', 't')     *         returns "starring with a turtle tortoise"     * "JonL".replace('q', 'x') returns "JonL" (no change)     * 
   
     *     * @param   oldChar   the old character.     * @param   newChar   the new character.     * @return  a string derived from this string by replacing every     *          occurrence of {@code oldChar} with {@code newChar}.     */    public String replace(char oldChar, char newChar) {        if (oldChar != newChar) {            int len = value.length;            int i = -1;            char[] val = value; /* avoid getfield opcode */            while (++i < len) {                if (val[i] == oldChar) {                    break;                }            }            if (i < len) {                char buf[] = new char[len];                for (int j = 0; j < i; j++) {                    buf[j] = val[j];                }                while (i < len) {                    char c = val[i];                    buf[i] = (c == oldChar) ? newChar : c;                    i++;                }                //String的value 是final char[]，一旦创建不能改变                return new String(buf, true);            }        }        return this;    }

引用类型会引起浅拷贝和深拷贝现象。