[Java] 5.Object-oriented Programming_객체지향①

Intro.객체지향언어

💙 객체지향언어 : 규칙 이용 → 코드 간 서로 관계를 맺어줌 → 유기적으로 프로그램 구성

특징	개념
코드의 높은 재사용성	새로운코드 작성 시, 기존코드 이용 → 쉽게작성 ✅
유지보수 용이	코드간 관계 이용 → 쉽게 코드 변경 가능 ✅
신뢰성 높음	제어자 + method → 데이터보호 + 데이터무결성유지 ✅
중복된 코드제거	코드중복 제거 → 코드 불일치로 인한 오작동 방지 ✅

---

1 클래스와 객체

💙 클래스(class) : 객체를 정의해놓은 것

• 객체(object) 생성 시, 사용됨

• 객체(object)는 클래스에 정의된 대로 생성됨

💙 객체(object) : class에 정의된 내용대로 memory에 생성된 것

• 클래스는 객체를 생성하는데 사용될 뿐, 객체 그자체가 아님 ⛔️

• 객체를 사용한다는 것 → 객체 속성과 기능을 사용한다는 것

1️⃣ 객체의 구성요소 (속성과 기능)

class Tv {
    // 멤버변수 (속성)
    String color; // null 초기화
    boolean power; // false 초기화
    int channel; // 0 초기화

    // method(기능)
    void power() {power = !power;}
    void channelUp() {++channel;}
    void channelDown() {--channel;}
}

2️⃣ 객체와 인스턴스

📍 인스턴스화 : 클래스로부터 객체를 만드는 과정
	- A class -> a object
    - 위 과정을 인스턴스화라 함

📍 인스턴스 : 클래스로부터 만들어진 그 객체
	- A class -> a object
    - a를 A의 인스턴스라 함

3️⃣ 한 파일에 여러 클래스 작성

• public class → 소스파일이름 반드시 public class와 일치

Hello.java
public class Hello {} ✅
class Hello1 {} ❌

• public class 없는경우 → 소스파일이름 제약 없음

Hello.java
class Hello1 {} ✅
class Hello2 {} ✅

---

2 객체의 생성과 사용

💙 객체생성

• 클래스명 참조변수명 = new 클래스명(생성자);

1️⃣ Java code

class Object1 {
    public static void main(String[] args) {
        // 객체생성
        Tv t = new Tv();

        // 객체사용
        t.channel = 7; // Tv 객체 t -> 멤버변수 초기화
        t.channelDown(); // Tv 객체 t -> 메서드 사용

        System.out.println("현재 채널은 " + t.channel + "입니다.");
    }
}

• 참조변수 t ← 생성된 객체의 주소값이 참조변수에 저장됨

• 그 이후엔, 참조변수 t를 통해 객체에 접근 가능

• 객체의 멤버변수 사용 : 참조변수.멤버변수

• 인스턴스는 참조변수를 통해서만 다룰 수 있음

• 참조변수의 타입 = 인스턴스 타입

2️⃣ 객체 멤버변수와 메서드

class Object2 {
    public static void main(String[] args) {
        // 객체생성
        Tv t1 = new Tv();
        Tv t2 = new Tv();

        // 객체 생성 후 -> 기본 초기화
        System.out.println("t1의 channel 값 : " + t1.channel);
        System.out.println("t2의 channel 값 : " + t2.channel);

        // 객체 멤버변수 재초기화
        // 객체 멤버변수 : 서로 다른 값 유지가능
        t1.channel = 10;
        t2.channelUp();

        System.out.println("t1의 현재 channel 값 : " + t1.channel);
        System.out.println("t2의 현재 channel 값 : " + t2.channel);
    }
}

• 객체 멤버변수는 서로 다른 값을 유지할 수 있음

• method 내용 → 모든 객체에 대해 동일함

---

3 객체배열

💙 객체배열 : 많은 수의 객체를 다뤄야할 때 사용

• 객체 배열에 객체의 주소 (참조값)이 저장됨

• 객체배열 = 참조변수배열

1️⃣ 객체배열 생성

Tv tv1, tv2, tv3;

📍 type[] 참조변수이름 = new type[길이];
	Tv[] tvArray = new Tv[3];
    // 클래스가 type이 됨

2️⃣ 객체배열 생성과정

• ① 객체배열 tvArray -> 각 배열요소 참조변수의 기본값 null로 자동초기화

