1. 객체지향 프로그래밍 (생략)

2. 클래스와 객체

1) 클래스와 객체의 정의와 용도

클래스: 객체를 정의해 놓은 것
용도: 객체 생성

→ 객체는 클래스에 정의해놓은 대로 생성된다.

(프로그래밍에서의) 객체: 클래스에 정의된대로 메모리에 생성된 것
용도: 객체가 가지고 있는 기능과 속성에 따라 다름

2) 객체와 인스턴스

클래스 → 객체: 클래스의 인스턴스화
인스턴스: 어떤 클래스로부터 만들어진 객체

3) 객체의 구성 요소 — 속성과 기능

객체는 속성과 기능의 집합. 객체가 갖고 있는 속성과 기능을 그 객체의 멤버라고 한다.

속성: 멤버변수, 특성(attribute), 필드(field), 상태(state)
기능: 메서드(method), 함수(function), 행위(behavior)

4) 인스턴스의 생성과 사용

Tv t; // Tv 클래스 타입의 참조변수 선언
t = new Tv(); // Tv 인스턴스를 생성한 후, 생성된 Tv 인스턴스의 주소를 t에 저장
인스턴스는 참조변수를 통해서만 다룰 수 있으며, 참조 변수의 타입은 인스턴스의 타입과 일치해야 한다.

5) 객체 배열

Tv[] tvArr = new Tv[3];
tvArr[0] = new Tv();
tvArr[1] = new Tv();
tvArr[2] = new Tv();

// 배열의 초기화 블럭을 사용
Tv[] tvArr = {new Tv(), new Tv(), new Tv()};

// 다뤄야 할 객체의 수가 많을 때
Tv[] tvArr = new Tv[100];
for(int i = 0; i < tvArr.length; i++){
		tvArr[i] = new Tv();
}

여러 종류의 객체를 하나의 배열에 저장하는 방법 → 다형성

6) 클래스의 또 다른 정의 — 프로그래밍의 관점

— 데이터 처리를 위한 데이터 저장 형태의 발전 과정
변수: 하나의 데이터를 저장할 수 있는 공간
배열: 같은 종류의 여러 데이터를 하나의 집합으로 저장할 수 있는 공간
구조체: 서로 관련된 여러 데이터를 종류에 관계없이 하나의 집합으로 저장할 수 있는 공간
클래스: 데이터와 함수의 결합(구조체 + 함수)

— 클래스: 사용자 정의 타입
사용자 정의 타입: 프로그래밍 언어에서 제공하는 자료형 외에 프로그래머가 서로 관련된 변수들을 묶어서 하나의 타입으로 새로 추가하는 것

3. 변수와 메서드

1) 선언 위치에 따른 변수의 종류

변수 종류	선언 위치	생성 시기	설명
클래스 변수 (class variable)	클래스 영역	클래스가 메모리에 올라갈 때	- static 메모리에 생성 - 프로그램 실행시 생성, 종료시 소멸 - 변수의 초기화 지원(초기화 필요 없음)
인스턴스 변수 (instance variable)	클래스 영역	인스턴스가 생성됐을 때	- heap 메모리에 생성 -GC에 의해 메모리 소멸
지역변수 (local variable)	클래스 영역 이외의 영역 (메서드, 생성자, 초기화 블럭 내부)	변수 선언문이 수행됐을 때	- 메서드 수행시 stack 메모리에 생성 - 초기화 후 사용가능 - 메소드 종료시 메모리에서 소멸

— 클래스 변수

• static
• 인스턴스마다 독립적인 저장공간을 갖는 인스턴스 변수와 달리, 클래스 변수는 모든 인스턴스가 공통된 저장공간(변수)를 공유
• 한 클래스의 모든 인스턴스들이 공통적인 값을 유지해야하는 속성의 경우 클래스 변수로 선언
• 인스턴스를 생성하지 않고도 사용 가능 → 클래스이름.클래스변수 형식으로 사용
• 클래스가 메모리에 로딩될 때 생성되어 프로그램이 종료될 때까지 유지
• public을 붙이면 프로그램 내 어디서나 접근 가능한 전역변수

