[JAVA]_Primitive and Reference(기본형과 참조형)

1. 기본형과 참조형

 

변수의 데이터 타입은 크게 기본형과 참조형으로 분류할 수 있음.

기본형은 사용하는 값을 변수에 직접 넣을 수 있는 것, 참조형은 객체가 저장된 메모리의 위치를 가리키는 참조값을 넣을 수 있는 것.

 

- 기본형(Primitive Type) : int, long, double, boolean처럼 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입.

- 참조형(Reference Type) :

     Student student1, int[] students와 같이 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터 타입. (객체, 배열에 사용)

 

쉽게 말해 기본형 변수에는 직접 사용할 수 있는 값이 들어있지만, 참조형 변수에는 위치(참조값)가 들어가 있음.

참조형 변수를 통해서 뭔가 하려면 결국 참조값을 통해 해당 위치로 이동해야 함.

 

int a = 10, b = 20;
int sum1 = a + b;

Student s1 = new Student();
Student s2 = new Student();
s1 + s2	// 오류 발생

s1.grade = 100;
s2.grade = 90;
int sum2 = s1.grade + s2.grade;	// 연산 가능

 

쉽게 말해서 기본형을 제외한 나머지는 모두 참조형임.

기본형은 자바가 기본으로 제공하는 데이터 타입이므로 개발자가 새로 정의할 수 없음.

개발자는 참조형인 클래스만 직접 정의 가능.

클래스는 대문자로 시작하므로 클래스 모두 참조형임.

 

! 참고 !

String은 사실 클래스임. 따라서 참조형인데 기본형처럼 문자값을 바로 대입 가능.

문자는 매우 자주 다루기 때문에 자바에서 특별하게 편의 기능을 제공함.

String에 대한 자세한 내용은 추후에 설명.

 

대원칙 : 자바는 항상 변수의 값을 복사해서 대입한다!!!! (잊지말기)

// 기본형 대입
int a = 10;
int b = a;

// 참조형 대입
Student s1 = new Student();
Student s2 = s1;

기본형은 변수에 값을 대입하더라도 실제 사용하는 값이 변수에 바로 들어있기 때문에 해당 값만 복사해서 대입한다고 생각.

하지만 참조형의 경우 실제 사용하는 객체가 아니라 객체의 위치를 가리키는 참조값만 복사됨.

예를 들면 실제 건물이 복사가 되는 것이 아닌 건물의 위치 즉 주소만 복사되는 것으로 생각하면 됨.

따라서 같은 건물을 찾아갈 수 있는 방법이 하나 늘어나는 것임.

 

package ref;

public class VarChange1 {
    public static void main(String[] args) {

        int a = 10;
        int b = a;
        System.out.println("a = " + a); // 10
        System.out.println("b = " + b); // 10

        // a 변경
        a = 20;
        System.out.println("변경 a = 20");
        System.out.println("a = " + a); // 20
        System.out.println("b = " + b); // 10

        // b 변경
        b = 30;
        System.out.println("변경 b = 30");
        System.out.println("a = " + a); // 20
        System.out.println("b = " + b); // 30
    }
}

// 실행결과

a = 10
b = 10
변경 a = 20
a = 20
b = 10
변경 b = 30
a = 20
b = 30

[VarChange1]

 

변수의 대입은 변수에 들어있는 값을 복사해서 대입하므로, 변수 a에 들어있는 값 10을 복사해서 변수 b에 대입.

변수 a 자체를 b에 대입하는 것이 아님을 잊지 말자.

그렇기 때문에 a를 변경해도 b에 영향이 없고, b를 변경해도 a에 아무런 영향을 끼치지 않음.

---

package ref;

public class Data {
    int value;
}

package ref;

public class VarChange2 {
    public static void main(String[] args) {

        Data dataA = new Data();
        dataA.value = 10;
        Data dataB = dataA;

        System.out.println("dataA 참조값 = " + dataA);
        System.out.println("dataB 참조값 = " + dataB);
        System.out.println("dataA.value = " + dataA.value); // 10
        System.out.println("dataB.value = " + dataB.value); // 10

        // dataA 변경
        dataA.value = 20;
        System.out.println("변경 dataA.value = 20");
        System.out.println("dataA.value = " + dataA.value); // 20
        System.out.println("dataB.value = " + dataB.value); // 20

        // dataB 변경
        dataB.value = 30;
        System.out.println("변경 dataB.value = 30");
        System.out.println("dataA.value = " + dataA.value); // 30
        System.out.println("dataB.value = " + dataB.value); // 30
    }
}