• ② 객체 생성 → 배열의 각 요소에 저장

// 객체배열 생성
Tv[] tvArray = new Tv[3];

// 객체 생성 -> 배열의 각 요소에 저장
tvArray[0] = new Tv();
tvArray[1] = new Tv();
tvArray[2] = new Tv();

---

4 클래스의 정의

1️⃣ 데이터와 함수의 결합

💙 객체지향언어의 클래스 : 서로 관련된 변수들을 정의하고, 이에 대한 작업을 수행하는 함수들을 함께 정의한 것

• 변수(data) + 함수(method) → 하나의 클래스에 정의
  ➡️ 서로 관계 있는 변수와 함수를 함께 다룸

데이터저장형태의 발전과정

	저장형태	특징
①	변수	하나의 데이터 저장
②	배열	같은종류의 여러 데이터 → 하나의 집합으로 저장
③	구조체	서로 관련된 데이터 → 종류 관계없이 하나의 집합으로 저장
④	클래스	변수(data) + 함수(method) 결합

2️⃣ 사용자정의 타입

💙 사용자정의타입(user-defined type)
프로그래밍언어에서 제공하는 기본자료형 외,
프로그래머가 서로 관련된 변수 → 묶어서 하나의 type으로 추가하는 것

• Java(객체지향언어)에서는 class → 사용자정의타입

• 기본형 개수 8개와 달리 참조형 개수가 정해져 있지 않은 이유

사용자정의타입 사용과정

📍 변수선언
	int hour;
    int minute;
    float second;

📍 변수 3개선언
	int hour1, hour2, hour3;
    int minute1, minute2, minute3;
    float second1, second2, second3;
    // 변수개수가 많아질수록 곤란해짐

📍 배열선언으로 1차 해결
	int[] hour = new int[3];
    int[] minute = new minute[3];
    float[] second = new float[3];
    // 데이터 개수 늘어나도 배열의 크기만 변경하면 됨

📍 사용자정의타입, 클래스정의
	class Time {
    	int hour;
        int minute;
        float second;
    }

비객체지향적 code 🆚 객체지향적 code

비객체지향적 code	객체지향적 code
int hour1, hour2, hour3;	Time t1 = new Time();
int minute1, minute2, minute3;	Time t2 = new Time();
float second1, second2, second3;	Time t3 = new Time();

비객체지향적 code	객체지향적 code
int[] hour = new int[3];	Time[] t = new Time[3];
	t[0] = new Time[];
int[] minute = new int[3];	t[1] = new Time[];
float[] second = new float[3];	t[2] = new Time[];

제어자와 메서드를 이용한 데이터보호

class Time {
	// 접근제어자 private -> new 연산자 통해 값 변경 불가
    // 메서드로 유효성 검사를 한 후에만 값 변경 가능
    private int hour;
    private int minute;
    private float second;
    
    public void setHour(int h) {
    	if (h < 0 || h > 23) {
        	return;
        } else {
        	hour = h; // 생성자역할
        }
    }
}

---

5 선언위치에 따라 다른 변수

💙 변수의 종류

• 클래스변수, 인스턴스변수, 지역변수
• 변수의 선언위치 → 변수의 종류 결정됨

class Variable {
	int iv; // 멤버변수_인스턴스변수
    static int cv; // 멤버변수_클래스변수
    
    // 메서드
    void method() {
    	int lv = 0; // 지역변수
    }
}

변수종류	선언위치	생성시기
클래스변수	클래스영역(멤버변수)	클래스 → 메모리에 올라갈 때
인스턴스변수	클래스영역(멤버변수)	인스턴스(객체) 생성 시
지역변수	메서드, 생성자, 초기화블럭내부	변수 선언문이 수행될 시

1️⃣ 인스턴스변수

• 클래스영역 → 멤버변수

• 인스턴스 (객체) 생성 시, 변수가 생성됨
  ➡️ 인스턴스변수 값 읽기•저장 : 선 객체 생성 필수 🚨

• 인스턴스마다 별도의 저장공간을 가짐 → 서로 다른 값 가질 수 있음 ✅

• 인스턴스마다 고유한 상태를 유지해야하는 속성 → 인스턴스변수로 선언

📍 선 객체생성
	Variable obj = new Variable();

📍 인스턴수변수 값 읽기•저장
	obj.iv = 22;

