[TIL] 이노베이션 캠프 in 동북 Part 05 . 객체지향 1

Part 05. 객체 지향 (1)
클래스와 객체
객체의 사용예시
객체 배열
클래스의 정의
변수의 종류
메서드
호출 스택(Call Stack)
기본형 매개변수와 참조형 매개변수
static 메서드와 인스턴스 메서드
오버로딩
생성자(Constructor)
this와 this()
변수의 초기화

클래스와 객체

---

클래스의 정의 : 클래스란, 객체를 정의 해놓은 것을 의미한다.

클래스의 용도 : 클래스는 객체를 생성하는데 사용한다.

 

객체의 정의 : 실제로 존재하는 것, 사물 또는 개념

객체의 용도 : 객체가 가지고 있는 속성과 기능에 따라 다르다.

 

객체와 인스턴스 용어 정리

• 객체 : 모든 인스턴스를 대표하는 일반적인 용어 (Ex: Tv 객체)
• 인스턴스 : 특정 클래스로부터 생성된 객체 ( Tv를래스를 사용해서 만든 Tv인스턴스)
• 인스턴스화 : 클래스 => 인스턴스(객체)

객체의 구성요소

 객체 = 속성(변수) + 기능(메서드)

 

객체의 생성과 배열

객체의 생성

클래스명 변수명;

변수명 = new 클래스명;

예시 :

• Tv t;  (Tv 클래스 타입의 참조변수 t를 선언)
• t = new Tv(); (Tv 인스턴스를 생성한후, 생성된 Tv인스턴스의 주소를 t에 저장)

 

객체의 사용 예시

---

Tv 클래스

속성

• 색깔
• 전원상태
• 채널

기능

• 파워(전원)
• 채널 증가
• 채널 감소

Tv1 인스턴스

속성

• 색깔 : 검정색
• 전원상태 : false
• 채널 : 1

기능

• 파워(전원)
• 채널 증가
• 채널 감소

Tv2 인스턴스

속성

• 색깔 : 흰색
• 전원상태 : false
• 채널 : 1

기능

• 파워(전원)
• 채널 증가
• 채널 감소

class Tv1_1 {
    // 속성 : 변수 선언
    String color; // 색깔
    boolean power = false; // 전원상태 : false 로 초기화
    int channel = 1;  // 채널 : 1 로 초기화
 
    // 기능 : 메서드 선언
    void power() {  // 전원 기능
        power = !power;
        if (power) {
            System.out.println("전원 ON");
        } else {
            System.out.println("전원 OFF");
        }
    }
 
    void channelUp() { // 채널 증가
        channel++;
        System.out.println("채널 증가");
    }
 
    void channelDown() { // 채널 감소
        channel--;
        System.out.println("채널 감소");
    }
}
 
class Tv1_1Main {
    public static void main(String[] args) {
        Tv1_1 t1 = new Tv1_1(); // TV1 인스턴스
        t1.color = "검정색"; // 색깔 초기화
        Tv1_1 t2 = new Tv1_1(); // TV2 인스턴스
        t2.color = "흰색"; // 색깔 초기화
 
        System.out.println("TV1 인스턴스 색깔 = " + t1.color);
        System.out.println("TV2 인스턴스 색깔 = " + t2.color);
 
        t1.power(); // 메서드 호출
        System.out.println("TV1 인스턴스 채널 = " + t1.channel);
 
        t1.channelUp(); // 메서드 호출
        System.out.println("TV1 인스턴스 채널 : " + t1.channel);
        t1.channelDown(); // 메서드 호출
        System.out.println("TV1 인스턴스 채널 : " + t1.channel);
 
        t1.power(); // 메서드 호출
 
 
        // TV2 인스턴스 참조변수에 TV1 인스턴스의 주소 저장 했을 때
        t2 = t1;
 
        System.out.println("TV1 인스턴스 색깔 = " + t1.color); // 검정색
        System.out.println("TV2 인스턴스 색깔 = " + t2.color); // 검정색
 
        // 흰색이었던 TV2 인스턴스 의 색깔이 검정색으로 바뀐건가요?
        // 아닙니다.
        // 참조변수 t2 에 저장되어있던 TV2 인스턴스 의 주소가 없어지고
        // TV1 의 주소가 t2 참조변수에 저장이 됩니다
 
        // 따라서 t2 = t1; 이후 부터는
        // t2 참조변수로는 더 이상 TV2 인스턴스 에 접근할 수 없습니다.
 
    }
}

 

