hello啊，各位观众姥爷们！！！本牛马baby今天又来了！哈哈哈哈哈嗝🐶
Java中是引用传递还是值传递？
在 Java 中，方法参数传递是通过 值传递 的方式实现的，但这可能会引起一些误解，尤其是在处理引用类型（对象）时。为了更好地理解这一点，让我们详细探讨一下：
1. 基本数据类型
对于基本数据类型（如 int、float、char 等），Java 采用值传递的方式。这意味着：
- 当你将一个基本数据类型的变量作为参数传递给方法时，实际上传递的是该变量的值的副本。这意味着方法内部对参数的修改不会影响方法外部的原始变量。
public class Test {
public static void main(String[] args) {
int a = 5;
modifyValue(a);
System.out.println(a); // 输出 5
}
public static void modifyValue(int value) {
value = 10; // 只修改了 value 的副本，不影响 a
}
}
在这个例子中，尽管我们在 modifyValue 方法内部修改了 value 的值，但原始变量 a 的值仍然是 5。
2. 引用数据类型
对于引用类型（如对象和数组），Java 依然使用值传递，但这里传递的是引用的副本。具体来说：
- 当你将一个对象作为参数传递给方法时，传递的是该对象引用的副本。这意味着方法内部可以通过这个引用访问和修改对象的数据。如果你改变了过去的对象的状态（比如改变其属性），原始对象也会被影响。
public class Person {
String name;
public Person(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person("Alice");
modifyPerson(person);
System.out.println(person.name); // 输出 "Bob"
}
public static void modifyPerson(Person p) {
p.name = "Bob"; // 修改了对象的属性
}
}
在这个例子中，尽管 p 是 person 的引用的副本，但通过 p 修改的 name 属性实际上是原始对象的属性。因此，输出的结果是 “Bob”。
3. 不可改变引用
需要注意的是，虽然你可以通过引用修改对象的内容，但你不能改变引用本身。即在方法内部重新赋值引用并不会影响外部的引用：
public static void changeReference(Person p) {
p = new Person("Charlie"); // 改变了 p 的引用，对外部 person 无影响
}
总的来说：Java 是通过值传递的方式传递参数的，对于基本数据类型，传递的是值的副本；对于引用类型，传递的是对象引用的副本，能够通过该引用修改对象的内容，但无法改变外部引用指向其他对象。
Java中深拷贝和浅拷贝是什么？它们有什么区别？
在 Java 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是指复制对象时对对象内部引用成员的处理方式的不同。理解这两种拷贝方式对于有效管理对象的内存和避免不必要的共享状态是非常重要的。
1. 浅拷贝（Shallow Copy）
浅拷贝是指复制对象时，仅仅复制对象的基本数据类型（值）和引用类型（对象引用）的显式值。对于引用类型，拷贝的是对象引用，而不是其所引用的对象本身。因此，如果一个对象包含对其他对象的引用，浅拷贝不会创建那些引用对象的副本，而是会复制它们的引用。
示例代码:
class Address {
String city;
public Address(String city) {
this.city = city;
}
}
class Person implements Cloneable {
String name;
Address address; // 引用类型
public Person(String name, Address address) {
this.name = name;
this.address = address;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 浅拷贝
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address("New York");
Person person1 = new Person("Alice", address);
// 进行浅拷贝
Person person2 = (Person) person1.clone();
// 修改 person2 的地址
person2.address.city = "Los Angeles";
// 输出 person1 的地址
System.out.println(person1.address.city); // 输出 "Los Angeles"
}
}
在这个例子中，person2 的地址被修改，person1 的地址也受到了影响，因为它们共享同一个 Address 对象引用。
2. 深拷贝（Deep Copy）
深拷贝是指复制对象的所有内容，包括所有引用对象。这意味着在进行深拷贝时，不仅复制了对象本身，还会递归地复制所有被引用的对象。这使得深拷贝的对象和原对象之间完全独立。
示例代码:
class Address implements Cloneable {
String city;
public Address(String city) {
this.city = city;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 深拷贝
}
}
class Person implements Cloneable {
String name;
Address address; // 引用类型
public Person(String name, Address address) {
this.name = name;
this.address = address;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person copy = (Person) super.clone();
copy.address = (Address) address.clone(); // 深拷贝
return copy;
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address("New York");
Person person1 = new Person("Alice", address);
// 进行深拷贝
Person person2 = (Person) person1.clone();
// 修改 person2 的地址
person2.address.city = "Los Angeles";
// 输出 person1 的地址
System.out.println(person1.address.city); // 输出 "New York"
}
}
在这个例子中，person2 的地址被修改，但 person1 的地址没有受到影响，因为它们分别引用了不同的 Address 对象。
3. 区别总结
拷贝内容:
- 浅拷贝: 只复制对象的基本类型值和引用，引用指向的对象不被复制。
- 深拷贝: 复制对象及其所有引用的对象，形成完全独立的副本。
内存影响:
- 浅拷贝会导致多个对象共享同一内存区域中数据的引用。
- 深拷贝则会占用更多内存，因为它复制了所有的底层数据。
使用场景:
- 浅拷贝适用于对象内部状态不需要独立管理的简单场景。
- 深拷贝适用于需要独立管理对象内部状态的复杂数据结构。
IDEA ji huo
https://pan.quark.cn/s/4216736c0427
🎬大全
https://kdocs.cn/l/cqhxNU9I2lLD
12306回家科技
https://pan.quark.cn/s/45f6bf9be1b3
