共计 3083 个字符,预计需要花费 8 分钟才能阅读完成。
示意图
利用场景
1. 赋值
2. 办法入参
调用办法和被调用办法
代码
import com.alibaba.fastjson.JSONObject;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author gzh
* @createTime 2020/8/25 8:41 AM
*/
public class Test {private static final Logger log = LoggerFactory.getLogger(Test.class);
public static void main(String[] args) {
//
List<User> userList = new ArrayList<User>();
User user1 = new User();
user1.setName("gzh1");
userList.add(user1);
User user2 = new User();
user2.setName("gzh2");
userList.add(user2);
log.info(JSONObject.toJSONString(userList));
//
// for (User user: userList) { // 这里的 list 元素最终是旧值,因为没有被新的对象自身间接赋值
// log.info(JSONObject.toJSONString(user));
// User user3 = new User();
// user3.setName("gzh3");
//
// user = user3;
// log.info(JSONObject.toJSONString(user));
// }
// for (int i = 0; i < userList.size(); i++) { // 这里的 list 元素最终是新值,因为被新的对象自身间接赋值
// //
// User user = userList.get(i);
//
// //
// log.info(JSONObject.toJSONString(user));
// User user3 = new User();
// user3.setName("gzh3");
// user = user3;
//
// //
// log.info(JSONObject.toJSONString(user));
// userList.set(i,user);
// }
for (int i = 0; i < userList.size(); i++) { // 同上:这里的 list 元素最终是新值,因为被新的对象自身间接赋值
//
log.info(JSONObject.toJSONString(userList.get(i)));
//
User user3 = new User();
user3.setName("gzh3");
//
userList.set(i,user3);
log.info(JSONObject.toJSONString(userList.get(i)));
}
//
log.info(JSONObject.toJSONString(userList));
}
}
执行后果
19:49:39.062 [main] INFO Test - [{"name":"gzh1"},{"name":"gzh2"}]
19:49:39.064 [main] INFO Test - {"name":"gzh1"}
19:49:39.065 [main] INFO Test - {"name":"gzh3"} // 因为 list 的元素被新的对象自身间接赋值,所以值扭转了
19:49:39.065 [main] INFO Test - {"name":"gzh2"}
19:49:39.065 [main] INFO Test - {"name":"gzh3"} // 同上
19:49:39.065 [main] INFO Test - [{"name":"gzh3"},{"name":"gzh3"}] // 同上
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author gzh
* @createTime 2020/8/25 8:41 AM
*/
public class Test2 {private static final Logger log = LoggerFactory.getLogger(Test2.class);
public static void main(String[] args) {User user = new User();
user.setName("gzh1");
log.info("调用办法之前:{}",JSONObject.toJSONString(user));
updateUser2(user);
log.info("调用办法之后:{}",JSONObject.toJSONString(user));
}
private static void updateUser(User user) {
//
log.info(JSONObject.toJSONString(user));
//
User user2 = new User();
user2.setName("gzh2");
user = user2;
//
log.info(JSONObject.toJSONString(user));
}
private static void updateUser2(User user) {
//
log.info(JSONObject.toJSONString(user));
user.setName("gzh2");
//
log.info(JSONObject.toJSONString(user));
}
}
运行后果
19:50:35.072 [main] INFO Test2 - 调用办法之前:{"name":"gzh1"}
19:50:35.077 [main] INFO Test2 - {"name":"gzh1"}
19:50:35.077 [main] INFO Test2 - {"name":"gzh2"}
19:50:35.077 [main] INFO Test2 - 调用办法之后:{"name":"gzh2"} // 因为入参依然指向同一个对象自身,并没有被新的对象自身从新赋值,所以入参的值 (即对象自身) 扭转之后,入参的原始对象援用的值 (即对象自身) 也扭转了。
总结
1. 不同的对象援用,寄存在不同的内存地址,而该内存地址存储的值又是对象自身的内存地址,对象援用正是通过对象自身的内存地址指向对象自身。
2. 对象援用的值 (即指向的对象自身) 什么时候会被扭转?什么时候不会被扭转?
只有间接赋值了新的对象自身,对应援用的值才会扭转。
不同的对象援用没有关系,1)如果被同一个对象自身赋值,那么两个对象援用都指向同一个对象自身,除此之外,就没有其余的关系,不同的对象援用是相互独立的,且他们之间没有任何关系 2)如果一个对象援用被新的对象自身赋值,另一个对象援用依然是指向旧的对象自身,所以再次证实两个对象援用之间是没有任何关系的,两个对象自身之间也是没有任何关系的。
3. 如果改的是同一个对象自身,那么对象援用 1 和对象援用 2 的值同时扭转。
4. 如果对象援用 2 是指向了新的对象,那么对象援用 2 的值扭转,对象援用 1 的值不变。
最佳实际
1. 如果想要扭转援用的值,应该间接赋值,而不是间接通过其余对象援用来扭转。
2. 如果是调用办法批改,应该通过返回值批改,而不是通过对象援用。
正文完