— 인스턴스 변수

• 클래스 영역에 선언, 클래스의 인스턴스를 생성할 때 만들어짐
• 인스턴스 변수의 값을 읽어오거나 저장하기 위해선 먼저 인스턴스를 생성해야
• 독립적인 저장공간 → 서로 다른 값 사용 가능
• 인스턴스마다 고유한 상태를 유지해야 하는 속성

— 지역변수

• 메서드 내에 선언되어 메서드 내에서만 사용 가능
• 메서드가 종료되면 소멸

2) 클래스 변수와 인스턴스 변수

생략

3) 메서드

함수

— 메서드를 사용하는 이유

높은 재사용성
중복된 코드의 제거
프로그램의 구조화

4) 메서드의 선언과 구현

선언부와 구현부

— 메서드 선언부

반환타입 메서드이름 (매개변수 선언)

메서드의 선언부를 변경하게 되면 그 메서드가 호출되는 모든 곳도 같이 변경해야 하므로, 후에 변경사항이 발생하지 않도록 신중히 작성

— 매개변수 선언

생략

5) 메서드의 호출

— 인자와 매개변수

생략

— 메서드의 실행흐름

같은 클래스 내의 메서드끼리는 참조변수를 사용하지 않고도 서로 호출이 가능하지만 static 메서드는 같은 클래스 내의 인스턴스 메서드를 호출할 수 없다.

— parameter의 타입과 argument의 타입(형변환)

double 타입 매개변수를 받는 메서드에 long 타입을 사용하여 호출 가능. 호출 시 입력된 값은 메서드의 매개변수에 대입되는 값이므로 double a = 5L;을 수행했을 때와 마찬가지로 자동 형변환되어 매개변수에 저장된다.

6) return문

현재 실행중인 메서드를 종료하고 호출한 메서드로 되돌아감.

if - else문 등을 포함하고 있다면 각각의 return 값을 써줘야 함

— 반환값

생략

— 매개변수의 유효성 검사

호출하는 쪽에서 알아서 적절한 값을 넘겨줄거라고 생각하지 말고 잘 대비해야 함.

ex) 나눗셈 결과를 리턴하는 메서드에서 0으로 나누는 걸 금지하기

— JVM의 메모리 구조

JVM의 메모리 구조

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

기본형 매개변수: 값 복사 / 변수의 값을 읽기만 할 수 있다.
참조형 매개변수: 인스턴스의 주소 복사 / 변수의 값을 읽고 변경할 수 있다.

class Data{int x;}

public class PrimitiveAndReferenceParameter {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        System.out.println("main(): x = " + d.x); // 10

        change(d.x); // 1000
        System.out.println("After change(d.x)");
        System.out.println("main(): x = " + d.x); // 10
    }

    static void change(int x){ // 기본형 매개변수
        x = 1000;
        System.out.println("change(): x = " + x);
    }
}

d.x의 값이 변경된 게 아니라 change 메서드의 매개변수 x의 값이 변겨오딘 것. 즉, 원본이 아닌 복사본이 변경된 것이라 원본에는 아무런 영향을 미치지 못한다.

class Data{int x;}

public class PrimitiveAndReferenceParameter {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        System.out.println("main(): x = " + d.x); // 10

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

    static void change(Data d){
        d.x = 1000;
        System.out.println("change(): x = " + d.x); // 1000
    }
}

위와 달리 매개변수가 참조형이라 값이 아닌 값이 저장된 주소를 change 메서드에 넘겨주었기 때문에 값을 읽어오는 것뿐만 아니라 변경하는 것도 가능

9) 참조형 반환타입

반환타입이 참조형이라는 것은 메서드가 객체의 주소를 반환한다는 것을 의미한다.

10) 재귀

