아니, 근데 그게

제네릭

Mon, 29 Jul 2024 07:47:53 GMT

목표

Java의 제네릭에 대해 학습

1. 제네릭 사용법

Java의 제네릭(Generics)은 컴파일 시 타입을 검사하고, 코드 재사용성을 높이는데 매우 유용한 기능입니다. 제네릭을 사용하면 클래스나 메서드를 작성할 때 타입을 파라미터로 사용할 수 있어 타입 안전성을 보장할 수 있습니다.

1-1) 제네릭 클래스

제네릭 클래스는 클래스 선언에서 타입 파라미터를 사용하는 클래스입니다. 타입 파라미터는 보통 대문자 T(Type), E(Element), K(Key), V(Value) 등을 사용합니다.

public class Box {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public static void main(String[] args) {
        Box stringBox = new Box<>();
        stringBox.setItem("Hello, Generics");
        System.out.println(stringBox.getItem());

        Box integerBox = new Box<>();
        integerBox.setItem(123);
        System.out.println(integerBox.getItem());
    }
}

위의 예시에서 Box 클래스는 타입 파라미터 T를 사용하여 저장할 항목의 타입을 지정합니다. Box 인스턴스는 문자열을, Box인스턴스는 정수를 저장할 수 있습니다.

1-2) 제네릭 메서드

제네릭 메서드는 메서드 선언에서 타입 파라미터를 사용하는 메서드입니다. 메서드 선언에서 타입 파라미터를 사용하려면 리턴 타입 앞에 타입 파라미터를 지정합니다.

public class GenericMethodExample {
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"Hello", "Generics"};

        printArray(intArray);
        printArray(strArray);
    }
}

위 예시에서 printArray 메서드는 타입 파라미터 T를 사용하여 배열의 요소를 출력합니다. Integer 배열과 String 배열을 모두 처리할 수 있습니다.

1-3) 제네릭 인터페이스

제네릭 인터페이스는 인터페이스 선언에서 타입 파라미터를 사용하는 인터페이스 입니다.

public interface Pair {
    K getKey();
    V getValue();
}

public class OrderedPair implements Pair {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    public static void main(String[] args) {
        Pair pair = new OrderedPair<>("One", 1);
        System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
    }
}

위 예제에서 Pair 인터페이스는 두 개의 타입 파라미터 K와 V를 사용합니다. Orderedpair 클래스는 Pair 인터페이스를 구현하며, 타입 파라미터 K와 V를 사용합니다.

요약

제네릭 클래스 클래스 선언에서 타입 파라미터를 사용하여 타입 안전성을 보장하고 코드 재사용성을 높입니다.
제네릭 메서드 메서드 선언에서 타입 파라미터를 사용하여 다양한 타입의 데이터를 처리할 수 있습니다.
제네릭 인터페이스 인터페이스 선언에서 타입 파라미터를 사용하여 타입 안전성을 보장하고 코드 재사용성을 높입니다.

2. 제네릭 주요 개념

여기서는 Bounded types와 Wildcards에 대해 설명하겠습니다.

2-1) 바운디드 타입(Bounded Types)

바운디드 타입은 타입 파라미터가 특정 클래스나 인터페이스의 서브타입 또는 슈퍼타입이어야 한다는 제약을 추가하는 기능입니다. 이를 통해 타입 파라미터에 대해 더 구체적인 제약을 걸 수 있습니다.

2-1-1) 상한 바운드(Upper Bound)

상한 바운드는 타입 파라미터가 특정 클래스나 인터페이스의 서브타입이어야 한다는 제약입니다. extends 키워드를 사용합니다.

public class BoundedTypeExample {
    public static  void printDoubleValue(T number) {
        System.out.println(number.doubleValue() * 2);
    }

    public static void main(String[] args) {
        printDoubleValue(10);       // Integer 타입
        printDoubleValue(10.5);     // Double 타입
        printDoubleValue(5.75f);    // Float 타입
    }
}

위 예시에서 printDoubleValue 메서드는 타입 파라미터 T가 Number의 서브 타입이어야 한다고 제한합니다. 따라서 Integer, Double, Float 타입만 사용할 수 있습니다.

2-1-2) 하한 바운드(Lower Bound)

하한 바운드는 타입 파라미터가 특정 클래스나 인터페이스의 슈퍼타입이어야 한다는 제약입니다. super 키워드를 사용합니다. 이는 주로 와일드카드와 함께 사용됩니다.

import java.util.List;
import java.util.ArrayList;

public class LowerBoundExample {
    public static void addNumbers(List list) {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public static void main(String[] args) {
        List numList = new ArrayList<>();
        addNumbers(numList);
        System.out.println(numList);
    }
}

위 예시에서 addNumbers 메서드는 타입 파라미터가 Integer의 슈퍼타입이어야 한다는 제약을 겁니다. 따라서 Number나 Object 타입의 리스트에 Integer 값을 추가할 수 있습니다.

2-2) 와일드카드 (Wildcards)

와일드카드는 제네릭 타입을 사용할 때 불특정 타입을 나타내기 위해 사용됩니다. 세 가지 종류의 와일드카드가 있습니다.

2-2-1) 불특정 와일드카드(Unbounded Wildcard)

불특정 와일드카드는?를 사용하여 어떤 타입이든 받아들일 수 있습니다.

import java.util.List;

public class UnboundedWildcardExample {
    public static void printList(List list) {
        for (Object element : list) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        List intList = List.of(1, 2, 3);
        List strList = List.of("Hello", "Generics");
        printList(intList);
        printList(strList);
    }
}

위 예시에서 printList 메서드는 어떤 타입의 리스트든 받아들일 수 있습니다.

2-2-2) 상한 와일드카드 (Upper Bounded Wildcard)

상한 와일드카드는 형태로 사용하며, 특정 타입의 서브타입만 받아들일 수 있습니다.

import java.util.List;
import java.util.ArrayList;

public class UpperBoundedWildcardExample {
    public static double sumOfList(List list) {
        double sum = 0.0;
        for (Number num : list) {
            sum += num.doubleValue();
        }
        return sum;
    }

    public static void main(String[] args) {
        List intList = List.of(1, 2, 3);
        List doubleList = List.of(1.1, 2.2, 3.3);
        System.out.println("Sum of intList: " + sumOfList(intList));
        System.out.println("Sum of doubleList: " + sumOfList(doubleList));
    }
}

위 예시에서 sumOfList 메서드는 Number의 서브타입을 받아들입니다.

2-2-3) 하한 와일드 카드(Lower Bounded Wildcard)

하한 와일드카드는 형태로 사용하며, 특정 타입의 슈퍼타입만 받아들일 수 있습니다.

import java.util.List;
import java.util.ArrayList;

public class LowerBoundedWildcardExample {
    public static void addNumbers(List list) {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public static void main(String[] args) {
        List numList = new ArrayList<>();
        addNumbers(numList);
        System.out.println(numList);
    }
}

위 예시에서 addNumber 메서드는 Integer의 슈퍼타입을 받아들입니다.

2-3) 제네릭 타입의 제한 사항

1. 프리미티브 타입 사용 불가 제네릭 타입 파라미터에는 프리미티브 타입을 사용할 수 없습니다. 대신 박싱된 타입을 사용해야합니다.

// 불가능
// List list = new ArrayList<>();

// 가능
List list = new ArrayList<>();

2. 정적 컨텍스트에서 사용 제한 제네릭 타입 파라미터는 정적 변수나 정적 메서드에서 사용할 수 없습니다.

public class GenericClass {
    // 불가능
    // private static T instance;

    // 가능
    private T instance;

    public static  void staticMethod(T param) {
        // 제네릭 타입 파라미터는 메서드 수준에서만 사용 가능
    }
}

3. 런타임 시 타입 소거(Type Erasure) 자바의 제네릭은 컴파일 타임에 타입 체크를 하고, 런타임에는 타입 정보가 소거됩니다. 따라서 런타임에 타입 파라미터의 실제 타입을 알 수 없습니다.

public class GenericClass {
    public void printClassName() {
        // 런타임 시에는 타입 정보를 알 수 없음
        System.out.println(T.class.getName());  // 컴파일 오류
    }
}

Erasure는 아래에서 다시한번 자세히 설명하겠습니다.

요약

바운디드 타입 타입 파라미터에 상한(extends) 또는 하한(super) 제한을 걸어 특정 타입 게층 내에서만 사용할 수 있도록 합니다.
와일드 카드 ?를 사용하여 제네릭 타입을 불특정 타입으로 나타내며, extends와 super를 사용하여 상한 및 하한을 지정할 수 있습니다.
제네릭 메서드 메서드 선언에서 타입 파라미터를 사용하여 다양한 타입의 데이터를 처리할 수 있습니다.
제네릭 타입의 제한 사항 프리미티브 타입 사용 불가, 정적 컨텍스트에서 사용 제한, 런타임 시 타입 소거 등의 제한이 있습니다.

3. 제네릭 메소드 만들기

제네릭 메서드는 메서드 선언에서 타입 파라미터를 사용하는 메서드입니다. 이는 메서드가 호출될 때 타입을 명시할 수 있게 하여 다양한 타입의 데이터를 처리할 수 있게 합니다.

3-1) 제네릭 메서드 선언

제네릭 메서드를 선언할 때는 메서드의 리턴 타입 파라미터를 선언합니다. 이는 메서드의 인수와 리턴 타입에서 사용할 수있습니다.

기본형태

public  void methodName(T param) {
    // 메서드 구현
}

예제 1: 제네릭 메서드

배열의 요소를 출력하는 제네릭 메서드의 예제 입니다.

public class GenericMethodExample {
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"Hello", "Generics"};

        printArray(intArray);  // 제네릭 메서드 호출
        printArray(strArray);  // 제네릭 메서드 호출
    }
}

예제 2: 제네릭 메서드와 타입 변환

제네릭 메서드는 반환 타입에서도 제네릭을 사용할 수 있습니다. 다음은 두 개의 인수를 비교하여 큰 값을 반환하는 제네릭 메서드의 예제입니다.

public class GenericMethodExample {
    public static > T findMax(T a, T b) {
        return a.compareTo(b) > 0 ? a : b;
    }

    public static void main(String[] args) {
        System.out.println(findMax(3, 5));           // 정수 비교
        System.out.println(findMax("apple", "pear")); // 문자열 비교
    }
}

3-2) 제네릭 메서드의 타입 파라미터 제한

앞서 설명한 바운디드 타입을 통해 파라미터의 타입을 제한할 수있습니다. 특정 클래스나 인터페이스의 서브타입으로 제한될 수 있습니다.

public class BoundedGenericMethodExample {
    public static  void printDoubleValue(T number) {
        System.out.println(number.doubleValue() * 2);
    }

    public static void main(String[] args) {
        printDoubleValue(10);        // Integer 타입
        printDoubleValue(10.5);      // Double 타입
        printDoubleValue(5.75f);     // Float 타입
    }
}

위 예시에서 printDoubleValue 메서드는 타입 파라미터 T가 Number의 서브 타입이도록 제한하고 있습니다.

3-3) 여러 개의 타입 파라미터

제네릭 메서드는 여러 개의 타입 파라미터를 가질 수 있습니다. 이는 타입 파라미터를 쉼표로 구분하여 선언합니다.

public class MultiGenericMethodExample {
    public static  void printKeyValue(K key, V value) {
        System.out.println("Key: " + key + ", Value: " + value);
    }

    public static void main(String[] args) {
        printKeyValue("One", 1);
        printKeyValue("Apple", "Fruit");
    }
}

위 예시에서 printkeyValue 메서드는 두 개의 타입 파라미터 K와 V를 가집니다.

3-4) 제네릭 메서드의 호출

제네릭 메서드는 메서드 호출 시 타입을 명시적으로 지정하지 않아도 컴파일러가 타입을 추론해줍니다. 하지만 명시적으로 타입을 지정해 주는 방법도 있습니다.

public class ExplicitTypeGenericMethodExample {
    public static  void printElement(T element) {
        System.out.println("Element: " + element);
    }

    public static void main(String[] args) {
        // 컴파일러가 타입을 추론
        printElement(123);
        printElement("Hello");

        // 명시적으로 타입 지정
        ExplicitTypeGenericMethodExample.printElement("Generics");
    }
}

요약

제네릭 메서드 선언 리턴 타입 앞에 타입 파라미터를 선언합니다.
타입 파라미터 제한 extends 키워드를 사용하여 타입 파라미터를 특정 클래스나 인터페이스의 서브타입으로 제한할 수 있습니다.
여러 개의 타입 파라미터 쉼표로 구분하여 여러 개의 타입 파라미터를 선언할 수 있습니다.
제네릭 메서드 호출 컴파일러가 타입을 추론하지만, 필요에 따라 명시적으로 타입을 지정할 수도 있습니다.

4. Erasure

제네릭 타입 소거(Erasure)는 Java의 제네릭이 컴파일 타임에만 검사를 수행하고, 런타임에는 제네릭 타입 정보를 제거하는 과정입니다.

이 개념은 자바의 제네릭 구현 방식의 핵심으로, 호환성과 성능 측면에서 중요한 역할을 합니다.

제네릭 타입 소거(Erasure)란?

제네릭 타입 소거는 자바 컴파일러가 제네릭 타입을 처리하는 방법입니다. 제네릭 코드가 컴파일되면 모든 제네릭 타입 정보는 제거(소거)되고, 제네릭 타입을 사용한 코드는 타입 안전성을 보장하는 기본형 코드로 변환됩니다.

즉, 제네릭 타입 파라미터는 제거되고, 필요에 따라 해당 타입은 Object나 바운드로 대체됩니다.

왜 타입 소거가 필요한가?

타입 소거는 자바의 제네릭이 Java5 에서 도입되었을 때, 이전 버전과의 하위 호환성을 유지하기 위해 도입되었습니다.

기존의 Java 코드와 새로운 제네릭 코드가 함께 동작할 수 있도록 하기 위해, 제네릭 타입 정보는 컴파일 타임에만 사용되고 런타임에는 제거됩니다. 이를 통해 제네릭 도입 이전에 작성된 코드와 제네릭 코드가 동일한 바이트코드를 공유할 수 있었습니다.

타입 소거의 작동방식

타입 소거는 다음과 같은 방식으로 작동합니다.

1. 제네릭 타입 파라미터 제거 모든 제네릭 타입 파라미터가 제거되고, 필요에 따라 Object 또는 Upper Bound로 대체됩니다.

2. 타입 검사 및 캐스팅 추가 타입 안정성을 보장하기 위해 컴파일러는 필요한 곳에 강제 캐시팅을 추가합니다.

3. 바운드 적용 타입 파라미터가 바운드(extends 키워드)로 제한된 경우, 제네릭 타입은 해당 바운드 타입으로 대체됩니다.

예제: 타입 소거 전후

제네릭 코드

public class Box {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

타입 소거 후 코드

public class Box {
    private Object item;

    public void setItem(Object item) {
        this.item = item;
    }

    public Object getItem() {
        return item;
    }
}

보시는 바와 같이 제네릭 타입 파라미터 T는 Object로 대체되게 됩니다.

예제: 바운드 타입 소거

제네릭 코드

public class Box {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

타입 소거 후 코드

public class Box {
    private Number item;

    public void setItem(Number item) {
        this.item = item;
    }

