오늘의 학습 키워드

1. 객체 지향 프로그래밍 이해하기
2. 클래스 설계
3. 객체 생성과 참조형 변수
4. 객체의 속성: 필드
5. 객체의 행위: 메소드
6. 인스턴스 멤버와 클래스 멤버
7. 생성자
8. this와 this()
9. 접근 제어자
10. pakage와 import

1. 객체 지향 프로그래밍 이해하기

• 객체는 식별이 가능한 것을 의미 - 물리적은 존재하는 것은 물론 식별 가능한 개념적 인 것 또한 객체라 볼 수 있음
• 객체는 속성과 행위로 구성됨 -> 속성 = 필드, 행위 = 메소드
• 객체간의 서로 메소드(행위)를 통해 상호작용 -> 객체에서 메소드를 호출할 때 괄호() 안에 데이터를 넣어 호출하는 경우 이 괄호 안에 데이터를 매개변수라고 함
• 객체 간의 관계: 사용관계, 포함관계, 상속관계
• 객체지향 프로그래밍의 특징: 캡슐화, 상속, 다형성, 추상화
  -> 캡슐화 - 보안에 좋고 접근제어자를 통해 제어
  -> 상속 - 부모 객체, 자식 객체 존재
  -> 다형성 - 메소드의 구현을 다르게 재정의
  -> 추상화 - 객체간의 반복되는, 공통되는 것들을 모아 상위 개념으로 선언, 이 상위개념을 가지고 객체마다 구체적으로 구현

2. 클래스 설계

• 클래스 구성: 필드, 생성자, 메소드
• 클래스 생성 step: 클래스 선언 -> 필드(속성) 정의 -> 생성자 정의 -> 메소드 정의
• 변수를 제어하는 것을 메소드
• 필드를 처음에 어떻게 정의할 것인가 -> 생성자
• 생성자는 클래스 이름과 동일해야 함
• Public Car (인풋 부분) {
  로직 부분
  }

public class Car { //이부분이 클래스 선언 부분
    //지금부터 필드 정의
    String company;
    String model;
    String color;
    double price;
    double speed;
    char gear;
    boolean lights;

    //생성자 선언 부분: 처음 객체가 생성될 때 어떤 로직을 수행해야 하며, 어떤 값이 필수로 들어와야하는지 정의
    public Car(){} // 기본생성자-> 생략이 가능

    //메소드 정의 부분
    public double gasPedal(double kmh){
        speed = kmh;
        return speed;
    }
    public double brakePedal(){
        speed = 0;
        return speed;
    }
    public char changeGear(char type){
        gear = type;
        return gear;
    }
    boolean onOffLights(){
        lights = !lights;
        return lights;
    }
    void horn(){
        System.out.println("빵빵");
    }

}

3. 객체 생성과 참조형 변수

• 객체 생성: new Car(); -> car 클래스의 객체를 생성 => 인스턴스화
• 참조형 변수:
  Car car1 = new Car();
  Car car2 = new Car();
• 기본 생성자와 new 키워드의 차이⭐️
  1) public Car() {}: 기본 생성자를 정의하는 부분, 이 생성자는 아무런 매개변수를 받지 않고 객체를 초기화 할 때 호출되는 메소드
  2) Car car1 = new Car();⭐️
  • 객체를 인스턴스화 하는 부분, 이 코드는 Car 클래스의 인스턴스를 생성하고, 이 생성된 인스턴스를 car1이라는 변수에 할당하는 과정
  • new Car()는 Car 클래스의 생성자를 호출하여 새로운 Car 객체를 생성하는 부분. 여기서 new 키워드는 객체를 생성하기 위해 메모리에서 공간을 할당하고 클래스의 생성자를 호출하여 해당 객체를 초기화함.
    이렇게 생성된 객체는 car1이라는 변수에 할당되어 나중에 사용됨.
• 참조형 변수 -> 객체 또한 별도 공간의 저장하고 그 공간의 주소를 가져오는 것 => 배열로 확장할 수 있음

Car[] carArray = new Car[3];
        Car car1 = new Car();
        car1.changeGear('P');
        carArray[0] = car1; //carArray에 car1을 넣는 과정!

        Car car2 = new Car();
        car2.changeGear('N');
        carArray[1] = car2;

        Car car3 = new Car();
        car3.changeGear('D');
        carArray[2] = car3;

        for (Car car : carArray){
            System.out.println("car.gear = "+car.gear);
        }
        // 출력값: 
        car.gear = P
        car.gear = N
        car.gear = D

4. 객체의 속성: 필드

• 필드는 객체의 데이터를 저장하는 역할
• 필드는 크게 고유 데이터, 상태 데이터, 객체 데이터로 분류 가능
• 고유데이터:
  해당 객체를 식별하고 유일하게 식별되는 데이터
  다른 객체와 구별하기 위한 정보 포함
  예: company, model, color, price
• 상태데이터:
  객체가 가지고 있는 현재 상태를 나타내는 데이터
  객체가 존재하는 동안 변할 수 있는 데이터를 말함
  예: speed, gear, lights