// 실행결과

dataA 참조값 = ref.Data@682a0b20
dataB 참조값 = ref.Data@682a0b20
dataA.value = 10
dataB.value = 10
변경 dataA.value = 20
dataA.value = 20
dataB.value = 20
변경 dataB.value = 30
dataA.value = 30
dataB.value = 30

[Data, VarChange2]

 

dataA 변수는 Data 클래스를 통해서 만들었기 때문에 참조형임.

이 변수는 Data형 객체의 참조값을 저장함. Data 객체를 생성하고, 참조값을 dataA에 저장한 뒤, 객체의 value 변수에 값 10을 저장함.

 

변수의 대입은 변수에 들어있는 값을 복사해서 대입하는데, 여기서는 변수 dataA에 들어있는 참조값을 복사해서 변수 dataB에 대입.

dataA가 가리키는 인스턴스를 복사하는 것이 아닌 변수에 들어있는 참조값만 복사해서 전달함.

따라서 dataA와 dataB에 들어있는 참조값은 같으므로 같은 참조값인 Data 인스턴스를 가리킴.

 

dataB를 변경하면 dataA에 영향이 없을 줄 알았지만 그것은 아님. dataB를 변경하면 그의 참조값의 값을 변경하였으므로 같은 인스턴스를 참조하기 때문에 dataA의 값도 변경되는 것을 알아야 함.

---

package ref;

public class MethodChange1 {
    public static void main(String[] args) {

        int a = 10;
        System.out.println("메서드 호출 전 : a = " + a);  // 10
        changePrimitive(a);
        System.out.println("메서드 호출 후 : a = " + a);  // 10

    }

    static void changePrimitive (int x) {
        x = 20;
    }
}

// 실행결과

메서드 호출 전 : a = 10
메서드 호출 후 : a = 10

[MethodChange1]

 

메서드 호출에서 매개변수(파라미터)도 결국 변수이기 때문에 메서드 호출할 때도 매개변수에 값을 전달하는 것이므로 앞에서 설명한 내용과 같이 값을 복사해서 전달함.

 

메서드 호출할 때 매개변수 x에 변수 a의 값을 전달하는데 이때 코드는 다음과 같이 해석 가능.

int x = a

자바에서 변수에 값을 대입하는 것은 항상 값을 복사해서 대입하므로 변수 a, x각각 숫자 10을 가지고 있음.

 

그러고 메서드 안에서 x = 20으로 새로운 값을 대입하므로 결과적으로 x의 값만 20으로 변경되고, 10의 값은 10으로 유지.

 

따라서 메서드 종료 후 값을 확인하면 a는 10이 출력되는 것을 확인할 수 있음.

(참고로 메서드 종료 시 매개변수 x는 제거됨.)

---

package ref;

public class MethodChange2 {
    public static void main(String[] args) {

        Data dataA = new Data();
        dataA.value = 10;
        System.out.println("메서드 호출 전 : dataA.value = " + dataA.value);  // 10
        changeReference(dataA);
        System.out.println("메서드 호출 후 : dataA.value = " + dataA.value);  // 20

    }
    public static void changeReference(Data dataX) {
        dataX.value = 20;
    }
}

// 실행결과

메서드 호출 전 : dataA.value = 10
메서드 호출 후 : dataA.value = 20

[MethodChange2]

 

메서드 호출 시 매개변수 dataX에 변수 dataA의 값을 전달하는데 이 때 코드는 다음과 같이 해석 가능.

Data dataX = dataA

 

변수 dataA는 참조값(예를들어 x001)을 가지고 있으므로 참조값을 복사해서 전달하기 때문에 변수 dataA, dataX 둘 다 같은 참조값인 x001을 가지게 됨.

 

메서드 안에서 dataX.value = 20으로 새로운 값을 대입하면,

참조값을 통해 x001 인스턴스에 접근하고 그 안에 있는 value의 값을 20으로 변경함.

 

dataA, dataX 모두 같은 x001 인스턴스를 참조하기 때문에 dataA.value와 dataX.value는 둘 다 20이라는 값을 가짐.

 

자바에서 메서드의 매개변수(파라미터)는 항상 값에 의해 전달됨.

그러나 이 값이 실제 값이나, 참조(메모리주소) 값이냐에 따라 동작이 달라짐.

 

- 기본형 : 메서드 기본형 데이터를 전달하면, 해당 값이 복사되어 전달되기 때문에 메서드 내부에서 매개변수(파라미터)의 값을 변경해도 호출자의 변수 값에는 영향이 없음.