    public Number getItem() {
        return item;
    }
}

여기서는 T extends Number가 Number로 대체됩니다.

타입 소거의 영향

타입 소거는 제네릭 타입을 런타임에 사용할 수 없게 만듭니다. 이는 몇 가지 제약을 발생시킵니다.

1. 런타임 타입 검사 불가 제네릭 타입 파라미터의 런타임 타입 정보를 알 수 없습니다.

public  void checkType(T item) {
    if (item instanceof T) {  // 컴파일 오류
        // ...
    }
}

2. 제네릭 배열 생성 불가 제네릭 타입 파라미터를 사용해 배열을 생성할 수 없습니다.

public  void createArray() {
    T[] array = new T[10];  // 컴파일 오류
}

3. 강제 캐스팅 필요 타입 소거로 인해 제네릭 타입 정보가 제거되므로, 종종 강제 캐스팅이 필요하게 됩니다.

Box stringBox = new Box<>();
Box rawBox = stringBox;
String item = (String) rawBox.getItem();  // 강제 캐스팅 필요

와일드카드와 타입 소거

와일드카드(?), 상한 바운드(? extends T), 하한 바운드(? super T)도 타입 소거의 영향을 받습니다. 컴파일 타임에 타입 검사가 이루어지고, 런타임에는 와일드카드 정보가 소거됩니다.

요약

타입소거는 제네릭 타입 정보를 컴파일 타임에만 사용하고, 런타임에는 제거하는 과정입니다.
하위 호환성을 유지하기 위해 자바에서 도입된 방식입니다.
타입 파라미터는 Object 또는 바운드 타입으로 대체됩니다.
제약사항 : 런타임 타입 검사 불가, 제네릭 배열 생성 불가, 강제 캐스팅 필요

Java의 I/O

Mon, 15 Jul 2024 08:31:40 GMT

목표

Java의 Input과 Output에대해 학습

1. Stream / Buffer / Channel 기반의 I/O

Java에서 I/O(Input/Output) 작업을 처리하는 방법중 Stream, Buffer, Channel에 대해 알아보겠습니다.

1-1 Stream기반의 I/O

Stream은 자바에서 I/O 작업을 처리하는 가장 기본적인 방법입니다. Stream은 데이터를 순차적으로 읽고 쓰는 통로를 의미합니다.

자바의 Stream은 다음과 같이 두 가지 유형으로 나뉩니다.

InputStream : 입력 데이터를 읽기 위한 스트림 ( Ex: FileInputStream, ByteArrayInputStream )
OutputStream : 출력 데이터를 쓰기 위한 스트림 ( Ex: FileOutputStream, ByteArrayOutputStream )

스트림은 바이트 단위로 데이터를 처리하며, 이러한 스트림은 데이터를 한 바이트씩 읽거나 쓸 수 있습니다. 이를 통해 파일, 네트워크 소켓 등의 다양한 I/O 소스를 처리할 수 있습니다.

Reader와 Writer

스트림은 기본적으로 바이트 단위로 데이터를 처리하지만, 문자 데이터를 효율적으로 처리하기 위해 자바는 Reader와 Writer 클래스를 제공합니다. 이들은 문자 단위로 데이터를 읽고 씁니다.

Reader : 입력을 위한 문자 스트림입니다.
Writer : 출력을 위한 문자 스트림입니다.

스트림 기반 I/O는 단순하고 직관적이지만, 데이터를 한 바이트씩 처리하기 때문에 성능 면에서 비효율적일 수 있습니다. 이를 보완하기 위해 버퍼를 사용합니다.

1-2 Buffer 기반의 I/O

Buffer는 데이터 입출력 성능을 향상시키기 위해 사용되는 메모리의 특정 영역입니다. 버퍼는 데이터를 일시적으로 저장하여, 한 번에 많은 데이터를 읽거나 쓸 수 있도록 도와줍니다. 이는 디스크나 네트워크와의 I/O 작업에서 특히 유용합니다.

Bufferd Stream

자바에서 버퍼링을 사용하기 위해 BufferedInputStream과 BufferedOutputStream 클래스를 제공합니다. 이 클래스들은 내부적으로 버퍼를 사용하여 데이터를 한 번에 더 많이 읽거나 씁니다.

BufferedInputStream : 입력을 위한 버퍼링된 바이트 스트림
BufferedOutputStream : 출력을 위한 버퍼링된 바이트 스트림

Buffered Reader와 Writer

문자 스트림에도 버퍼링이 가능합니다. 이를 위해 BufferedReader와 BufferedWriter 클래스를 사용합니다.

BufferedReader : 입력을 위한 버퍼링된 문자 스트림
BufferedWriter : 출력을 위한 버퍼링된 문자 스트림

버퍼링된 스트림을 사용하면 성능이 크게 향상될 수 있습니다. 이는 특히 대량의 데이터를 처리할 때 유용합니다.

1-3 Channel 기반의 I/O

Channel은 Java NIO (New I/O)패키지에서 도입된 개념으로, 스트림보다 더 유연하고 강력한 I/O 처리를 제공합니다. 채널은 양방향 통신을 지원하며, 비동기 I/O 및 버퍼와 함께 사용됩니다.

주요 채널 클래스는 아래와 같습니다.

FileChannel : 파일 I/O를 위한 채널
SocketChannel : 소켓 I/O를 위한 채널
ServerSocketChannel : 서버 소켓 I/O를 위한 채널
DatagramChannel : UDP 소컷 I/O를 위한 채널

버퍼와 채널의 조합

채널은 데이터를 직접 일고 쓰지 않고, 항상 버퍼를 통해 데이터를 처리합니다. 이는 효율적인 데이터 전송과 처리를 가능하게 합니다.

예를 들어, FileChannel을 사용하여 파일에서 데이터를 읽는 과정은 아래와 같습니다.

*1. 파일 채널 열기 *

FileChannel fileChannel = 
FileChannel.open(Paths.get("file.txt"), StandardOpenOption.READ);

*2. 버퍼 생성 *

ByteBuffer buffer = ByteBuffer.allocate(1024);

3. 채널에서 버퍼로 데이터 읽기

int bytesRead = fileChannel.read(buffer);

4. 채널에서 버퍼로 데이터 읽기

int bytesRead = fileChannel.read(buffer);

*5. 채널 닫기 *

fileChannel.close();

요약

Stream : 단순하고 사용하기 쉬우며, 단방향I/O를 지원하지만, 성능이 떨어질 수 있습니다.
Buffer : 성능을 향상시키기 위해 데이터를 일시적으로 저장하여 한 번에 읽고 쓰는 방식입니다.
Channel : 양방향 I/O와 비동기 처리를 지원하며, 버퍼와 함께 사용하여 효율적인 데이터 처리를 가능하게 합니다.

2. InputStream과 OutputStream

InputStream과 OutputStream은 자바에서 기본적인 I/O 처리를 위한 추상 클래스입니다.

이 두 클래스는 바이트 단위로 데이터를 읽고 쓰는데 사용됩니다. 이들은 I/O의 핵심이며, 다양한 서브클래스를 통해 파일, 네트워크 소켓, 메모리 등 여러 소스와 목적지로부터 데이터를 처리할 수 있습니다.

InputStream

InputStream은 바이트 단위로 데이터를 읽기 위한 추상 클래스입니다. 주로 데이터를 읽는 작업에 사용되며, 주요 서브클래스와 함께 사용됩니다.

주요 메서드

int read() 입력 스트림에서 다음 바이트 데이터를 읽습니다. 바이트 값을 0~255 사이의 정수로 반환하며, 더 이상 읽을 데이터가 없으면 -1을 반환합니다.
int read(byre[] b) 입력 스트림에서 바이트 배열 b의 길이만큼 데이터를 읽습니다. 읽은 바이트 수를 반환하며, 더 이상 읽을 데이터가 없으면 -1을 반환합니다.
int read(byte[] b, int off, int len) 입력 스트림에서 최대 len 바이트를 읽고, 이를 바이트 배열 b의 off 위치에서 시작하여 저장합니다.
void close() 스트림을 닫고, 자원을 해제합니다.
int available() 스트림에서 읽을 수 있는 바이트 수를 반환합니다.

주요 서브 클래스

FileInputStream 파일로부터 바이트 입력을 읽기 위한 스트림입니다.
ByteArrayInputStream 바이트 배열로부터 바이트 입력을 읽기 위한 스트림 입니다.
BufferedInputStream 다른 입력 스트림에 버퍼링 기능을 추가하여 입력 성능을 향상시킵니다.
DataInputStream 기본 데이터 타입 (int, float 등)을 입력 스트림에서 읽을 수 있습니다.

예시

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

OutputStream

OutputStream은 바이트 단위로 데이터를 쓰기 위한 추상 클래스입니다. 주로 데이터를 쓰는 작업에 사용되며, 주요 서브클래스와 함께 사용됩니다.

주요 메서드

void write(int b) 출력 스트림에 주어진 바이트 데이터를 씁니다.
void write(byte[] b) 바이트 배열 b의 모든 바이트 데이터를 출력 스트림에 씁니다.
void write(byte[] b, int off, int len) 바이트 배열 b의 off 위치에서 시작하여 len 바이트 데이터를 출력 스트림에 씁니다.
void flush() 출력 스트림을 비우고, 모든 버퍼된 출력 바이트를 실제 출력 대상에 씁니다.
void close() 스트림을 닫고, 자원을 해제합니다.

주요 서브 클래스

FileOutputStream 파일에 바이트 출력을 쓰기 위한 스트림입니다.
ByteArrayoutputStream 바이트 배열에 바이트 출력을 쓰기 위한 스트림입니다.
BufferedOutputStream 다른 출력 스트림에 버퍼링 기능을 추가하여 출력 성능을 향상시킵니다.
DataOutputStream 기본 데이터 타입 (int, float 등)을 출력 스트림에 쓸 수 있습니다.

예시

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String data = "Hello, World!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

결합 사용 예시 InputStream과 OutputStream을 결합하여 파일 복사를 할 수 있습니다.

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {

            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

요약

InputStream과 OutputStream은 자바에서 바이트 단위 I/O를 처리하기 위한 기본 추상 클래스입니다.
InputStream은 데이터를 읽고, OutputStream은 데이터를 씁니다.
이들 클래스는 다양한 서브클래스를 통해 파일, 네트워크 소켓, 메모리 등 여러 소스와 목적지로부터 데이터를 처리할 수 있습니다.
버퍼링 클래스(BufferedInputStream, BufferedOutputStream)를 사용하면 성능이 향상될 수 있습니다.
스트림을 사용할 때는 항상 자원을 해제하기 위해 close() 메서드를 호출해야 하며, 이를 위해 try-with-resources 구문을 사용하는 것이 권장됩니다.

3. Byte와 Character 스트림

Java의 I/O 시스템은 데이터를 바이트 단위로 처리하는 바이트 스트림과, 문자를 처리하는 캐릭터 스트림으로 나뉩니다. 각각의 스트림은 특정 용도와 데이터 형식에 맞춰 설계되었으며, 효율적인 데이터 처리를 위해 다양한 클래스가 제공됩니다.

Byte 스트림

Byte 스트림은 바이트 단위로 데이터를 읽고 쓰는 스트림입니다. 주로 바이너리 데이터를 처리하는 데 사용됩니다. 예를 들어, 이미지 파일, 오디오 파일, 비디오 파일 등은 바이트 스트림을 사용하여 처리할 수 있습니다.

주요 클래스

InputStream

FileInputStream 파일로부터 바이트 단위로 데이터를 읽습니다.
ByteArrayInputStream 메모리 내의 바이트 배열로부터 데이터를 읽습니다.
BufferedInputStream 다른 InputStream에 버퍼링 기능을 추가하여 성능을 향상시킵니다.
DataInputStream 기본 데이터 타입(int, float 등)을 읽기 위한 기능을 제공합니다.

OutputStream

FileOutputStream 파일에 바이트 단위로 데이터를 씁니다.
ByteArrayOutputStream 메모리 내의 바이트 배열에 데이터를 씁니다.
BufferedOutputStream 다른 OutputStream에 버퍼링 기능을 추가하여 성능을 향상시킵니다.
DataOutputStream 디본 데이터 타입(int, float 등)을 쓰기 위한 기능을 제공합니다.

예제

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // 파일에 데이터 쓰기
        try (FileOutputStream fos = new FileOutputStream("byte_output.txt")) {
            String data = "Hello, Byte Stream!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 파일로부터 데이터 읽기
        try (FileInputStream fis = new FileInputStream("byte_output.txt")) {
            int byteData;
            while ((byteData = fis.read()) != -1) {
                System.out.print((char) byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Character 스트림

Character 스트림은 문자 단위로 데이터를 읽고 쓰는 스트림입니다. 주로 텍스트 데이터를 처리하는 데 사용됩니다. Java에서 문자는 2바이트 유니코드로 처리되므로, 캐릭터 스트림은 국제화된 텍스트 데이터를 처리하는 데 적합합니다.

주요 클래스

Reader

FileReader 파일로부터 문자 데이터를 읽습니다.
CharArrayReader 메모리 내의 문자 배열로부터 데이터를 읽습니다.
BufferedReader 다른 Reader에 버퍼링 기능을 추가하여 성능을 향상시킵니다. 또한 readLine() 메서드를 제공하여 한 줄씩 읽을 수 있습니다.
InputStreamReader 바이트 스트림을 문자 스트림으로 변환합니다.

Writer

FileWriter 파일에 문자 데이터를 씁니다.
CharArrayWriter 메모리 내의 문자 배열에 데이터를 씁니다.
BufferedWriter 다른 Writer에 버퍼링 기능을 추가하여 성능을 향상시킵니다.
OutpufStreamWriter 바이트 스트림을 문자 스트림으로 변환합니다.

예제

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharacterStreamExample {
    public static void main(String[] args) {
        // 파일에 문자 데이터 쓰기
        try (FileWriter fw = new FileWriter("char_output.txt")) {
            String data = "Hello, Character Stream!";
            fw.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 파일로부터 문자 데이터 읽기
        try (FileReader fr = new FileReader("char_output.txt")) {
            int charData;
            while ((charData = fr.read()) != -1) {
                System.out.print((char) charData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Byte 스트림과 Character 스트림 비교

데이터 단위 바이트 스트림은 바이트 단위로 데이터를 처리하며, 캐릭터 스트림은 문자 다누이로 데이터를 처리합니다.
용도 바이트 스트림은 바이너리 데이터를 처리하는 데 적합하고, 캐릭터 스트림은 텍스트 데이터를 처리하는데 적합합니다.
유니코드 지원 캐릭터 스트림은 유니코드 문자를 지원하여 국제화된 텍스트 데이터를 처리할 수 있습니다.
버퍼링 두 스트림 모두 버퍼링된 클래스를 제공하여 성능을 향상시킬 수 있습니다.

요약

Byte 스트림 바이트 단위로 데이터를 읽고 쓰며, 바이너리 데이터를 처리하는데 사용됩니다. 주요 클래스는 InputStream과 OutputStream입니다.
Character 스트림 문자 단위로 데이터를 읽고 쓰며, 텍스트 데이터를 처리하는 데 사용됩니다. 주요 클래스는 Reader와 Writer입니다.

4. 표준 스트림

표준 스트림은 자바 프로그램이 실행될 때 기본적으로 사용할 수 있는 세 가지 스트림을 의미합니다. 이 스트림들은 프로그램과 사용자 간의 기본적인 입출력을 처리하기 위해 저공됩니다. 표준 스트림에는 표준 입력 스트림, 표준 출력 스트림, 표준 오류 스트림이 있습니다.

표준 입력 스트림(Standard Input Stream)

표준 입력 스트림은 기본적으로 키보드로부터 입력을 받는 스트림입니다. Java에서는 System.in 객체로 제공됩니다. 이 스트림은 InputStream 타입이며, 주로 콘솔에서 사용자 입력을 읽는 데 사용됩니다.

import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;

public class StandardInputExample {
    public static void main(String[] args) {
        System.out.println("Enter some text:");

        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            String input = reader.readLine();
            System.out.println("You entered: " + input);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

표준 출력 스트림(Standard Output Stream)

표준 출력 스트림은 기본적으로 콘솔에 출력을 보내는 스트림입니다. Java에서는 System.out 객체로 제공됩니다. 이 스트림은 PrintStream 타입이며, 프로그램의 출력을 사용자에게 보여주는 데 사용됩니다.

public class StandardOutputExample {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
        System.out.println("This is an example of standard output.");
    }
}

표준 오류 스트림(Standard Error Stream)

표준 오류 스트림은 기본적으로 오류 메시지를 콘솔에 출력하는 스트림입니다. Java에서는 System.err 객체로 제공됩니다. 이 스트림도 PrintStream 타입이며, 오류 메시지나 예외 정보를 출력하는 데 사용됩니다.

public class StandardErrorExample {
    public static void main(String[] args) {
        System.err.println("An error occurred!");
        System.err.println("This is an example of standard error output.");
    }
}

표준 스트림의 리디렉션

Java에서는 표준 스트림을 다른 스트림으로 리디렉션 할 수 있습니다. 예를 들어, 파일로 출력을 리디렉션하거나 입력을 파일로부터 받을 수 있습니다. 이는 System.setIn(), System.setOut(), System.setErr() 메서드를 사용하여 가능합니다.

표준 출력 스트림 리디렉션

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.IOException;

public class RedirectOutputExample {
    public static void main(String[] args) {
        try (PrintStream out = new PrintStream(new FileOutputStream("output.txt"))) {
            System.setOut(out);
            System.out.println("This will be written to the file instead of the console.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

표준 입력 스트림 리디렉션

import java.io.FileInputStream;
import java.io.IOException;

public class RedirectInputExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt")) {
            System.setIn(fis);
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("Read from file: " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

요약

표준 입력 스트림(System.in) 기본적으로 키보드로부터 입력을 받는 스트림입니다. InputStream 타입이며, 주로 BufferedReader와 함께 사용하여 문자열 입력을 처리합니다.
표준 출력 스트림(System.out) 기본적으로 콘솔에 출력을 보내는 스트림입니다. PrintStream타입이며, println 메서드를 사용하여 텍스트를 출력합니다.
표준 오류 스트림(System.err) 기본적으로 콘솔에 오류 메시지를 보내는 스트림입니다. PrintStream 타입이며, 오류나 예외 정보를 출력합니다.
리디렉션 표준 스트림을 다른 스트림으로 리디렉션하여 입력을 파일에서 받거나 출력을 파일로 보낼 수 있습니다.

5. 파일 읽고 쓰기

파일 읽고 쓰기를 위해 Java는 다양한 클래스를 제공합니다. 파일 I/O는 크게 바이트 스트림과 문자 스트림의로 나뉘며, 각각의 스트림을 사용하여 파일을 읽고 쓸 수 있습니다.

바이트 스트림을 이용한 파일 읽기와 쓰기

바이트 스트림은 파일의 데이터를 바이트 단위로 읽고 쓰는데 사용됩니다. 바이트 스트림은 바이너리 파일(이미지, 비디오, 오디오 파일 등)을 처리하는 데 적합합니다.

파일 읽기(FileInputStream)

FileInputStream 클래스를 사용하여 파일을 바이트 단위로 읽을 수 있습니다.

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

파일 쓰기(FileOutputStream)

FileOutputStream 클래스를 사용하여 파일에 바이트 단위로 데이터를 쓸 수 있습니다.

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String data = "Hello, World!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

문자 스트림을 이용한 파일 읽기와 쓰기

문자 스트림은 파일의 데이터를 문자 단위로 읽고 쓰는 데 사용됩니다. 문자 스트림은 텍스트 파일(.txt, .csv, .html 등)을 처리하는데 적합합니다.

파일 읽기(FileReader)

FileReader 클래스를 사용하여 파일을 문자 단위로 읽을 수 있습니다.

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        try (FileReader fr = new FileReader("input.txt")) {
            int data;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

파일 쓰기(FileWriter)

FileWriter 클래스를 사용하여 파일에 문자 단위로 데이터를 쓸 수 있습니다.

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("output.txt")) {
            String data = "Hello, World!";
            fw.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

버퍼링된 스트림을 이용한 파일 읽기와 쓰기

버퍼링된 스트림은 데이터의 입출력 성능을 향상시키기 위해 사용됩니다. 버퍼를 사용하여 데이터를 한 번에 더 많이 읽거나 쓸 수 있습니다.

파일 읽기(BufferedReader)

BufferedReader 클래스를 사용하여 파일을 효율적으로 읽을 수 있습니다.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

파일 쓰기(BufferedWriter)

BufferedWriter 클래스를 사용하여 파일에 효율적으로 데이터를 쓸 수 있습니다.

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            String data = "Hello, World!";
            bw.write(data);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

데이터 스트림을 이용한 파일 읽기와 쓰기

데이터 스트림은 기본 데이터 타입(int, float, double 등)을 입출력하는 데 사용됩니다.

파일 쓰기(DataOutputStream)

DataOutputStream 클래스를 사용하여 파일에 기본 데이터 타입을 쓸 수 있습니다.

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOutputStreamExample {
    public static void main(String[] args) {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"))) {
            dos.writeInt(123);
            dos.writeFloat(4.56f);
            dos.writeUTF("Hello, World!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

파일 읽기(DataInputStream)

DataInputStream 클래스를 사용하여 파일로부터 기본 데이터 타입을 읽을 수 있습니다.

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataInputStreamExample {
    public static void main(String[] args) {
        try (DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"))) {
            int intValue = dis.readInt();
            float floatValue = dis.readFloat();
            String strValue = dis.readUTF();
            System.out.println("Read values: " + intValue + ", " + floatValue + ", " + strValue);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

파일 복사 예제

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopyExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("source.txt");
             FileOutputStream fos = new FileOutputStream("destination.txt")) {

            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }

            System.out.println("File copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

요약

바이트 스트림 FileInputStream과 FileOutputStream을 사용하여 파일의 데이터를 바이트 단위로 읽고 씁니다.
문자 스트림 FileReader와 FileWriter를 사용하여 파일의 데이터를 문자 단위로 읽고 씁니다.
버퍼링된 스트림 BufferedReader와 BufferedWriter를 사용하여 효율적으로 파일을 읽고 씁니다.
데이터 스트림 DataInputStream과 DataOutputStream을 사용하여 기본 데이터 타입을 파일로부터 읽고 씁니다.

어노테이션

Wed, 03 Jul 2024 09:56:10 GMT

목표

자바의 어노테이션에 대해 학습

1. 어노테이션 정의하는 방법

Java에서 어노테이션(Annotation)은 메타데이터를 제공하는 특별한 종류의 인터페이스입니다. 어노테이션은 코드에 대한 추가 정보를 제공하며, 주로 컴파일러 지시자, 런타임 정보 제공, 또는 코드 분석 도구에서 사용됩니다.

1-1 어노테이션 정의하기

어노테이션 인터페이스 생성 @interface 키워드를 사용하여 어노테이션을 정의합니다.
요소 정의 어노테이션 내에 요소(Element)를 정의할 수 있습니다. 요소는 기본값을 가질 수 있습니다.

** 예제 **

// 어노테이션 정의
public @interface MyAnnotation {
    String value();
    int number() default 0;
}

// 어노테이션 사용
@MyAnnotation(value = "Hello", number = 5)
public class MyClass {
    // 클래스 내용
}

1-2 어노테이션 요소의 기본값 설정

어노테이션 요소에 기본값을 설정할 수 있습니다. 기본값을 설정하면 어노테이션을 사용할 때 해당 요소를 생략할 수 있습니다.

// 어노테이션 정의
public @interface MyAnnotation {
    String value() default "default value";
    int number() default 42;
}

@MyAnnotation
public class MyClass {
    // 클래스 내용
    // 기본값을 설정해 두었기때문에, 요소를 생략할 수 있습니다.
}

1-3 어노테이션의 메타-어노테이션

어노테이션도 다른 어노테이션으로 설명할 수 있습니다. 이를 메타-어노테이션(Meta-Annotation)이라고 합니다. Java에서는 여러 가지 메타-어노테이션이 있습니다.

@Retention : 어노테이션의 유지 정책을 정의합니다.
@Target : 어노테이션이 적용될 수 있는 위치를 정의합니다.
@Documented : 어노테이션이 Javadoc에 포함되도록 합니다.
@Inherited : 어노테이션이 하위 클래스에 상속되도록 합니다.

** 예제 **

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 어노테이션 정의
@Retention(RetentionPolicy.RUNTIME) // 런타임까지 어노테이션 유지
@Target(ElementType.METHOD) // 메서드에만 적용 가능
public @interface MyAnnotation {
    String value() default "default value";
    int number() default 42;
}

2. @Retention

@Retention 어노테이션은 Java에서 어노테이션이 얼마나 오래 유지될지를 지정하는 메타-어노테이션입니다. 이를 통해 어노테이션이 소스 코드, 클래스 파일, 런타임 중 어느 단계까지 유지될지를 결정할 수 있습니다.

2-1 @Retention 사용 방법

@Retention 어노테이션을 사용하여 어노테이션의 유지 정책을 설정할 수 있습니다. 유지 정책은 java.lang.annotation.RetentionPolicy 열거형을 통해 지정됩니다. RetentionPolicy는 다음과 같은 세 가지 값을 가질 수 있습니다.

1. RetentionPolicy.SOURCE 어노테이션이 소스코드에만 유지되고, 컴파일 과정에서 제거됩니다. 이는 주로 컴파일러에 대한 힌트로 사용됩니다.

2. RetentionPolicy.CLASS 어노테이션이 컴파일된 클래스 파일에 포함되지만, JVM에서 실행될 때는 사용할 수 없습니다. 이는 기본값입니다.

3. RetentionPolicy.RUNTIME 어노테이션이 런타임까지 유지되며, 리플렉션을 사용하여 런타임에 접근할 수 있습니다. 런타임 시에 동적으로 어노테이션 정보를 필요로 하는 경우에 사용됩니다.

예제

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface MyRuntimeAnnotation {
    String value();
}

// ----------------------------------------------------------

public class MyClass {
    @MyRuntimeAnnotation(value = "Example")
    public void myMethod() {
        // 메서드 내용
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();
        // 런타임에 어노테이션 정보 읽기
        MyRuntimeAnnotation annotation 
        = obj.getClass().getMethod("myMethod")
        .getAnnotation(MyRuntimeAnnotation.class);

        System.out.println(annotation.value()); 
        // "Example" 출력
    }
}

2-2 요약

@Retention 어노테이션은 어노테이션의 유지 정책을 결정합니다.
RetentionPolicy.SOURCE : 컴파일 후 어노테이션 제거
RetentionPolicy.CLASS : 컴파일된 클래스 파일에 어노테이션 유지
RetentionPolicy.RUNTIME : 런타임까지 어노테이션 유지

3. @Target

@Target 어노테이션은 Java에서 어노테이션이 적용될 수 있는 프로그램 요소를 지정하는 메타-어노테이션입니다. 이 어노테이션을 어디에 적용할 수 있는지 제한할 수 있습니다.

3-1 @Target 사용 방법

@Target 어노테이션은 java.lang.annotation.ElementType 열거형을 인수로 받습니다. ElementType은 어노테이션이 적용될 수 있는 프로그램 요소를 정의하는 여러 상수를 제공합니다. 주요 ElemetType 값은 다음과 같습니다.

1. ElementType.Type 클래스, 인터페이스(어노테이션 유형 포함), 열거형에 적용됩니다.

2. ElementType.FIELD 필드(인스턴스 변수 포함)에 적용됩니다.

3. ElementType.METHOD 메서드에 적용됩니다.

4. ElementType.PARAMETER 메서드의 매개변수에 적용됩니다.

5. ElementType.CONSTRUCTOR 생성자에 적용됩니다.

6. ElementType.LOCAL_VARIABLE 지역 변수에 적용됩니다.

7. ElementType.ANNOTATION_TYPE 다른 어노테이션에 적용됩니다.

8. ElementType.PACKAGE 패키지 선언에 적용됩니다.

9. ElementType.TYPE_PARAMETER 제네릭 타입 매개변수에 적용됩니다.

*10. ElementType.TYPE_USE * 타입 사용에 적용됩니다.

3-2 @Target 예제

다음은 @Target 어노테이션을 사용하여 어노테이션이 메서드에만 적용되도록 하는 예제입니다.

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
public @interface MethodOnlyAnnotation {
    String value();
}

//-----------------------------------------------
public class MyClass {
    @MethodOnlyAnnotation(value = "This is a method")
    public void myMethod() {
        // 메서드 내용
    }

    // 잘못된 사용 - 컴파일 오류 발생
    // @MethodOnlyAnnotation(value = "This is a field")
    // private String myField;
}

@Target 어노테이션은 배열 형태로 여러 ElementType 값을 지정할 수 있습니다.

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})
public @interface TypeAndMethodAnnotation {
    String value();
}

//-----------------------------------------------

@TypeAndMethodAnnotation(value = "This is a class")
public class MyClass {
    @TypeAndMethodAnnotation(value = "This is a method")
    public void myMethod() {
        // 메서드 내용
    }
}

3-3 요약

@Target 어노테이션은 어노테이션이 적용될 수 있는 프로그램 요소를 지정합니다.
주요 ElementType 값은 클래스, 메서드, 필드, 생성자, 매개변수 등 다양한 프로그램 요소를 포함합니다.
여러 ElementType 값을 배열 형태로 지정할 수있습니다.

4. @Documented

@Documented 어노테이션은 Java에서 메타-어노테이션 중 하나로, 어노테이션이 Javadoc 문서에 포함되도록 지정하는 데 사용됩니다. 이를 통해 어노테이션이 문서화되고, Javadoc 도구를 사용하여 생성된 API 문서에 어노테이션의 존재와 설명이 포함됩니다.

4-1 @Documented 사용방법

@Documented 어노테이션은 단순히 어노테이션 타입에 적용하여 Javadoc에 포함되도록 하는 역할을 합니다. 이는 주로 라이브러리나 API를 작성할 때 유용하며, 사용자가 어노테이션의 의미와 사용 방법을 문서에서 쉽게 확인할 수 있게 합니다.

예제

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyDocumentedAnnotation {
    String value();
}

// -----------------------------------------------

public class MyClass {
    /**
     * 이 메서드는 예제 메서드입니다.
     *
     * @param param 예제 매개변수
     */
    @MyDocumentedAnnotation(value = "Example annotation")
    public void myMethod(String param) {
        // 메서드 내용
    }
}

이제 Javadoc 도구를 사용하여 문서를 생성하면 myMethod 메서드에 @MyDocumentedAnnotation 어노테이션이 포함된다는 내용이 문서화됩니다.

/**
 * 이 메서드는 예제 메서드입니다.
 *
 * @param param 예제 매개변수
 * @MyDocumentedAnnotation(value = "Example annotation")
 */
public void myMethod(String param) {
    // 메서드 내용
}

4-2 요약

@Documented 어노테이션은 어노테이션이 Javadoc 문서에 포함되도록 지정합니다.
이는 API 문서를 작성할 때 어노테이션의 의미와 사용 방법을 문서에 포함시켜 사용자에게 제공하는 데 유용합니다.

5. 어노테이션 프로세서

Java 어노테이션 프로세서(Annotation Processor)는 컴파일러가 소스 코드를 컴파일하는 동안 어노테이션을 처리할 수 있는 도구입니다.

어노테이션 프로세서를 사용하면 컴파일 타임에 어노테이션을 분석하고, 소스코드를 생성하거나 검증 작업을 수행할 수 있습니다. 이를 통해 코드의 유지보수성과 생산성을 높일 수 있습니다.

5-1 어노테이션 프로세서의 동작 원리

어노테이션 프로세서는 컴파일러 API를 사용하여 특정 어노테이션이 적용된 코드를 분석하고, 이에 따라 추가적인 작업을 수행합니다. 주요 단계는 아래와 같습니다.

1. 어노테이션 프로세서 정의 어노테이션 프로세서 클래스를 정의하고 javax.annotation.processing.Processor 인터페이스를 구현합니다.

2. 어노티이션 프로세서 등록 META-INF/service/javax.annotation.processing.Processor 파일에 어노테이션 프로레서 클래스 이름을 등록합니다.

3. 어노테이션 프로세서 실행 컴파일 시 컴파일러가 어노테이션 프로세서를 자동으로 실행하여 어노테이션을 처리합니다.

5-2 어노테이션 프로레서 구현 예제

이 예제에서는 @MyAnnotation 어노테이션이 적용된 클래스의 정보를 출력하는 어노테이션 프로세서를 작성합니다.

*어노테이션 정의 * 먼저, @MyAnnotation 어노테이션을 정의합니다.

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
    String value();
}

어노테이션 프로세서 구현 다음으로, @MyAnnotation 어노테이션을 처리하는 어노테이션 프로세서를 구현합니다.

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import java.util.Set;

@SupportedAnnotationTypes("MyAnnotation")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class MyAnnotationProcessor extends AbstractProcessor {

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
    }

    @Override
    public boolean process(Set annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            MyAnnotation annotation = element.getAnnotation(MyAnnotation.class);
            System.out.println("Found @MyAnnotation with value: " + annotation.value());
        }
        return true; // 어노테이션이 처리되었음을 표시
    }
}

어노테이션 프로세서 등록 META-INF/services/javax.annotation.processing.Processor파일을 생성하고, 어노테이션 프로세서 클래 이름 등록을 합니다.

MyAnnotationProcessor

어노테이션 프로세서 사용 이제 @MyAnnotation 어노테이션을 사용하여 클래스를 작성하고 컴파일하면 어노테이션 프로세서가 실행됩니다.

@MyAnnotation(value = "Hello, World!")
public class MyClass {
    public static void main(String[] args) {
        // 메인 메서드 내용
    }
}

5-3 주요 클래스와 인터페이스

AbstractProcessor Processor 인터페이스의 기본 구현을 제공하는 추상 클래스입니다. 어노테이션 프로세서를 작성할 때 주로 이 클래스를 확장합니다.
ProcessingEnvironment 어노테이션 프로세서 환경을 제공하는 인터페이스로, 필수 유틸리티 메서드와 메시지 출력을 지원합니다.
RoundEnvironment 현재 프로세스 라운드에 대한 정보를 제공하는 인터페이스로, 어노테이션이 적용된 요소들을 탐색할 수 있습니다.

5-4 요약

어노테이션 프로세서는 컴파일 타임에 어노테이션을 처리하여 추가적인 작업을 수행합니다.
어노테이션 프로세서를 정의하려면 AbstractProcessor 클래스를 확장하고, 필요한 메서드를 구현해야 합니다.
어노테이션 프로세서를 등록하려면 META-INF/services/javax.annotation.processing.Processor 파일에 프로세러 클래스를 등록해야 합니다.

Enum

Wed, 26 Jun 2024 13:34:01 GMT

목표

Java의 열거형에 대해 학습

1. enum 정의하는 방법

Java에서 enum(열거형)은 상수의 집합을 정의하는 특수한 데이터 타입입니다. enum을 사용하면 코드의 가독성을 높이고, 특정 값들만 사용할 수 있도록 제한할 수있습니다.

1-1 기본적인 enum의 정의

바로 코드를 통해 알아보겠습니다.

public enum Day {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("오늘은: " + today);

        switch (today) {
            case MONDAY:
                System.out.println("월요일입니다.");
                break;
            case TUESDAY:
                System.out.println("화요일입니다.");
                break;
            // 다른 요일에 대한 처리...
            default:
                System.out.println("다른 요일입니다.");
                break;
        }
    }
}

이렇게 정의된 enum을 사용할 때는 위와 같이 사용할 수 있습니다.

1-2 enum에 멤버 변수와 메서드 추가

enum은 단순히 상수 값만 가질 수 있는 것이 아니라, 멤버 변수와 메서드도 추가할 수 있습니다. 예를 들어 각 요일에 대한 간단한 설명을 추가해 보겠습니다.

public enum Day {
    SUNDAY("휴일"),
    MONDAY("평일"),
    TUESDAY("평일"),
    WEDNESDAY("평일"),
    THURSDAY("평일"),
    FRIDAY("평일"),
    SATURDAY("휴일");

    private String description;

    Day(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.SUNDAY;
        System.out.println("오늘은: " + today);
        System.out.println("설명: " + today.getDescription());
    }
}

1-3 enum에 추상 메서드 추가

enum에 추상 메서드를 추가하고 각 열거형 값에서 이를 구현할 수 있습니다. 예를 들어 각 요일에 따라 다른 행동을 정의해보겠습니다.

public enum Day {
    SUNDAY {
        @Override
        public void action() {
            System.out.println("휴식을 취합니다.");
        }
    },
    MONDAY {
        @Override
        public void action() {
            System.out.println("일을 합니다.");
        }
    },
    TUESDAY {
        @Override
        public void action() {
            System.out.println("일을 합니다.");
        }
    },
    WEDNESDAY {
        @Override
        public void action() {
            System.out.println("일을 합니다.");
        }
    },
    THURSDAY {
        @Override
        public void action() {
            System.out.println("일을 합니다.");
        }
    },
    FRIDAY {
        @Override
        public void action() {
            System.out.println("일을 합니다.");
        }
    },
    SATURDAY {
        @Override
        public void action() {
            System.out.println("휴식을 취합니다.");
        }
    };

    public abstract void action();
}

public class Main {
    public static void main(String[] args) {
        Day today = Day.FRIDAY;
        today.action();  // "일을 합니다." 출력
    }
}

요약

enum은 상수의 집합을 정의하는 특수한 데이터 타입입니다.
enum에 멤버 변수와 메서드를 추가할 수 있습니다.
enum에 추상 메서드를 추가하고 각 열거형 값에서 이를 구현할 수 있습니다.

2. enum이 제공하는 메소드(values()와 valueOf())

enum은 자동으로 valuse()와 valueOf(String name) 메서드를 제공합니다.

2-1 values() 메서드

values() 메서드는 해당 enum 타입의 모든 열거형 상수들을 배열로 반환합니다. 이 메서드는 컴파일러가 자동으로 추가하는 메서드로, 모든 enum 타입에서 사용할 수 있습니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class Main {
    public static void main(String[] args) {
        Day[] days = Day.values();

        for (Day day : days) {
            System.out.println(day);
        }
    }
}

// 출력
// SUNDAY
// MONDAY
// TUESDAY
// WEDNESDAY
// THURSDAY
// FRIDAY
// SATURDAY

위 예제를 보면 알 수 있듯이, Day.values()는 Day 열거형 타입의 모든 상수를 배열로 반환합니다. 이 배열을 반복하여 모든 상수를 출력할 수 있습니다.

2-2 valueOf(String name) 메서드

valueOf(String name) 메서드는 주어진 문자열과 일치하는 enum 상수를 반환합니다. 이 메서드는 java.lang.Enum 클래스에 정의되어 있으며, 문자열이 일치하는 enum 상수가 없으면 IllegalArgumentException을 던집니다. 문자열은 대소문자를 구분합니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class Main {
    public static void main(String[] args) {
        Day day = Day.valueOf("MONDAY");
        System.out.println(day);

        // 만약 문자열이 열거형 상수와 일치하지 않으면 예외가 발생합니다.
        try {
            Day invalidDay = Day.valueOf("FUNDAY");
        } catch (IllegalArgumentException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }
}

위 예제 코드의 출력은 아래와 같습니다.

MONDAY
예외 발생: No enum constant Main.Day.FUNDAY

위 예제에서 Day.valueOf("MONDAY")는 Day.MONDAY 상수를 반환합니다. 하지만, "FUNDAY"는 Day 열거형에 없는 타입이므로 IllegalArgumentException이 발생합니다.

요약

values() 메서드 : 해당 enum 타입의 모든 상수를 배열로 반환합니다.
valueOf(String name) 메서드 : 주어진 문자열과 일치하는 enum 상수를 반환하며, 일치하는 상수가 없으면 IllegalArgumentException을 던집니다.

3. java.lang.Enum

java.lang.Enum 클래스는 자바에서 모든 enum 타입의 공통적인 상위 클래스입니다. 이 클래스는 enum 타입을 보다 유용하게 만들기 위해 다양한 메서드와 기능을 제공합니다.

Enum 클래스는 제네릭 클래스이며, Enum>로 정의되어 있습니다. 이는 모든 enum 타입이 이 클래스를 상속받아야 함을 의미합니다.

3-1 name()

name() 메서드는 열거형 상수의 이름을 반환합니다. 이 이름은 열거형 상수가 선언된 그대로의 문자열입니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY
}

public class Main {
    public static void main(String[] args) {
        Day day = Day.MONDAY;
        System.out.println(day.name());  // "MONDAY" 출력
    }
}

3-2 ordinal()

ordinal() 메서드는 열거형 상수가 열거형 선언에서 정의된 순서를 반환합니다. 순서는 0부터 시작합니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY
}

public class Main {
    public static void main(String[] args) {
        Day day = Day.MONDAY;
        System.out.println(day.ordinal());  // 1 출력
    }
}

3-3 compareTo(E o)

compareTo(E o) 메서드는 현재 열거형 상수와 주어진 열거형 상수를 비교합니다. 열거형 상수의 정의 순서에 따라 비교하며, 이 순서에 기반하여 정렬에 사용할 수 있습니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY
}

public class Main {
    public static void main(String[] args) {
        Day day1 = Day.MONDAY;
        Day day2 = Day.TUESDAY;
        System.out.println(day1.compareTo(day2));  // -1 출력
    }
}

3-4 toString()

toString() 메서드는 열거형 상수의 이름을 반환합니다. name() 메서드와 동일한 결과를 반환합니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY
}

public class Main {
    public static void main(String[] args) {
        Day day = Day.MONDAY;
        System.out.println(day.toString());  // "MONDAY" 출력
    }
}

3-5 `valueOf(Class enumType, String name)`

valueOf(Class enumType, String name) 메서드는 주어진 클래스 객체와 문자열을 사용하여 열거형 상수를 반환합니다. 주어진 이름과 일치하는 열거형 상수가 없으면 IllegalArgumentException을 던집니다.

public enum Day {
    SUNDAY, MONDAY, TUESDAY
}

public class Main {
    public static void main(String[] args) {
        Day day = Enum.valueOf(Day.class, "MONDAY");
        System.out.println(day);  // "MONDAY" 출력
    }
}

Enum 클래스의 구조

java.lang.Enum 클래스의 기본 구조는 다음과 같습니다.

public abstract class Enum> implements Comparable, Serializable {
    private final String name;
    private final int ordinal;

    // 기본 생성자
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

    // 기타 메서드...
}

요약

모든 enum 타입의 공통적인 상위 클래스 Enum클래스는 모든 enum 타입이 자동으로 상속받는 클래스입니다.
이름과 순서 Enum 클래스는 각 열거형 상수의 이름과 순서를 저장합니다.
비교와 정렬 compareTo()메서드를 통해 열거형 상수 간의 비교와 정렬이 가능합니다.
직렬화 가능 Enum 클래스는 Serializable 인터페이스를 구현하여 열거형 상수가 직렬화 가능함을 보장합니다.
유용한 메서드 제공 name(), ordinal(), valueOf() 등 다양한 유용한 메서드를 제공합니다.

4. EnumSet

EnumSet은 자바에서 enum 타입의 상수를 저장하기 위해 특별히 설계된 집합(Set) 구현체입니다.

EnumSet은 일반적인 Set과는 다르게 성능 최적화 및 메모리 절약을 위해 특별한 내부 구조를 가지고 있습니다. EnumSet은 java.util 패키지에 속해 있으며, enum 상수 집합을 다룰 때 매우 유용합니다.

특징

enum 타입 전용 EnumSet은 특정 enum 타입의 상수들만 저장할 수 있습니다.
효율적이고 빠름 비트 백터(bit vector)로 내부적으로 구현되어 있어 메모리 사용이 적고 매우 빠릅니다.
정렬 저장된 요소들은 enum 상수가 정의된 순서대로 정렬됩니다.
불변 객체 EnumSet 자체는 변경 가능하지만, enum 상수는 불변 객체이므로 추가나 제거 시 항상 안전하게 작동합니다.

4-1 사용방법

EnumSet을 생성하는 방법은 아주 다양합니다.

`allOf()`

특정 enum 타입의 모든 상수를 포함하는 EnumSet을 생성합니다.

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

EnumSet allDays = EnumSet.allOf(Day.class);

`nonOf()`

비어있는 EnumSet을 생성합니다.

EnumSet noDays = EnumSet.noneOf(Day.class);

`of()`

하나 이상의 특정 enum 상수를 포함하는 EnumSet을 생성합니다.

EnumSet weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);

`range()`

두 enum 상수 사이의 범위를 포함하는 EnumSet을 생성합니다.

EnumSet workdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);

`copyOf()`

다른 컬렉션을 복사하여 EnumSet을 생성합니다.

Set someDays = EnumSet.of(Day.MONDAY, Day.WEDNESDAY);
EnumSet copiedDays = EnumSet.copyOf(someDays);

4-2 `EnumSet`의 메서드

EnumSet은 Set 인터페이스를 구현하므로 일반적인 Set 메서드들을 사용할 수 있습니다.

public class Main {
    public static void main(String[] args) {
        EnumSet weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);

        // 요소 추가
        weekend.add(Day.FRIDAY);
        System.out.println("주말과 금요일: " + weekend);

        // 요소 제거
        weekend.remove(Day.FRIDAY);
        System.out.println("주말: " + weekend);

        // 포함 여부 확인
        boolean isWeekend = weekend.contains(Day.SUNDAY);
        System.out.println("일요일이 포함되어 있는가? " + isWeekend);

        // 반복
        for (Day day : weekend) {
            System.out.println(day);
        }
    }
}

출력은 아래와 같습니다.

주말과 금요일: [FRIDAY, SATURDAY, SUNDAY]
주말: [SATURDAY, SUNDAY]
일요일이 포함되어 있는가? true
SATURDAY
SUNDAY

4-3 활용 예시

EnumSet은 특정 enum 값들의 집합을 관리할 때 유용합니다. 예를 들어, 권한이나 상태를 관리하는데 사용할 수 있습니다.

enum Permission {
    READ, WRITE, EXECUTE
}

public class Main {
    public static void main(String[] args) {
        EnumSet permissions = EnumSet.of(Permission.READ, Permission.WRITE);

        // 권한 추가
        permissions.add(Permission.EXECUTE);

        // 권한 확인
        if (permissions.contains(Permission.WRITE)) {
            System.out.println("쓰기 권한이 있습니다.");
        }

        // 권한 제거
        permissions.remove(Permission.READ);
        System.out.println("권한: " + permissions);
    }
}

출력은 아래와 같습니다.

쓰기 권한이 있습니다.
권한: [WRITE, EXECUTE]

요약

EnumSet은 특정 enum 타입의 상수를 저장하기 위한 효율적이고 메모리 절약형 집합입니다.
EnumSet은 enum 상수의 순서를 유지하고, 다양한 유용한 메서드를 제공합니다.
다양한 생성 방법과 Set 인터페이스의 메서드들을 통해 쉽게 사용할 수 있습니다.

멀티쓰레드 프로그래밍

Thu, 20 Jun 2024 09:41:58 GMT

목표

자바의 멀티 쓰레드 프로그래밍에 대해 학습

1. Thread 클래스와 Runnable 인터페이스

1-1 Thread 클래스

Thread 클래스는 자바에서 스레드를 생성하고 제어할 수 있게 해주는 클래스입니다. 스레드는 프로그램 내에서 독립적으로 실행될 수 있는 작은 단위의 작업을 말합니다.

** 사용방법 **

Thread 클래스를 상속받아 새로운 클래스를 정의하고, run 메서드를 오버라이드하여 실행할 코드를 작성합니다.
Thread 객체를 생성한 후 start 메서드를 호출하면, 새로운 스레드가 시작되고 run 메서드 내의 코드가 실행됩니다.

class MyThread extends Thread {
    public void run() {
        // 스레드에서 실행할 코드
        System.out.println("스레드 실행 중...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  
        // 새로운 스레드를 시작
    }
}

1-2 Runnable 인터페이스

Runnable 인터페이스는 스레드로 실행할 작업을 정의하는 데 사용됩니다.

Runnable 인터페이스를 구현한 클래스는 run 메서드를 오버라이드해야 합니다. Runnable은 스레드를 생성하는 Thread 클래스와 함께 사용됩니다.

** 사용방법 **

Runnable 인터페이스를 구현하는 클래스를 정의하고, run 메서드를 오버라이드하여 실행할 코드를 작성합니다.
Thread 객체를 생성할 때 Runnable 객체를 전달하고, start 메서드를 호출하여 스레드를 시작합니다.

class MyRunnable implements Runnable {
    public void run() {
        // 스레드에서 실행할 코드
        System.out.println("Runnable 실행 중...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();  // 새로운 스레드를 시작
    }
}

차이점

Thread 클래스는 스레드를 생성하고 제어하는 기능을 포함하고 있고, 이 클래스를 상속받으면 다른 클래스를 상속받을 수 없습니다. 자바는 단일 상속만 지원하기 때문입니다.

Runnable 인터페이스는 스레드로 실행할 작업만을 정의하며, 클래스를 다른 클래스에서 상속받는 것이 가능합니다. 이렇게 하면 보다 유연하게 코드를 작성할 수 있습니다.

✨ Thread Vs Runnable

보통 Runnable 인터페이스를 구현하여 사용하는 방법이 더 많이 권장됩니다. 이렇게 하면 스레드와 실행 로직을 분리할 수 있고, 더 유연하고 재사용 가능한 코드를 작성할 수 있습니다.

** 왜 Runnable이 더 나은 선택일까? **

단일 상속의 제약 회피 자바는 단일 상속만 지원하므로, Thread 클래스를 상속받으면 다른 클래스를 상속받을 수 없습니다. 반면, Runnable 인터페이스는 다른 클래스를 상속받으면서 동시에 구현할 수 있습니다.
유연한 설계 Runnable 인터페이스를 사용하면 실행 로직을 정의하는 클래스와 스레드 실행을 관리하는 클래스를 분리할 수 있습니다. 이렇게 하면 코드의 모듈성이 높아지고 재사용성이 증가합니다.

결론적으로, Runnable 인터페이스를 사용하면 코드의 유연성과 재사용성이 높아지고, 불필요한 중복을 줄일 수 있습니다.

** Thread를 사용하는 경우 **

Thread 클래스의 메서드를 오버라이드할 필요가 있는 경우 Thread 클래스에는 run 메서드 외에도 여러 가지 메서드가 있습니다. 이 중 특정 메서드를 오버라이드하여 고유한 기능을 추가하고자 할 때 Thread 클래스를 상속받을 수 있습니다.
Thread의 일부 기능을 변경해야 하는 경우 Thread 클래스의 특정 기능을 변경하거나 확장해야 할 때도 상속이 필요할 수 있습니다.

예시는 아래와 같습니다.

class CustomThread extends Thread {
    private static int threadCount = 0;
    private int threadID;

    public CustomThread() {
        threadID = ++threadCount;
    }

    @Override
    public void run() {
        System.out.println("Thread " + threadID + " 시작");
        // 실행할 로직
        try {
            Thread.sleep(1000);  // 스레드 실행 중인 척
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread " + threadID + " 종료");
    }

    @Override
    public void start() {
        System.out.println("Thread " + threadID + " 준비 중...");
        super.start();
    }
}

public class Main {
    public static void main(String[] args) {
        CustomThread thread1 = new CustomThread();
        CustomThread thread2 = new CustomThread();

        thread1.start();
        thread2.start();
    }
}

위 코드처럼 쓰레드가 시작될 때마다 고유한 ID를 부여하고, 종료될 때 로그를 출력하도록 커스텀 할 수 있습니다.

2. 쓰레드의 상태

Java의 쓰레드는 여러 가지 상태를 가질 수 있으며, 각 상태는 쓰레드가 실행중 어떤 단계에 있는지를 나타냅니다.

Thread 클래스에는 쓰레드 상태를 나타내는 State 열거형이 정의되어 있습니다.

New 쓰레드가 생성되었지만, start 메서드가 호출되지 않은 상태입니다.
RUNNABLE 쓰레드가 실행 가능한 상태입니다. 자바 가상 머신(JVM)에서는 이 상태를 RUNNING 상태와 구별하지 않습니다.
BLOCKED 쓰레드가 동기화 블록에 들어가기 위해 대기하고 있는 상태입니다.
WAITING 쓰레드가 다른 쓰레드가 특정 작업을 완료할 때까지 대기하고 있는 상태입니다. Object.wait() 메서드나 Thread.join() 메서드, LockSupport.park() 메서드를 호출하여 이 상태로 진입할 수 있습니다.
TIMED_WAITING 쓰레드가 일정 시간 동안 기다리는 상태입니다. Thread.sleep(), Object.wait(long timeout), Thread.join(long millis), LockSupport.parkNanos(long nanos), LockSupport.parkUntil(long deadline) 메서드를 호출하여 이 상태로 진입할 수 있습니다.
TERMINATED 쓰레드가 실행을 마친 상태입니다. run 메서드가 종료되거나 예외로 인해 쓰레드가 종료된 경우 이 상태가 됩니다.

상태확인 예제

Java에서는 Threada.getState() 메서드를 사용하여 쓰레드의 현재 상태를 확인할 수 있습니다.

public class ThreadStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        System.out.println("스레드 상태: " + thread.getState());  
        // NEW 상태
        thread.start();
        System.out.println("스레드 상태: " + thread.getState());  
        // RUNNABLE 상태

        Thread.sleep(500);
        System.out.println("스레드 상태: " + thread.getState());  
        // TIMED_WAITING 상태

        thread.join();
        System.out.println("스레드 상태: " + thread.getState());  
        // TERMINATED 상태
    }
}

3. 쓰레드의 우선순위

쓰레드에는 우선순위가 있습니다. 이 우선선위는 쓰레드가 실행될 순서를 결정하는데 사용됩니다. 우선순위는 1부터 10까지의 정수 값으로 설정할 수 있으며, 기본 우선순위는 5입니다.

우선순위 상수

Thread.MIN_PRIORITY (1) : 최소 우선순위
Thread.NORM_PRIORITY (5) : 기본 우선순위
Thread.MAX_PRIORITY (10) : 최대 우선순위

예제

class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + " 실행 중, 우선순위: " + getPriority());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("Thread1");
        MyThread thread2 = new MyThread("Thread2");
        MyThread thread3 = new MyThread("Thread3");

        thread1.setPriority(Thread.MIN_PRIORITY);  // 우선순위 1
        thread2.setPriority(Thread.NORM_PRIORITY); // 우선순위 5
        thread3.setPriority(Thread.MAX_PRIORITY);  // 우선순위 10

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

위 코드에서 Thread1, Thread2, Thread3는 각각 다른 우선순위를 가집니다. 우선순위가 높을수록 쓰레드가 더 자주 실행될 가능성이 있지만, 이는 운영체제의 스케줄러에 따라 다를 수 있습니다.

우선순위의 한계

플랫폼 의존적 Java 쓰레드 스케줄링은 운영체제에 따라 다릅니다. 일부 운영체제에서는 우선순위가 제대로 반영되지 않을 수 있습니다.
비보장성 우선순위는 쓰레드의 실행 순서를 보장하지 않습니다. 쓰레드 스케줄러가 항상 높은 우선순위의 쓰레드를 먼저 실행하는 것은 아닙니다.
복잡성 증가 우선순위 기반 스케줄링은 프로그램의 복잡성을 증가시키며, 잘못 사용하면 예상치 못한 결과를 초래할 수 있습니다.

결론

쓰레드 우선순위는 쓰레드의 실행 순서를 결정하는 데 도움을 줄 수 있지만, 운영체제와 자바 런타임의 스케줄러에 따라 다르게 동작할 수 있습니다. 따라서 우선순위는 보조적인 수단으로 사용하고, 주요 논리 흐름은 다른 방식으로 제어하는것이 좋습니다.

4. Main 쓰레드

Java 프로그램이 실행될 때, Java 런타임 환경(JRE)은 기본적으로 하나의 쓰레드를 생성하여 프로그램을 시작합니다. 이 쓰레드를 Main Thread라고 합니다.

메인 쓰레드는 main 메서드를 실행하는 쓰레드로, 모든 자바 프로그램은 메인 쓰레드로 부터 시작됩니다.

메인 쓰레드의 역할

프로그램 시작 메인 쓰레드는 프로그램이 시작될 때 main 메서드를 실행합니다.
다른 쓰레드 생성 메인 쓰레드는 필요에 따라 추가로 생성되는 다른 쓰레드의 부모 쓰레드가 됩니다. 새로운 쓰레드가 생성되면 메인 쓰레드가 해당 쓰레드를 시작할 수 있습니다.
프로그램 종료 메인 쓰레드가 종료되면 프로그램이 종료됩니다. 단, 다른 사용자 정의 쓰레드가 실행 중인 경우에는 그 쓰레드들이 모두 종료될때까지 프로그램이 계속 실행됩니다.

메인 쓰레드와 쓰레드 관리

메인 쓰레드도 다른 일반 쓰레드처럼 관리할 수 있습니다. 예를 들어, 메인 쓰레드의 우선순위를 변경하거나 메인 쓰레드의 상태를 확인할 수 있습니다.

public class MainThreadExample {
    public static void main(String[] args) {
        // 현재 실행 중인 쓰레드 얻기 (메인 쓰레드)
        Thread mainThread = Thread.currentThread();

        // 메인 쓰레드의 이름 출력
        System.out.println("메인 쓰레드 이름: " + mainThread.getName());

        // 메인 쓰레드의 우선순위 출력
        System.out.println("메인 쓰레드 우선순위: " + mainThread.getPriority());

        // 메인 쓰레드의 우선순위 변경
        mainThread.setPriority(Thread.MAX_PRIORITY);
        System.out.println("변경된 메인 쓰레드 우선순위: " + mainThread.getPriority());

        // 메인 쓰레드가 종료되기 전에 다른 작업 수행
        for (int i = 0; i < 5; i++) {
            System.out.println("메인 쓰레드 작업: " + i);
        }

        // 메인 쓰레드가 종료되면 프로그램이 종료됨
        System.out.println("메인 쓰레드 종료");
    }
}

메인 쓰레드의 종료와 프로그램 종료

메인 쓰레드가 종료되면, JVM은 다른 실행 중인 사용자 정의 쓰레드가 있는지 확인합니다.

만약 다른 모든 사용자 정의 쓰레드가 종료된 상태라면 JVM은 프로그램을 종료합니다.

하지만, 다른 사용자 정의 쓰레드가 실행 중이라면 그 쓰레드들이 모두 종료될 때까지 프로그램은 계속 실행됩니다.

public class MainThreadExample {
    public static void main(String[] args) {
        // 새로운 쓰레드 생성 및 시작
        Thread newThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("새로운 쓰레드 작업: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("새로운 쓰레드 종료");
        });

        newThread.start();

        // 메인 쓰레드 작업
        for (int i = 0; i < 3; i++) {
            System.out.println("메인 쓰레드 작업: " + i);
        }
        System.out.println("메인 쓰레드 종료");
    }
}

5. 동기화

동기화는 여러 쓰레드가 동시에 공유 자원에 접근할 때 발생할 수 있는 문제를 방지하기 위한 방법입니다.

동기화를 통해 하나의 쓰레드만이 공유 자원에 접근하도록 보장할 수 있습니다.

이를 통해 데이터의 일관성과 무결성을 유지할 수 있습니다.

동기화의 필요성

멀티쓰레딩 환경에서는 여러 쓰레드가 동시에 공유 자원(변수, 객체 등)에 접근하고 수정할 수 있습니다. 이로 인해 아래와 같은 문제가 발생할 수 있습니다.

데이터 일관성 문제 여러 쓰레드가 동시에 데이터를 읽고 쓰는 경우, 데이터의 일관성이 깨질 수 있습니다.
데드락(Deadlock) 두 개 이상의 쓰레드가 서로의 자원을 기다리며 무한 대기에 빠지는 현상입니다.
레이스 컨디션(Race Condition) 여러 쓰레드가 동시에 자원에 접근할 때 발생하는 문제로, 쓰레드들이 경쟁적으로 자원에 접근하여 예기치 않은 결과를 초래할 수 있습니다.

동기화 방법

Java에서는 synchronized 키워드를 사용하여 동기화를 구현할 수 있습니다. 동기화 방법에는 두 가지 주요 방법이 있습니다. 바로 메서드 동기화와 블록 동기화입니다.

** 1. 메서드 동기화 ** 메서드에 synchronized 키워드를 붙여서 동기화할 수 있습니다. 이렇게 하면 메서드가 호출될 때 해당 메서드의 객체에 대해 락(Lock)을 획득하게 되어, 다른 쓰레드가 이 메서드를 호출하려면 락을 해제할 때까지 기다려야 합니다.

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());  // 2000
    }
}

** 2. 블록 동기화 ** 특정 코드 블록만 동기화할 수도 있습니다. 이 방법은 필요하지 않은 경우 전체 메서드를 동기화하는 대신, 특정 코드 블록만 동기화할 수 있어서 효율적입니다.

class Counter {
    private int count = 0;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());  // 2000
    }
}

주의 사항

성능 저하 동기화는 성능을 저하시킬 수 있습니다. 동기화된 메서드나 블록은 동시에 하나의 쓰레드만 접근할 수 있으므로 병렬 처리를 제한할 수 있습니다.
데드락 동기화된 코드에서 여러 락을 사용하다 보면 데드락이 발생할 수 있습니다. 데드락을 피하기 위해서는 락을 획득하는 순서를 일관되게 유지해야 합니다.
대기 시간 동기화된 메서드나 블록에서 오랜 시간 동안 작업을 수행하면 다른 쓰레드가 오랫동안 대기해야 할 수 있습니다. 이를 피하기 위해 가능한 짧은 코드 블록을 동기화하는 것이 좋습니다.

6. 데드락

데드락(Deadlock)은 멀티쓰레드나 멀티프로세스 환경에서 발생할 수 있는 심각한 문제입니다.

데드락은 두 개 이상의 쓰레드나 프로세스가 서로 필요로 하는 자원을 무한히 기다리며 진행이 멈춘 상태를 말합니다.

각 쓰레드는 다음과 같은 조건을 만족할때 데드락에 빠집니다.

상호 배제(Mutual Exclusion) 자원은 한 번에 하나의 쓰레드나 프로세스만 사용할 수 있어야 합니다.
점유와 대기(Hold and Wait) 최소한 하나의 자원을 점유하고 있는 상태에서 다른 쓰레드나 프로세스가 점유하고 있는 자원을 기다려야 합니다.
비선점(No Preemption) 다른 쓰레드나 프로세스가 이미 점유한 자원을 강제로 빼앗아 사용할 수 없어야 합니다.
순환 대기(Circular Wait) 쓰레드나 프로세스 사이에 무한 순환 형태로 자원을 요구하는 사이클이 형성되어야 합니다.

데드락 예제

class SharedResource {
    synchronized void method1(SharedResource resource) {
        System.out.println(Thread.currentThread().getName() + " 메서드 1 실행");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 메서드 1에서 method2 호출");
        resource.method2(this);
        System.out.println(Thread.currentThread().getName() + " 메서드 1 실행 완료");
    }

    synchronized void method2(SharedResource resource) {
        System.out.println(Thread.currentThread().getName() + " 메서드 2 실행");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 메서드 2에서 method1 호출");
        resource.method1(this);
        System.out.println(Thread.currentThread().getName() + " 메서드 2 실행 완료");
    }
}

public class DeadlockExample {
    public static void main(String[] args) {
        final SharedResource resource1 = new SharedResource();
        final SharedResource resource2 = new SharedResource();

        Thread thread1 = new Thread(() -> {
            resource1.method1(resource2);
        });

        Thread thread2 = new Thread(() -> {
            resource2.method2(resource1);
        });

        thread1.start();
        thread2.start();
    }
}

위 예제에서 SharedResource 클래스는 두 개의 메서드 method1과 method2를 가지고 있습니다.

각 메서드는 synchronized 키워드로 동기화 되어 있어, 한 번에 하나의 쓰레드만이 접근할 수 있습니다. 그러나 두 쓰레드가 서로의 자원을 동시에 점유하려고 하고 있습니다. 따라서 이 예제는 데드락에 빠질 가능성이 높습니다.

데드락 방지 및 해결 방법

상호 배제 원칙 사용 최소화 락을 최소한으로 사용하고, 필요한 경우만 사용합니다.
락의 순서 여러 자원을 사용할 때 일관된 순서로 락을 획득하도록 합니다.
시간 제한 자원을 얻기 위한 대기 시간을 제한합니다. 일정 시간 내에 자원을 얻지 못한다면 다시 시도하거나 포기합니다.
락을 해제 락을 오랫동안 유지하지 않고 가능한 빨리 해제합니다.
데드락 탐지 및 복구 시스템이 데드락을 탐지하고, 탐지되면 적절히 복구할 수 있는 방법을 구현합니다.

예외 처리

Fri, 14 Jun 2024 08:25:44 GMT

목표

자바의 예외 처리에 대해 학습

1. 자바에서 예외 처리 방법

Java에서 예외 처리는 프로그램 실행 중 발생하는 예외 상황을 적절히 처리하여 프로그램이 갑작스럽게 종료되는 것을 방지하고, 사용자에게 유의미한 에러 메시지를 제공하며, 프로그램의 정상적인 흐름을 유지하기 위해 사용됩니다.

Java에서는 예외 처리를 위해 try, catch, finally, throw, throws 키워드를 사용합니다.

1-1 예외의 종류

Checked Exception 컴파일러가 예외 처리를 강제하는 예외입니다. 주로 외부 자원(파일, 네트워크 등)을 다룰 때 발생합니다. Ex) IOException, SQLException
Unchecked Exception 컴파일러가 예외 처리를 강제하지 않는 예외입니다. 주로 프로그래머의 실수로 발생합니다. Ex) NullPointerException, ArrayIndexOutOfBoundsException
Error 시스템 수준에서 발생하는 심각한 오류로, 보통 애플리케이션에서 처리하지 않습니다. Ex) OutOfMemoryError

아래에서 좀 더 자세하게 설명하겠습니다.

1-2 예외 처리 키워드

try-catch

예외가 발생할 수 있는 코드를 try 블록에 넣고, 예외가 발생했을 떄의 처리를 catch블록에 넣습니다.

try {
    // 예외가 발생할 수 있는 코드
} catch (예외타입 변수이름) {
    // 예외 처리 코드
}

예제

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; 
            // 여기서 ArithmeticException 발생
        } catch (ArithmeticException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }
}

위 예제에서 10 / 0 연산으로 ArithmeticException이 발생하며, catch 블록에서 이를 처리합니다.

finally

try 블록에서 예외가 발생하든 발생하지 않든 항상 실행되는 블록입니다. 주로 자원해제에 사용됩니다.

try {
    // 예외가 발생할 수 있는 코드
} catch (예외타입 변수이름) {
    // 예외 처리 코드
} finally {
    // 항상 실행되는 코드
}

예제

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("예외 발생: " + e.getMessage());
        } finally {
            System.out.println("finally 블록 실행");
        }
    }
}