메서드 내부에서 메서드 자신을 다시 호출하는 것
오로지 재귀호출 뿐이면 무한히 자신을 호출하기 때문에 무한 반복에 빠진다. 무한반복문이 조건문과 함께 사용되어야 하는 것처럼, 재귀 호출도 조건문이 필수적으로 따라다닌다.
메서드를 호출하는 것은 반복문보다 몇 가지 과정을 추가로 필요로 하기 때문에 반복문보다 재귀 호출의 수행 시간이 더 오래 걸린다.

— factorial

public class Factorial {
    public static void main(String[] args) {
        int result = factorial(4);
        System.out.println(result);
    }

    static int factorial(int n){
        return (n==1) ? 1 : n * factorial(n-1);
    }
}

이때 factorial 메서드의 매개변수의 값이 0이면? 혹은 100000과 같이 큰 값이면?
⇒ 100000인 경우: while문으로 작성한 팩토리얼 코드는 재귀호출과 달리 많은 수의 반복에도 스택오버플로우(메모리 부족 문제)를 겪지 않고 속도도 빠르다.

int factorial(int n){ 
	int result = 1; 
    
    while(n != 0) 
    	result *= n--; 
    
    return result; 
}

⇒ 0인 경우: if(n==1) 조건을 만족시킬 수가 없으므로 무한반복 → 스택 오버플로우

— factorial의 매개변수가 음수거나 20보다 크면 -1을 반환

public class Factorial {
    static long factorial (int n){
        if(n <= 0 || n > 20) return -1; // 매개변수의 유효성 검사
        if(n <= 1) return 1;
        return n * factorial(n-1);
    }
    public static void main(String[] args) {
        int n = 21;
        long result = 0;

        for(int i = 1; i <= n; i++) {
            result = factorial(i);

            if (result == -1) {
                System.out.printf("유효하지 않은 값입니다. (0 < n <= 20): %d%n", n);
                break;
            }

            System.out.printf("%2d!=%20d%n", i, result);
        }
    }
}

— x^1부터 x^n까지의 합 구하기

public class PowerSum {
    public static void main(String[] args) {
        int x = 2;
        int n = 5;
        long result = 0;

        for(int i = 1; i <= n; i++){
            result += power(x, i);
        }

        System.out.println(result);
    }

    static long power(int x, int n){
        if(n==1) return x;
        return x * power(x, n-1);
    }
}

11) 클래스 메서드와 인스턴스 메서드

메서드 앞에 static이 붙어 있으면 클래스메서드, 붙어있지 않으면 인스턴스 메서드

— 클래스메서드와 인스턴스 메서드

클래스메서드	인스턴스 메서드
객체를 생성하지 않고도 ‘클래스이름. 메서드이름(매개변수)’ 형식으로 호출 가능 인스턴스와 관계없는(인스턴스 변수나 인스턴스 메서드를 사용하지 않는)	반드시 객체를 생성해야 호출 가능 인스턴스 변수와 관련된 작업을 하는, 즉 메서드 작업을 수행하는데 인스턴스 변수를 필요로 하는 메서드

— 유의 사항

• 클래스를 설계할 때 멤버변수 중 모든 인스턴스에 공통으로 사용하는 것에 static을 붙인다.
• 각 인스턴스는 독립적이기 때문에 인스턴스 변수는 서로 다른 값을 유지
• 모든 인스턴스에서 같은 값이 유지되어야 하는 변수는 static
• 클래스 변수(static 변수)는 인스턴스를 생성하지 않아도 사용할 수 있다.
• 클래스 변수(static 변수)는 클래스가 메모리에 올라갈 때 자동으로 생성
• 클래스 메서드(static 메서드)는 인스턴스 변수 사용 불가
• 클래스 메서드가 호출되었을 때 인스턴스가 존재하지 않을 가능성이 있으므로 클래스메서드에서 인스턴스 변수의 사용을 금지
• 메서드 내에서 인스턴스 변수를 사용하지 않는다면 static을 붙이는 것을 고려

cf) Math.random()과 같은 Math 클래스의 메서드는 모두 클래스 메서드. Math클래스에는 인스턴스 변수가 하나도 없거니와 작업을 수행하는데 필요한 값들을 모두 매개변수도 받아서 처리
→ Math math = new Math() 이런 거 한 적 없으니까

