์ถ์ฒ
ChatGPT
Pass by Value
์ ์
Pass by Value๋ ํจ์๋ ๋ฉ์๋์ ์ธ์๋ฅผ ์ ๋ฌํ ๋, ์ธ์์ ์ค์ ๊ฐ์ด ๋ณต์ฌ๋์ด ์ ๋ฌ๋๋ ๋ฐฉ์์ด๋ค. ์ฆ, ํจ์๊ฐ ํธ์ถ๋๋ฉด ์ธ์์ ๊ฐ์ ๋ณต์ฌํ ์๋ก์ด ๋ณ์๊ฐ ์์ฑ๋๊ณ , ํจ์๋ด์์๋ ์ด ๋ณต์ฌ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ค.
ํน์ง
๋ ๋ฆฝ์ฑ
ํธ์ถ๋ ํจ์ ๋ด์์ ๋ณ์์ ๋ณ๊ฒฝ์ด ํธ์ถ์์ ๋ณ์์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค.
์์ ์ฑ
์ธ๋ถ ๋ณ์์ ์ํ๋ฅผ ๋ณดํธํ ์ ์๋ค.
๋ณต์ฌ ๋น์ฉ
ํฐ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๋ณต์ฌํ๋ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ฑ๋ฅ์ ์ํฅ์ ์ค ์ ์๋ค.
์์
public class PassByValueExample {
public static void main(String[] args) {
int number = 10;
modifyValue(number);
System.out.println("Original number: " + number); // 10
}
public static void modifyValue(int num) {
num = 20; // Only modifies the local copy
}
}
์ค๋ช
- modifyValue ๋ฉ์๋์ number๊ฐ ์ ๋ฌ๋ ๋, number์ ๊ฐ์ธ 10์ด ๋ณต์ฌ๋์ด num ๋ณ์์ ํ ๋น๋๋ค.
- ํจ์ ๋ด์์ num์ ๋ณ๊ฒฝํ๋๋ผ๋ ์๋์ number๋ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
Pass by Reference
์ ์
Pass by Reference๋ ํจ์๋ ๋ฉ์๋์ ์ธ์๋ฅผ ์ ๋ฌํ ๋, ์ธ์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ ์ ๋ฌ๋๋ ๋ฐฉ์์ด๋ค. ํจ์๋ ์๋ ๋ฐ์ดํฐ์ ์ง์ ์ ๊ทผํด ์์ ํ ์ ์๊ฒ ๋๋ค.
ํน์ง
๊ณต์ ์ฑ
ํจ์ ๋ด์์์ ๋ณ๊ฒฝ์ด ํธ์ถ์์ ๋ณ์์ ์ํฅ์ ๋ฏธ์น๋ค.
ํจ์จ์ฑ
ํฐ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๋ณต์ฌํ์ง ์๊ณ ์ง์ ์ฐธ์กฐํ ์ ์์ด ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ํจ์จ์ ์ด๋ค
์ํ์ฑ
์ธ๋ถ ๋ฐ์ดํฐ์ ์ํ๋ฅผ ๋ณ๊ฒฝํ ์ ์์ด ์ฃผ์๊ฐ ํ์ํ๋ค.
์์(๋ค๋ฅธ ์ธ์ด(C++)์์์ ์์, Java์์๋ ์ง์๋์ง ์์)
void modifyValue(int* num) {
*num = 20; // Directly modifies the original variable
}
int main() {
int number = 10;
modifyValue(&number);
printf("Original number: %d", number); // 20
return 0;
}
์ค๋ช
- modifyValue ํจ์์ number์ ์ฃผ์๊ฐ ์ ๋ฌ๋๋ค
- ํจ์ ๋ด์์ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์๋์ number ๊ฐ์ ์ง์ ๋ณ๊ฒฝํ ์ ์๋ค.
Java์ ์ ๋ฌ ๋ฐฉ์
Java๋ ํญ์ Pass by Value ๋ฐฉ์์ ์ฌ์ฉํ๋ค. ์ด๋ Java์์ ๋ชจ๋ ๋ณ์, ๊ธฐ๋ณธํ ๋๋ ๊ฐ์ฒด ์ฐธ์กฐ, ๊ฐ์ ๋ณต์ฌ๋ณธ์ ๋ฉ์๋์ ์ ๋ฌํ๋ ๊ฒ์ ์๋ฏธํ๋ค. ๊ทธ๋ฌ๋ ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ๋ค๋ฃจ๋ ๋ฐฉ์ ๋๋ฌธ์ ๋ง์น Pass by Reference์ฒ๋ผ ์๋ํ๋ค๊ณ ์คํดํ ์ ์๋ค.
๊ธฐ๋ณธํ ๋ฐ์ดํฐ ํ์
๊ธฐ๋ณธํ ๋ฐ์ดํฐ ํ์ (int, double, char ๋ฑ)์ ์ค์ ๊ฐ์ด ๋ณต์ฌ๋์ด ์ ๋ฌ๋๋ค.
public class BasicTypeExample {
public static void main(String[] args) {
int a = 5;
modifyPrimitive(a);
System.out.println(a); // 5
}
public static void modifyPrimitive(int x) {
x = 10; // Changes local copy only
}
}
๊ฐ์ฒด ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์
๊ฐ์ฒด ์ฐธ์กฐ ๋ฐ์ดํฐ ํ์ (๋ชจ๋ ํด๋์ค ํ์ )์ ์ฐธ์กฐ ๋ณ์์ ๊ฐ์ด ๋ณต์ฌ๋์ด ์ ๋ฌ๋๋ค. ์ด ์ฐธ์กฐ๋ ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๊ธฐ ๋๋ฌธ์, ๋ณต์ฌ๋ ์ฐธ์กฐ๋ฅผ ํตํด ์๋ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
class Person {
String name;
Person(String name) {
this.name = name;
}
}
public class ObjectReferenceExample {
public static void main(String[] args) {
Person person = new Person("Alice");
modifyObject(person);
System.out.println(person.name); // Bob
}
public static void modifyObject(Person p) {
p.name = "Bob"; // Modifies the object that p refers to
}
}
์ค๋ช
- modifyObject ๋ฉ์๋์ person ๊ฐ์ฒด์ ์ฐธ์กฐ๊ฐ ์ ๋ฌ๋๋ค.
- p.name = "Bob";์ person์ด ๊ฐ๋ฆฌํค๋ ์ค์ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ณ๊ฒฝํ๋ค.
Java์์์ Pass by Value ํน์ฑ
๊ฐ์ฒด ์ฐธ์กฐ์ ๋ณต์ฌ
๊ฐ์ฒด ์์ฒด๊ฐ ์๋๋ผ ๊ฐ์ฒด์ ์ฐธ์กฐ๊ฐ ๋ณต์ฌ๋๋ค.
๊ฐ์ฒด ๋ณ๊ฒฝ ๊ฐ๋ฅ
๋ฉ์๋ ๋ด์์ ๊ฐ์ฒด์ ์์ฑ์ ๋ณ๊ฒฝํ ์ ์๋ค.
์ฐธ์กฐ ๋ณ๊ฒฝ ๋ถ๊ฐ
๋ฉ์๋ ๋ด์์ ๊ฐ์ฒด ์ฐธ์กฐ๋ฅผ ๋ณ๊ฒฝํด๋ ์๋ ์ฐธ์กฐ์๋ ์ํฅ์ ์ฃผ์ง ์๋๋ค.
์์
class Car {
String model;
Car(String model) {
this.model = model;
}
}
public class JavaPassByValue {
public static void main(String[] args) {
Car car = new Car("Toyota");
changeReference(car);
System.out.println(car.model); // Toyota
changeObject(car);
System.out.println(car.model); // Honda
}
public static void changeReference(Car c) {
c = new Car("Honda"); // New reference, does not affect original
}
public static void changeObject(Car c) {
c.model = "Honda"; // Changes the object referred to by c
}
}
์ค๋ช
- changeReference ๋ฉ์๋๋ Car ๊ฐ์ฒด์ ๋ํ ์๋ก์ด ์ฐธ์กฐ๋ฅผ ํ ๋นํ์ง๋ง, ์ด ๋ณ๊ฒฝ์ main ๋ฉ์๋์ car ๊ฐ์ฒด์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค.
- changeObject ๋ฉ์๋๋ car ๊ฐ์ฒด์ model ์์ฑ์ ์ง์ ๋ณ๊ฒฝํ๋ค.
Java์ Pass by Value์ Pass by Reference ์ ๋ฆฌ
- Java๋ ํญ์ Pass by Value๋ฅผ ์ฌ์ฉํ๋ค.
- ๊ฐ์ฒด ์ฐธ์กฐ๊ฐ ์ ๋ฌ๋ ๋ ์ฐธ์กฐ์ ๊ฐ(์ฃผ์)์ด ๋ณต์ฌ๋๋ค.
- ๋ฉ์๋ ๋ด์์ ๊ฐ์ฒด์ ์์ฑ์ ๋ณ๊ฒฝํ ์ ์์ง๋ง, ์ฐธ์กฐ ์์ฒด๋ฅผ ๋ณ๊ฒฝํ ์๋ ์๋ค.
ChatGPT ๊ธ์ ์ถ์ฒ
์ถ์ฒ
- Java Language Specification - Java์์์ ๋ฐ์ดํฐ ์ ๋ฌ ๋ฐฉ์ ์ค๋ช
- Effective Java by Joshua Bloch - Java์ ๊ฐ์ฒด ์ฐธ์กฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ๋ํ ์ค๋ช
- Java Programming Language Guide - Pass by Value์ Pass by Reference์ ์ฐจ์ด์ ์ค๋ช
Passing Reference Data Type Arguments
์ฐธ์กฐ ๋ฐ์ดํฐ ์ ํ ์ธ์ ์ ๋ฌ
Reference data type parameters, such as objects, are also passed into methods by value. This means that when the method returns, the passed-in reference still references the same object as before. However, the values of the object's fields can be changed in the method, if they have the proper access level.
๊ฐ์ฒด์ ๊ฐ์ ์ฐธ์กฐ ๋ฐ์ดํฐ ์ ํ ๋งค๊ฐ๋ณ์๋ ๊ฐ๋ณ๋ก ๋ฉ์๋์ ์ ๋ฌ๋ฉ๋๋ค. ์ฆ, ๋ฉ์๋๊ฐ ๋ฐํ๋ ๋ ์ ๋ฌ๋ ์ฐธ์กฐ๋ ์ฌ์ ํ ์ด์ ๊ณผ ๋์ผํ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํฉ๋๋ค. ํ์ง๋ง ์ ์ ํ ์ก์ธ์ค ์์ค์ด ์๋ ๊ฒฝ์ฐ ๊ฐ์ฒด ํ๋์ ๊ฐ์ ๋ฉ์๋์์ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค.
'๋น ๊ตฌ๋ฉ ์ฑ์ฐ๊ธฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ํจํค์ง ์กด์ฌ ์ด์ (0) | 2024.08.12 |
---|---|
[Java] ๊ฐ๋ณ ์ธ์ Varargs (0) | 2024.08.08 |
[์ฉ์ด][Java] DTO, VO (0) | 2024.08.08 |
[Java] ๋ฐฐ์ด๋ ๊ฐ์ฒด์ธ๊ฐ (0) | 2024.08.08 |
[์ฉ์ด] ํ์ดํผ์ค๋ ๋ฉ๊ณผ ๋ฉํฐ์ฝ์ด (1) | 2024.08.07 |