앞서 설명한것과 같이 finally는 예외 발생 여부와 관계없이 항상 실행됩니다.

throw

프로그램의 특정 시점에서 예외를 직접 발생시킬 때 사용합니다.

public class ThrowExample {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (IllegalArgumentException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }

    public static void validateAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("나이는 18 이상이어야 합니다.");
        }
    }
}

위 예제에서 validateAge 메서드는 나이가 18 미만일 경우 IllegalArgumentException을 발생시킵니다.

throws

메서드 선언부에 사용하여 해당 메서드가 특정 예외를 던질 수 있음을 선언합니다. 주로 CheckedException에 사용됩니다.

throws를 통해 컴파일러가 예외 처리 여부를 검증할 수 있게 합니다.

public class ThrowsExample {
    public static void main(String[] args) {
        try {
            checkFile();
        } catch (IOException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }

    public static void checkFile() throws IOException {
        FileReader file = new FileReader("nonexistentfile.txt");
    }
}

위 예제에서 checkFile 메서드는 FileReader 객체를 생성할때 IOException을 던질 수 있음을 throws 키워드를 통해 선언합니다.

✨ throws와 throw의 차이

throws : 메서드 선언부에 사용되며, 해당 메서드가 어떤 예외를 던질 수 있는지 선언합니다.
throw : 메서드 본문 내에서 사용되며, 실제로 예외를 던질 때 사용됩니다.

✨ throws의 예외 전파

메서드가 예외를 처리하지 않고 호출한 메서드로 예외를 전파할 수 있습니다. 호출한 메서드에서 예외를 처리해야 합니다!

import java.io.IOException;

public class ExceptionPropagationExample {
    public static void main(String[] args) {
        try {
            method1();
        } catch (IOException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }

    public static void method1() throws IOException {
        method2();
    }

    public static void method2() throws IOException {
        throw new IOException("파일을 읽을 수 없습니다.");
    }
}

method2는 IOException을 던지고, method1은 이를 처리하지 않고 throws IOException을 통해 예외를 전파합니다. main메서드에서 최종적으로 예외를 처리합니다.

이와 같이 throws 키워드를 사용하면 메서드가 던질 수 있는 예외를 명시적으로 선언할 수 있으며, 호출한 메서드에서 예외를 처리하거나, 다시 전파할 수 있습니다.

사용자 정의 예외

기본 제공 예외 클래스 외에 사용자가 정의한 예외를 만들 수 있습니다. 사용자 정의 예외는 Exception 클래스를 상속하여 생성합니다.

class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomException {
        if (age < 18) {
            throw new CustomException("나이는 18 이상이어야 합니다.");
        }
    }
}

CustomException은 사용자 정의 예외로, 나이가 18 미만일 경우, validateAge 메서드에서 CustomException을 던집니다.

2. 자바가 제공하는 예외 계층 구조

Java에서 제공하는 예외 계층 구조는 예외를 체계적으로 관리하고 처리하기 위해 설계되었습니다. 예외 계층 구조는 크게 Throwable 클래스를 기반으로 두 가지 분류인 Error와 Exceprion 클래스로 나뉩니다.

java.lang.Object
   └── java.lang.Throwable
         ├── java.lang.Error
         └── java.lang.Exception
              ├── java.lang.RuntimeException
              └── 기타 예외 클래스

Throwable 클래스는 Java의 모든 예외와 오류의 최상위 클래스입니다. 이 클래스는 예외나 오류가 발생했을 때 잡히거나 던질 수 있는 객체를 나타냅니다.

3. Exception과 Error의 차이

Exception과 Error는 모두 Throwable클래스를 기반으로 하지만, 명확한 차이가 있습니다.

3-1 Error

Error 클래스는 애플리케이션에서 복구할 수 없는 심각한 문제를 나타냅니다. 이러한 오류는 보통 애플리케이션 수준에서 처리하지 않으며, 주로 JVM에서 발생합니다.

Ex) OutOfMemoryError, StackOverflowError, VirtualMachineError