클래스의 정의

---

클래스 == 데이터 + 함수

 

클래스의 탄생과정

1. 변수 : 하나의 데이터를 저장할 수 있는 공간

2. 배열 : 같은 종류의 여러 데이터를 하나로 저장 할 수 있는 공간

3. 구조체 : 서로 연관된 여러 데이터(종류관계 X) 를 하나로 저장할 수 있는 공간

4. 클래스 : 데이터 와 함수의 결합 (구조체 + 함수)

 

클래스 == 사용자 정의 타입 ( 원하는 타입을 직접 만들 수 있다 )

 

시간을 다루는 타입을 직접 만드록 싶다면?

• 기본형 8개가 아닌 새로운 타입인 시간 클래스를 작성한다.

Ex: 사용자 3명의 시간을 기록하려면 ?

class NoneClassTime {
    public static void main(String[] args) {
        // 총 3명 의 시간을 변수로 관리
        int hour1, hour2, hour3;
        int minute1, minute2, minute3;
        int second1, second2, second3;
 
        // 총 3명 의 시간을 배열로 관리
        int[] hour = new int[3];
        int[] minute = new int[3];
        int[] second = new int[3];
    }
}

class Time3_1 {
    int hour;
    int minute;
    int second;
}
class Time3_1Main {
    public static void main(String[] args) {
        // 총 3명 의 시간을 객체로 관리
        Time3_1 t1 = new Time3_1();
        Time3_1 t2 = new Time3_1();
        Time3_1 t3 = new Time3_1();
 
        // 총 3명 의 시간을 객체 배열로 관리
        Time3_1[] timeArr = new Time3_1[3];
        timeArr[0] = new Time3_1();
        timeArr[1] = new Time3_1();
        timeArr[2] = new Time3_1();
    }
}

class Obj4_1 {
    int iv;        // 인스턴스 변수
    static int cv; // 클래스 변수(static 변수, 공유 변수)
 
    void method() {
        int lv;
        lv = 30;
        // 지역변수는 자동으로 초기화가 되지 않기 때문에 사용하려면 반드시 초기화 필요
        System.out.println("lv 지역 변수 = " + lv);
    }
}
 
 
class Obj4_1Main {
    public static void main(String[] args) {
 
        // 클래스 변수 접근 및 사용
        // 접근방법 : 클래스명.클래스변수이름
        Obj4_1.cv = 10;
        System.out.println("ObjVar.cv 클래스 변수 = " + Obj4_1.cv);
 
        // 인스턴스 변수 생성 및 사용
        // Obj4_1.iv = 20; // Error, 인스턴스를 통해서만 생성 및 사용 가능
        Obj4_1 objVar = new Obj4_1();
        objVar.iv = 20;
        System.out.println("objVar.iv 인스턴스 변수 = " + objVar.iv);
 
        // 지역 변수 생성 및 사용
        // objVar.lv // Error, 인스턴스로 지역 변수 바로 접근 불가능
        objVar.method(); // 메서드 호출 시 지역 변수 생성
        // 메서드 종료시 지역 변수 삭제
    }
}

객체 변수 이해를 돕기위한 예시 :

예시

위 포커카드를 객체라고 정의하면, 객체의 속성에는 무늬,숫자,폭,높이 등이 있을것이다.

각 카드(객체) 마다, 숫자와 무늬는 다르다. 하지만, 객체의 고유한 속성인 폭(width)와 높이(height)는 같아야한다.