• 객체데이터:
  다른 객체에 대한 참조나 링크를 포함하는 데이터
  객체 간의 관계를 나타내거나 다른 객체에 대한 참조를 저장하는데 사용
  예: tire, door, handle
  ** 여기서 tire, door, handle 객체들은 하위 객체⭐️
  = 클래스 안에서도 객체를 생성할 수 있음 (하위 객체)

public class Car { //이부분이 클래스 선언 부분
    //지금부터 필드 정의
    //1) 고유 데이터 영역
    String company;
    String model;
    String color;
    double price;
    
    //2) 상태 데이터 영역
    double speed;
    char gear;
    boolean lights;

    //객체 데이터 영역
    Tire tire;
    Door door;
    Handle hondle;

    //생성자 선언 부분: 처음 객체가 생성될 때(인스턴스화 될 때) 어떤 로직을 수행해야 하며, 어떤 값이 필수로 들어와야하는지 정의
    public Car(){} // 기본생성자-> 생략이 가능
    
    ...
    }

[Tire 클래스 선언 및 기본 생성자 선언 -> Door, Handle도 동일]

public class Tire {
    public Tire(){
        System.out.println("타이어가 생성되었습니다.");
    }
}

• 필드 사용법 - 외부접근, 내부접근
  클래스에 필드를 정의하여 선언했다고 해서 바로 사용할 수 있는 것은 아님 -> 인스턴스화를 시켜야 사용가능. 클래스는 실체가 아닌 설계도
  1) 외부접근: 도트 연산자(.) 사용
  2) 내부접근: 클래스 내에서 메소드 호출시 필드 바로 사용 가능

5. 객체의 행위: 메소드

• 리턴타입 필수
• 외부 접근: 도트 연산자 사용
• 내부 접근: 같은 클래스 내에서 호출 가능
• 오버로딩: 매개변수만 다르고 나머지(메소드 이름 등)는 같은 메소드
• 기본형 매개변수: 값이 복사되어 전달되기 때문에 메소드 내에서 이 값이 변경되더라도 원본 값에는 영향을 미치지 않음
• 참조형 매개변수: 메모리 주소(참조)가 전달되기 때문에 메소드 내에서 참조하는 객체의 내용을 변경할 수 있음
  => 매개변수를 참조형으로 선언하면 값이 저장된 곳의 원본 주소를 알 수 있기 때문에 값을 읽어 오는 것은 물론 값을 변경하는 것도 가능⭐️⭐️

public class Car { //이부분이 클래스 선언 부분
    //지금부터 필드 정의
    //1) 고유 데이터 영역
    String company;
    String model;
    String color;
    double price;
    //2) 상태 데이터 영역
    double speed;
    char gear;
    boolean lights;

    //객체 데이터 영역
    Tire tire;
    Door door = new Door();
    Handle hondle = new Handle();

    //생성자 선언 부분: 처음 객체가 생성될 때(인스턴스화 될 때) 어떤 로직을 수행해야 하며, 어떤 값이 필수로 들어와야하는지 정의
    public Car(){} // 기본생성자-> 생략이 가능

    //메소드 정의 부분
    public double gasPedal(double kmh, char type){
        changeGear(type);
        speed = kmh;
        return speed;
    }
    public double breakPedal(char type){
        speed = 0;
        type = 'P';
        changeGear(type);
        return speed;
    }
    public char changeGear(char type){
        gear = type;
        return gear;
    }
    boolean onOffLights(){
        lights = !lights;
        return lights;
    }
    void horn(){
        System.out.println("빵빵");
    }

    Tire setTire(Tire tireCompany){
        tireCompany.company = "KIA";
        tire = tireCompany;
        return tire;
    }

}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();

        //기본형 매개변수
        char type = 'D';
        car.breakPedal(type);

        //메소드 실행 완료 후 전달할 매개값으로 지정된 type 값 확인
        System.out.println("type = " + type );

        //메소드 실행 완료 후 반환된 car 인스턴스의 gear 타입 확인
        System.out.println("gear = "+ car.gear);

        System.out.println();

        //참조형 매개변수
        Tire tire = new Tire(); //tire객체 생성
        tire.company = "금호";

        //차 객체의 타이어를 등록하는 메소드 호출한 후 반환값으로 차 객체의 타이어 객체 변환
        Tire carInstanceTire = car.setTire(tire);

        //메소드 실행 완료 후 전달할 매개값으로 지정된 참조형 변수 tire의 company 값 확인
        System.out.println("tire.company = " + tire.company); //전달할 매개 값으로 지정된 tire 인스턴스의 주소값이 전달되었기 때문에 호출된 메소드에 의해 값이 변경됨

        System.out.println("carInstanceTire.company = "+ carInstanceTire.company);
    }
}

출력값:
type = D
gear = P

tire.company = KIA
carInstanceTire.company = KIA