3-2 Exception

Exception 클래스는 애플리케이션에서 발생할 수 있는 예외 상황을 나타냅니다. Exception은 다시 Checked Exception과 Unchecked Exception으로 나뉩니다.

** Checked Exception **

Checked Exception은 컴파일러가 예외 처리를 강제하는 예외입니다. 즉, 이 예외를 처리하거나 메서드 선언부에 throws 키워드를 사용하여 선언해야 합니다.

Ex) IOException, SQLException, ClassNotFoundException

** Unchecked Exception **

Unchecked Exception는 컴파일러가 예외 처리를 강제하지 않는 예외입니다. 이러한 예외는 주로 프로그래머의 실수로 인해 발생합니다. 모든 Unchecked Exception은RuntimeException클래스를 상속합니다.

RuntimeException 클래스는 Unchecked Exception중 최상위 클래스입니다. 일반적으로 프로그래밍 오류에 발생합니다. 이 예외는 명시적으로 선언하지 않아도 되며, 런타임에 발생할 수 있습니다.

4. RuntimeException과 RE가 아닌 것의 차이

위에서도 여러번 설명드렸지만, 한번더 정리해보겠습니다.

RuntimeException과 RuntimeException이 아닌 예외의 주요 차이는 컴파일러가 예외 처리를 강제하는지 여부와 예외가 발생하는 상황에 있습니다.

이 차이는 Checked Exception과 Unchecked Exception의 차이로 이해할 수 있습니다.

4-1 RuntimeException (Unchecked Exception)

RuntimeException 클래스는 Unchecked Exception의 최상위 클래스입니다.

Unchecked Exception은 컴파일러가 예외 처리를 강제하지 않는 예외로, 주로 프로그래머의 실수로 인해 발생하는 예외들입니다. 이 예외들은 프로그램의 논리적 오류를 나타내며, 런타임에만 발견될 수 있습니다.

특징

컴파일 시 예외 처리를 강제하지 않습니다. (throws 키워드를 사용하지 않아도 됩니다.)
런타임에서만 예외 발생 여부를 알 수 있습니다.
주로 프로그래머의 실수로 발생합니다. (Ex : 잘못된 타입 캐스팅, 잘못된 인덱스 접근 등)

** 예시 **

NullPointerException
ArrayIndexOutOfBoundsException
ArithmeticException
ClasscastException

** 예제 **

public class RuntimeExceptionExample {
    public static void main(String[] args) {
        String str = null;
        System.out.println(str.length());  // NullPointerException 발생
    }
}

4-2 Checked Exception

Checked Exception은 Exception 클래스의 서브클래스로, RuntimeException을 상속하지 않는 예외들입니다.

이 예외들은 컴파일러가 예외 처리를 강제하며, 일반적으로 외부 환경과의 상호작용에서 발생하는 예외들입니다.

이러한 예외는 반드시 예외 처리(try-catch)를 하거나 메서드 선언부에 *throws *키워드를 사용하여 선언해야합니다.

** 특징 **

컴파일 시 예외 처리를 강제합니다. (throws키워드를 사용하여 선언하거나, try-catch로 처리해야함)
주로 외부 자원(파일, 네트워크, 데이터베이스 등)과의 상호작용에서 발생합니다.
예외 처리를 통해 복구 가능한 상황을 나타냄

** 예시 **

IOException
SQLException
ClassNotFoundException
FileNotFoundException

** 예제 **

import java.io.*;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            readFile("nonexistentfile.txt");
        } catch (IOException e) {
            System.out.println("예외 발생: " + e.getMessage());
        }
    }

    public static void readFile(String filename) throws IOException {
        FileReader file = new FileReader(filename);  
        // FileNotFoundException 발생 가능
        file.read();
        file.close();
    }
}

주요 차이점 요약

특징	RuntimeException (Unchecked Exception)	Checked Exception
예외 처리 강제 여부	컴파일러가 예외 처리를 강제하지 않음	컴파일러가 예외 처리를 강제
발생 시점	주로 런타임에서 발생	컴파일 시 예외 처리 요구
발생 원인	주로 프로그래머의 실수	외부 자원과의 상호작용 (I/O, DB 등)
예제	`NullPointerException`, `ArrayIndexOutOfBoundsException`	`IOException`, `SQLException`

5. 커스텀한 예외 만드는 방법

Checked Exception과 Unchecked Exception을 커스텀하게 만들 수 있습니다. Exception클래스나 RuntimeException 클래스를 상속받도록 하면 됩니다.

5-1 Checked Exception

Checked Exception을 만들기 위해서는 Exception 클래스를 상속받아야 합니다. 이는 컴파일러가 예외 처리를 강제하는 예외입니다.

** 예제 **

// CustomCheckedException.java
public class CustomCheckedException extends Exception {
    public CustomCheckedException() {
        super();
    }

    public CustomCheckedException(String message) {
        super(message);
    }

    public CustomCheckedException(String message, Throwable cause) {
        super(message, cause);
    }

    public CustomCheckedException(Throwable cause) {
        super(cause);
    }
}

사용 예제

public class CustomCheckedExceptionExample {
    public static void main(String[] args) {
        try {
            methodThatThrowsCustomException();
        } catch (CustomCheckedException e) {
            System.out.println("Custom checked exception caught: " + e.getMessage());
        }
    }

    public static void methodThatThrowsCustomException() throws CustomCheckedException {
        throw new CustomCheckedException("This is a custom checked exception");
    }
}

5-2 Unchecked Exception

Unchecked Exception을 만들기 위해서는 RuntimeException 클래스를 상속받아야 합니다. 이는 컴파일러가 예외 처리를 강제하지 않는 예외 입니다.

** 예제 **

// CustomUncheckedException.java
public class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException() {
        super();
    }

    public CustomUncheckedException(String message) {
        super(message);
    }

    public CustomUncheckedException(String message, Throwable cause) {
        super(message, cause);
    }

    public CustomUncheckedException(Throwable cause) {
        super(cause);
    }
}

** 사용 예제 **

public class CustomUncheckedExceptionExample {
    public static void main(String[] args) {
        try {
            methodThatThrowsCustomException();
        } catch (CustomUncheckedException e) {
            System.out.println("Custom unchecked exception caught: " + e.getMessage());
        }
    }

    public static void methodThatThrowsCustomException() {
        throw new CustomUncheckedException("This is a custom unchecked exception");
    }
}

요약

Checked Exception 만들기 Exception 클래스를 상속받아 정의합니다. 컴파일러가 예외 처리를 강제하게 됩니다.
Unchecked Exception 만들기 RuntimeException 클래스를 상속받아 정의합니다. 컴파일러가 예외 처리를 강제하지 않습니다.

인터페이스

Tue, 11 Jun 2024 07:35:52 GMT

목표

자바의 인터페이스에 대해 학습

1. 인터페이스 정의하는 방법 2. 인터페이스 구현하는 방법 3. 인터페이스 레퍼런스를 통해 구현체를 사용하는 방법 4. 인터페이스 상속 5. 인터페이스의 기본 메소드 (Default Method), 자바 8 6. 인터페이스의 static 메소드, 자바 8 7. 인터페이스의 private 메소드, 자바 9

1. 인터페이스 정의하는 방법

Java에서 인터페이스는 클래스가 구현해야 할 메서드의 집합을 정의하는 일종의 계약입니다. 인터페이스를 사용하면 클래스의 기능을 규격화하고 다형성을 구현할 수 있습니다.

기본 문법

public interface 인터페이스이름 {
    // 상수 (static final 생략 가능)
    타입 상수이름 = 값;

    // 추상 메서드 (abstract 생략 가능)
    반환타입 메서드이름(매개변수);

    // 디폴트 메서드 (Java 8 이후)
    default 반환타입 메서드이름(매개변수) {
        // 메서드 구현
    }

    // 정적 메서드 (Java 8 이후)
    static 반환타입 메서드이름(매개변수) {
        // 메서드 구현
    }

    // private 메서드 (Java 9 이후)
    private 반환타입 메서드이름(매개변수) {
        // 메서드 구현
    }
}

예제

public interface Animal {
    // 상수
    int LEGS = 4;

    // 추상 메서드
    void sound();

    // 디폴트 메서드
    default void sleep() {
        System.out.println("Sleeping...");
    }

    // 정적 메서드
    static void printLegs() {
        System.out.println("This animal has " + LEGS + " legs.");
    }

    // private 메서드 (Java 9 이후)
    private void breathe() {
        System.out.println("Breathing...");
    }
}

2. 인터페이스 구현하는 방법

클래스는 implements 키워드를 사용하여 인터페이스를 구현할 수 있습니다. 인터페이스의 모든 추상메서드를 구현해야만 합니다.

기본 문법

public class 클래스이름 implements 인터페이스이름 {
    // 인터페이스의 모든 추상 메서드를 구현해야 함
    @Override
    public void 메서드이름(매개변수) {
        // 메서드 구현
    }
}

예제

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }

    // 디폴트 메서드 sleep()은 선택적으로 오버라이드 가능
}

3. 인터페이스 레퍼런스를 통해 구현체를 사용하는 방법

인터페이스 타입의 변수를 사용하면 해당 인터페이스를 구현한 클래스의 객체를 참조할 수 있습니다. 이를 통해 다형성을 구현할 수 있으며, 코드의 유연성과 확장성을 높일 수 있습니다.

예제

public interface Animal {
    void sound();
    void sleep();
}

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping...");
    }
}

public class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }

    @Override
    public void sleep() {
        System.out.println("Cat is sleeping...");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sound(); // "Bark" 출력
        myDog.sleep(); // "Dog is sleeping..." 출력

        myCat.sound(); // "Meow" 출력
        myCat.sleep(); // "Cat is sleeping..." 출력
    }
}

Animal 타입의 변수를 사용하여 Dog와 Cat 객체를 참조할 수 있으며, 이를 통해 다형성을 구현합니다. 이렇게 하면 새로운 동물 클래스가 추가되어도 Animal 인터페이스를 구현하기만 하면 동일한 방식으로 사용할 수 있습니다.

4. 인터페이스 상속

인터페이스는 다른 인터페이스를 상속할 수 있습니다. 이 경우 하위 인터페이스는 상위 인터페이스의 모든 메서드를 상속받습니다.

기본 문법

public interface 상위인터페이스 {
    void 메서드1();
}

public interface 하위인터페이스 extends 상위인터페이스 {
    void 메서드2();
}

여기에서 하위인터페이스는 상위인터페이스를 상속받습니다. 따라서 하위인터페이스는 상위인터페이스의 메서드도 포함하게 됩니다. 구현 클래스는하위인터페이스의 모든 메서드를 구현해야합니다.

예제

public interface Animal {
    void sound();
}

public interface Pet extends Animal {
    void play();
}

public class Dog implements Pet {
    @Override
    public void sound() {
        System.out.println("Bark");
    }

    @Override
    public void play() {
        System.out.println("Playing with the dog...");
    }
}

public class Main {
    public static void main(String[] args) {
        Pet myDog = new Dog();
        myDog.sound(); // "Bark" 출력
        myDog.play();  // "Playing with the dog..." 출력
    }
}

Animal 인터페이스는 sound() 메서드를 선언하고, Pet 인터페이스는 Animal 인터페이스를 상속하여 play() 메서드를 추가로 선언합니다.

Dog 클래스는 Pet 인터페이스를 구현하며, sound()와 play() 메서드를 모두 구현해야 합니다.

이러한 상속 구조를 통해 인터페이스 간의 관계를 정의하고, 코드의 재사용성을 높일 수 있습니다. 특히, 다중 상속을 지원하는 인터페이스를 사용하면 여러 인터페이스를 결합하여 더 복잡한 기능을 가진 인터페이스를 만들 수 있습니다.

다중 상속 예제

public interface Animal {
    void sound();
}

public interface Playable {
    void play();
}

public interface Pet extends Animal, Playable {
}

public class Dog implements Pet {
    @Override
    public void sound() {
        System.out.println("Bark");
    }

    @Override
    public void play() {
        System.out.println("Playing with the dog...");
    }
}

public class Main {
    public static void main(String[] args) {
        Pet myDog = new Dog();
        myDog.sound(); // "Bark" 출력
        myDog.play();  // "Playing with the dog..." 출력
    }
}

Pet 인터페이스는 Animal과 Playable 인터페이스를 동시에 상속받습니다. Dog클래스는 Pet 인터페이스를 구현하며, sound()와 play()메서드를 모두 구현합니다.

이를 통해 Pet 인터페이스는 두 부모 인터페이스의 모든 메서드를 포함하게 됩니다.

인터페이스 상속을 통해 더 복잡한 인터페이스를 구성할 수 있으며, 코드의 유연성과 재사용성을 크게 향상시킬 수 있습니다.

5. 인터페이스의 기본 메소드 (Default Method), 자바 8

Java 8부터 인터페이스는default 키워드를 사용하여 디폴트 메서드를 정의할 수 있습니다. 디폴드 메서드는 인터페이스를 구현하는 클래스에서 선택적으로 오버라이드할 수 있으며, 기본 구현을 제공하므로 구현 클래스에서 반드시 구현할 필요는 없습니다.

예제

public interface Animal {
    void sound();

    default void sleep() {
        System.out.println("Sleeping...");
    }
}

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }

    // sleep() 메서드는 디폴트 구현을 사용
}

public class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }

    @Override
    public void sleep() {
        System.out.println("Cat is sleeping...");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sleep(); // "Sleeping..." 출력
        myCat.sleep(); // "Cat is sleeping..." 출력
    }
}

위 예제에서 Animal 인터페이스는 디폴트 메서드인 sleep()을 제공합니다. Dog 클래스는 이 메서드를 오버라이드하지 않고 디폴트 구현을 사용합니다.

반면 Cat 클래스는 sleep() 메서드를 오버라이드하여 자신만의 구현을 제공합니다.

디폴트 메서드를 사용하면 인터페이스를 확장할 때 기존 코드를 깨지 않고 새로운 메서드를 추가할 수 있습니다. (인터페이스 추상메서드를 추가하면, 상속받는 모든 클래스에 구현이 추가되어야 하기 때문에...)

6. 인터페이스의 static 메소드, 자바 8

Java 8부터 인터페이스는 static 키워드를 사용하여 정적 메서드를 정의할 수 있습니다. 정적 메서드는 인스턴스가 아닌 인터페이스 이름을 통해 호출할 수 있으며, 인터페이스의 공통 기능을 제공하는 데 사용될 수 있습니다.

예제

public interface Animal {
    void sound();