개별적인 속성, (무늬,숫자) : 인스턴스 변수 (iv)

공통적인 속성, (폭,넓이) : 공통변수(cv)라고 정의한다. 

 

코드로 표현하면 아래와 같다.

class Card{
 
    String kind; //무늬 (iv)
    int numbber; //숫자 (iv)
 
    static int width = 100; //폭 (cv)
    static int height = 250; // 높이 (cv)

class Method5_1 {
    int add(int x, int y) {
        int result = x + y;
        return result; // 값을 반환
    }
}
 
class Method5_1Main {
    public static void main(String[] args) {
        Method5_1 method = new Method5_1(); // Method5_1 클래스에 만든 메서드 add 를 사용하기 위해 객체 생성
 
        int result = method.add(3, 5); // add 메서드를 사용해서 입력한 값(3,5)으로 처리된 값을 반환받아 result 변수에 저장
        System.out.println("result = " + result);
    }
}

return

실행 중인 메서드를 종료하고 호출한 곳으로 되돌아간다.

• 반환타입이 void가 아닌 경우, 반드시 return 문이 필요하다.
• void는 컴파일러가 자동으로 마지막에 return; 문을 추가해준다.

class Method5_2 {
    void gugudan(int dan) {
        if (!(dan >= 2 && dan <= 9)) {
            System.out.println(dan + "단은 없습니다.");
            return;
        }
        System.out.println(dan + "단 시작!");
        for (int i = 1; i < 10; i++) {
            System.out.println(dan + "*" + i + " = " + dan * i);
        }
        System.out.println();
    }
 
    boolean checkMax(int x, int y) {
        if (x > y) {
            return true;
        } else {
            return false;
            // return 반드시 필요합니다. 만약 없으면 조건문이 false 일 경우, void 가 아닌데 return 문이 없음으로 Error
        }
    }
 
}
 
class Method5_2Main {
    public static void main(String[] args) {
        Method5_2 method = new Method5_2();
 
        method.gugudan(2);
        method.gugudan(5);
        method.gugudan(10);
        method.gugudan(9);
 
        System.out.println("method.checkMax(10, 8) = " + method.checkMax(10, 8));
        System.out.println("method.checkMax(5, 9) = " + method.checkMax(5, 9));
    }
}

 

문장들의 묶음

코드의 중복을 하나의 묶음으로 만들어, 코드의 가독성 및 효율을 높여준다.

class Time5_1 {
    int hour;
    int minute;
    int second;
}
 
class Method5_3 {
    static void initObj(Time5_1 time, int hour, int minute, int second) {
        time.hour = hour;
        time.minute = minute;
        time.second = second;
    }
}
 
class Method5_3Main {
    public static void main(String[] args) {
        Time5_1 t1 = new Time5_1();
        t1.hour = 100;
        t1.minute = 20;
        t1.second = 43;
 
        Time5_1 t2 = new Time5_1();
        t2.hour = 22;
        t2.minute = 30;
        t2.second = 23;
 
        Time5_1 t3 = new Time5_1();
        t3.hour = 45;
        t3.minute = 40;
        t3.second = 52;
 
        System.out.println("t1.hour = " + t1.hour);
        System.out.println("t2.hour = " + t2.hour);
        System.out.println("t3.hour = " + t3.hour);
        System.out.println();
 
        // 하나하나 인스턴스를 만들고 위처럼 인스턴스 변수를 초기화 하려니 매우 귀찮다.
        // 물론 '생성자' 라는 개념이 뒤에 나오지만 일단은 메서드를 사용하여 코드의 수 줄인다.
 
        Time5_1 t4 = new Time5_1();
        Time5_1 t5 = new Time5_1();
        Time5_1 t6 = new Time5_1();
 
        Method5_3.initObj(t4, 100, 20, 43);
        Method5_3.initObj(t5, 22, 30, 23);
        Method5_3.initObj(t6, 45, 40, 52);
 
        System.out.println("t4.hour = " + t4.hour);
        System.out.println("t5.hour = " + t5.hour);
        System.out.println("t6.hour = " + t6.hour);
 
        // 이처럼 메서드를 사용하니 코드의 수가 굉장히 많이 줄어 가독성이 좋아졌습니다.
    }
}

class CallStack5_1 {
 