2️⃣ 클래스변수

• 선언방법 : static + type + 변수명

• 모든 인스턴스 → 공통된 저장공간(변수) 공유

• 한 클래스의 모든 인스턴스들이 공통값을 유지해야하는 속성 → 클래스변수로 선언

• 인스턴스 생성 ❌ → 바로 사용 가능 ✅

• 클래스이름.클래스변수명 → 사용가능

3️⃣ 지역변수

• method()내에 선언 → method() 내에서만 사용가능 🚨

• 메서드 종료 → 소멸되어 더이상 사용불가 ⛔️

4️⃣ Java code

class Card {
    String kind; // 멤버변수_인스턴스변수 (카드무늬)
    int number; // 멤버변수_인스턴스변수 (숫자)

    static int width = 100; // 멤버변수_클래스변수
    static int height = 250; // 멤버변수_클래스변수
}

class Object3 {
    public static void main(String[] args) {
        // 클래스변수 -> 객체생성없이 바로 사용가능
        System.out.println("Card.width = " + Card.width);
        System.out.println("Card.height = " + Card.height);

        // 인스턴스변수 -> 선 객체 생성 후, 멤버변수 사용가능
        // 객체생성 후, 인스턴스변수 값저장
        Card card1 = new Card();
        card1.kind = "Heart";
        card1.number = 7;

        Card card2 = new Card();
        card2.kind = "Spade";
        card2.number = 4;

        System.out.println("card1은 " + card1.kind + ", " + card1.number + "이며, 크기는 ("
                + card1.width + ", " + card1.height + ")");
        System.out.println("card2는 " + card2.kind + ", " + card2.number + "이며, 크기는 ("
                + card2.width + ", " + card2.height + ")");

        System.out.println("card1의 width와 height를 각각 50, 80으로 변경합니다.");
        card1.width = 50;
        card1.height = 80;

        System.out.println("card1은 " + card1.kind + ", " + card1.number + "이며, 크기는 ("
                + card1.width + ", " + card1.height + ")");
        System.out.println("card2는 " + card2.kind + ", " + card2.number + "이며, 크기는 ("
                + card2.width + ", " + card2.height + ")");
    }
}

---

6 메서드

💙 메서드(method) : 특정작업을 수행하는 일련의 문장들을 하나로 묶은 것

• 입력값 → 작업수행 → 결과 반환

• 입력값 또는 출력값이 없을 수도 있음

• 입력값 출력값 모두 없을 수도 있음

• 구성 형식 → 선언부(header) + 구현부(body)

반환타입 메서드명 (매개변수 -> 타입, 변수명) {
	// 메서드 호출 시 수행될 코드
}

int add(int a, int b) {
	int result = a + b;
    
    return result;
}

---

7 메서드 선언부

💙 메서드선언부 : 메서드작업 수행에 어떤 값이 필요하고, 작업결과로 어떤 타입의 값을 반환하는지에 대한 정보

• 구성형식 → 반환타입 + 메서드이름 + 매개변수선언

• 메서드선언부 변경사항 발생하지 않도록 신중 🚨

  • 메서드선언부 변경 → 메서드 호출되는 부분 모두 수정필요

1️⃣ 매개변수선언

• 메서드가 작업을 수행하는데 필요한 값들을 제공받음

• 매개변수 = 입력값

• 필요한 값의 개수만큼 변수 선언

• 두 변수의 타입이 같아도 생략 불가능 ⛔️

• 배열이나 참조변수 사용가능

int add (int x, int y) {} // 가능
int add (int x, y) {} // Error 🚨

2️⃣ 반환타입

케이스	반환타입
반환값이 있는 경우	반환값의 타입
반환값이 없는 경우	void

📍 반환값(return) ❌ → void 사용

void print99danAll() {
	for (int i = 1; i <= 9; i++) {
    	for (int j = 2; j <= 9; j++) {
        	System.out.print(j * i);
        }
        System.out.println();
    }
}

---

8 메서드 구현부

💙 메서드구현부 : 메서드를 호출했을 때, 수행될 문장을 넣음

1️⃣ return문

• 메서드 반환타입이 void가 아닌 경우 → 구현부에 무조건return 필수 ✅

• return : 작업 수행결과인 반환값 → 호출한 메서드로 전달

• 매개변수는 여러개 가능 ✅ , 반환값은 무조건 한개만 🚨