12) 클래스 멤버와 인스턴스 멤버간의 참조와 호출

static 메서드는 인스턴스 메서드 호출 불가
인스턴스 메서드는 인스턴스 변수 사용 가능, static 메서드는 인스턴스 변수 사용 불가능

4. 오버로딩

1) 오버로딩이란?

한 클래스 내에 매개변수의 개수/타입만 다른, 같은 이름의 메서드를 여러 개 정의하는 것

2) 오버로딩의 조건

메서드 이름이 같아야 한다
매개변수의 개수 또는 타입이 달라야 한다.
⇒ 반환타입은 오버로딩 구현에 아무런 영향을 주지 못한다.

3) 오버로딩의 예

println 메서드
cf) long add(int a, long b)와 long add(long a, int b)는 오버로딩 성립

→ 매개변수 순서만 다르게 오버로딩을 구현할 때 주의점

add(3, 3L)과 같이 호출되면 첫번째 메서드가, add(3L, 3)과 같이 호출되면 두 번째 메서드가 호출된다. 단, 이 경우엔 두 메서드 중 어느 메서드가 호출된 것인지 알 수 없기 때문에 메서드를 호출하는 곳에서 컴파일 에러가 발생한다.

결론: 같은 일을 하지만 매개변수를 달리해야 하는 경우에 오버로딩을 구현

4) 오버로딩의 장점

이름을 짓기도 외우기도 쉬움.

5) 가변인자(varargs)와 오버로딩

가변인자: 메서드의 매개변수 개수 동적 지정

‘타입… 변수명’과 같은 형식으로 선언, printf()가 대표적인 예

public PrintStream printf(String format, Object... args) {...}
// 가변인자 외에도 매개변수가 더 있다면, 가변인자를 매개변수 중에서 제일 마지막에 선언해야 함

// 가변인자가 없을 때
    String concatenate(String s1, String s2) {}
    String concatenate(String s1, String s2, String s3) {    }
    String concatenate(String s1, String s2, String s3, String s4) {    }

// 가변인자 사용
    String concatenate(String... str){    }

가변인자는 내부적으로 배열을 이용. 가변인자가 선언된 메서드를 호출할 때마다 배열이 새로 생성되는 비효율이 숨어있으므로 꼭 필요한 경우에만 가변인자를 사용할 것

그렇다면 가변인자는 매개변수의 타입을 배열로 하는 것과 어떤 차이가 있는가?
→ 인자 생략 불가. null이나 길이가 0인 배열이라도 인자로 지정해줘야 함.

— 가변인자의 오버로딩 주의점

class Lab{
    public static void main(String[] args) {
        String[] strArr = {"100", "200", "300"};

        System.out.println(concatenate("", "100", "200", "300")); // 100200300
        System.out.println(concatenate("-", strArr)); // 100-200-300-
        System.out.println(concatenate(",", new String[]{"1", "2", "3"})); // 1,2,3,
        System.out.println("[" + concatenate(",", new String[0]) + "]"); // []
        System.out.println("[" + concatenate(",") + "]"); // []

    }

// 매개변수로 입력된 문자열에 구분자를 결합하여 반환
    static String concatenate(String delim, String... args){
        String result = "";
        for(String str: args){
            result += str + delim;
        }
        return result;
    }

    /*
    static String concatenate(String... args){
        return concatenate("", args);
    }
     */
}

concatenate(”-”, {”100”, “200”, “300”}); ⇒ 불가능
주석처리한 부분 컴파일 에러: 가변인자를 선언한 메서드를 오버로딩하면 메서드를 호출했을 때 구별 불가능한 경우가 발생하기 쉽기 때문에 가능하면 가변인자를 사용한 메서드는 오버로딩 하지 않는 것이 좋다.

5. 생성자(constructor)

1) 생성자란?

인스턴스가 생성될 때 호출되는 인스턴스 초기화 메서드
인스턴스 변수의 초기화, 인스턴스 생성 시에 실행되어야 할 작업 수행