=> 기본형 매개변수는 원본 값이 변경되지 않지만 참조형 매개변수는 원본 값이 변경이 됨

[추가]

• 기본형 매개변수

public class Example {
    public static void modifyPrimitive(int number) {
        number = number * 2;
        System.out.println("Modified value inside method: " + number);
    }

    public static void main(String[] args) {
        int original = 5;
        System.out.println("Original value before method call: " + original);
        modifyPrimitive(original);
        System.out.println("Original value after method call: " + original);
    }
}

Original value before method call: 5
Modified value inside method: 10
Original value after method call: 5

• 참조형 매개변수

import java.util.ArrayList;

public class Example {
    public static void modifyArrayList(ArrayList<Integer> list) {
        list.add(100);
        System.out.println("Modified list inside method: " + list);
    }

    public static void main(String[] args) {
        ArrayList<Integer> originalList = new ArrayList<>();
        originalList.add(5);
        System.out.println("Original list before method call: " + originalList);
        modifyArrayList(originalList);
        System.out.println("Original list after method call: " + originalList);
    }
}

Original list before method call: [5]
Modified list inside method: [5, 100]
Original list after method call: [5, 100]

6. 인스턴스 멤버와 클래스 멤버

• 멤버: 필드 + 메소드
• 인스턴스 멤버는 객체 생성 후에 사용할 수 있고 클래스 멤버는 객체 생성 없이도 사용할 수 있음
• Class {
  public static void main() {

  }

  }
  => 이 클래스를 객체화 시킨 것은 아님 => 클래스 멤버
  ** 클래스를 객화시킨다 : 클래스를 기반으로 실제로 메모리에 할당된 인스턴스를 생성하는 것을 의미
• 인스턴스 멤버
  • 객체를 생성해야 사용 가능 -> 인스턴스화가 일어난 후 호출되어야함
  • 객체의 메소드는 매번 생성되지 않음 - 메소드는 메소드영역에 두고서 모든 인스턴스들이 공유해서 사용
• 클래스 멤버
  • 고정적으로 위치하고 있어 인스턴스화가 필요없는 멤버
  • 클래스 멤버는 객체의 생성 필요 없이 바로 사용 가능
• 클래스 멤버 선언 static
  ** static으로 선언했다면 인스턴스화시킬 필요가 없음
• 지역 변수: 메소드 내부에서 정의될 때 생성되어 메소드가 종료될 때까지만 유지
• final필드: 초기값이 지정되면 절대로 수정할 수 없음, 반드시 초기값을 지정해야 함
• 상수: static final String Company = "GENESIS";
  상수는 수정 불가능
  일반적으로 상수는 대문자로 작성하는 것이 관례

7. 생성자

• 생성자는 객체가 생성될 때 호출되며 객체를 초기화하는 역할 수행
• 기본 생성자: public Car () {}
  • 기본 생성자는 선언할 때 괄호() 안에 아무것도 넣지 않는 생성자
  • 모든 클래스는 반드시 생성자가 하나 이상 존재
  • 클래스에 생성자가 존재해야 new 키워드로 객체를 만들 수 있음
• 객체를 만들 때 인스턴스마다 다른 값을 가져야 한다면 생성자를 통해서 필드를 초기화 할 수 있음
• 인스턴스 마다 동일한 데이터를 가지는 필드는 초기값을 대입하는 것이 좋음
• 생성자 오버로딩: 매개변수의 위치만 다르면 똑같은 메소드로 인식

8. this와 this()

• this는 인스턴스 자신을 표현하는 키워드
• 예:

public Car (String model, String color, double price) {
	this.model = model;
	this.color = color;
	this.price = price;
}

이 인스턴스의 model(color, price)에 매개변수로 받은 model(color, price)를 전달

• return this;도 가능
  • 예:

  Car returnInstance() {
  	return this;
  }

• this(): 인스턴스 자신의 생성자를 호출하는 키워드

public Car (String model) {
	this(model, "Blue", 5000);
}

public Car (String model, String color) {
	this(model, color, 10000);
}

public Car (String model, String color, double price) {
	this.model = model;
    this.color = color;
    this.price = price;
}

• this() 키워드를 사용해서 다른 생성자를 호출할 때는 반드시 해당 생성자의 첫 줄에 작성되어야 함

9. 접근제어자

• 접근제어자: public, protected, default, private
• 그 외 제어자: static, final, abstract
• public - protected - default - private 순으로 허용 범위가 좁아짐
• 활용도는 private가 좋음
• Getter & Setter
  • 직접적인 값의 조회, 세팅을 방지하기 위해 getter & setter 사용
  • 변수를 private로 선언하고 getter & setter 메소드를 public으로 선언하여 사용

10. pacakage와 import

• pacakage 내 코드를 impor를 사용해서 불러 올 수 있음

오늘의 회고

오늘의 목표는 자바 3주차 강의를 완강하는 거이였는데 3-10까지 밖에 듣지 못했다. 내일은 그래도 나머지 3주차 강의와 4주차 강의를 모두 들어야 할 것 같다.