    static void printLegs() {
        System.out.println("This animal has 4 legs.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal.printLegs(); 
        // "This animal has 4 legs." 출력
    }
}

위 예제에서 Animal 인터페이스는 printLegs()라는 정적 메서드를 정의합니다. 정적 메서드는 인스턴스 없이 인터페이스 이름을 통해 직접 호출됩니다.

이를 통해 공통 기능을 인터페이스에 정의하고 모든 구현 클래스에서 사용할 수 있습니다.

7. 인터페이스의 private 메소드, 자바 9

Java 9부터 인터페이스는 private 키워드를 사용하여 프라이빗 메서드를 정의할 수 있습니다.

프라이빗 메서드는 인터페이스 내에서만 사용될 수 있으며, 공통 코드의 재사용을 돕습니다.

프라이빗 메서드는 다른 디폴트 메서드나 정적 메서드 내에서 호출될 수 있습니다.

예제

public interface Animal {
    void sound();

    default void sleep() {
        breathe();
        System.out.println("Sleeping...");
    }

    private void breathe() {
        System.out.println("Breathing...");
    }
}

public class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sleep(); 
        // "Breathing..." 및 "Sleeping..." 출력
    }
}

위 예제에서 Animal 인터페이스는 breath()라는 프라이빗 메서드를 정의하고, 이를 sleep() 디폴트 메서드에서 호출합니다.

breathe() 메서드는 외부에서 직접 접근할 수 없고, 인터페이스 내에서만 사용됩니다. 이를 통해 인터페이스 내에서 공통 코드의 재사용이 가능해집니다.

이와 같이 인터페이스는 클래스 간의 결합도를 낮추고, 코드의 유연성과 재사용성을 높이는 데 중요한 역할을 합니다. Java의 다양한 인터페이스 기능을 활용하면 더욱 견고하고 유지보수하기 쉬운 코드를 작성할 수 있습니다.

패키지

Mon, 10 Jun 2024 08:10:52 GMT

목표

자바의 패키지에 대해 학습

1. package 키워드

package 키워드는 Java에서 클래스들을 그룹하하는 데 사용됩니다. 패키지는 비슷한 기능을하는 클래스들을 논리적으로 묶어 관리할 수 있도록 해줍니다. 패키지를 사용하면 클래스의 이름의 충돌을 피할 수 있고, 코드의 가독성과 유지보수성를 높일 수 있습니다.

1-1 기본 문법

패키지는 소스 파일의 가장 첫 번째 줄에 선언됩니다. 패키지를 선언하는 방법은 다음과 같습니다.

package com.example.myapp;

위의 코드는 com.example.myapp이라는 패키지에 해당 클래스를 포함시킵니다.

1-2 패키지의 역할

이름 충돌 방지 동일한 이름을 가진 클래스들이 다른 패키지에 존재할 수 있습니다.
조직화 관련된 클래스들을 묶어서 관리할 수 있습니다.
접근 제어 패키지 레벨의 접근 제어를 통해 클래스와 멤버에 대한 접근을 제어할 수 있습니다.

예제

package com.example.utils;

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

이렇게 만들어둔 MathUtils를 다른 패키지에서 import 키워드를 통해 사용할 수 있습니다.

import com.example.utils.MathUtils;

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.add(5, 3);
        System.out.println("Result: " + result);
    }
}

2. import 키워드

위에서 언급한 import 키워드는 Java에서 다른 패키지에 정의된 클래스를 현재 클래스에서 사용할 수 있게 해줍니다. 이를 통해 필요한 클래스나 패키지를 가져와서 코드에서 활용할 수 있습니다.

2-1 기본 문법

import 키워드는 클래스나 패키지를 가져올 때 사용됩니다. import문은 패키지 선언문 다음에, 클래스 선언문 전에 위치합니다.

import 패키지명.클래스명;

또는 패키지 내의 모든 클래스를 가져오려면 *를 사용할 수 있습니다.

import 패키지명.*;

예제

import java.util.*;

public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        HashMap map = new HashMap<>();

        list.add("Hello");
        map.put("key", "value");

        System.out.println(list);
        System.out.println(map);
    }
}

이는 java.util의 Date와 ArrayList를 가져와 사용한 예제입니다. *를 통해 한번에 가져와 사용해 보았습니다.

주의 사항

import 문은 코드의 가독성을 높이고, 명확하게 하기 위해 사용됩니다.

java.lang 패키지는 자동으로 import되므로, String, System등의 클래스를 사용할 때는 import문이 필요없습니다.
같은 패키지 내의 클래스는 import 없이 사용할 수 있습니다.
import 문을 과도하게 사용하면 코드가 복잡해질 수 있으므로, 필요한 클래스만 선택적으로 임포트하는 것이 좋습니다.

3. 클래스패스

클래스패스(Classpath)는 Java 프로그램이 컴파일되고 실행될 때, Java 런타임이 클래스 파일을 찾는 데 사용하는 경로입니다. 클래스패스는 Java 컴파일러와 JVM(Java Virtual Machine)에게 프로그램 실행 시 필요한 클래스와 패키기의 위치를 알려줍니다.

3-1 클래스패스의 구성 요소

클래스패스는 디렉토리, JAR 파일, ZIP 파일의 경로를 포함할 수 있습니다. 여러 경로를 지정할 때는 운영체제에 따라 구분자가 다릅니다.

Windows : 세미콜론(;)
Linux/Mac : 콜론(:)

예를 들어, 두 개의 디렉토리와 하나의 JAR 파일을 클래스패스에 추가하려면 아래와 같이 설정할 수 있습니다.

Windows

set CLASSPATH=C:\dir1;C:\dir2;C:\path\to\library.jar

Linux/Mac

export CLASSPATH=/dir1:/dir2:/path/to/library.jar

예제

project/
  ├─ main/
  │    └─ Main.java
  └─ util/
       └─ Util.java

두 개의 클래스 파일 Main.java와 Util.java가 각각 다른 디렉토리에 있는 경우입니다.

Main.java

package main;

import util.Util;

public class Main {
    public static void main(String[] args) {
        Util.printMessage();
    }
}

Util.java

package util;

public class Util {
    public static void printMessage() {
        System.out.println("Hello from Util!");
    }
}

컴파일과 실행 명령

javac -cp . main/Main.java util/Util.java
java -cp . main.Main

4. CLASSPATH 환경변수

CLASSPATH 환경 변수를 적절히 설정하지 않으면 Java 런타임이 필요한 클래스를 찾지 못해 ClassNotFoundException이 발생할 수 있습니다.

4-1 클래스패스 설정 방법

** 1) 명령줄에서 설정 ** -classpath 또는 -cp옵션을 사용하여 설정할 수 있습니다.

javac -classpath /path/to/library myprogram.java
java -classpath /path/to/library myprogram

# 또는
javac -cp /path/to/library myprogram.java
java -cp /path/to/library myprogram

** 2) 환경 변수 설정 ** CLASSPATH 환경 변수를 설정하여 클래스패스를 지정할 수 있습니다.

Windows

set CLASSPATH=C:\path\to\library

Linux

export CLASSPATH=/path/to/library

** 3) IDE에서 설정 **

Eclipse, IntelliJ IDEA 등의 통합 개발 환경(IDE)에서는 프로젝트 속성에서 클래스패스를 설정할 수 있습니다. 보통 프로젝트의 빌드 패스(build path)나 라이브러리 설정에서 JAR 파일이나 클래스 파일을 추가하여 설정합니다.

5. -classpath 옵션

앞에서도 간단하게 설명하긴 했습니다만... 추가로 설명하자면

-classpath 또는 -cp 옵션은 Java 컴파일러(javac)와 Java 런타임(java)에서 클래스 파일이나 JAR 파일의 경로를 지정할 때 사용됩니다. 이 옵션은 CLASSPATH 환경 변수를 설정하는 것과 유사하게 동작하지만, 명령줄에서 특정 컴파일 또는 실행 명령에만 적용된다는 점에서 차이가 있습니다.

예제

예를 들어, 두 개의 디렉토리와 하나의 JAR 파일을 포함한 프로젝트가 있다고 가정합니다. Main.java 파일이 src 디렉토리에 있고, 필요한 라이브러리는 libs 디렉토리에 있습니다.

project/
  ├─ src/
  │    └─ Main.java
  ├─ classes/
  └─ libs/
       └─ example-library.jar

** 컴파일 **

javac -d classes -cp libs/example-library.jar src/Main.java

** 실행 **

java -cp classes:libs/example-library.jar Main

이 예제에서 -d 옵션은 클래스 파일이 저장될 디렉토리를 지정하고, -cp 옵션은 필요한 라이브러리 경로를 지정합니다.

요약

-classpath 또는 -cp 옵션은 Java 프로그램을 컴파일하고 실행할 때 클래스와 라이브러리의 경로를 명령줄에서 설정하는 데 유용합니다. 이는 특정 작업에만 적용되므로 CLASSPATH 환경 변수를 설정하는 것보다 유연하게 사용할 수 있습니다.

6. 접근지시자

이전 포스팅에도 한번씩 언급되었던 접근지시자 입니다.

접근지시자는 Java에서 클래스, 변수, 메소드 및 생성자의 접근 수준을 제어하는 키워드입니다.

접근지시자는 코드의 가시성을 관리하고, 클래스 간의 결합도를 낮추며, 캡슐화를 구현하는데 중요한 역할을합니다.

종류와 역할

1. public

정의 : 모든 클래스에서 접근할 수 있습니다.

사용 예 : 클래스, 메서드, 변수, 생성자 등

public class MyClass {
  public int publicVar;
  public void publicMethod() {
      // ...
  }
}

2. protected

정의 : 동일한 패키지 내의 클래스와 하위 클래스(다른 패키지에 있어도)에서 접근할 수 있습니다.

사용 예 : 메서드, 변수, 생성자 등(클래스에서는 사용할 수 없음)

public class MyClass {
  protected int protectedVar;
  protected void protectedMethod() {
      // ...
  }
}

3. default

정의 : 동일한 패키지 내의 클래스에서만 접근할 수 있습니다.(패키지 접근수준)

사용 예 : 클래스, 메서드, 변수, 생성자 등

class MyClass {
  int defaultVar;
  void defaultMethod() {
      // ...
  }
}

4. private

정의 : 동일한 클래스 내에서만 접근할 수 있습니다

사용 예 : 메서드, 변수, 생성자 등(클래스에는 사용할 수 없음)

public class MyClass {
  private int privateVar;
  private void privateMethod() {
      // ...
  }
}

접근지시자의 적용 범위

접근지시자	클래스 내부	동일 패키지	하위 클래스 (다른 패키지)	모든 클래스
`public`	O	O	O	O
`protected`	O	O	O	X
`default`	O	O	X	X
`private`	O	X	X	X

예시

public class AccessModifiersExample {

    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;
    private int privateVar = 4;

    public void publicMethod() {
        System.out.println("Public Method");
    }

    protected void protectedMethod() {
        System.out.println("Protected Method");
    }

    void defaultMethod() {
        System.out.println("Default Method");
    }

    private void privateMethod() {
        System.out.println("Private Method");
    }

    public static void main(String[] args) {
        AccessModifiersExample example = new AccessModifiersExample();

        // 같은 클래스 내에서는 모든 접근지시자에 접근 가능
        System.out.println("Public Variable: " + example.publicVar);
        System.out.println("Protected Variable: " + example.protectedVar);
        System.out.println("Default Variable: " + example.defaultVar);
        System.out.println("Private Variable: " + example.privateVar);

        example.publicMethod();
        example.protectedMethod();
        example.defaultMethod();
        example.privateMethod();
    }
}

다른 클래스에서 AccessModifiersExample 클래스를 사용할 때 접근할 수 있는 멤버는 접근지시자에 따라달라집니다.

예를들어, 동일한 패키지 내의 다른 클래스에서는 public, protected, default 멤버에 접근할 수 있지만, private멤버에는 접근할 수 없습니다.

접근지시자를 적절히 사용하면 코드의 가독성과 유지보수성을 높이고, 불필요한 외부 접근을 막아 클래스의 일관성을 유지할 수 있습니다.

상속(Inheritance)

Thu, 06 Jun 2024 15:27:28 GMT

목표

자바의 상속에 대해 학습

1. 자바 상속의 특징

상속은 객체 지향 프로그래밍(OOP)의 중요한 개념 중 하나로, 자바에서도 매우 중요한 역할을 합니다. 상속을 통해 기존 클래스의 속성과 메소드를 새로운 클래스에서 재사용하고 확장할 수 있습니다.

1-1 상속의 개념

상속을 사용하면 새로운 클래스(자식 클래스 도는 서브 클래스)가 기존 클래스(부모 클래스 또는 슈퍼 클래스)의 특성과 동작을 물려받을 수 있습니다.

자식 클래스는 부모 클래스의 모든 필드와 메소드를 상속받으며, 필요한 경우 이를 재정의(오버라이딩)하거나 새로운 특성과 동작을 추가할 수 있습니다.

1-2 상속의 특징

1) 재사용성

상속은 기존 클래스의 코드를 재사용할 수 있게 합니다. 이를 통해 코드 중복을 줄이고, 유지보수를 쉽게 합니다.

2) 계층 구조

클래스간의 상속 관계를 통해 계층 구조를 만들 수 있습니다. 이는 복잡한 시스템을 더 이해하기 쉽고, 관리하기 쉽게 만듭니다.

3) 확장성

자식 클래스는 부모 클래스의 기능을 확장할 수 있습니다. 새로운 속성이나 메소드를 추가하거나 부모 클래스의 메소드를 재정의(오버라이딩)하여 기능을 변경할 수 있습니다.

4) 다형성

상속은 다형성을 지원합니다. 자식 클래스의 인스턴스를 부모클래스의 타입으로 처리할 수 있습니다. 이를 통해 동일한 인터페이스나 부모 클래스를 공유하는 여러 객체를 동일한 방법으로 다룰 수 있습니다.

5) 접근 제어자

부모 클래스의 필드와 메소드는 접근 제어자에 따라 자식 클래스에서 접근 가능 여부가 달라집니다.

public : 모든 클래스에서 접근 가능 protected : 같은 패키지와 자식 클래스에서 접근 가능 default(접근제어자가 없을때) : 같은 패키지에서 접근 가능 private : 동일 클래스 내에서만 접근 가능

6) 단일 상속

자바는 단일 상속만을 지원합니다. 즉, 한 클래스는 하나의 부모 클래스만 가질 수 있습니다. 다중 상속은 인터페이스를 통해 구현됩니다.

✨ 다이아 몬드 문제(Diamond Problem)

다이아몬드 문제 를 참고해주세요!

1-3 예시 코드

// 부모 클래스
class Animal {
    String name;

    void eat() {
        System.out.println("Eating...");
    }

    void sleep() {
        System.out.println("Sleeping...");
    }
}

// 자식 클래스
class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.name = "Buddy";
        myDog.eat();   // 부모 클래스의 메소드 호출
        myDog.sleep(); // 부모 클래스의 메소드 호출
        myDog.bark();  // 자식 클래스의 메소드 호출
    }
}

1-4 상속과 오버라이딩

상속받은 메소드를 자식 클래스에서 재정의(오버라이딩)할 수 있습니다. 이를 통해 부모 클래스의 동작을 변경하거나 확장할 수 있습니다.

// 부모 클래스
class Animal {
    void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

// 자식 클래스
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound(); // 출력: Some generic animal sound

        Dog myDog = new Dog();
        myDog.makeSound(); // 출력: Bark
    }
}

@Override를 붙여 재정의 할 수 있습니다. 그래서 Animal의 makeSound와 Dog의 makeSound가 다르게 출력됩니다.

이처럼 상속(Inheritance)은 코드 재사용성을 높이고, 계츨 구조를 형성하며, 다형성을 지원하는 강력한 도구라고 할 수 있겠습니다.

2. super 키워드

super 키워드는 자바에서 부모 클래스의 멤버(필드, 메소드, 생성자)에 접근할 때 사용되는 특별한 키워드 입니다. 이를 통해 자식 클래스는 부모 클래스의 필드와 메소드에 접근하거나 부모 클래스의 생성자를 호출할 수 있습니다.

경우

부모 클래스의 메소드 호출

자식 클래스에서 부모 클래스의 메소드를 호출 할때, super 키워드를 사용합니다. 이를 통해 자식 클래스에서 재정의(오버라이딩)된 메소드를 호출할 수 있습니다.
부모 클래스의 필드 접근

자식 클래스에서 부모 클래스의 필드에 접근할 때 super키워드를 사용합니다.
부모 클래스의 생성자 호출

자식 클래스의 생성자에서 부모 클래스의 생성자를 호출할 때 super 키워드를 사용합니다. 이는 부모 클래스의 초기화 작업을 수행하기 위해 필요합니다.
부모 클래스의 매개변수가 있는 생성자 호출

자식 클래스의 생성자에서 부모 클래스의 매개변수가 있는 생성자를 호출할때 super 키워드를 사용할 수 있습니다.

예시 코드

class Parent {
    // 부모 클래스의 필드
    int value = 100;

    // 부모 클래스의 기본 생성자
    Parent() {
        System.out.println("Parent Constructor");
    }

    // 부모 클래스의 매개변수가 있는 생성자
    Parent(String message) {
        System.out.println("Parent Constructor: " + message);
    }

    // 부모 클래스의 메소드
    void display() {
        System.out.println("Display from Parent");
    }
}

class Child extends Parent {
    // 자식 클래스의 필드
    int value = 200;

    // 자식 클래스의 기본 생성자
    Child() {
        super("Hello from Child"); // 부모 클래스의 매개변수가 있는 생성자 호출
        System.out.println("Child Constructor");
    }

    // 자식 클래스의 메소드
    @Override
    void display() {
        System.out.println("Display from Child");
    }

    // 자식 클래스의 메소드
    void show() {
        super.display(); // 부모 클래스의 display() 메소드 호출
        this.display();  // 현재 클래스의 display() 메소드 호출

        System.out.println("Value from Parent: " + super.value); // 부모 클래스의 value 필드
        System.out.println("Value from Child: " + this.value);   // 현재 클래스의 value 필드
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.show();
    }
}

출력 결과

Parent Constructor: Hello from Child
Child Constructor
Display from Parent
Display from Child
Value from Parent: 100
Value from Child: 200

요약

생성자 호출: super("Hello from Child")를 사용하여 부모 클래스의 매개변수가 있는 생성자를 호출했습니다.

메소드 호출: super.display()를 사용하여 부모 클래스의 display 메소드를 호출하고, this.display()를 사용하여 자식 클래스의 display 메소드를 호출했습니다.

필드 접근: super.value를 사용하여 부모 클래스의 value 필드에 접근하고, this.value를 사용하여 자식 클래스의 value 필드에 접근했습니다.

3. 메소드 오버라이딩

메소드 오버라이딩(Method Oberriding)은 자바에서 상속 관계에 있는 클래스들간에 부모 클래스의 메소드를 자식 클래스에서 재정의 하여 사용하는 기능입니다.

이는 다형성(Polymorphism)의 중요한 요소로, 부모 클래스의 기본 동작을 자식 클래스에서 변경할 때 사용됩니다.

3-1 메소드 오버라이딩의 특징

동일한 메소드 이름 부모 클래스의 메소드와 동일한 이름을 가져야 합니다.
동일한 매개변수 목록 매개변수의 개수, 타입, 순서가 부모 클래스의 메소드와 동일해야 합니다.
동일한 반환 타입 반환 타입이 부모 클래스의 메소드와 동일해야 합니다. 자바 5 이후부터는 공변 반환 타입(Convariant Return Type)을 허용하여 자식 클래스에서 반환 타입을 부모 클래스의 반환 타입의 서브 클래스로 변경할 수 있습니다.

✨ 잠깐...! 공변 변환 타입

class Animal {
    public Animal getInstance() {
        return new Animal();
    }
}

class Dog extends Animal {
    @Override
    public Dog getInstance() { 
    // 공변 반환 타입: Animal의 서브 타입인 Dog 반환
        return new Dog();
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal animalInstance = animal.getInstance(); 
        // Animal 객체 반환

        Dog dog = new Dog();
        Dog dogInstance = dog.getInstance(); 
        // Dog 객체 반환

        Animal polyAnimal = new Dog();
        Animal polyAnimalInstance = polyAnimal.getInstance(); 
        // 다형성 사용 시 여전히 Dog 객체 반환
    }
}

이렇게 원래라면 Animal을 반환해야하지만, Dog 타입을 반환할 수 있게 되었습니다. 타입 안정성, 가독성 향상, 다형성 지원 강화라는 장점이 있겠습니다.

요약하자면,

공변 변환 타입은 자식 클래스에서 메소드를 오버라이딩할 때 부모 클래스의 메소드가 반환하는 타입의 하위 타입을 반환할 수 있도록 허용하는 기능입니다.
자바 5부터 도입되었으며, 타입 안정성과 코드 가독성을 높이고, 다형성을 유연하게 지원합니다.
공변 반환 타입은 상속 계층 및 인터페이스 구현에서 유용하게 사용할 수 있습니다.

접근 제어자

부모 클래스의 메소드 보다 더 강한 접근 제어자를 가질 수 없습니다. 예를 들어, 부모 클래스의 메소드가 protected이면 자식 클래스에서는 protected 또는 public만 가능합니다.

예시 코드

class Parent {
    // 부모 클래스의 메소드
    void display() {
        System.out.println("Display from Parent");
    }
}

class Child extends Parent {
    // 자식 클래스에서 메소드 오버라이딩
    @Override
    void display() {
        System.out.println("Display from Child");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Parent();
        parent.display(); 
        // Output: Display from Parent

        Child child = new Child();
        child.display(); 
        // Output: Display from Child

        Parent parentRef = new Child();
        parentRef.display(); 
        // Output: Display from Child (다형성)
    }
}

예외 처리

자식 클래스에서 오버라이딩하는 메소드는 부모클래스의 메소드가 던지는 예외보다 더 많은 예외를 던질 수 없습니다. 던지는 예외의 범위는 같거나 더 좁아야합니다.

class Parent {
    void display() throws IOException {
        System.out.println("Display from Parent");
    }
}

class Child extends Parent {
    @Override
    void display() throws FileNotFoundException { 
    // 허용됨: 더 좁은 범위의 예외
        System.out.println("Display from Child");
    }
}

요약

메소드 오버라이딩은 자식 클래스에서 부모 클래스의 메소드를 재정의 하는 것입니다.
다형성을 통해 부모 클래스 타입의 참조 변수로 자식 클래스의 오버라이딩된 메소드를 호출할 수 있습니다.
@Override 어노테이션을 사용하여 오버라이딩을 명시적으로 표시하고, 컴파일러의 체크를 받을 수 있습니다.
접근 제어자와 예외 처리 규칙을 준수해야 합니다.

4. 다이나믹 메소드 디스패치

다이나믹 메소드 디스패치(Dynamic Method Dispatch)는 객체 지향 프로그래밍에서 다형성을 구현하는 기술 중 하나입니다. 이는 컴파일 시점에는 어떤 메소드가 호출될지 결정되지 않고, 실행 시점에 객체의 실제 타입에 따라 메소드가 동적으로 호출되는 것을 의미합니다.

자바에서는 메소드 오버라이딩과 함께 다이나믹 메소드 디스패치를 통해 다형성을 구현합니다. 예를 들어, 부모 클래스의 참조 변수로 자식 클래스의 인스턴스를 참조할 때, 메소드 호출은 실제 객체의 타입에 따라 동적으로 결정됩니다.

class Animal {
    void makeSound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); 
        // 다형성: 부모 클래스의 참조 변수로 자식 클래스의 인스턴스를 참조
        animal.makeSound(); 
        // Output: Dog barks 
        // (실제 객체인 Dog의 makeSound 메소드가 호출됨)
    }
}

위 예제에서 animal.makeSound() 호출 시, 컴파일 시점에는 Animal 클래스의 makeSound 메소드가 호출될 것으로 예상되지만, 실행 시점에는 실제 객체가 Dog 클래스의 인스턴스이므로 Dog 클래스의 makeSound 메소드가 호출됩니다.

이렇게 컴파일 시점에는 어떤 메소드가 호출될지 확정되지 않고, 실행 시점에 결정되는 것이 다이나믹 메소드 디스패치의 핵심입니다.

장점

다형성 객체 지향 프로그래밍의 핵심인 다형성을 구현할 수 있습니다. 부모 클래스의 참조 변수로 여러 종류의 자식 클래스 인스턴스를 참조하여 각각의 메소드를 호출할 수 있습니다.
유연성 실행 시점에 메소드 호출이 결정되므로 프로그램의 동작을 동적으로 조절할 수 있습니다. 이는 프로그램의 유연성과 확장성을 향상시킵니다.
코드 재사용 메소드 오버라이딩을 통해 부모 클래스의 기능을 자식 클래스에서 재정의할 수 있습니다. 이는 코드의 재사용성을 높여줍니다.

원리

자바에서는 다이나믹 메소드 디스패치를 가상 메소드 테이블(Virtual Method Table, VMT)을 통해 구현합니다. 각 클래스에는 해당 클래스의 메소드들에 대한 참조를 가지고 있는 VMT가 존재하며, 객체가 생성될 때마다 VMT가 생성됩니다. 메소드 호출 시에는 객체의 VMT를 참조하여 해당 메소드의 주소를 찾아서 호출하게 됩니다.

요약

다이나믹 메소드 디스패치는 실행 시점에 메소드 호출이 결정되는 기술로, 다형성을 구현하는 중요한 요소입니다.
다형성을 통해 부모 클래스의 참조 변수로 여러 종류의 자식 클래스 인스턴스를 참조하여 다양한 메소드를 호출할 수 있습니다.
자바에서는 가상 메소드 테이블을 사용하여 다이나믹 메소드 디스패치를 구현합니다.