— 생성자의 조건

• 생성자의 이름은 클래스 이름과 같아야 한다
• 생성자는 리턴값이 없다
  → 모든 생성자는 return 값이 없으므로 void를 생략할 수 있게 한 것

— 생성자: 오버로딩, new, 단계별 수행과정

• 생성자도 오버로딩이 가능 → 한 클래스에 여러 생성자 존재 가능
• 연산자 new가 인스턴스를 생성하는 것이지 생성자가 인스턴스를 생성하는 게 아니다. → 생성자는 인스턴스 변수 초기화에 사용되는 특별한 메소드일 뿐

Card c = new Card();

연산자 new에 의해 heap에 Card 클래스의 인스턴스가 생성
생성자 Card()가 호출됨
연산자 new의 결과로, 생성된 Card 인스턴스의 주소가 반환되어 참조변수 c에 저장된다.
⇒ 즉 Card()가 생성자

2) 기본 생성자(default constructor)

생성자가 없으면 컴파일러가 기본 생성자를 추가

3) 매개변수가 있는 생성자

생성자 Car()를 사용한다면 인스턴스 생성 후 인스턴스 변수들을 따로 초기화해주어야 하지만, 매개변수가 있는 생성자 Car(String color, String gearType, int door)를 사용하면 인스턴스 생성과 동시에 원하는 값으로 초기화 가능

클래스를 작성할 때 다양한 생성자를 제공함으로써 인스턴스 생성 후 별도로 초기화를 하지 않아도 되도록 하는 것이 바람직

class CarTest{
    public static void main(String[] args) {
        Car c1 = new Car();
        c1.color = "white";
        c1.gearType = "auto";
        c1.door = 4;
        
        Car c2 = new Car("white", "auto", 4);
    }
}

class Car{
    String color;
    String gearType;
    int door;
    
    Car() {}
    
    Car(String c, String g, int d){
        color = c;
        gearType = g;
        door = d;
    }
}

4) 생성자에서 다른 생성자 호출하기 - this(), this

같은 클래스 멤버들 간에 서로 호출할 수 있듯 생성자 간에도 서로 호출 가능

— 생성자 호출의 조건

생성자의 이름으로 클래스 이름 대신 this를 사용한다
한 생성자에서 다른 생성자를 호출할 땐 반드시 첫 줄에서만 호출이 가능

생성자에서 다른 생성자를 첫 줄에서만 호출 가능하도록 한 이유
: 생성자 내에서 초기화 작업 도중 다른 생성자를 호출하게 되면, 호출된 다른 생성자 내에서도 멤버변수들의 값을 초기화할 것이므로 다른 생성자를 호출하기 이전의 초기화 작업이 무의미해질 수 있기 때문

class Car{
    String color;
    String gearType;
    int door;

    Car() {
        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;
    }
}

— 참조변수 this

생성자의 매개변수로 선언된 변수의 이름이 color로 인스턴스 변수 color와 같을 경우엔 this.color는 인스턴스 변수, color는 생성자의 매개변수로 정의된 지역변수로 구분한다. 생성자의 매개변수로 인스턴스 변수의 초기값을 제공받을 때는 매개변수 이름을 다르게 하는 것보다 this를 사용해서 구별되도록 하는 것이 의미가 더 명확하고 이해하기 쉽다.

구분	설명
this	인스턴스 자신을 가리키는 참조변수, 인스턴스의 주소가 저장되어 있다. 모든 인스턴스 메서드에 지역변수로 숨겨진 채 존재
this(), this(매개변수)	생성자, 같은 클래스의 다른 생성자를 호출할 때 사용

5. 생성자를 이용한 인스턴스의 복사

현재 사용중인 인스턴스와 같은 상태를 갖는 인스턴스를 하나 더 만들고자 할 때 생성자 이용 가능
어떤 인스턴스의 상태를 전혀 알지 못해도 똑같은 상태의 인스턴스를 추가로 생성 가능

1) new Car(c1)