- 참조형 : 메서드 참조형 데이터를 전달하면, 참조값이 복사되어 전달되기 때문에 메서드 내부에서 매개변수(파라미터)로 전달된 객체의 멤버변수를 변경하면, 호출자의 객체도 변경됨.

---

package ref;

public class Student {
    String name;
    int age;
    int grade;
}

package ref;

public class Method1 {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.name = "학생1";
        student1.age = 15;
        student1.grade = 90;

        Student student2 = new Student();
        student2.name = "학생2";
        student2.age = 16;
        student2.grade = 80;

        printStudent(student1);
        printStudent(student2);
    }

    static void printStudent(Student student) {
        System.out.println("이름 : " + student.name + ", 나이 : " + student.age + ", 성적 : " + student.grade);
    }
}

[Student, Method1]

 

참조형은 메서드를 호출할 때 참조값을 전달하므로 메서드 내부에서 전달된 참조값을 통해 객체의 값을 변경하거나, 값을 읽어서 사용 가능.

 

package ref;

public class Method1 {
    public static void main(String[] args) {
        Student student1 = new Student();
        initStudent(student1, "학생1", 15, 90);

        Student student2 = new Student();
        initStudent(student2, "학생2", 16, 80);
        
        printStudent(student1);
        printStudent(student2);
    }

    static void initStudent(Student student, String name, int age, int grade) {
        student.name = name;
        student.age = age;
        student.grade = grade;
    }

    static void printStudent(Student student) {
        System.out.println("이름 : " + student.name + ", 나이 : " + student.age + ", 성적 : " + student.grade);
    }
}

[Method1]

 

student1이 참조하는 Student 인스턴스에 값을 편리하게 할당하길 원한다면 initStudent() 메서드를 생성해서 대입 가능.

이 메서드를 호출하면서 student1을 전달함. 그러면 student1의 참조값이 매개변수 student에 전달됨.

이 참조값을 통해 initStudent() 메서드 안에서 student1이 참조하는 것과 동일한 Student 인스턴스에 접근하고 값을 변경 가능.

 

! 주의 !

import class1.Student;이 선언되어 있으면 안 됨.

이렇게 되면 class1 패키지에서 선언한 Student를 사용하게 되므로 접근제어가 때문에 컴파일 오류가 발생.

만약 선언되어 있으면 삭제하기. 삭제하면 같은 패키지에 있는 ref.Student를 사용하게 됨.

---

package ref;

public class Method2 {
    public static void main(String[] args) {
        Student student1 = createStudent("학생1", 15, 90);
        Student student2 = createStudent("학생2", 16, 80);

        printStudent(student1);
        printStudent(student2);
    }

    static Student createStudent(String name, int age, int grade) {
        Student student = new Student();
        student.name = name;
        student.age = age;
        student.grade = grade;

        return student;
    }

    static void printStudent(Student student) {
        System.out.println("이름 : " + student.name + ", 나이 : " + student.age + ", 성적 : " + student.grade);
    }
}

[Method2]

 

바로 객체를 생성하고, 초기값을 설정할 수 있음.

Student student1 = new Student();
initStudent(student1, "학생1", 15, 90);

Student student2 = new Student();
initStudent(student2, "학생2", 16, 80);

 

2번 반복되는 부분을 하나로 합치는 것.

 

createStudent()라는 메서드 생성 후 객체를 생성하는 부분도 이 메서드 안에 함께 포함.

이 메서드 하나로 객체의 생성과 초기값 설정 모두 처리 가능.

그런데 메서드 안에서 객체를 생성했기 때문에 만들어진 객체를 메서드 밖에서 사용할 수 있게 돌려주어야 함. 그래야 메서드 밖에서 이 객체를 사용할 수 있음. 따라서 호출 결과를 반환하는 return을 사용하면 됨.

메서드의 반환 기능을 사용해서 만들어진 객체의 참조값을 메서드 밖으로 반환하는 것.

---

* 변수와 초기화 *

 

변수의 종류에는 멤버변수(필드)와 지역변수가 있음.

 

- 멤버변수(필드) : 클래스에 선언.

- 지역변수 : 메서드에 선언. 매개변수도 지역변수의 한 종류.

 

* 변수의 값 초기화 *

- 멤버변수 : 

     자동으로 초기화되는데, 인스턴스의 멤버 변수는 인스턴스 생성 시 자동으로 초기화됨.

     숫자(int) = 0, boolean = false, 참조형 = null(null 값은 참조할 대상이 없다는 뜻.)