5. 추상 클래스

추상 클래스는 상속 관계에서 공통된 동작을 정의하고 확장하기 위한 용도로 사용됩니다.

예를 들어, 동물의 동물을 나타내는 추상 클래스에서는 추상 메소드로 움직이다, 소리내다 등의 행동을 정의할 수 있고, 실제 동물 종류(개, 고양이 등)를 나타내는 구체적인 클래스에서는 이러한 메소드를 구현할 수 있습니다.

특징

추상 메소드 포함 가능 추상 클래스는 추상 메소드(Abstract Method)를 포함할 수 있습니다.

추상 메소드는 메소드의 시그니처(이름, 매개변수, 반환 타입)만을 정의하고 메소드의 본문(구현)은 포함하지 않습니다. 따라서 추상 메소드를 가지는 클래스는 반드시 추상 클래스여야 합니다.
일반 메소드 포함 가능 추상 클래스는 추상 메소드 뿐만 아니라 일반 메소드를 포함할 수도 있습니다. 일반 메소드는 메소드의 시그니처와 구현을 모두 포함합니다.
인스턴스 생성 불가능 추상 클래스는 직접적으로 인스턴스를 생성할 수 없습니다. 즉, 추상 클래스로부터 객체를 생성할 수 없으며, 추상 클래스를 상속받아서 추상메소드를 구현한 하위 클래스를 통해서만 인스턴스를 생성할 수 있습니다. 또한 추상메소드가 있다면, 반드시 구현부를 작성해야합니다.
상속을 통한 확장 추상 클래스는 다른 클래스에게 공통된 메소드나 속성을 상속하여 코드의 재사용성을 높일 수 있습니다. 하위 클래스에서는 추상 클래스의 추상 메소드를 구현하거나 재정의하여 사용할 수 있습니다.

✨ 잠깐...! 추상클래스가 일반메소드만 포함한다면...?

원래 추상클래스는 추상메소드를 포함할때, 구현부가 없기때문에, 하위 클래스에서 구현한 뒤, 인스턴스를 생성할 수 있습니다만...

만약 추상클래스가 일반 메소드만 가지고 있다면, 하위 클래스에서 따로 구현할 필요 없이 바로 인스턴스를 생성해서 사용이 가능합니다.

✨ 여기서 하나더... 추상 메소드만 포함하는 추상클래스는 인터페이스와 뭐가 다르지..?

구현의 유연성 추상 클래스의 하위 클래스는 원하는 메소드만 가져다 사용할 수 있지만, 인터페이스는 강제적으로 전부 구현해야합니다.
다중 상속 자바는 단일 상속만 지원하기 때문에, 하나의 클래스가 여러개의 인터페이스를 구현할 수 있습니다. 이를 통해 다중 상속의 장점을 일부 활용할 수 있습니다. 하지만 추상클래스는 여러개의 추상 클래스를 동시에 상속받을 수 없습니다.
관련성 추상 클래스는 주로 is-a 관계를 나타내는데 사용됩니다. 즉, 개(Dog)는 동물(Animal)의 일종이므로 추상 클래스로 구현할 수 있습니다.

반면 인터페이스는 can-do의 관계를 나타내는데 사용됩니다. 즉, 클래스가 특정 동작을 할 수 있는지 여부를 나타내는데 사용됩니다. 예를 들어날수있는(Flyable)또는 수행할 수 있는(Perfomable)등의 동작을 나타내는 인터페이스를 구현할 수 있습니다.
용도 추상 클래스는 클래스 간의 코드 재사용과 확장을 위해 사용됩니다.

반면 인터페이스는 클래스 간의 느슨한 결합(loose coupling)을 위해 사용됩니다. 인터페이스를 통해 다양한 구현체를 대체할 수 있으며, 이는 유연하고 확장 가능한 설계를 위한 중요한 도구 입니다.

6. final 키워드

final 키워드는 자바에서 변수, 메소드, 클래스에 적용될 수 있습니다.

6-1 변수에 적용할 때

변수에 final 키워드를 사용하면 해당 변수는 상수(Constant)로 선언됩니다. 한 번 초기화된 이후에는 값을 변경할 수 없게됩니다.

final int MAX_SIZE = 10; // final 변수 선언과 동시에 초기화

final double PI; // final 변수 선언
PI = 3.14; // 생성자에서 final 변수 초기화

6-2 메소드에 적용할 때

메소드에 final 키워드를 사용하면 해당 메소드는 하위 클래스에서 오버라이딩(재정의)할 수 없습니다. 즉, final 메소드는 부모 클래스에서 정의된 그대로의 동작을 보장하게 됩니다.

class Parent {
    final void doSomething() { // final 메소드
        // 메소드 구현
    }
}

class Child extends Parent {
    // 오버라이딩을 시도하면 컴파일 에러 발생
    // void doSomething() {
    //     // 오버라이딩 불가
    // }
}

6-3 클래스에 적용할때

클래스에 final 키워드를 사용하면 해당 클래스는 상속될 수 없게 됩니다. 즉, final 클래스는 다른 클래스에서 확장될 수 없습니다.

final class FinalClass {
    // 클래스 내용
}

// FinalClass를 상속하려고 하면 컴파일 에러 발생
// class SubClass extends FinalClass {
//     // 상속 불가
// }

결론

final 키워드는 코드의 안정성과 확장성을 높이는데 사용됩니다. final 변수는 변하지 않는 값으로사용되며, final 메소드와 클래스는 의도적으로 오버라이딩이나, 상속을 제한하여 코드의 안정성을 확보합니다.

7. Object 클래스

Object 클래스는 자바에서 모든 클래스의 최상위 부모 클래스이며, 모든 클래스는 Object 클래스에서 상속을 받습니다. 따라서 자바에서 정의된 모든 클래스는 Object 클래스의 멤버들을 상속받아 사용할 수 있습니다.

Object 클래스가 포함하는 주요 메소드

equals(Object obj) 객체의 동등성을 확인하기 위해 사용됩니다. 두 객체가 동일한 값을 가지는지 비교하여 true 또는 false를 반환합니다.

기본적으로는 객체의 참조 값(identity)을 비교하지만, 클래스에서 이 메소드를오버라이딩 하여 동등성 비교를 사용자 정의할 수 있습니다.
hashCode() 객체의 해시 코드 값을 반환합니다. 이 메소드는 객체를 저장허거나 검색하는데 사용되는 해시 기반 컬렉션에서 객체를 식별하는 데 사용됩니다.

equals 메소드를 오버라이딩한 경우에는 hashCode 메소드도 함께 오버라이딩하여 일관성을 유지해야합니다.
toString() 객체의 문자열 표현을 반환합니다. 기본적으로는 객체의 클래스 이름과 해시 코드 값을 반환하지만, 클래스에서 이 메소드를 오버라이딩 하여 사용자 정의 문자열 표현을 제공할 수 있습니다.
getClass() 객체의 클래스를 나타내는 Class 객체를 반환합니다. Class 객체는 클래스에 대한 정보를 제공하며, 리플랙션(reflection)을 통해 클래스의 메타 데이터를 다룰 수 있게 해줍니다.
clone() 객체의 얕은 복사(Shallow Copy)를 생성하여 반환합니다. 이 메소드는 Cloneable 인터페이스를 구현한 클래스에서만 사용할 수 있으며, 클래스 에서 이 메소드를 오버라이딩 하여 깊은 복사(Deep Copy)를 수행할 수 있습니다.
finalize() 객체가 더 이상 사용되지 않을 때 가비지 컬렉터에 의해 호출되는 메소드입니다. 이 메소드는 자원의 해제나 정리 작업을 수행할 수 있습니다.

정리

Object 클래스의 이러한 메소드들은 모든 자바 클래스에서 사용할 수 있으며, 필요에 따라 클래스에서 이러한 메소드를 오버라이딩하여 특정 동작을 정의할 수 있습니다.

다이아 몬드 문제(Diamond Problem)

Thu, 06 Jun 2024 11:46:51 GMT

나, D는 B의 말을 들어야할것인가...
C의 말을 들어야 할것인가...
아주 모호해요... 아주 곤란하군요...

다이아몬드 문제(Diamond Problem)

다이아몬드 문제는 객체 지향 프로그래밍에서 다중 상속을 지원하는 언어에서 발생할 수 있는 모호성 문제입니다.

이는 두 개 이상의 부모 클래스가 동일한 메소드를 가지며, 자식 클래스가 이를 상속받을 때 어떤 부모 클래스의 메소드를 상속받아야 하는지 모호해지는 상황을 의미합니다.

다이아몬드 문제의 구조

다이아몬드 문제는 다음과 같은 구조를 가집니다.

두 클래스(B 와 C)가 하나의 클래스(A)를 상속받습니다.

또 다른 클래스(D)가 B와 C를 동시에 상속받습니다.

이러한 상속 구조가 다이아몬드 형태를 이루기 때문에 다이아 몬드 문제라고 불립니다.

다이아 몬드 문제의 예시

다중 상속을 지원하는 언어(C++ 등)에서 다이아몬드 문제는 아래와 같은 코드로 나타낼 수 있습니다.

class A {
public:
    void sayHello() {
        std::cout << "Hello from A" << std::endl;
    }
};

class B : public A { };

class C : public A { };

class D : public B, public C { };

int main() {
    D d;
    d.sayHello(); // 모호성 문제 발생
    return 0;
}

위 코드에서 D클래스는 B와 C를 상속 받습니다. 그러나 B와 C는 모두 A를 상속받고 있으며, A클래스의 sayHello 메소드를 가지고 있습니다. 이로 인해 D 클래스의 인스턴스에서 sayHello 메소드를 호출할 때 문제가 발생합니다.

B를 통해 상속받은 A의 sayHello인지, C를 통해 상속받은 A의 sayHello인지 모호해지게 됩니다.

** 참고 **

위의 C++ 코드는 컴파일 에러가 발생하게 됩니다. 위 상황같은 다이아몬드 문제를 해결하려면

가상 상속(Virtual Inheritance)
- virtual 키워드를 사용하여 하나의 공통 부모 클래스를 명시적으로 상속받게 합니다.
명시적 호출(Explicit Call)
- 특정 부모 클래스의 메소드를 명시적으로 호출하여 모호성을 해결합니다.

이러한 2가지 방법을 통해 해결할 수 있습니다.

자바에서의 해결책. 인터페이스

자바는 클래스 간의 다중 상속을 지원하지 않기 때문에 다이아몬드 문제가 발생하지 않습니다. 대신, 자바는 인터페이스를 사용하여 다중 상속의 유연성을 제공합니다.

인터페이스는 구현만을 강제할 뿐, 상태(필드)를 가지지 않기 때문에 다이아몬드 문제가 발생하지 않습니다.

interface A {
    void sayHello();
}

interface B extends A { }

interface C extends A { }

class D implements B, C {
    @Override
    public void sayHello() {
        System.out.println("Hello from D");
    }
}

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.sayHello(); // Hello from D
    }
}

위 코드에서 D 클래스는 B와 C인터페이스를 구현합니다. B와 C는 모두 A 인터페이스를 상속받지만, D 클래스가 sayHello 메소드를 구현하기 때문에 모호성 문제가 발생하지 않습니다.

interface A {
    void sayHello();
}

interface B extends A { }

interface C extends A { }

class D implements B, C {
    @Override
    public void sayHello() {
        System.out.println("Hello from D");
    }
}

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.sayHello(); // Hello from D
    }
}

위 코드에서 D 클래스는 B와 C 인터페이스를 구현합니다. B와 C는 모두 A 인터페이스를 상속받지만, D 클래스가 sayHello 메소드를 구현하기 때문에 모호성 문제가 발생하지 않습니다.

인터페이스의 기본 메소드

자바 8부터 인터페이스는 기본 메소드(Default Method)를 가질 수 있습니다. 기본 메소드는 구현을 포함할 수 있기 때문에 다이아몬드 문제가 다시 발생할 가능성이 있습니다.

자바는 이를 해결하기 위해 명시적인 방법을 제시했습니다.

interface A {
    default void sayHello() {
        System.out.println("Hello from A");
    }
}

interface B extends A {
    @Override
    default void sayHello() {
        System.out.println("Hello from B");
    }
}

interface C extends A { }

class D implements B, C {
    @Override
    public void sayHello() {
        B.super.sayHello(); // 명시적으로 B의 sayHello 호출
    }
}

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.sayHello(); // Hello from B
    }
}

위 코드에서 D 클래스는 B와 C 인터페이스를 구현합니다. B는 A의 sayHello 메소드를 오버라이드 하여 새로운 구현을 제공합니다. D 클래스는 sayHello 메소드에서 B의 sayHello 메소드를 명시적으로 호출합니다.

요약

다이아몬드 문제: 다중 상속으로 인해 어떤 부모 클래스의 메소드를 상속받아야 할지 모호해지는 문제가 발생합니다.
자바에서의 해결책: 자바는 클래스의 다중 상속을 지원하지않지만, 인터페이스를 통해 다중 상속의 유연성을 제공합니다.
기본 메소드: 자바 8부터 인터페이스는 기본 메소드를 가질 수 있으며, 다이아몬드 문제를 명시적으로 해결할 수 있는 방법을 제공합니다.

클래스

Sun, 02 Jun 2024 11:19:33 GMT

목표

자바의 Class에 대해 학습

1. 클래스 정의하는 방법

자바에서 클래스는 객체를 생성하기 위한 청사진(blueprint) 역할을 하며, 속성(필드)과 동작(메소드)를 정의하여 사용합니다.

1-1 클래스의 정의

클래스는 class 키워드를 사용하여 정의합니다. 기본적인 구조는 아래와 같습니다.

public class ClassName {
    // 필드 (속성)
    // 생성자
    // 메소드 (동작)
}

여기서 public은 접근 제어자 입니다. 이 위치에 클래스에 접근할 수 있는 범위를 지정할 수 있습니다.
className은 클래스의 이름입니다. 클래스 이름은 대문자로 시작하는것이 관례라고 합니다.

1-2 필드(속성) 정의

필드는 클래스의 상태를 저장하는 변수입니다.

예시)

public class Car {
    // 필드
    private String color;
    private String model;
    private int year;
}

car 라는 클래스에 색상, 모델, 만들어진 연도 등의 정보를 담을 수 있겠습니다. 위 클래스를 통해 만들어지는 car들은 각각 다른 정보드를 가지고 있을 수 있습니다. 그렇기 때문에 청사진(blueprint, 여러번 찍어낼 수 있는..)와 비슷하다고 이해하면 알기 쉽습니다.

** ※ 여기서 private는 접근 제어자 중 하나로, 해당 필드가 클래스 내부에서만 접근 가능하도록 합니다. **

1-3 생성자 정의

생성자는 클래스의 인스턴스가 생성될 때 호출 되며, 주로 필드를 초기화하는 데 사용됩니다. 생성자의 이름은 클래스의 이름과 같아야 하며, 반환타입이 없습니다.

1-4 메소드 (동작) 정의

메소드는 클래스의 동작을 정의합니다. 메소드는 특정 작업을 수행하는 코드 블럭입니다.

예시)

public class Car {
    private String color;
    private String model;
    private int year;

    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    // 메소드
    public void startEngine() {
        System.out.println("Engine started");
    }

    public void stopEngine() {
        System.out.println("Engine stopped");
    }

    public String getColor() {
        return this.color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getModel() {
        return this.model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public int getYear() {
        return this.year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

설명

public 메소드는 클래스 외부에서도 접근할 수 있습니다.
void는 반환 타입으로, 해당 메소드는 값을 반환하지 않음을 의미합니다.
메소드 이름은 소문자로 시작하며, 동사형을 사용하는 것이 관례입니다.
getColor와 setColor메소드는 필드에 접근하고 수정하는 데 사용되는 getter와 setter 메소드입니다. 이를 통해 private 로 지정된 필드에 접근할 수 있습니다.

2. 객체 만드는 방법

객체는 위에서 설명한 class를 기반으로 생성이 되며, 객체는 클래스의 인스턴스라고도 불리웁니다. 객체는 클래스로 부터 생성된 실제 존재하는 개체를 의미한다고 볼 수 있겠습니다.

2-1 객체 생성

객체를 생성하려면 new 키워드를 사용하여 클래스의 생성자를 호출합니다. 기본적인 형시은 아래와 같습니다.

ClassName objectName = new ClassName(parameters);

className은 객체를 생성할 클래스의 이름입니다.
objectName은 생성된 객체를 참조할 변수의 이름입니다.
new 키워드는 객체를 힙 메모리에 생성합니다.
ClassName(parameters)는 클래스의 생성자를 호출합니다. parameters는 생성자가 필요로 하는 인자입니다.

기껏 위에서 Car클래스를 만들어 두었으니, 이를 사용해 예시를 보여드리겠습니다.

public class Main {
    public static void main(String[] args) {
        // Car 객체 생성
        Car myCar = new Car("Red", "KIA", 2020);

        // 객체의 메소드 호출
        myCar.startEngine(); 
        // 출력: Engine started
        System.out.println("Car color: " + myCar.getColor()); // 출력: Car color: Red

        // 객체의 필드 변경
        myCar.setColor("Blue");
        System.out.println("Updated car color: " + myCar.getColor()); 
        // 출력: Updated car color: Blue

        // 다른 Car 객체 생성
        Car anotherCar = new Car("Black", "HD", 2018);
        System.out.println("Another car model: " + anotherCar.getModel()); 
        // 출력: Another car model: Honda
    }
}

2-2 객체 생성과 관련된 주요 개념

생성자 : 생성자는 객체가 생성될 때 호출되는 특별한 메소드입니다. 객체의 필드를 초기화하는 역할을 합니다.
필드 접근 및 수정 : 객체의 필드를 직접 접근하거나 수정할 때는 보통 getter와 setter 메소드를 사용합니다. 이는 필드의 직접 접근을 막고 캡슐화를 유지하기 위해서입니다.
메소드 호출 : 객체가 생성되면 객체의 메소드를 호출하여 다양한 동작을 수행할 수 있습니다.

2-3 여러 객체 생성

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Red", "Toyota", 2020);
        Car car2 = new Car("Blue", "Honda", 2019);

        // 각 객체의 필드와 메소드에 독립적으로 접근 가능
        System.out.println("Car 1 color: " + car1.getColor()); // 출력: Car 1 color: Red
        System.out.println("Car 2 color: " + car2.getColor()); // 출력: Car 2 color: Blue

        car1.startEngine(); // 출력: Engine started
        car2.stopEngine();  // 출력: Engine stopped
    }
}

이처럼 클래스는 객체를 생성하기 위한 템플릿을 제공하며, 각 객체는 독립적인 필드와 메소드를 가집니다. 객체는 클래스의 인스턴스로, new 키워드를 통해 생성되고 생성자를 통해 초기화 됩니다.

3. 메소드 정의하는 방법

자바에서 메소드는 특정 작업을 수행하기 위해 클래스 내에 정의된 코드 블록입니다. 메소드는 재사용 가능한 코드를 만들고, 객체의 행동을 정의하는 데 사용됩니다. 메소드 정의는 크게 두 가지 부분으로 나뉩니다. 여기서는 메소드 선언과 메소드 분문 이 두 부분을 보겠습니다.

3-1 메소드 선언

메소드 선언은 메소드의 이름, 반환 타입, 매개변수 목록을 정의합니다. 기본적인 구조는 아래와 같습니다.

accessModifier returnType methodName(parameterList) {
    // 메소드 본문
}

accessModifier : 메소드의 접근 제어자를 지정합니다. (예: public, private, protected, default)
returnType : 메소드가 반환하는 값의 타입을 지정합니다. 반환값이 없는 경우, void를 사용합니다.
methodName : 메소드가 받을 매개변수 목록을 정의합니다. 매개변수가 없으면 빈 괄호 ()를 사용하면됩니다.

** 메소드 본문은 {}로 감싸며, 이 안에 실행할 코드를 작성합니다. **

예제

public class MathUtils {

    // 두 숫자의 합을 반환하는 메소드
    public int add(int a, int b) {
        return a + b;
    }

    // 두 숫자의 차를 반환하는 메소드
    public int subtract(int a, int b) {
        return a - b;
    }

    // 인삿말을 출력하는 메소드
    public void printGreeting(String name) {
        System.out.println("Hello, " + name + "!");
    }
}

add : 두 정수를 입력받아, 합을 반환합니다. 여기서 알 수 있듯이, 반환 타입은 int 타입입니다.
subtract : 두 정수를 입력받아 차를 반환합니다. 마찬가지로 int 타입을 반환합니다.
printGreeting : 문자열을 입력받아 인사말을 출력합니다. 출력하고 끝이므로, 반환값이 없어 void입니다.

3-2 메소드 호출

정의된 메소드는 클래스의 객체를 통해 호출할 수 있습니다.

public class Main {
    public static void main(String[] args) {
        // MathUtils 객체 생성
        MathUtils mathUtils = new MathUtils();

        // add 메소드 호출
        int sum = mathUtils.add(5, 3);
        System.out.println("Sum: " + sum); 
        // 출력: Sum: 8

        // subtract 메소드 호출
        int difference = mathUtils.subtract(10, 4);
        System.out.println("Difference: " + difference); 
        // 출력: Difference: 6

        // printGreeting 메소드 호출
        mathUtils.printGreeting("Alice"); 
        // 출력: Hello, Alice!
    }
}

3-3 메소드 오버로딩

메소드 오버로딩은 동일한 이름의 메소드를 여러 개 정의하되, 매개변수 목록이 다르도록 하는 것입니다.

public class MathUtils {

    // 두 정수를 더하는 메소드
    public int add(int a, int b) {
        return a + b;
    }

    // 세 정수를 더하는 메소드 (오버로딩)
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 두 실수를 더하는 메소드 (오버로딩)
    public double add(double a, double b) {
        return a + b;
    }
}

예제

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

        int sum1 = mathUtils.add(1, 2);
        int sum2 = mathUtils.add(1, 2, 3);
        double sum3 = mathUtils.add(1.5, 2.5);

        System.out.println("Sum1: " + sum1); 
        // 출력: Sum1: 3
        System.out.println("Sum2: " + sum2); 
        // 출력: Sum2: 6
        System.out.println("Sum3: " + sum3); 
        // 출력: Sum3: 4.0
    }
}

3-4 기타 중요 개념

반환 타입 : 메소드는 작업을 수행한 결과를 호출자에게 반환할 수 있습니다. 반환 타입이 void가 아닌 경우 return 키워드를 사용하여 값을 반환합니다.
매개변수 : 메소드는 호출 시 전달받은 값을 매개변수를 통해 사용할 수 있습니다. 매개변수는 타입과 이름을 지정하여 선언합니다.
접근 제어자 : 메소드의 접근 수준을 정의합니다. public, private, protected, default 등이 있습니다.
스코프 : 메소드 내에서 선언된 변수는 해당 메소드 내에서만 유효합니다. 이를 지역 변수라고 합니다.

스코프 관련해서 call of value vs call of reference 를 한번 찾아 보시면 좋을것 같습니다.

이처럼 자바에서 메소드는 클래스의 동작을 정의하며, 메소드 선언과 본문을 통해 다양한 작업을 수행할 수 있습니다. 메소드는 객체의 행동을 정의하고, 재사용 가능한 코드를 작성하는 데 중요한 역할을 합니다.

4. 생성자 정의하는 방법

자바에서 생성자는 클래스의 인스턴스를 초기화하는 특별한 메소드입니다.

생성자의 이름은 클래스의 이름과 같아야 하며, 반환 타입이 없습니다. 생성자는 객체가 생성될 때 호출되며, 객체의 필드를 초기화하거나 초기 설정 작업을 수행하는데 사용됩니다.

4-1 기본 생성자

기본 생성자는 매개변수를 가지지 않는 생성자입니다. 클래스에 명시적으로 생성자를 정의하지 않으면 컴파일러가 자동으로 기본 생성자를 제공합니다.

하지만 생성자가 하나라도 명시적으로 정의되어 있으면 기본 생성자는 자동으로 제공되지 않습니다.

public class Car {
    private String color;
    private String model;
    private int year;

    // 기본 생성자
    public Car() {
        // 필드 초기화 (기본값)
        this.color = "Unknown";
        this.model = "Unknown";
        this.year = 0;
    }
}

4-2 매개변수가 있는 생성자

매개변수가 있는 생성자는 객체를 생성할 때 필요한 값을 전달받아 필드를 초기화 합니다.

public class Car {
    private String color;
    private String model;
    private int year;

    // 매개변수가 있는 생성자
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }
}

4-3 여러 생성자(생성자 오버로딩)

클래스는 여러 개의 생성자를 가질 수 있으며, 이를 생성자 오버로딩이라고 합니다. 각 생성자는 다른 매개변수 목록을 가질 수 있습니다.

public class Car {
    private String color;
    private String model;
    private int year;

    // 기본 생성자
    public Car() {
        this.color = "Unknown";
        this.model = "Unknown";
        this.year = 0;
    }

    // 매개변수가 있는 생성자
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    // 일부 필드만 초기화하는 생성자
    public Car(String color, String model) {
        this.color = color;
        this.model = model;
        this.year = 0;
    }
}

4-4 생성자 호출

생성자는 new 키워드를 사용하여 객체를 생성할 때 호출됩니다. 예신느 아래와 같습니다.