<int add (int x, int y) { // 매개변수 2개
	int result = x + y;
    
    return result; // 반환값 1개
}
// 반환값 = 반환타입 일치!

2️⃣ 지역변수

• 메서드 내 선언된 변수 → 해당 메서드 내에서만 사용가능 ✅
  ➡️ 서로 다른 메서드면, 같은 이름 변수 사용가능

• 메서드 내 선언된 변수 = 지역변수

int add (int x, int y) {
	int result = x + y;
    
    return result;
}

int multiply (int x, int y) {
	int result = x * y;
    
    return result;
}

---

9 메서드 호출

💙 메서드호출

• 메서드 정의 후, 메서드를 호출해야 구현부{}의 문장이 수행됨
• main()메서드는 프로그램 실행 시, OS가 자동으로 호출함

1️⃣ 메서드호출방법

📍 method이름(매개변수 값1, 값2 •••)
	print99danAll(); // void print99danAll() 호출
    int result = add(3, 5); // 메서드 호출 -> 결과 변수에 저장

2️⃣ 인수와 매개변수

구분	의미
인수 (argument)	메서드 호출 시, 괄호() 안에 지정해준 값
매개변수 (parameter)	메서드 작업수행 시 필요한 값 입력받는 곳 (메서드선언부)

• 인수 → 메서드 호출 시, 매개변수에 대입됨

• 인수 type = 매개변수 type (or 자동형변환)

---

10 메서드실행흐름

class MyMath {
    // 덧셈
    long add(long a, long b) {
        long result = a + b;
        return result;
    }

    // 뺄셈
    long subtract(long a, long b) {
        long result = a - b;
        return result;
    }

    // 곱셈
    long multiply(long a, long b) {
        long result = a * b;
        return result;
    }

    // 나눗셈
    double divide(double a, double b) {
        double result = a / b;
        return result;
    }
}

class Object4 {
    public static void main(String[] args) {
        // 객체생성
        MyMath myMath = new MyMath();

        // 객체 메서드 호출
        long result1 = myMath.add(5L, 3L);
        long result2 = myMath.subtract(5L, 3L);
        long result3 = myMath.multiply(5L, 3L);
        double result4 = myMath.divide(5, 3);

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
    }
}

---

11 반환값과 호출스택

1️⃣ return문

💙 return문 : 현재 실행중인 메서드 종료 → 호출한 메서드로 돌아감

• 반환값 유무관계 ❌ → 모든 메서드에 적어도 하나의 return문 있어야함 ✅

• void method → 컴파일러가 메서드 마지막에 return; 자동적으로 추가해줌

• 조건식 결과에 따라 return문 실행되지 않으면 안됨 🚨

• return문 반환값 → 변수, 수식 모두 가능

2️⃣ 호출스택

💙 호출스택(call stack) : 메서드 작업에 필요한 메모리 공간을 제공함

• 메서드 호출 → 호출스택에 메모리 할당됨

• 메모리 ➡️ 작업 수행 중, 지역변수(매개변수) + 연산중간결과 저장하는데 사용됨

• 메서드 종료 → 메모리공간 반환되어 비워짐

• 호출스택 가장 위의 메서드 : 현재 실행중인 메서드

• 아래에 있는 메서드 : 바로 위의 메서드를 호출한 메서드

class Object5 {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}
// main 메서드 -(위에)-> println 메서드
// println 메서드 종료 -> main 메서드 종료 -> 스택 Empty

---

12 매개변수

• 메서드 호출 → 매개변수로 지정한 값 (인수)
  ➡️ 메서드의 매개변수에 복사해서 넘겨줌

1️⃣ 기본형매개변수

💙 기본형매개변수

• 기본형 값이 복사됨
• 변수의 값 → 읽기만 가능 ✅

class Data {
    int x; // 멤버변수(인스턴스)
}

class Object6 {
    public static void main(String[] args) {
        // 객체생성
        Data data = new Data();

        // 인스턴스변수 초기화
        data.x = 10;
        System.out.println("main() : x = " + data.x);

        change(data.x); // 인스턴스변수 값 10 자치게 복사되어 전달됨

        System.out.println("After change(data.x)");
        System.out.println("main() : x = " + data.x);
    }

    // 메서드정의
    static void change(int x) {
        x = 1000;
        System.out.println("change() : x = " + x);
    }
}