- 지역변수 : 

     수동으로 초기화되는데, 항상 직접 초기화해야 함.

package ref;

public class initData {
    int value1; // 초기화 하지 않음
    int value2 = 10;    // 10으로 초기화
}

package ref;

public class initMain {
    public static void main(String[] args) {
        initData data= new initData();
        System.out.println("value1 = " + data.value1);
        System.out.println("value2 = " + data.value2);
    }
}

// 실행 결과

value1 = 0
value2 = 10

[initData, initMain]

 

value1은 초기값을 지정하지 않았고, value2는 10으로 초기값을 저장했기 때문에 value1은 자동으로 초기화되어 0으로 초기화되고, value2는 객체 생성 시 10으로 초기화됨.

---

package ref;

public class Data {
    int value;
}

package ref;

public class NullMain1 {
    public static void main(String[] args) {

        Data data = null;
        System.out.println("1. data = " + data);

        data = new Data();
        System.out.println("2. data = " + data);

        data = null;
        System.out.println("3. data = " + data);
    }
}

// 실행결과

1. data = null
2. data = ref.Data@682a0b20
3. data = null

[Data, NullMain1]

 

Data 타입을 받을 수 있는 참조형 변수 data 생성.

그리고 여기에 null 값을 할당함. 따라서 data 변수에는 아직 가리키는 객체가 없음.

이후 새로운 Data 객체 생성 후 그 참조값을 data 변수에 할당. 이제는 data 변수가 참조할 객체가 존재함.

마지막에는 data에 다시 null 값을 할당. 그러면 data 변수는 앞서 만든 Data 인스턴스를 더는 참조하지 않음.

* Null *

참조형 변수에는 항상 객체가 있는 위치를 가리키는 참조값이 들어감.그런데 아직 가리키는 대상이 없거나, 가리키는 대상을 나중에 입력하고 싶다면 null이라는 특별한 값을 넣어둘 수 있음.nul은 값이 존재하지 않는, 없다는 뜻임.

 

* GC(Garbage Collection) *

위에 코드에서 data에 null을 할당하여 Data 인스턴스를 더는 아무도 참조하지 않게 됨.이렇게 아무도 참조하지 않게 되면 참조값을 다시 구할 방법이 없음. 따라서 해당 인스턴스에 다시 접근할 방법이 없음.이렇게 아무도 참조하지 않는 인스턴스는 사용되지 않고 메모리 용량만 차지함.자바는 과거 C와 같은 프로그래밍 언어를 개발자가 직접 명령어를 사용해서 인스턴스를 메모리에서 제거하는 일을 자동으로 처리해 줌.

---

package ref;

public class NullMain2 {
    public static void main(String[] args) {

        Data data = null;
        data.value = 10;    // NullPointerException 예외 발생
        System.out.println("data = " + data.value);
    }
}

// 실행결과

Exception in thread "main" java.lang.NullPointerException:
Cannot assign field "value" because "data" is null
	at ref.NullMain2.main(NullMain2.java:7)

[NullMain2]

 

NullPointerException은 이름 그대로 nul을 가리키는데(pointer), 이때 발생하는 예외임.

null은 없다는 뜻이므로 결국 주소가 없는 곳을 찾아갈 때 발생하는 예외임.

 

객체 참조할 때 .(dot)을 사용하여 참조값을 사용해 해당 객체를 찾아갈 수 있음.

그런데 참조값이 null이라면 값이 없다는 뜻이므로, 찾아갈 수 있는 객체(인스턴스)가 없음.

따라서 NullPointerException은 이처럼 null에 .(dot)을 찍었을 때 발생함.

 

data.value = 10은 null.value = 10으로 해석할 수 있음.

---

package ref;

public class Data {
    int value;
}

package ref;

public class BigData {
    Data data;
    int count;
}

package ref;

public class NullMain3 {
    public static void main(String[] args) {

        BigData bigData = new BigData();
        System.out.println("bigData.count = " + bigData.count); // 0
        System.out.println("bigData.data = " + bigData.data);   // null

        // NullPointerException
        System.out.println("bigData.data.value = " + bigData.data.value);
    }
}

// 실행결과

bigData.count = 0
bigData.data = null
Exception in thread "main" java.lang.NullPointerException: Cannot read field "value" because "bigData.data" is null
	at ref.NullMain3.main(NullMain3.java:11)

[Data, BigData, NullMain3]

 