예시

public class Main {
    public static void main(String[] args) {
        // 기본 생성자를 사용하여 객체 생성
        Car defaultCar = new Car();
        System.out.println("Default car: " + defaultCar.getColor() + ", " + defaultCar.getModel() + ", " + defaultCar.getYear());

        // 매개변수가 있는 생성자를 사용하여 객체 생성
        Car myCar = new Car("Red", "KIA", 2020);
        System.out.println("My car: " + myCar.getColor() + ", " + myCar.getModel() + ", " + myCar.getYear());

        // 일부 필드만 초기화하는 생성자를 사용하여 객체 생성
        Car anotherCar = new Car("Blue", "HD");
        System.out.println("Another car: " + anotherCar.getColor() + ", " + anotherCar.getModel() + ", " + anotherCar.getYear());
    }
}

출력

Default car: Unknown, Unknown, 0
My car: Red, KIA, 2020
Another car: Blue, HD, 0

4-5 주의 사항

생성자는 클래스의 이름과 동일해야 하며, 반환 타입이 없어야 합니다.
생성자는 오버로딩이 가능하므로 여러개 정의할 수 있습니다.
하나의 생성자에서 다른 생성자를 호출할 때는 this 키워드를 사용하며, 이 경우 호출하는 구문은 반드시 첫 번째 줄에 위치해야 합니다.

결론

생성자는 클래스의 인스턴스를 초기화하는데 중요한 역할을 하며, 객체가 생성될 때 필드의 초기값을 설정하거나 초기 설정 작업을 수행합니다.

생성자 오버로딩을 통해 다양한 방법으로 객체를 생성할 수 있으며, this 키워드를 사용하여 코드의 중복을 줄일 수 있습니다.

5. this 키워드 이해하기

this 키워드는 자바에서 중요한 개념 중 하나로, 현재 객체 자신을 참조하는 데 사용됩니다.

this 키워드를 이해하면 객체 지향 프로그래밍에서 객체와 인스턴스 변수를 다루는 방법을 명확히 이해할 수 있습니다.

5-1 현재 객체 참조

this 키워드는 클래스의 인스턴스 메소드나 생성자 내에서 현재 객체를 참조합니다. 이는 메소드나 생성자에서 클래스의 필드와 메소드를 명확하게 접근할 수 있도록 합니다.

5-2 인스턴스 변수와 로컬 변수 구분

가장 일반적인 사용 사례는 인스턴스 변수와 로컬 변수의 이름이 동일할 때, 이를 구분하는 것입니다. this 키워드는 인스턴스 변수를 명확하게 참조하는데 사용됩니다.

public class Car {
    private String color;
    private String model;
    private int year;

    // 생성자
    public Car(String color, String model, int year) {
        this.color = color;  
        // this.color는 인스턴스 변수, color는 매개변수
        this.model = model;  
        // this.model는 인스턴스 변수, model은 매개변수
        this.year = year;    
        // this.year는 인스턴스 변수, year는 매개변수
    }

    // 인스턴스 메소드
    public void setColor(String color) {
        this.color = color;  
        // this.color는 인스턴스 변수, color는 매개변수
    }
}

5-3 생성자에서 다른 생성자 호출

this 키워드는 같은 클래스 내의 다른 생성자를 호출할 때 사용됩니다. 이를 통해 코드의 중복을 줄이고, 공통 초기화 로직을 하나의 생성자로 집중시킬 수 있습니다.

이때 this 키워드를 사용한 생성자 호출은 반드시 생성자의 첫 번째 줄에 위치해야 합니다.

public class Car {
    private String color;
    private String model;
    private int year;

    // 기본 생성자
    public Car() {
        this("Unknown", "Unknown", 0); 
        // 다른 생성자 호출
    }

    // 매개변수가 있는 생성자
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    // 일부 필드만 초기화하는 생성자
    public Car(String color, String model) {
        this(color, model, 0); // 다른 생성자 호출
    }
}

5-4 메소드 체이닝(Method Chaining)

this 키워드는 메소드 체이닝을 구현할 때 사용됩니다. 메소드 체이닝은 객체의 메소드를 연속적으로 호출 할 수 있게 하는 패턴입니다. 이를 위해 메소드가 this를 반환하도록 정의됩니다.

public class Car {
    private String color;
    private String model;
    private int year;

    // 생성자
    public Car(String color, String model, int year) {
        this.color = color;
        this.model = model;
        this.year = year;
    }

    // 메소드 체이닝을 위한 메소드
    public Car setColor(String color) {
        this.color = color;
        return this;  // 현재 객체 반환
    }

    public Car setModel(String model) {
        this.model = model;
        return this;  // 현재 객체 반환
    }

    public Car setYear(int year) {
        this.year = year;
        return this;  // 현재 객체 반환
    }
}

// 메소드 체이닝 사용 예
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Red", "Toyota", 2020);
        myCar.setColor("Blue")
             .setModel("Honda")
             .setYear(2022);

        System.out.println("Car: " + myCar.getColor() + ", " + myCar.getModel() + ", " + myCar.getYear());
    }
}

5-5 내부 클래스에서 외부 클래스 참조

내부 클래스에서 외부 클래스의 인스턴스를 참조할 때 outerClass.this 형식을 사용합니다.

public class OuterClass {
    private int outerValue = 10;

    public class InnerClass {
        private int innerValue = 20;

        public void display() {
            System.out.println("Outer value: " + OuterClass.this.outerValue);
            System.out.println("Inner value: " + this.innerValue);
        }
    }
}

// 사용 예
public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}

요약

현재 객체 참조 : this 키워드는 현재 객체를 참조합니다.
인스턴스 변수와 로컬 변수 구분 : this를 사용화여 인스턴스 변수와 로컬 변수를 구분합니다.
다른 생성자 호출 : 생성자 내에서 다른 생성자를 호출할 때 this를 사용합니다.
메소드 체이닝 : this를 반환하여 메소드 체이닝을 구현할 수 있습니다.
내부 클래스에서 외부 클래스 참조 : 내부 클래스에서 외부 클래스의 인스턴스를 참조할 때 사용됩니다.

this 키워드는 객체 지향 프로그래밍에서 중요한 역할을 하며, 이를 잘 활용하면 코드의 가독성과 재사용성을 높일 수 있습니다.

제어문

Mon, 27 May 2024 07:01:40 GMT

목표

자바가 제공하는 제어문을 학습

1. 선택문

크게 if문과 switch 문이 존재합니다. 먼저 if 문을 살펴보겠습니다.

1) if문

int number = 0;
if (number > 0) {
    System.out.println("The number is positive.");
} else if (number < 0) {
    System.out.println("The number is negative.");
} else {
    System.out.println("The number is zero.");
}

가장먼저 if문 내부의 조건을 확인합니다. 순차적으로 조건을 검사하며, 첫 번째 참인 조건의 코드 블록을 실행합니다. 만약 마지막까지 조건이 일치하지 않는다면, else문의 코드블럭을 실행합니다.

2) switch문

switch 문은 하나의 변수 값에 따라 여러 코드 블록 중 하나를 실행할 때 사용합니다. switch 문은 정수, 문자열, 열거형(enum) 값에 대해 사용할 수 있습니다.

int day = 3;
switch (day) {
    case 1:
        System.out.println("1");
        break;
    case 2:
        System.out.println("2");
        break;
    case 3:
        System.out.println("3");
        break;
    default:
        System.out.println("Invalid num");
        break;
}

break: 각 case블록의 끝에 사용되며, 해당 블록이 실행된 후 switch문을 빠져나갑니다. break를 사용하지 않으면, 다음 **case블럭이 실행됩니다.**

3) Java13의 switch 표현식

이전 포스팅에서도 소개하였지만, Java13부터 switch문은 표현식으로 사용될 수 있으며, yield 키워드를 사용하여 값을 반환할 수 있습니다.

예시 1

int day = 3;
String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    case 4 -> "Thursday";
    case 5 -> "Friday";
    case 6 -> "Saturday";
    case 7 -> "Sunday";
    default -> "Invalid day";
};
System.out.println(dayName);

여기서는 day 변수의 값에 따라 dayName 변수가 설정됩니다. case 블록은 화살표(->)를 사용하여 값을 반환합니다.

예시 2

각 case에서 여러 레이블을 쉼표로 구분할 수 있으며, 복잡한 로직을 처리하기 위해 중괄호 {}를 사용하여 코드 블록을 작성할 수 있습니다.

int score = 85;
String grade = switch (score) {
    case 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100 -> "A";
    case 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 -> "B";
    case 70, 71, 72, 73, 74, 75, 76, 77, 78, 79 -> "C";
    case 60, 61, 62, 63, 64, 65, 66, 67, 68, 69 -> "D";
    default -> {
        if (score < 60) {
            yield "F";
        } else {
            yield "Invalid score";
        }
    }
};
System.out.println("Grade: " + grade);

yield 키워드를 사용하여 값 반환

yield 키워드는 중괄호를 사용한 복잡한 코드 블록 내에서 값을 반환할 때 사용됩니다.

int num = 10;
String parity = switch (num % 2) {
    case 0 -> {
        String result = "even";
        yield result;
    }
    case 1 -> {
        String result = "odd";
        yield result;
    }
    default -> throw new IllegalStateException("Unexpected value: " + num % 2);
};
System.out.println("The number is " + parity);

요약

더 간결한 문법으로 가독성이 향상되는 장점이 있습니다.
각 case 블록에서 명시적으로break를 사용하지 않아도 됩니다.
값을 반환하여 함수형 프로그래밍 스타일을 지원
다중 레이블과 yield 키워드를 사용하여 보다 복잡한 로직을 처리할 수 있음

2. 반복문

1-1) for문

for 문은 반복 횟수가 명확할 때 주로 사용됩니다. 초기화, 조건 검사, 증감식을 한 줄에 작성하여 반복문을 제어합니다.

for (initialization; condition; update) {
    // 반복할 코드
}

for (int i = 0; i < 5; i++) {
    System.out.println("i: " + i);
}

1-2) for-each

향상된 for문이라고도 불립니다. 반복자를 사용하지 않고도 각 요소에 접근할 수 있습니다.

for (type element : array/collection) {
    // 반복할 코드
}

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println("number: " + number);
}

2) while 문

while 문은 반복 횟수가 명확하지 않고, 조건이 참인 동안 반복을 계속할 때 사용됩니다. 조건이 처음에 검사됩니다.

while (condition) {
    // 반복할 코드
}

int i = 0;
while (i < 5) {
    System.out.println("i: " + i);
    i++;
}

3) do-while 문

do-while 문은 조건이 참인지 여부에 상관없이 코드를 최소한 한 번 실행하고, 이후 조건이 참인 동안 반복을 계속합니다. 조건이 나중에 검사됩니다.

do {
    // 반복할 코드
} while (condition);


int i = 0;
do {
    System.out.println("i: " + i);
    i++;
} while (i < 5);

4) 반복문 제어 키워드

break : 반복문을 즉시 종료합니다.
continue : 현재 반복을 건너뛰고, 다음 반복을 시작합니다.

// break
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println("i: " + i);
}


// continue
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println("i: " + i);
}

연산자

Sun, 26 May 2024 09:17:40 GMT

목표

자바가 제공하는 다양한 연산자를 학습

1. 산술 연산자

산술 연산을 수행하는 연산자입니다.

산술 연산자의 종류: +, -, *, /, % 특히 나눗셈 연산자의 경우 두 피연산자가 정수인 경우에는 정수형 나눗셈이, 실수인 경우에는 실수형 나눗셈이 진행됩니다.

추가로 증가연산자(++) 감소연산자(--) 가 있습니다. 값을 1씩 증가하거나 감소시키는데, 이 연산자의 위치에 따라 조금 사용법이 다릅니다.** 앞에 붙게되면 증/감 후 연산수행하고, 뒤에 붙게되면 연산후 증/감 됩니다.**

2. 비트 연산자

비트 연산자는 정수형 데이터의 개별 비트를 직접 조작하는 데 사용됩니다. Java에서 제공하는 주요 비트 연산자는 다음과 같습니다

연산자	설명	예제
비트 AND (`&`)	두 비트가 모두 1일 때만 1을 반환합니다.	`int result = a & b;`
비트 OR (`\|`)	두 비트 중 하나라도 1이면 1을 반환합니다.	`int result = a \| b;`
비트 XOR (`^`)	두 비트가 다를 때만 1을 반환합니다.	`int result = a ^ b;`
비트 NOT (`~`)	비트의 값을 반전시킵니다 (0을 1로, 1을 0으로).	`int result = ~a;`
왼쪽 시프트 (`<<`)	비트를 왼쪽으로 이동시키고, 오른쪽에 0을 채웁니다.	`int result = a << 2;` (a의 비트를 왼쪽으로 2칸 이동)
오른쪽 시프트 (`>>`)	비트를 오른쪽으로 이동시키고, 왼쪽에 부호 비트를 채웁니다.	`int result = a >> 2;` (a의 비트를 오른쪽으로 2칸 이동)
부호 없는 오른쪽 시프트 (`>>>`)	비트를 오른쪽으로 이동시키고, 왼쪽에 0을 채웁니다.	`int result = a >>> 2;` (a의 비트를 오른쪽으로 2칸 이동)

이 연산자들은 정수 값을 비트 수준에서 조작할 때 유용하며, 특정 비트 패턴을 빠르게 계산하거나 확인하는 데 자주 사용됩니다.

3. 관계 연산자

관계 연산자는 두 피연산자 간의 관계를 비교하는 데 사용됩니다. Java에서 제공하는 주요 관계연산자는 다음과 같습니다.

연산자	설명	예제
`==`	두 피연산자가 서로 같으면 `true`를 반환합니다.	`if (a == b)`
`!=`	두 피연산자가 서로 다르면 `true`를 반환합니다.	`if (a != b)`
`>`	왼쪽 피연산자가 오른쪽 피연산자보다 크면 `true`를 반환합니다.	`if (a > b)`
`<`	왼쪽 피연산자가 오른쪽 피연산자보다 작으면 `true`를 반환합니다.	`if (a < b)`
`>=`	왼쪽 피연산자가 오른쪽 피연산자보다 크거나 같으면 `true`를 반환합니다.	`if (a >= b)`
`<=`	왼쪽 피연산자가 오른쪽 피연산자보다 작거나 같으면 `true`를 반환합니다.	`if (a <= b)`

주로 조건문과 함께 사용되며, 두 값의 관계를 판단하여 프름을 제어하는데 유용합니다.

4. 논리 연산자

논리식의 결과에 따라 true, 또는 false를 반환하는 연산자 입니다.

연산자의 종류 : &&, ||, !

피연산자1	피연산자2	연산 결과 ( && )
true	true	true
true	false	false
false	true	false
false	false	false

피연산자1	피연산자2	연산 결과 ( \|\| )
true	true	true
true	false	true
false	true	true
false	false	false

주의 할점

public class Operator {
    public static void main(String[] args){
        int num1 = 0;
        int num2 = 0;
        boolean result;

        result = ((num1 += 10) < 0) && ((num2 += 10) > 0);
        System.out.println("num1: "+num1+" num2: "+num2 + " result: " + result);
        // 실행 결과: num1: 10 num2: 0 result: false
    }
}

num1과 num2가 모두 10이 되어야 할것같지만, 실제로 num1은 10, num2는 0의 결과를 리턴합니다.

왜 그럴까?

이유는 연산의 특성중 Short-Circuit Evaluation(SCE)에서 이유를 찾을 수 있습니다.

((num1 += 10) < 0) && ((num2 += 10) > 0) 이 연산을 진행할 때, &&의 왼편에 있는 연산이 먼저 실행되는데, 이때 num1은 증가합니다. 그리고 < 연산결과는 false이므로 아래와 같다고 볼 수있습니다.

false && ((num2 += 10) > 0)

&&의 오른쪽 연산을 진행해야하지만, &&의 이전에 false가 왔기때문에, 오른쪽의 결과가 어떻든간에 result는 false가 됩니다.

그렇기 때문에 오른쪽을 비교할 필요가 없습니다.

여기서 SCE의 특성이 나오는데, 정리하자면 아래와 같습니다.

&&의 왼쪽 피연산자가 false이면, 오른쪽 피연산자는 확인하지 않는다.
||의 왼쪽 피연산자가 true이면, 오른쪽 피연산자는 확인하지 않는다.

5. instanceof

instanceof는 객체가 특정 클래스의 인스턴스인지를 확인하는데 사용되는 연산자 입니다. 리턴값은 true, false 입니다.

예시 코드

class Animal {
    // Animal 클래스 구현 내용
}

class Dog extends Animal {
    // Dog 클래스 구현 내용
}

class Cat extends Animal {
    // Cat 클래스 구현 내용
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        System.out.println(animal1 instanceof Dog); // true
        System.out.println(animal2 instanceof Dog); // false
        System.out.println(animal2 instanceof Cat); // true
    }
}

Animal1은 Dog의 클래스의 인스턴스 이므로 true를 반환합니다.
그러나 animal2는 Cat의 인스턴스이므로 false를 반환합니다.
마지막은 물론 animal2는 Cat이므로 true입니다.

6. assignment(=) operator

할당(대입) 연산자 =는 값을 할당하는데 사용됩니다. 왼쪽 피연산자에 오른쪽 피연산자 값을 할당합니다.

int x = 10;             // 정수 값 할당
double y = 3.14;        // 실수 값 할당
char c = 'A';           // 문자 값 할당
boolean flag = true;    // 논리 값 할당
String name = "Lee";    // 문자열 값 할당

7. 화살표(->) 연산자

화살표(->) 연산자는 람다 표현식에서 사용됩니다. 람다 표현식은 함수형 프로그래밍의 핵심 개념으로, 익명 함수를 간결하게 표현하는 방법입니다. Java8부터 도입되었습니다.

사용 방법

(parameters) -> expression
// 또는
(parameters) -> { statements; }

매개변수를 본문(하나의 표현식이거나 여러 문장의 블록)에 연결합니다.

예시 코드

Comparator comparator = new Comparator() {
    public int compare(Integer a, Integer b) {
        return a.compareTo(b);
    }
};

이랬던 코드가

Comparator comparator = (a, b) -> a.compareTo(b);

이렇게 변화 합니다.

여기서 (a, b) -> a.compareTo(b)는 두 개의 정수를 비교하는 비교자를 나타냅니다. 이것은 두 정수를 받아서 첫 번째 정수가 두 번째 정수보다 작으면 음수를 반환하고, 같으면 0을 반환하고, 크면 양수를 반환합니다.

람다 표현식을 사용하면 코드를 더 간결하고 가독성 있게 만들 수 있으며, 함수형 프로그래밍 스타일을 채택할 수 있습니다.

8. 3항 연산자

3항 연산자는 세 개의 피연산자를 갖는 조건부 연산자입니다. 조건식의 결과에 따라 두 개의 표현식 중 하나를 선택하여 반환합니다.

조건식 ? 표현식1 : 표현식2 여기서 조건식은 참 또는 거짓으로 평가될 수 있는 표현식 입니다. 만약 조건식이 참이면 표현식1이 반환되고, 거짓이면 표현식2가 반환됩니다.

예시 코드

int x = 10;
String result = (x > 0) ? "양수입니다." : "음수입니다.";
System.out.println(result);

이 코드에서 출력값은 양수입니다.가 출력될 것입니다.

9. 연산자 우선 순위

연산자의 우선 순위는 표현식에서 연산이 수행되는 순서를 결정합니다. 우선 순위가 높은 연산자가 먼저 계산되고, 낮은 우선 순위 연산자는 나중에 계산됩니다. 수학적인 우선 순위와 비슷합니다.

기본적으로 연산자에는 우선수누이가 있으며, 괄호의 우선순위가 제일 높습니다. 다음으로는 산술 > 비교 > 논리 > 대입의 순서이며, 단항 > 이항 > 삼항의 순서입니다.

연산자의 연산 진행방향은 왼쪽에서 오른쪽으로 수행되며, 단항 연산자와 대입 연산자의 경우에는 오른쪽에서 왼쪽으로 수행됩니다.

10. (optional) Java 13. switch 연산자

switch 문의 확장된 형태입니다. 기존의 switch 문과는 다르게 switch 표현식은 값을 반환할 수 있으며, 각 case에 대한 값도 명시적으로 지정할 수 있습니다.

예시 코드

int dayOfWeek = 3;
String dayName = switch (dayOfWeek) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    case 4 -> "Thursday";
    case 5 -> "Friday";
    case 6, 7 -> {
        yield "Weekend";
    }
    default -> throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeek);
};

이 코드에서 switch 표현식은 dayOfWeek 변수를 평가하고 해당하는 문자열 값을 dayName 변수에 할당합니다. 즉, dayOfWeek가 3이면 dayName에는 "Wednesday"가 할당됩니다.

yield 키워드는 "Weekend"라는 것을 반환하고 switch 블록을 종료합니다.

switch 표현식의 주요 특징은 다음과 같습니다

case 라벨은 콜론(:) 대신 화살표(->)를 사용합니다.
각 case는 값을 반환할 수 있습니다.
여러 case를 쉼표(,)로 결합하여 하나의 case로 처리할 수 있습니다.
default 블록도 값을 반환할 수 있습니다.
모든 경우를 처리하거나, default 블록을 제공해야합니다.

자바 데이터타입 & 변수 & 배열

Fri, 24 May 2024 02:45:16 GMT

목표

자바의 프리미티브 타입, 변수 그리고 배열을 사용하는 방법을익힙니다.

1. 프리미티브 타입 종류와 값의 범위 그리고 기본 값 2. 프리미티브 타입과 레퍼런스 타입 3. 리터럴 4. 변수 선언 및 초기화하는 방법 5. 변수의 스코프와 라이프타임 6. 타입 변환, 캐스팅 그리고 타입 프로모션 7. 1차 및 2차 배열 선언하기 8. 타입 추론, var

1. 프리미티브 타입 종류와 값의 범위 그리고 기본 값

Primitive Type 요약

primitive type은 자바의 기본 타입들이라고 할 수 있습니다. 총 8개로 이루어져있으며, 자바에서는 필드 선언시 초기화를 하지 않으면, 기본값으로 초기화 됩니다.

기본자료형 혹은 원시 자료형 이라고 불리는 프리미티브 타입은 값을 할당할 때 변수의 주소값에 값이 그 자체로 저장되는 데이터 타입입니다. 해당 데이터 타입은 값이 할당되면 JVM Runtime Data Area 영역 중 Stack 영역에 값이 저장됩니다.

프리미티브 타입의 종류

정수형 : byte, short, int, long 실수형 : float, double 문자형 : char 논리형 : Boolean

2. 프리미티브 타입과 레퍼런스 타입

Reference Type?

Reference Type은 Primitive Type을 제외한 모든 타입을 포함합니다. 참조값을 통해 관리하기 때문에 Reference Type이라고 불리며, Null을 사용할 수 있습니다.

또한 Reference Type은 변수 선언시 변수에 값이 저장되는 것이 아니라 객체에 대한 힙 영역의 참조를 저장하게 됩니다. 즉, *프리미티브 타입과 다르게 변수의 주소가 아닌, heap영역에 할당된 주소가 저장됩니다. *

*※ WrapperClass *

Primitive Type을 인스턴스로 다룰 수 있게끔 도와주는 것들을 말합니다. 값을 조작하기 위해 작성된 UtilMethod를 사용하기 위해서 이용하는 경우도 많습니다.

// 대응 클래스
// 가장 앞 문자를 대문자로 사용하면 됩니다.
byte -> Byte      char -> Character
short -> Short    float -> Float
int -> Integer    double -> Double
long -> Long      boolean -> Boolean

// 선언 예시
Integer num = new Integer(10);

3. 리터럴

리터럴(literal)은 프로그래밍에서 변수에 저장되는 값을 나타내는 구체적인 표기입니다. 즉, 코드에서 고정된 값으로 직접 작성되는 데이터를 말합니다. 리터럴은 여러가지 유형이 있으며, 각 유형은 특정한 데이터 타입을 나타냅니다.

// ex) 정수
`10`, `-5` ...

// 실수(float)
`3.14`, `-0.001`, ..

이 외에도 list([ ]), tuple(( )), set({ }),
dictionary({'key': 'value'}), None, boolean 등이 있습니다.

참고로 특수문자 리터럴도 존재합니다.(\t, \n, \r 등등)

4. 변수 선언 및 초기화하는 방법

Declaration / Initialization

Declaration 변수를 선언한다는 것은, 저장공간을 확보하겠다는 의미라고 볼 수 있습니다.

Initialization 변수를 초기화 한다는 것은, 저장공간에 원하는 값을 저장하는 것을 의미합니다.

// Declaration
int a;

// Initialization
a = 10;

위 코드의 Declaration을 보면 int 타입의 a 라는 이름으로 4byte(int는 4byte)를 확보했다고 볼 수 있겠습니다. 이어서 Initialization을 보면, a 이름에 10이라는 값을 할당해 주었다는 것을 알 수 있습니다.

5. 변수의 스코프와 라이프타임

여기서 scope는 변수의 유효범위를 뜻하고, lifetime은 존재 기간을 의미합니다.

스코프(Scope)

1) 클래스 스코프(Class Scope)