Car c2 = new Car(c1); // c1의 복사본 c2

인스턴스 c2는 c1을 복사하여 생성한 것이므로 서로 같은 상태를 받지만, 서로 독립적으로 메모리 공간에 존재하는 별도의 인스턴스이므로 c1의 값이 변경되어도 c2는 영향을 받지 않는다.

Car(Car c) {
	this(c.color, c.gearType, c.door);
}

2) Object.clone()

3) 인스턴스 생성 시 결정해야 할 사항

클래스: 어떤 클래스의 인스턴스를 생성할 것인가?
생성자: 선택한 클래스의 어떤 생성자로 인스턴스를 생성할 것인가?

6. 변수의 초기화

1) 변수의 초기화

멤버변수(클래스 변수, 인스턴스 변수)와 배열의 초기화는 선택적이지만, 지역변수의 초기화는 필수적이다.

— 멤버변수의 초기화 방법

• 명시적 초기화(explicit intialization)
• 생성자(constructor)
• 초기화 블럭(intialization block)
  인스턴스 초기화 블럭
  클래스 초기화 블럭

— 명시적 초기화

변수 선언과 동시에 초기화
보다 복잡한 초기화 작업이 필요할 땐 초기화 블럭 또는 생성자 사용

— 초기화 블럭(initialization block)

class InitBlock{
	static { /* 클래스 초기화 블럭 */}
	
	{ /* 인스턴스 초기화 블럭 */}
}

클래스 초기화 블럭	인스턴스 초기화 블럭
클래스 변수의 복잡한 초기화에 사용 static{} 클래스가 메모리에 처음 로딩될 때 한번만 수행	인스턴스 변수의 복잡한 초기화에 사용 {} 생성자와 같이 인스턴스를 생성할 때마다 수행 생성자보다 인스턴스 초기화블럭이 먼저 수행

⇒ 인스턴스 변수의 초기화는 주로 생성자를 사용
⇒ 인스턴스 초기화 블럭은 모든 생성자에서 공통으로 수행해야 하는 코드를 넣는데 사용

class Car{
    Car() {
        count++;
        serialNo = count;
        color = "White";
        gearType = "Auto";
    }
    
    Car(String color, String gearType){
        count++;
        serialNo = count;
        this.color = color;
        this.gearType = gearType;
    }
    
    //   count++; / serialNo = count; 중복되니 인스턴스 초기화 블럭 사용
    {
        count++;
        serialNo = count;
    }
}

* 난수로 arr을 채우는 초기화 블럭

public class StaticBlockTest {
    static int[] arr = new int[10];

    static{
        for(int i = 0; i < arr.length; i++){
            // 1 ~ 10 사이의 임의의 값을 배열 arr에 저장한다
            arr[i] = (int)(Math.random() * 10) + 1;
        }
    }

    public static void main(String[] args) {
        Arrays.toString(arr);
    }
}

4) 멤버변수의 초기화 시기와 순서

클래스 변수의 초기화 시점: 클래스가 처음 로딩될 때 단 한 번
인스턴스 변수의 초기화 시점: 인스턴스가 생성될 때마다 각 인스턴스 별로
클래스 변수의 초기화 순서: 기본값 → 명시적 초기화 → 클래스 초기화블럭
인스턴스 변수의 초기화 순서: 기본값 → 명시적 초기화 → 인스턴스 초기화 블럭 → 생성자

import java.util.Arrays;

class Document{
    static int count = 0;
    String name;

    Document(){
        this("제목없음" + ++count);
    }

    Document(String name){
        this.name = name;
        System.out.println("문서 " + this.name + "가 생성되었습니다.");
    }
}

public class Lab {
    public static void main(String[] args) {
        Document d1 = new Document(); // 문서 제목없음1가 생성되었습니다.
        Document d2 = new Document("자바.txt"); // 문서 자바.txt가 생성되었습니다.
        Document d3 = new Document(); // 문서 제목없음2가 생성되었습니다.
        Document d4 = new Document(); // 문서 제목없음3가 생성되었습니다.
    }
}