BigData를 생성하면 BigData의 인스턴스가 생성.

이때 BigData 인스턴스의 멤버 변수에 초기화가 일어나는데 BigData의 data 멤버 변수는 참조형이므로 null로 초기화됨.

count 멤버 변수는 숫자이므로 0으로 초기화됨.

 

BigData.data.value를 출력하면 data의 값이 null이므로 null에 .(dot)을 찍게 되고, 따라서 참조할 곳이 없으므로 예외 발생.

 

위에 문제를 해결하려면 Data 인스턴스를 만들고 BigData.data 멤버 변수에 참조값을 할당하면 됨.

 

package ref;

public class NullMain4 {
    public static void main(String[] args) {

        BigData bigData = new BigData();
        bigData.data = new Data();
        System.out.println("bigData.count = " + bigData.count); // 0
        System.out.println("bigData.data = " + bigData.data);   // null

        // NullPointerException
        System.out.println("bigData.data.value = " + bigData.data.value);
    }
}

// 실행결과

bigData.count = 0
bigData.data = ref.Data@568db2f2
bigData.data.value = 0

---

1-1. 기본형과 참조형 문제

[ProductOrder, ProductOrderMain2]

 

ref.ex 패키지에 생성.

 

1. ProductOrder 클래스는 다음과 같은 멤버 변수 포함.

 - 상품명 (productName)

 - 가격 (price)

 -  주문수량 (quantity)

 

2. ProductOrderMain2

 여러 상품의 주문 정보를 배열로 관리하고, 그 정보들을 출력하고, 최종 결제 금액을 계산하여 출력.

 - static ProductOrder createOrder(String productName, int price, int quantity)

      - ProductOrder 생성 후 매개변수로 초기값 설정.

      - 마지막으로 생성한 ProductOrder를 반환

 - static void printOrders(ProductOrder[] orders)

      -  배열을 받아 배열에 들어있는 전체 ProductOrder의 상품명, 가격, 수량 출력.

 - static int getTotalAmount(ProductOrder[] orders)

      - 배열을 받아 배열에 들어있는 전체 ProductOrder의 총 결제 금액 계산 후 반환.

// 출력 예시

상품명 : 두부, 가격 : 2000, 수량 : 2
상품명 : 김치, 가격 : 5000, 수량 : 1
상품명 : 콜라, 가격 : 1500, 수량 : 2
총 결제 금액 : 12000

package ref.ex;

public class ProductOrder {
    String productName;
    int price;
    int quantity;
}

package ref.ex;

public class ProductOrderMain2 {
    public static void main(String[] args) {

        // 여러 상품의 주문 정보 담는 배열 생성
        ProductOrder[] orders = new ProductOrder[3];

        // createOrder() 여러번 사용해서 주문 정보들 생성하고 배열에 저장
        orders[0] = createOrder("두부", 2000, 2);
        orders[1] = createOrder("김치", 5000, 1);
        orders[2] = createOrder("콜라", 1500, 2);

        // printOrders() 사용해서 상품 주문 정보 출력
        printOrders(orders);

        // getTotalAmount() 사용해서 총 결제 금액 계산
        int totalAmount = getTotalAmount(orders);   // ctrl + alt + v 단축키 사용 시 변수명 생성

        // 총 결게 금액 출력
        System.out.println("총 결제 금액 : " + totalAmount);
    }

    static ProductOrder createOrder(String productName, int price, int quantity) {
        ProductOrder order = new ProductOrder();
        order.productName = productName;
        order.price = price;
        order.quantity = quantity;

        return order;
    }

    static void printOrders(ProductOrder[] orders) {
        for (ProductOrder order : orders) {
            System.out.println("상품명 : " + order.productName + ", 가격 : " + order.price + ", 수량 : " + order.quantity);
        }
    }

    static int getTotalAmount(ProductOrder[] orders) {
        int totalAmount = 0;

        for (ProductOrder order : orders) {
            totalAmount += order.price * order.quantity;
        }
        return totalAmount;
    }
}

---

[ProductOrder, ProductOrderMain3]

 

앞서 만든 상품 주문 시스템을 사용자 입력을 받도록 개선.

 

요구사항

 - 아래 입력, 출력, 예시를 참고해 다음 사항 적용.

 - 주문 수량 입력받기 ex) 입력할 주문의 개수를 입력하세요 : 

 - 가격, 수량, 상품명을 입력 받기 ex) 입력 시 상품 순서를 알 수 있게 "n번째 주문 정보를 입력하세요 : "라는 메시지 출력.

 - 입력이 끝나면 등록한 상품과 총 결제 금액 출력