• change() 매개변수 x의 값이 변경된 것

• 복사본이 변경된 것이라 원본에는 아무영향을 안끼치는 것

• 기본형매개변수 : 변수에 저장된 값 읽을수만 있고, 변경 못함 ⛔️

2️⃣ 참조형매개변수

💙 참조형매개변수

• 인스턴스의 주소가 복사됨
• 값이 저장된 곳의 주소를 알 수 있음 → 값 읽기, 변경 모두가능 ✅

class Data2 {
    int x; // 멤버변수(인스턴스변수)
}

class Object7 {
    public static void main(String[] args) {
        // 객체생성
        Data2 data2 = new Data2();

        // 인스턴스변수 초기화
        data2.x = 10;
        System.out.println("main() : x = " + data2.x);

        change(data2); // 객체 주소값이 전달
        System.out.println("After change(data2)");
        System.out.println("main() : x = " + data2.x);
    }

    // 메서드정의
    static void change(Data2 data2) { // 참조형매개변수 (객체를 넣음)
        data2.x = 1000;
        System.out.println("change() : x = " + data2.x);
    }
}

3️⃣ 참조형반환타입

• 반환타입도 참조형이 될 수 있음

• 반환하는 값의 타입이 참조형

class Data3 {
    int x;
}

class Object8 {
    public static void main(String[] args) {
        // 객체생성
        Data3 data3_1 = new Data3();

        // 인스턴스변수 초기화
        data3_1.x = 10;

        Data3 data3_2 = copy(data3_1);
        System.out.println("data3_1.x = " + data3_1.x);
        System.out.println("data3_2.x = " + data3_2.x);
    }

    // 메서드정의
    static Data3 copy(Data3 data3_1) {
        Data3 tmp = new Data3();
        tmp.x = data3_1.x;
        return tmp;
    }
}

---

13 static

1️⃣ static메서드와 인스턴스메서드

💙 static 메서드 : 클래스메서드 (static이 붙음)

메서드종류	특징	호출방법
클래스메서드	static ✅	클래스 name.메서드 name
	인스턴스 변수, 메서드 사용 ❌	객체생성 ❌ → 호출가능 ✅
인스턴스메서드	static ⛔️	객체 생성 후, 호출 🚨
	인스턴스 변수, 메서드 사용 ⭕️

class MyMath2 {
    long a, b; // 인스턴스변수

    // 멤버변수(인스턴스변수)만 사용해서 작업 -> 매개변수 불필요
    // 인스턴스메서드
    long add() {return a + b;}
    long subtract() {return a - b;}
    long multiply() {return a * b;}
    double divide() {return a / b;}

    // 멤버변수(인스턴스변수)와 관계없이 매개변수만으로 작업
    // static(클래스)메서드
    static long add(long a, long b) {return a + b;}
    static long subtract(long a, long b) {return a - b;}
    static long multiply(long a, long b) {return a * b;}
    static double divide(long a, long b) {return a / (double) b;}
}

class Object9 {
    public static void main(String[] args) {
        // 클래스메서드 호출 (객체생성 없이 바로사용)
        System.out.println(MyMath2.add(200L, 100L));
        System.out.println(MyMath2.subtract(200L, 100L));
        System.out.println(MyMath2.multiply(200L, 100L));
        System.out.println(MyMath2.divide(200L, 100L));

        // 인스턴스메서드 : 선 객체생성
        MyMath2 myMath2 = new MyMath2();

        // 객체의 인스턴스변수 -> 초기화
        myMath2.a = 200L;
        myMath2.b = 100L;

        System.out.println(myMath2.add());
        System.out.println(myMath2.subtract());
        System.out.println(myMath2.multiply());
        System.out.println(myMath2.divide());
    }
}

2️⃣ static 사용하는경우

1. 클래스 설계 시, 멤버변수 중 모든 객체에 공통으로 사용하는 것

   • 생성된 각 객체 → 독립적 → 인스턴스변수는 다른 값을 유지함
   • 모든 객체에서 같은 값이 유지되야하는 변수 → 클래스변수로 정의

2. 클래스메서드(static method) → 인스턴스변수 사용 불가 ⛔️

3. 인스턴스메서드 → 클래스변수 사용 가능 ✅

4. 메서드 내, 인스턴스 변수 사용 ❌ → static 고려하기

   • 메서드 호출시간이 짧아져 성능향상에 도움 ✅