    static void firstMethod() {
        System.out.println("firstMethod()");
        secondMethod();
    }
 
    static void secondMethod() {
        System.out.println("secondMethod()");
        thirdMethod();
    }
 
    static void thirdMethod() {
        System.out.println("thirdMethod()");
        finalMethod();
    }
 
    static void finalMethod(){
        System.out.println("finalMethod()");
    }
 
    public static void main(String[] args) {
        firstMethod();
    }
}

class Method5_2Main {
 
    static void firstMethod() {
        secondMethod();
        System.out.println("firstMethod()");
    }
 
    static void secondMethod() {
        thirdMethod();
        System.out.println("secondMethod()");
    }
 
    static void thirdMethod() {
        finalMethod();
        System.out.println("thirdMethod()");
    }
 
    static void finalMethod(){
        System.out.println("finalMethod()");
    }
 
    public static void main(String[] args) {
        firstMethod();
    }
}

실행과정

1. main메서드 호출스택에 쌓임 firstMethod() 호출

2. secondMethod() 호출

3. thirdMethod() 호출

4. finalMethod() 호출

5. println(finalMeothod")문 실행

6. finalMethod()메소드가 호출 stack에서 pop 되면서, println(thirdMethod)문 실행

7. third 메소드가 호출 stack에서 pop되면서, println(secondMethod)문 실행

8. secondMethd()가 호출stack에서 pop되면서, println(firstMethod())문 실행

9. firstMethod() 호출 스택에서 pop.

10. main 메소드 호출 스텍에서 pop

 

기본형 매개변수와 참조형 매개변수 

---

기본형 매개변수 - 변수의 값을 읽기만 할 수 있다. (변경 불가)

 

예제 코드 

class Data { int x; }
public class Ex6_6 {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        System.out.println("main() :" + d.x);
        change(d.x);
        System.out.println("After change(d.x)");
        System.out.println("main() :  x = "+ d.x);
    }
    static void change(int x) { // 기본형 매개변수
        x = 1000; // 지역변수
        System.out.println("change() : x = " + x);
    }
 
}
 

실행과정

1. Data 객체 생성. 참조변수 d는 객체를 가리킴

2. 객체의 인스턴스 변수 x 를 10으로 초기화

3. 출력 

4. change 메서드 호출스택에 쌓이고, 지역변수 x =1000 으로 초기화 후 출력

5. change 메소드가 종료되면서, 호출스택에서 pop

6. x=10 출력됨

참조형 매개변수 - 변수의 값을 읽고 변경할 수 있다.

class Data2 { int x; }
 
public class Ex6_7 {
    public static void main(String[] args) {
        
        Data2 d = new Data2();
        d.x=10;
        System.out.println("main() : x = " + d.x);
        
        change(d);
        System.out.println("After change(d)");
        System.out.println("main() : " + d.x);
        
 
    }
    static void change(Data2 d) { // 참조형 변수
        d.x=1000;
        System.out.println("change() : " + d.x);
    }
}
 

* 인스턴스 변수를 사용할 필요가 없을 때  - > static 메서드 정의

* 인스턴스 변수를 필요로 할 때 -> 인스턴스 메서드 정의

 

오버로딩

---

의미 : 한 클래스 안에 같은 이름의 메서드를 여러 개 정의하는 것을 뜻함.

성립 조건 

1. 메서드 이름이 같아야함.

2. 매개변수의 개수 또는 타입, 위치가 달라야함

3. 반환타입에는 영향을 받지 않음

 

생성자(constructor)

---

인스턴스가 생성될 때 마다 호출되는 '인스턴스 초기화 메서드' 이다.

• 인스턴스 생성시 수행할 작업에 사용된다.
• 초기값이 필요한 인스턴스 변수의 값을 초기화 해준다.

생성 조건

• 이름이 클래스 이름과 같아야한다.
• return값이 없다
• voids는 붙이지 않는다.
• 오버로딩 가능
• - 생성자가 하나도 없을 때만, 컴파일러가 기본 생성자 자동 추가

class Tv9_1 {
    // 속성 : 변수 선언
    boolean power; // 전원상태
    int channel;  // 채널
    String color; // 색깔
    long price; // 가격
 