// 출력 예시

입력할 주문의 개수를 입력하세요 : 3
1번째 주문 정보를 입력하세요.
상품명 : 두부
가격 : 2000
수량 : 2
2번째 주문 정보를 입력하세요.
상품명 : 김치
가격 : 5000
수량 : 1
3번째 주문 정보를 입력하세요.
상품명 : 콜라
가격 : 1500
수량 : 2
상품명 : 두부, 가격 : 2000, 수량 : 2
상품명 : 김치, 가격 : 5000, 수량 : 1
상품명 : 콜라, 가격 : 1500, 수량 : 2
총 결제 금액 : 12000

package ref.ex;

public class ProductOrder {
    String productName;
    int price;
    int quantity;
}

package ref.ex;

import java.util.Scanner;

public class ProductOrderMain3 {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.print("입력할 주문의 개수를 입력하세요 : ");
        int n = scanner.nextInt();
        scanner.nextLine();

        ProductOrder[] order = new ProductOrder[n];

        for(int i = 0; i < order.length; i++) {
            System.out.println((i+1) + "번째 주문 정보를 입력하세요.");

            System.out.print("상품명 : ");
            String productName = scanner.nextLine();

            System.out.print("가격 : ");
            int price = scanner.nextInt();

            System.out.print("수량 : ");
            int quantity = scanner.nextInt();
            
            scanner.nextLine(); // 입력 버퍼를 비우기 위한 코드

            order[i] = createOrder(productName, price, quantity);
        }
        printOrders(order);

        int total = getTotalAmount(order);
        System.out.println("총 결제 금액 : " + total);
    }
    static ProductOrder createOrder(String productName, int price, int quantity) {
        ProductOrder order = new ProductOrder();
        order.productName = productName;
        order.price = price;
        order.quantity = quantity;

        return order;
    }
    static void printOrders(ProductOrder[] orders) {
        for (ProductOrder order : orders) {
            System.out.println("상품명 : " + order.productName + ", 가격 : " + order.price + ", 수량 : " + order.quantity);
        }
    }
    static int getTotalAmount(ProductOrder[] orders) {
        int totalAmount = 0;

        for (ProductOrder order : orders) {
            totalAmount += order.price * order.quantity;
        }
        return totalAmount;
    }
}

---

2. 정리

 

대원칙 : 자바는 항상 변수의 값을 복사해서 대입한다.

- 자바에서 변수에 값을 대입하는 것은 변수에 들어있는 값을 복사해서 대입하는 것.

- 기본형, 참조형 모두 항상 변수에 있는 값을 복사해서 대입함. 기본형이면 변수에 들어있는 실제 사용하는 값을 복사해서 대입하고, 참조형은 변수에 들어있는 참조값을 복사해서 대입.

- 기본형이든 참조형이든 변수의 값을 대입하는 방식은 같음. 하지만 기본형과 참조형에 따라 동작하는 방식이 다름.

 

기본형 vs  참조형 - 기본

- 자바의 데이터 타입을 가장 크게 보면 기본형, 참조형으로 나눔.

- 기본형을 제외한 나머지 변수는 모두 참조형. 클래스와 배열을 다루는 변수는 참조형.

- 기본형 변수는 값을 직접 저장하지만, 참조형 변수는 참조(주소)를 저장.

- 기본형 변수는 산술 연산을 수행할 수 있지만, 참조형 변수는 산술 연산 수행 불가능.

- 기본형 변수는 null을 할당할 수 없지만, 참조형 변수는 null을 할당 가능.

 

기본형 vs 참조형 - 대입

- 기본형과 참조형 모두 대입시 변수 안에 있는 값을 읽고 복사해서 전달.

- 기본형은 사용하는 값을 복사해서 전달하고, 참조형은 참조값을 복사해서 전달. 실제 인스턴스가 복사되는 것이 아닌 인스턴스를 가리키는 참조값을 복사해서 전달하는 것. 따라서 하나의 인스턴스를 여러 곳에서 참조 가능.

 

기본형 vs 참조형 - 메서드 호출

- 메서드 호출 시 기본형은 메서드 내부에서 매개변수(파라미터)의 값을 변경해도 호출자의 변수 값에는 영향 없음.

- 메서드 호출 시 참조형은 메서드 내부에서 매개변수(파라미터)로 전달된 객체의 멤버 변수를 변경하면, 호출자의 객체도 변경.