3️⃣ 메서드 간 호출과 참조

💙 메서드 간 호출과 참조

• 같은 클래스에 속한 멤버 → 별도의 객체 생성 없이 참조 + 호출 가능
• 클래스멤버가 인스턴스멤버 참조 + 호출 → 객체생성 필수!

• 인스턴스멤버가 존재하는 시점 : 클래스멤버 항상 존재 ✅

• 클래스멤버가 존재하는 시점 : 인스턴스멤버 존재하지 않을수도 있음 🚨

class TestClass {
	void instanceMethod() {} // 인스턴스메서드
    static void staticMethod() {} // 클래스메서드
    
    void instanceMethod2() { // 인스턴스메서드
    	instanceMethod(); // 다른 인스턴스메서드 호출가능 ✅
        staticMethod(){}; // 클래스메서드 호출가능 ✅
    }
    
    static void staticMethod2() { // 클래스메서드
    	instanceMethod(); // 인스턴스메서드 호출불가 ⛔️
        staticMethod(); // 클래스메서드 호출가능 ✅
    }
}

---

14 오버로딩

💙 오버로딩(overloading) : 한 클래스 → 같은 이름의 메서드를 여러개 정의하는 것

1️⃣ 오버로딩 조건

• 메서드 이름이 같아야 함

• 매개변수의 개수 or 타입이 달라야함 ⭐️

  • 메서드 이름이 같더라도, 매개변수로 구별함

• 반환타입은 관계없음

---

15 생성자

💙 생성자(constructor) : 객체 생성 시 → 자동으로 호출되는 객체(인스턴스)초기화 메서드

• 인스턴스변수 초기화 기능 + 객체생성 시 실행되어야하는 작업지정 기능

• 생성자 이름 = 클래스 이름 ⭐️

• return 값 없음 → void 사용 ❌

• 오버로딩 가능 → 하나의 클래스에 여러개 생성자 가능

• 생성자가 객체를 생성하는 것은 아님

• 매개변수 있을수도 있고, 없을수도 있음

1️⃣ 기본생성자

💙 기본생성자(default constructor) : 클래스에 정의된 생성자가 하나도 없을 때 → 컴파일러가 자동으로 추가함

• 모든 클래스에는 반드시 하나 이상의 생성자가 정의되어야함

• 컴파일 시, 소스파일(*.java) 클래스에 생성자가 없으면
  → 컴파일러가 기본생성자를 추가해 컴파일함

• 클래스에 이미 생성자가 존재하는 경우, 기본생성자 생성 ❌

class Data_1 {
    int value; // 멤버(인스턴스)변수
}

class Data_2 {
    int value; // 멤버(인스턴스)변수

    // 기본생성자
    Data_2() {}
}

class Object10 {
    public static void main(String[] args) {
        Data_1 data_1 = new Data_1();
        Data_2 data_2 = new Data_2();
    }
}

2️⃣ 매개변수가 있는 생성자

💙 매개변수가있는생성자 : 객체마다 각각 다른 값으로 초기화 되어야하는 경우에 사용함

• 생성자에 매개변수 선언 → 호출 시 값을 넘겨받아 인스턴스를 초기화함

• 객체생성과 멤버변수 초기화 동시에 가능 ⭐️

• 기본생성자와 매개변수생성자를 모두 선언 → 때에 맞춰 사용가능 ✅

• 객체 생성 후, 멤버변수 초기화 방법보다 코드가 간결하고 직관적임

class Car {
    // 멤버(인스턴스)변수
    String color;
    String gearType;
    int door;

    // 기본생성자
    Car () {}

    // 매개변수가있는생성자
    Car(String c, String g, int d) {
        color = c;
        gearType = g;
        door = d;
    }
}

class Object11 {
    public static void main(String[] args) {
        // 기본생성자사용
        Car car1 = new Car();
        car1.color = "white";
        car1.gearType = "auto";
        car1.door = 4;

        // 매개변수가있는생성자사용 -> 객체생성+초기화 동시에
        Car car2 = new Car("white", "auto", 4);

        System.out.println("car1 : " + car1.color + " " + car1.gearType + " " + car1.door);
        System.out.println("car2 : " + car2.color + " " + car2.gearType + " " + car2.door);
    }
}

3️⃣ 생성자에서 다른 생성자 호출 - this()