    // 위 속성에서 필수로 초기값이 필요한 값들을 초기화 해주는 기본 생성자
    public Tv9_1() {
        power = false;
        channel = 1;
    }
 
    //  오버로딩 한 생성자 - 매장 진열 용 일 경우에는 가격과 색깔의 초기화가 필요합니다. this 는 이전 챕터에서 잠깐 봤었죠! 매개변수와 인스턴스변수를 구분하기 위해 사용하겠습니다.
    public Tv9_1(String color, long price) {
        power = false; // this.power, power 둘다 지금 상황에서는 인스턴스 변수를 명확하게 판단 할 수 있기 때문에 어떤걸 사용해도 상관 없습니다.
        channel = 1;
        this.color = color;
        this.price = price;
    }
 
    // 기능 : 메서드 선언
    void power() {  // 전원 기능
        power = !power;
        if (power) {
            System.out.println("전원 ON");
        } else {
            System.out.println("전원 OFF");
        }
    }
 
    void channelUp() { // 채널 증가
        channel++;
        System.out.println("채널 증가");
    }
 
    void channelDown() { // 채널 감소
        channel--;
        System.out.println("채널 감소");
    }
 
}
 
class Tv9_1Main {
    public static void main(String[] args) {
        // 기본 초기화된 Tv9_1 생성
        Tv9_1 tv = new Tv9_1();
        System.out.print("기본 생성자 TV: ");
        tv.power();
 
        // 진열 용 Tv9_1 생성
        Tv9_1 exTv = new Tv9_1("보라색", 3456789);
        System.out.print("오버로딩 생성자 TV: ");
        exTv.power();
        System.out.println("exTv.color = " + exTv.color);
        System.out.println("exTv.price = " + exTv.price);
 
        // 근데 이때 주의할 점!
        // 기본 생성자는 없고 오버로딩한 생성자만 있을 경우!
        // 컴파일러는 기본 생성자를 만들어주지 않기 때문에 기본 생성자를 사용하려고 하면 Error 발생!
        // 위 기본 생성자를 주석 하세요!!!!
        Tv9_1 tv2 = new Tv9_1(); // Error 발생, 기본 생성자가 없기 때문에 매개 변수를 넣으라고 intellij 가 요구합니다.
 
    }
}

 

this와 this()

---

this

• 인스턴스 자신을 가리키는 참조변수임.
• 인스턴스 메서드(생성자 포함)에서 사용
• 지역 변수와 인스턴스 변수를 구별할 때 사

 

this() 

• 생성자 에서 다른 생성자를 호출할 때 사용
• 다른 생성자 호출 시 첫 줄에서만 사용 가능

 

class Car2 {
  String color; // 색상
  String gearType; // 변속기 종류 - auto(자동), manual (수동)
  int door;
 
  Car2() {
       this("white", "auto" , 4); 
     }
  Car(String color) {
     this(color, "auto",4);
    }
  Car(String color, String gearType, int door) {
      this.color = color;
      this.gearType = gearType;
      this.door = door;
     }
}
 
 

 

변수의 초기화

---

수동 / 자동 초기화

• 지역 변수는 수동으로 초기화 해야함.

지역 변수가 동작하는 스택 메모리는 재사용이 빈번하기 때문에, 매번 초기화 해주면 성능이 떨어짐

 

멤버 변수의 초기화

• 클래스 변수 : 클래스가 처음 로딩 될 때 단 한번만 초기화 됨
• 인스턴스 변수 : 인스턴스가 생성될 때 마다 초기화 됨