클래스 내에서 선언된 변수(필드)는 클래스 전체에서 접근 가능합니다.
클래스 변수(static 변수)는 클래스의 모든 인스턴스에서 공유됩니다.
인스턴스 변수(non-static 변수)는 각 인스턴스마다 개별적으로 존재합니다.

public class MyClass {
    // 클래스 변수 (static)
    static int staticVar;

    // 인스턴스 변수 (non-static)
    int instanceVar;

    public void myMethod() {
        // 메서드 내부에서는 static 변수와 인스턴스 변수 모두 접근 가능
        staticVar = 10;
        instanceVar = 20;
    }
}

2) 메서드 스코프(Method Scope)

메서드 내에서 선언된 변수는 메서드가 실행되는 동안에만 유효합니다.

메서드가 종료되면 메서드 스코프 내의 변수는 더 이상 접근할 수 없습니다.

public void myMethod() {
  int localVar = 10; // 지역 변수
  // localVar은 myMethod 내에서만 접근 가능
}

3) 블록 스코프(Block Scope)

중괄호 {} 로 둘러싸인 블록 내에서 선언된 변수는 해당 블록 내에서만 유효합니다.

블론이 종료되면 블록 스코프 내의 변수는 더 이상 접근 할 수 없습니다.

public void myMethod() {
  if (true) {
      int blockVar = 10; // 블록 변수
      // blockVar은 if 블록 내에서만 접근 가능
  }
  // 여기서는 blockVar에 접근할 수 없음
}

라이프 타임(Lifetime)

변수의 라이프타임은 변수가 메모리에 존재하는기간을 의미합니다. 변수의 스코프와 라이프타임은 종종 밀접하게 관련되어 있지만, 두 개념은 다릅니다.

1) 클래스 변수(static 변수)

프로그램 시작 시 메모리에 할당되고, 프로그램 종료시 해제 됩니다.
클래스 로더에 의해 클래스가 메모리에 로드될 때 생성되며, JVM이 종료될 때까지 유지됩니다.

2) 인스턴스 변수(non-static 변수)

객체가 생성될 때 메모리에 할당되고, 객체가 Garbage Collection에 의해 소멸될 때 해제됩니다.
객체가 메모리에 존재하는 동안 인스턴스 변수도 함께 존재합니다.

3) 지역 변수(Local Variable)

메서드 또는 블록이 실행될 때 메모리에 할당되고, 메서드 또는 블록이 종료되면 해제됩니다.
지역 변수는 스택 메모리에 저장되며, 메서드 호출이 끝나면 스택프레임과 함께 제거됩니다.

public class VariableScope {
    // 클래스 변수 (static)
    static int classVar = 10;

    // 인스턴스 변수 (non-static)
    int instanceVar = 20;

    public void method() {
        // 지역 변수 (local)
        int localVar = 30;

        // 블록 내에서 선언된 블록 변수 (block scope)
        if (true) {
            int blockVar = 40;
            // 여기서는 classVar, instanceVar, localVar, blockVar 모두 접근 가능
        }
        // 여기서는 blockVar에 접근할 수 없음
    }

    public static void main(String[] args) {
        // main 메서드도 하나의 블록이므로, 
        // 여기서 선언된 변수는 이 블록 내에서만 유효
        VariableScope obj = new VariableScope();
        obj.method();
    }
}

이 예제에서 classVar는 프로그램이 종료될 때까지 유효하며, instanceVar는 obj 객체가 가비지 컬렉션될 때까지 유효합니다. localVar는 method가 실행되는 동안에만 유효하고, blockVar는 if 블록 내에서만 유효합니다.

6. 타입 변환, 캐스팅 그리고 타입 프로모션

타입 변환(Type Conversion)

타입 변환은 하나의 데이터 타입을 다른 데이터 타입으로 변환하는 과정입니다. 타입 변환은 암시적(자동) 또는 명시적(수동)으로 이루어질 수 있습니다.

1) 자동 타입 변환(Implicit Type Conversion, Widening Conversion)

작은 크기의 데이터 타입이 큰 크기의 데이터 타입으로 자동으로 변환되는 것을 말합니다.
데이터 손실이 발생하지 않으므로 안전한 변환입니다.

int intValue = 100;
long longValue = intValue;  // int가 long으로 자동 변환
double doubleValue = intValue;  // int가 double로 자동 변환

2) 명시적 타입 변환(Explicit Type Conversion, Narrowing Conversion)

큰 크기의 데이터 타입 작은 크기의 데이터 타입으로 변환할 때 명시적으로 변환을 지정해야 합니다.

데이터 손실이 발생할 수 있으므로 주의가 필요합니다.

int intValue = 100;
long longValue = intValue;  // int가 long으로 자동 변환
double doubleValue = intValue;  // int가 double로 자동 변환

캐스팅 (Casting)

캐스팅은 명시적 타입 변환의 한 형태로, 주로 참조 타입(객체) 사이의 변환을 가리킵니다. 캐스팅은 상속 관계에 있는 클래스 간에 이루어집니다.

1) 업케스팅 (Upcasting)

서브 클래스 타입을 슈퍼 클래스 타입으로 변환합니다.
암시적으로 이루어지며, 명시적인 캐스팅이 필요하지 않습니다.
```
class Animal { }
class Dog extends Animal { }
```

Animal animal = new Dog(); // 업캐스팅





#### 2) 다운캐스팅 (Downcasting)
- 슈퍼 클래스 타입 서브 클래스 타입으로 변환합니다.
- 명시적인 캐스팅이 필요하며, 런타임에 'ClassCastException'이 발생할 수 있습니다.
```java
Animal animal = new Dog();
Dog dog = (Dog) animal;  // 다운캐스팅

타입 프로모션 (Type Promotion)

타입 프로모션은 표현식을 평가할 때 작은 데이터 타입의 피연산자가 큰 데이터 타입으로 자동 변환되는 과정입니다. 이는 주로 연산자와 함께 사용됩니다.

1) 정수형 타입 프로모션

byte, short, char 타입의 값이 int 타입으로 자동 프로모션됩니다.
여러 피연산자가 있을 경우, 피연산자의 데이터 타입이 가장 큰 타입으로 프로모션 됩니다.

byte b = 42;
char c = 'a';
int i = b + c;  // b와 c가 int로 프로모션됨

2) 실수형 타입 프로모션

float 타입이 double 타입으로 자동 프로모션 됩니다.

float f = 3.14f;
double d = f + 2.0;  // f가 double로 프로모션됨

예재 코드

public class TypeConversionExample {

    public static void main(String[] args) {
        // 자동 타입 변환 (Widening)
        int intVal = 100;
        long longVal = intVal;  // int to long
        double doubleVal = intVal;  // int to double

        // 명시적 타입 변환 (Narrowing)
        double doubleNum = 9.78;
        int intNum = (int) doubleNum;  // double to int
        System.out.println("Converted double to int: " + intNum);

        // 업캐스팅
        Animal animal = new Dog();  // Upcasting
        animal.makeSound();  // Animal의 메서드를 호출

        // 다운캐스팅
        Dog dog = (Dog) animal;  // Downcasting
        dog.bark();  // Dog의 메서드를 호출

        // 타입 프로모션
        byte byteVal = 42;
        char charVal = 'a';
        int result = byteVal + charVal;  // byte와 char가 int로 프로모션됨
        System.out.println("Promoted result: " + result);

        float floatVal = 3.14f;
        double doubleResult = floatVal + 2.0;  // float가 double로 프로모션됨
        System.out.println("Promoted double result: " + doubleResult);
    }
}

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog barks");
    }
}

7. 1차 및 2차 배열 선언하기

1차원 배열

1차원 배열은 단일 차원의 배열을 의미합니다. 배열은 동일한 데이터 타입의 요소를 저장하는 연속된 공간을 갖습니다.

1) 선언

array라는 이름의 정수형 배열

int[] array;

2) 배열생성 및 초기화

길이가 5인 정수 배열을 생성합니다. 배열 요소는 자동으로 기본값(정수의 경우 0)으로 초기화 됩니다.

array = new int[5]; // 길이가 5인 배열 생성

3) 선언과 동시에 초기화

int[] array = new int[5];

4) 선언과 동시에 값 할당

int[] array = {1, 2, 3, 4, 5}

2차원 배열

1) 배열 선언

int[][] matrix;

2) 배열 생성 및 초기화

matrix = new int[3][4]; // 3x4 배열 생성

이 구문은 3개의 행과 4개의 열을 갖는 2차원 배열을 생성합니다. 모든 요소는 기본값으로 초기화 됩니다.

3) 선언과 동시에 초기화

int[][] matrix = new int[3][4];

4) 선언과 동시에 값 할당

int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

예제 코드

public class ArrayExample {

    public static void main(String[] args) {
        // 1차 배열 선언 및 초기화
        int[] oneDimArray = new int[5];  // 선언과 동시에 길이가 5인 배열 생성
        oneDimArray[0] = 1;
        oneDimArray[1] = 2;
        oneDimArray[2] = 3;
        oneDimArray[3] = 4;
        oneDimArray[4] = 5;

        // 1차 배열 선언과 값 할당
        int[] anotherOneDimArray = {1, 2, 3, 4, 5};

        // 2차 배열 선언 및 초기화
        int[][] twoDimArray = new int[3][4];  // 3x4 배열 생성
        twoDimArray[0][0] = 1;
        twoDimArray[0][1] = 2;
        twoDimArray[0][2] = 3;
        twoDimArray[0][3] = 4;
        twoDimArray[1][0] = 5;
        twoDimArray[1][1] = 6;
        twoDimArray[1][2] = 7;
        twoDimArray[1][3] = 8;
        twoDimArray[2][0] = 9;
        twoDimArray[2][1] = 10;
        twoDimArray[2][2] = 11;
        twoDimArray[2][3] = 12;

        // 2차 배열 선언과 값 할당
        int[][] anotherTwoDimArray = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        // 배열 요소 출력
        System.out.println("1차 배열 요소:");
        for (int i = 0; i < oneDimArray.length; i++) {
            System.out.print(oneDimArray[i] + " ");
        }

        System.out.println("\n\n2차 배열 요소:");
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(twoDimArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

8. 타입 추론, var

타입 추론과 'var'는 Java 10부터 도입된 기능으로, 코드를 간결하게 만들어주고 가독성을 향상시키는 데 도움을 줍니다.

타입 추론(Type Inference)

타입 추론은 변수를 선언할 때 변수의 타입을 컴파일러가 자동으로 추론하여 할당하는 기능입니다. 이는 코드의 가독성을 향상시키고 타입 선언을 줄여줍니다.

// 타입 추론을 사용하지 않은 경우
Map> myMap = new HashMap>();

// 타입 추론을 사용한 경우
var myMap = new HashMap>();

컴파일러는 new HashMap>()를 보고 HashMap> 타입을 추론하고, myMap의 타입을 설정합니다.

var

var 키워드는 변수의 타입을 컴파일러가 자동으로 추론하도록 지시합니다. 이를 통해 코드를 간결하게 만들 수 있습니다.

// 타입 추론을 사용한 경우
var number = 10;  // number의 타입은 int로 추론됨
var name = "John";  // name의 타입은 String으로 추론됨

var myList = new ArrayList();  
// myList의 타입은 ArrayList으로 추론됨

제한사항

var는 지역 변수에 대해서만 사용할 수 있습니다. 클래스 멤버 변수, 메서드의 매개변수, 반환값의 타입으로는 사용할 수 없습니다.

var로 선언된 변수는 반드시 초기값이 있어야 합니다. 초기값이 없는 경우 컴파일 에러가 발생합니다.
var로 선언된 변수의 타입은 컴파일 시점에 결정되며, 런타임 시에는 변하지 않습니다.

주의 사항

var를 남용하면 코드의 가독성을 떨어뜨릴 수 있으므로 적절하게 사용하는 것이 중요합니다. 변수명이나 초기화 값에서 타입을 명시하는것이 코드의 가독성을 높일 수 있는 경우에는 명시적인 타입 선언을 사용하는 것이 좋습니다.

JVM의 개념과 JDK/JRE

Wed, 22 May 2024 06:19:37 GMT

목표

자바 소스 파일(.java)을 JVM으로 실행하는 과정 이해하기.

1. JVM이란 무엇인가?

Java Virtual Machine. 자바를 실행하기 위한 자바 가상머신

.java 파일을 컴파일러를 통해 .class 파일(ByteCode)로 만들고, 이를 운영체제가 이해할 수 있는 기계어로 바꿔주는 역할을 합니다.

이러한 JVM은 운영체제에 영향을 받지 않고 실행이 가능하도록 해줍니다.

Java Virtual Machine (JVM) 구조(위키 백과)

실행순서

프로그램이 실행되면 JVM은 운영체제로부터 실행하려는 프로그램이 필요로 하는 메모리에 할당 받습니다. (JVM은 이 메모리를 용도에 맞게 여러 영역으로 나누어 관리합니다.)
자바의 컴파일러(javac)가 소스코드(.java)를 읽어들여 자바 바이트코드(.class) 형식으로 바꿔줍니다.
Class Loader를 통해 class 파일을 JVM Memory에 적재합니다.
JVM Memory 영역에 적재된 class 파일을 Excution Engine을 통해 해석합니다.

2. 컴파일 하는 방법

준비물 : java.exe , javac.exc

javac.exe는 자바 소스코드를 컴파일 할때 사용하는 프로그램 입니다. 이때 만들어진 .class(바이트코드 파일) 을 실행하는게 java.exe 입니다.

$ javac 소스파일명.java

위와 같이 명령어를 입력하여, .class 파일을 생성할 수 있습니다. 만들어진 .class 파일은 같은경로에 생성되며, 이름 또한 소스파일명.java의 소스파일 명을 따라갑니다.

참고

컴파일러(javac.exe)와 실행파일(java.exe)의 JDK/JRE 버전은 일치해야 합니다. 컴파일 옵션을 통해 해결하는 방법도 있긴합니다.

3. 실행하는 방법

$ java 소스파일명

위와 같은 명령어를 통해 java.exe 를통해 바이트 코드로 컴파일된 .class를 실행 할 수 있습니다.

4. 바이트코드란 무엇인가

프로그램을 실행하는것은 컴퓨터이기 때문에, 컴퓨터가 이해할 수 있는 기계어를 전달해주어야 합니다.

1) 바이너리 코드란?

0과 1로 구성되어 있는 코드 입니다.
C언어로 작성 된 .c 파일을 컴파일한 .obj 파일이 바이너리 코드입니다.

하지만, .obj 파일은 완벽한 기계어는 아닙니다. 이 파일을 완벽한 기계어로 변환하려면 "링커"가 필요한데, 이 링커는 여러 개의 코드와 데이터를 모아 연결하여 메모리에서 실행 가능한 파일로 만드는 역할을 해줍니다.

※ 즉, 기계어는 컴퓨터가 이해할 수 있는 0과 1로 이루어져있는 바이너리 코드이지만, 기계어가 바이너리 코드로 이루어졌을 뿐이지, 모든 바이너리코드가 기계어인것은 아닙니다!

2) 바이트 코드

c언어와 다르게 Java에서는 컴파일러(javac)에 의해 소스파일(.java)이 바이트코드(.class)가 되는데, 컴퓨터는 이 바이트 코드를 바로 인식할 수는 없습니다.

이 바이트 코드를 인식할 수 있는게 바로 가상머신입니다. JVM을 통해 컴퓨터에게 코드를 전달 할 수 있는것입니다.

그럼 왜? 귀찮게 이러한 과정을 거치는가.

JVM이 설치되어있다면, 그게 어떤 플랫폼이라도 실행을 할 수 있게 되기 때문입니다. 즉, 이 JVM을 통해 운영체제의 종류나, 개발이 수행되는 환경의 종류에 구애받지 않고, 프로그램을 실행할 수 있게 됩니다.

5. JIT 컴파일러란 무엇이며 어떻게 동작하는지

JIT?

C나 C++처럼 프로그램을 실행하기 전에 처음 한 번 컴파일 하는 대신, 프로그램을 실행하는 시점에서 필요한 부분을 즉석으로 컴파일 하는 방식을 말합니다. (Just-In-Time)

JIT 컴파일러는 바이트코드를 읽어 빠른 속도로 기계어를 생성할 수 있습니다. 이런 기계어 변환은 코드가 실행되는 과정에 실시간으로 일어나며(Just-In-Time), 전체 코드의 필요한 부분만 변환합니다. 기계어로 변환된 코드는 캐시에 저장되기 때문에 재사용시 컴파일을 다시 할 필요는 없습니다.

6. JVM 구성요소

Java Virtual Machine (JVM) 구조(위키 백과)

1) Class Loader

클래스 로더는 자바 바이트코드(.class)를 읽고 JVM 내로 클래스를 로드하는 역할을 합니다. 클래스 파일을 찾고, 읽고, 검사한 후, JVM의 메모리 영역에 적재합니다. 주된 작업은 다음과 같습니다.

로딩(Loading): 클래스 파일을 찾아 읽어들입니다.

링킹(Linking): 클래스 파일의 유효성을 검증하고, 참조를 해결하며, 메모리를 할당합니다.

초기화(Initialization): 클래스 변수들을 초기화하고 static 블록을 실행합니다.

2) JVM Memory

JVM 메모리는 프로그램 실행 중에 필요한 데이터를 저장하는 여러 메모리 영역으로 나뉩니다.

Method Area(메소드 영역): 클래스 메타데이터, 상수 풀, 스태틱 변수, 메소드 코드 등이 저장됩니다. 일반적으로 퍼머넌트 제너레이션(PermGen) 또는 메타스페이스(Metaspace)로 구현됩니다.

Heap(힙): 모든 객체 인스턴스와 배열이 저장되는 영역입니다. 가비지 컬렉터가 이 영역을 관리하며, Young Generation과 Old Generation으로 나뉩니다.

JVM Language Stacks(JVM 언어 스택): 각 스레드마다 존재하며, 메소드 호출 시 생성되는 프레임을 저장합니다. 프레임에는 지역 변수, 피연산자 스택, 메소드 호출/복귀 정보가 포함됩니다.

PC Resgisters(PC 레지스터): 각 스레드마다 존재하며, 현재 실행 중인 JVM 명령의 주소를 저장합니다.

Native Method Stacks(네이티브 메소드 스택): 네이티브 메소드(자바 이외의 언어로 작성된 메소드) 호출시 사용되는 스택입니다.

3) Execution Engine(실행 엔진)

실행 엔진은 바이트코드를 실제로 실행하는 역할을 합니다. 실행 엔진은 다음의 세 가지 주요 구성 요소로 이루어져 있습니다.

Interpreter : 바이트 코드를 한 줄씩 읽고 실행합니다. 처음에는 빠르게 실행할 수 있지만, 반복문 등에서 속도가 느려질 수 있습니다.

JIT Compiler : 인터프리터의 단점을 보완하기 위해, 자주 사용되는 코드(핫스팟)를 기계어로 변환하여 실행 속도를 높입니다. 컴파일된 코드는 캐시에 저장되어 이후 빠르게 실행됩니다.

Garbage Collector: 힙 영역을 관리하며, 사용되지 않는 객체를 자동으로 메모리에서 해제하여 메모리 누수를 방지합니다.

** ✨ Garbage Collector의 역할 **

객체 할당: 새 객체가 생성될 때 힙 영역에 메모리를 할당합니다.
객체 수집: 더 이상 참조되지 않는 객체를 식별하고 메모리를 회수합니다.
메모리 정리: 힙 영역의 단편화를 줄이기 위해 메모리를 정리하고 재배치합니다.

4) Native Method Interface

네이티브 메소드 인터페이스는 자바 코드에서 네이티브(비자바) 코드를 호출할 수 있도록 해주는 프레임워크입니다. 주로 C, C++로 작성된 네이티브 라이브러리와 상호작용할 때 사용됩니다.

5) Native Method Libraries

네이티브 메소드 라이브러리는 JVM이 네이티브 메소드 인터페이스를 통해 호출할 수 있는 네이티브 코드로 작성된 라이브러리입니다. 예를 들어, 자바에서 시스템 레벨의 기능을 사용하기 위해 운영체제 API를 호출할 때 사용됩니다.

세줄요약

JVM은 자바 애플리케이션을 실행하기 위한 시스템
Class Loader는 클래스 파일을 로드하고, JVM Memory는 실행 중 필요한 데이터를 저장하며, Execution Engine은 바이트코드를 실제로 실행함.
Native Method Interface와 Native Method Libraries는 자바의 코드와 네이티브 코드를 연결하는 부가적이며 강력한 기능을 함.

7. JDK와 JRE의 차이

1) JDK

JDK는 자바 개발도구(Java Development Kit)의 약자입니다. Java로 애플리케이션을 개발하고 컴파일할 수 있도록 해주는 개발 환경의 세트를 의미합니다. JDK는 다음과 같은 구성 요소를 포함합니다:

javac: 자바 컴파일러로, 자바 소스 코드를 바이트코드로 컴파일합니다.
java: 자바 애플리케이션을 실행하는 명령어입니다.
jar: 자바 아카이브 도구로, 여러 클래스 파일을 하나의 압축 파일로 묶습니다.
javadoc: 자바 소스 코드에서 API 문서를 생성하는 도구입니다.
visualVM: 자바 애플리케이션의 모니터링, 디버깅, 프로파일링을 위한 도구입니다.
기타 유틸리티: 다양한 개발 도구와 유틸리티를 포함하여 개발 과정에서 필요한 여러 기능을 제공합니다.

JDK는 JRE(Java Runtime Environment)를 포함하며, 개발에 필요한 도구들을 추가적으로 제공합니다. 따라서, 자바 애플리케이션을 개발하고 실행할 수 있는 완전한 환경을 제공하는 것이 JDK입니다.

JRE

JRE는 자바 실행환경(Java Runtime Environment)의 약자입니다. 자바 애플리케이션을 실행할 수 있는 환경을 제공합니다. JRE는 다음과 같은 구성 요소를 포함합니다:

JVM (Java Virtual Machine): 자바 바이트코드를 실행하는 가상 머신으로, 플랫폼 독립적인 실행 환경을 제공합니다.
클래스 라이브러리: 자바 표준 라이브러리로, 자바 애플리케이션이 사용하는 다양한 클래스와 인터페이스를 포함합니다. 예를 들어, 컬렉션 프레임워크, I/O, 네트워킹, GUI, 유틸리티 클래스 등이 포함됩니다.
구성 파일 및 설정: JVM과 클래스 라이브러리의 동작을 제어하는 구성 파일과 설정을 포함합니다.

JRE는 자바 애플리케이션을 개발할 필요는 없지만, 자바 애플리케이션을 실행할 수 있는 환경을 제공합니다. 따라서, 자바 애플리케이션을 실행하려는 사용자나 서버 환경에서는 JRE만 설치하면 충분합니다.

아니, 근데 그게

제네릭

목표

목차

1. 제네릭 사용법

1-1) 제네릭 클래스

1-2) 제네릭 메서드

1-3) 제네릭 인터페이스

요약

2. 제네릭 주요 개념

2-1) 바운디드 타입(Bounded Types)

2-1-1) 상한 바운드(Upper Bound)

2-1-2) 하한 바운드(Lower Bound)

2-2) 와일드카드 (Wildcards)

2-2-1) 불특정 와일드카드(Unbounded Wildcard)

2-2-2) 상한 와일드카드 (Upper Bounded Wildcard)

2-2-3) 하한 와일드 카드(Lower Bounded Wildcard)

2-3) 제네릭 타입의 제한 사항

요약

3. 제네릭 메소드 만들기

3-1) 제네릭 메서드 선언

예제 1: 제네릭 메서드

예제 2: 제네릭 메서드와 타입 변환

3-2) 제네릭 메서드의 타입 파라미터 제한

3-3) 여러 개의 타입 파라미터

3-4) 제네릭 메서드의 호출

요약

4. Erasure

제네릭 타입 소거(Erasure)란?

왜 타입 소거가 필요한가?

타입 소거의 작동방식

예제: 타입 소거 전후

예제: 바운드 타입 소거

타입 소거의 영향

와일드카드와 타입 소거

요약

Java의 I/O

목표

목차

1. Stream / Buffer / Channel 기반의 I/O

1-1 Stream기반의 I/O

Reader와 Writer

1-2 Buffer 기반의 I/O

Bufferd Stream

Buffered Reader와 Writer

1-3 Channel 기반의 I/O

버퍼와 채널의 조합

요약

2. InputStream과 OutputStream

InputStream

주요 메서드

주요 서브 클래스

예시

OutputStream

주요 메서드

주요 서브 클래스

예시

요약

3. Byte와 Character 스트림

Byte 스트림

주요 클래스

예제

Character 스트림

주요 클래스

예제

Byte 스트림과 Character 스트림 비교

요약

4. 표준 스트림

표준 입력 스트림(Standard Input Stream)

표준 출력 스트림(Standard Output Stream)

표준 오류 스트림(Standard Error Stream)

표준 스트림의 리디렉션

표준 출력 스트림 리디렉션

표준 입력 스트림 리디렉션

요약

5. 파일 읽고 쓰기

바이트 스트림을 이용한 파일 읽기와 쓰기

파일 읽기(FileInputStream)

파일 쓰기(FileOutputStream)

문자 스트림을 이용한 파일 읽기와 쓰기

3-5 `valueOf(Class enumType, String name)`

`allOf()`

`nonOf()`

`of()`

`range()`

`copyOf()`

4-2 `EnumSet`의 메서드