💙 생성자호출 this() : 생성자 안에서 다른 생성자를 호출함

• 생성자 이름 → 클래스이름 ❌, this 사용 ✅

• 생성자 첫줄에서만 호출이 가능함 🚨

• 서로 호출 → 유기적으로 연결하면 더 좋은 코드를 얻을 수 있음

• 유지보수가 쉬워짐

class Car2 {
    // 멤버(인스턴스)변수
    String color;
    String gearType;
    int door;

    // 생성자
    Car2(String color, String gearType, int door) {
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }

    // 생성자호출
    Car2() { // 위의 생성자 호출 -> 초기화
        this("white", "auto", 4);
    }

    Car2(String color) { // 위의 생성자 호출 -> 초기화 (color만 따로 초기화)
        this(color, "auto", 4);
    }
}

class Object12 {
    public static void main(String[] args) {
        // 생성자호출한 생성자사용
        Car2 car2_1 = new Car2();

        // 생성자호출한 생성자사용 (color 따로 초기화)
        Car2 car2_2 = new Car2("blue");

        System.out.println("car2_1 : " + car2_1.color + " " + car2_1.gearType + " " + car2_1.door);
        System.out.println("car2_2 : " + car2_2.color + " " + car2_2.gearType + " " + car2_2.door);
    }
}

4️⃣ 객체자신을 가리키는 참조변수 - this()

💙 참조변수 this : 참조변수로 인스턴스 자신을 가리킴

• 인스턴스의 주소가 저장되어 있음

• 생성자 매개변수와 인스턴스변수의 이름 일치 문제해결 ✅

• 인스턴스멤버만 사용 가능 🚨

• static메서드는 사용 불가능 ⛔️

Car2(String color, String gearType, int door) {
        this.color = color;
        this.gearType = gearType;
        this.door = door;
}

---

16 변수의 초기화

💙 변수의 초기화 : 변수를 선언하고 처음으로 값을 저장하는 것

변수종류	초기화필수성
멤버변수	초기화 필수 ⛔️
	→ 변수자료형의 기본값으로 초기화됨
지역변수	초기화 필수 ✅

📍 멤버변수 초기화 예제
	class Test1 {
    	int x; // int 기본값 0으로 초기화
        int y = x; // y에 0이 저장됨 ✅
    }

📍 지역변수 초기화 예제
	class Test2 {
    	void method() {
        	int i; // 지역변수 -> 초기화안됨
            int j = i; // Error 🚨. 지역변수 초기화 필수 ⭐️
        }
    }

---

17 멤버변수 초기화

💙 멤버변수 초기화 과정

• 기본값 자동초기화 → 명시적초기화 → 초기화블럭, 생성자
• 클래스변수(cv)초기화 → 인스턴스변수(iv)초기화

1️⃣ 명시적초기화

• 변수를 선언과 동시에 초기화하는 것

• 가장 기본이므로 가장 우선적으로 고려

• 간단명료함

class Car {
	int door = 4; // 기본형변수의 초기화
    Engine engine = new Engine(); // 참조형변수의 초기화
    •••
}

2️⃣ 초기화블럭

초기화블럭종류	사용
클래스 초기화블럭	클래스변수의 복잡한 초기화에 사용
인스턴스 초기화블럭	인스턴스변수의 복잡한 초기화에 사용

• 인스턴스 초기화 블럭 : 클래스 내에 { } → 안에 코드작성

• 클래스 초기화 블럭 : static + 인스턴스초기화블럭

class Object13 {
    // 클래스초기화블럭
    static {
        System.out.println("static {}");
    }

    // 인스턴스초기화블럭
    {
        System.out.println("{}");
    }

    // 생성자
    Object13 () {
        System.out.println("생성자");
    }

    public static void main(String[] args) {
        System.out.println("Object13 object13 = new Object13();");
        Object13 object13 = new Object13();

        System.out.println("Object13 object13_1 = new Object13();");
        Object13 object13_1 = new Object13();
    }
}

class Object14 {
    // 명시적초기화
    static int[] iArray = new int[10];

    // 클래스초기화블럭
    static {
        for (int i = 0; i < iArray.length; i++) {
            iArray[i] = (int) (Math.random() * 10) + 1;
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < iArray.length; i++) {
            System.out.println("iArray[" + i + "] : " + iArray[i]);
        }
    }
}