crushed-taro 님의 블로그

[Java] Java Enum이란? 열거형 타입 개념과 활용법 총정리

1. 람다 개요

1. 람다식(Lambda Expression)이란

람다식은 익명 함수(Anonymous Function)를 단순한 표현식으로 나타내는 방식으로, Java 8부터 지원됩니다.

2. 람다식이 등장한 이유

기존에는 익명 클래스를 활용해 함수를 정의해야 했지만, 코드가 길고 가독성이 떨어졌습니다.

람다식을 사용하면 코드를 더 간결하게 작성할 수 있고, 함수형 프로그래밍 패러다임을 적용할 수 있습니다.

3. 람다식 기본 문법

• 코드가 간결해지고 가독성이 향상됩니다.
• 익명 함수처럼 활용 가능하며, 필요할 때 즉시 정의하여 사용할 수 있습니다.

// (매개변수) -> { 실행할 코드 }

// 기존 익명 클래스 방식
Comparator<Integer> comparator = new Comparator<Integer>() {
    @Override
    public int compare(Integer a, Integer b) {
        return a - b;
    }
};

// 람다식 적용
Comparator<Integer> comparatorLambda = (a, b) -> a - b;

2. 함수적 인터페이스 (@FunctionalInterface)

1. 함수적 인터페이스란

함수형 인터페이스(Functional Interface)는 단 하나의 추상 메서드만 가지는 인터페이스입니다.

람다식을 사용하려면 함수형 인터페이스가 필수적입니다.

2. @FunctionalInterface 어노테이션

Java에서는 함수형 인터페이스를 정의할 때 @FunctionalInterface를 사용하여 컴파일러가 올바르게 작성되었는지 검증할 수 있습니다.

@FunctionalInterface
interface MyFunction {
    int apply(int a, int b);
}

1. 기본 제공 함수형 인터페이스 (java.util.function 패키지)

• Predicate<T> → boolean test(T t) (조건 검사)
• Function<T, R> → R apply(T t) (입력값을 변환)
• Consumer<T> → void accept(T t) (입력값 소비)
• Supplier<T> → T get() (값 제공)

Function<String, Integer> lengthFunction = str -> str.length();
System.out.println(lengthFunction.apply("Lambda")); // 6

3. 메서드 참조

람다식이 더욱 간결해질 수 있도록 메소드 참조(Method Reference)를 활용할 수 있습니다.

1. 메서드 참조 기본 문법

클래스명::메서드명
객체참조::메서드명

2. 정적 메서드 참조

Function<Integer, String> intToString = String::valueOf;
System.out.println(intToString.apply(100)); // "100"

3. 인스턴스 메서드 참조

String str = "hello";
Supplier<Integer> lengthSupplier = str::length;
System.out.println(lengthSupplier.get()); // 5

4. 생성자 참조

Supplier<List<String>> listSupplier = ArrayList::new;
List<String> list = listSupplier.get();

4. 람다식을 활용한 스트림(Stream) 처리

Java에서는 람다식을 활용하여 Stream API와 함께 데이터를 손쉽게 처리할 수 있습니다.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 람다식 활용
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .collect(Collectors.toList());

System.out.println(filteredNames); // ["Alice"]

5. 람다식과 병렬 처리 (Parallel Stream)

람다식은 멀티코어 환경에서도 효율적으로 병렬 처리를 할 수 있도록 도와줍니다.

parallelStream()을 활용하면 데이터를 병렬로 처리하여 성능을 향상시킬 수 있습니다.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 병렬 스트림 활용
int sum = numbers.parallelStream()
                 .reduce(0, Integer::sum);

System.out.println(sum); // 55

1. Enum 개요

1. Enum 이란

Enum (Enumeration Type, 열거형)은 상수 값들의 집합을 정의하는 특별한 데이터 타입입니다.

일반적인 final static 상수보다 가독성이 높고 유지보수가 쉬운 장점이 있습니다.

2. Enum 기본 문법

Enum을 정의할 때는 enum 키워드를 사용합니다.

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

3. Enum을 사용하는 이유

• 가독성 향상: 의미 있는 이름을 부여하여 코드 가독성을 높임
• 타입 안정성: 잘못된 값을 방지 (문자열, 정수 상수보다 안전)
• 객체처럼 활용 가능: 메서드, 생성자 포함 가능

2. Enum 활용

1. Enum 값 사용하기

public class EnumExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("오늘은 " + today + "입니다.");
    }
}

2. Enum의 값 반복 처리

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

3. Enum에 필드 & 생성자 추가하기

Enum에 필드와 생성자를 추가하여 더 강력하게 활용할 수 있습니다.

public enum Status {
    SUCCESS(200), ERROR(500), NOT_FOUND(404);

    private final int code;

    Status(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

1. 활용 예제

public class EnumTest {
    public static void main(String[] args) {
        Status status = Status.SUCCESS;
        System.out.println("상태 코드: " + status.getCode());
    }
}

// 상태 코드: 200

4. Enum에서 메서드 활용하기

Enum에 추상 메서드를 정의하여 각 열거형 값마다 다른 동작을 수행할 수 있습니다.

public enum Operation {
    ADD {
        public int apply(int x, int y) {
            return x + y;
        }
    },
    SUBTRACT {
        public int apply(int x, int y) {
            return x - y;
        }
    };

    public abstract int apply(int x, int y);
}

1. 활용 예제

public class EnumMethodExample {
    public static void main(String[] args) {
        System.out.println(Operation.ADD.apply(5, 3)); // 8
        System.out.println(Operation.SUBTRACT.apply(5, 3)); // 2
    }
}

5. Enum을 활용한 실전 예제 (Switch문 & 데이터 매핑)

1. Enum과 Switch문

public class EnumSwitchExample {
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;

        switch (today) {
            case MONDAY:
                System.out.println("월요일입니다.");
                break;
            case FRIDAY:
                System.out.println("금요일입니다.");
                break;
            default:
                System.out.println("오늘은 " + today + "입니다.");
        }
    }
}

1. 입출력 개요

1. Java 입출력이란

입출력(I/O, Input and Output)이란 프로그램이 외부에서 데이터를 입력받고 출력하는 과정을 의미합니다.

Java에서는 java.io 패키지와 java.nio 패키지를 사용하여 입출력을 처리할 수 있습니다.

2. 입출력 방식의 종류

Java의 입출력은 크게 기본 스트림 (Stream)과 NIO (New I/O) 방식으로 나뉩니다.

• Stream (기본 I/O): InputStream, OutputStream, Reader, Writer 사용

• NIO (New I/O): java.nio 패키지를 활용하여 버퍼(Buffer) 기반의 비동기 처리 지원

2. 파일 관련 입출력

1. 파일 입력 (File Input)

Java에서 파일을 읽을 때 FileReader, BufferedReader, FileInputStream 등을 사용할 수 있습니다.

import java.io.*;

public class FileReadExample {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            System.out.println("파일을 읽는 중 오류 발생: " + e.getMessage());
        }
    }
}

2. 파일 출력 (File Output)

파일에 데이터를 쓰려면 FileWriter, BufferedWriter, FileOutputStream 등을 사용할 수 있습니다.

import java.io.*;

public class FileWriteExample {
    public static void main(String[] args) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write("Java 파일 입출력 예제입니다.");
            writer.newLine();
            writer.close();
        } catch (IOException e) {
            System.out.println("파일을 쓰는 중 오류 발생: " + e.getMessage());
        }
    }
}

3. 바이트 기반 vs 문자 기반 스트림

Java의 입출력 스트림은 바이트 기반과 문자 기반으로 구분됩니다.

1. 바이트 스트림 예제 (InputStream & OutputStream)

import java.io.*;

public class ByteStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("image.jpg");
             FileOutputStream fos = new FileOutputStream("copy.jpg")) {
            
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data);
            }
        } catch (IOException e) {
            System.out.println("파일 입출력 오류 발생: " + e.getMessage());
        }
    }
}

2. 문자 스트림 예제 (Reader & Writer)

import java.io.*;

public class CharStreamExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("text.txt");
             FileWriter writer = new FileWriter("copy.txt")) {
            
            int data;
            while ((data = reader.read()) != -1) {
                writer.write(data);
            }
        } catch (IOException e) {
            System.out.println("파일 입출력 오류 발생: " + e.getMessage());
        }
    }
}

4. 버퍼링 (Buffering)과 성능 최적화

1. 버퍼링이란

파일을 읽고 쓸 때 버퍼(Buffer)를 사용하면 속도가 빨라집니다.

• BufferedReader / BufferedWriter → 텍스트 처리 속도 향상

• BufferedInputStream / BufferedOutputStream → 바이너리 처리 속도 향상

import java.io.*;

public class BufferedExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("largeFile.txt"));
             BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            
            String line;
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine();
            }
        } catch (IOException e) {
            System.out.println("버퍼링 입출력 오류 발생: " + e.getMessage());
        }
    }
}

5. 자주 발생하는 입출력 예외 처리

1. 예외처리 개요

1. 예외(Exception)란

Java에서 예외(Exception)는 프로그램 실행 중 발생하는 오류를 의미합니다.

예외가 발생하면 프로그램이 갑자기 종료될 수 있으므로, 이를 적절히 처리하는 것이 중요합니다.

2. 예외처리가 필요한 이유

• 프로그램이 갑자기 종료되는 것을 방지

• 오류 원인을 명확하게 파악하고 해결 가능

• 안전한 코드 작성 (예: 파일 읽기/쓰기 실패 시 대비)

예외 처리는 try-catch 문, throws 키워드, finally 블록 등을 사용하여 구현할 수 있습니다.

2. 예외 클래스의 종류

Java에서 예외는 크게 Checked Exception과 Unchecked Exception으로 나뉩니다

1. Checked Exception (컴파일러 체크 예외)

• 프로그램 실행 전에 컴파일러가 예외 발생 가능성을 체크

• 반드시 예외를 처리해야 함 (try-catch 또는 throws 사용)

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

public class CheckedExceptionExample {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");
            FileReader fr = new FileReader(file);
        } catch (IOException e) {
            System.out.println("파일을 찾을 수 없습니다: " + e.getMessage());
        }
    }
}

2. Unchecked Exception (실행 시점 예외)

• 컴파일 시점이 아니라 실행 중 발생

• 예외 처리가 강제되지 않음

public class UncheckedExceptionExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        System.out.println(numbers[5]); // ArrayIndexOutOfBoundsException 발생
    }
}

3. Error 클래스

• 시스템 레벨에서 발생하는 심각한 오류

• 예: OutOfMemoryError, StackOverflowError

3. 예외 처리 방법

1. try-catch 문

예외가 발생할 가능성이 있는 코드를 try 블록에 작성하고, 예외가 발생하면 catch 블록에서 처리합니다.

public class TryCatchExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("0으로 나눌 수 없습니다!");
        }
    }
}

2. throws 키워드

메서드에서 예외를 직접 처리하지 않고 호출한 곳에서 처리하도록 위임합니다.

public class ThrowsExample {
    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(1000); // Checked Exception (InterruptedException)
    }
}

3. finally 블록

예외 발생 여부와 관계없이 항상 실행되는 코드를 작성할 때 사용합니다.

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 2;
            System.out.println("결과: " + result);
        } catch (ArithmeticException e) {
            System.out.println("예외 발생");
        } finally {
            System.out.println("이 코드는 항상 실행됩니다.");
        }
    }
}

4. 사용자 정의 예외 (Custom Exception)

필요에 따라 직접 예외 클래스를 정의할 수도 있습니다.

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

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            throw new MyException("사용자 정의 예외 발생!");
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }
}

1. 제네릭스(Generic)란

제네릭스(Generic)는 자바에서 컴파일 시 타입을 체크할 수 있도록 하는 기능입니다. 이를 통해 타입 안정성을 보장하고, 불필요한 형 변환(casting)을 줄일 수 있습니다.

// 제네릭스를 사용한 클래스 예제
class Box<T> {
    private T item;
    
    public void setItem(T item) {
        this.item = item;
    }
    
    public T getItem() {
        return item;
    }
}

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

1 제네릭스의 장점

• 컴파일 타임 타입 체크 → 타입 안정성 보장
• 형 변환 필요 없음 → 코드 간결화
• 재사용성 증가 → 다양한 타입을 지원

2. 와일드카드 (Wildcards)

1. 종류

• <?> : 모든 타입 허용 (Unbounded Wildcard)
• <? extends T> : T 또는 T의 하위 클래스만 허용 (Upper Bounded)
• <? super T> : T 또는 T의 상위 클래스만 허용 (Lower Bounded)

public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

3. 컬렉션 프레임워크

컬렉션(Collection)은 데이터를 효율적으로 저장하고 관리하기 위한 자바의 자료구조입니다.

1 주요 컬렉션 인터페이스

• List → 순서가 있는 자료구조, 중복 허용 (ArrayList, LinkedList 등)
• Set → 중복을 허용하지 않는 자료구조 (HashSet, TreeSet 등)
• Map → 키-값 쌍을 저장하는 자료구조 (HashMap, TreeMap 등)

4. List 인터페이스

1. List 특징

• 순서가 있는 데이터 저장
• 중복 데이터 허용
• 배열과 비슷하지만 크기 동적 변경 가능

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("JavaScript");

System.out.println(list.get(0)); // Java

5. Set 인터페이스

1. Set 특징

• 중복을 허용하지 않음
• 순서가 보장되지 않음 (일부 구현체 제외)

Set<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java"); // 중복 추가되지 않음

System.out.println(set.size()); // 2

6. Map 인터페이스

1. Map 특징

• 키(Key)-값(Value) 쌍으로 데이터 저장
• 키는 중복 불가능, 값은 중복 가능

Map<Integer, String> map = new HashMap<>();
map.put(1, "Java");
map.put(2, "Python");
map.put(1, "C++"); // 키가 같으면 값이 덮어쓰기됨

System.out.println(map.get(1)); // C++

1. 다형성(Polymorphism)이란

다형성(Polymorphism)은 객체 지향 프로그래밍(OOP)의 핵심 개념 중 하나로, 동일한 인터페이스를 가진 객체들이 다양한 방식으로 동작할 수 있도록 하는 기능입니다. 즉, 같은 메서드를 호출해도 객체에 따라 다른 결과가 나올 수 있습니다.

1. 다형성의 주요 특징

• 업캐스팅(Upcasting): 자식 클래스의 객체를 부모 클래스 타입으로 변환
• 오버로딩(Overloading): 같은 이름의 메서드를 매개변수에 따라 다르게 정의
• 오버라이딩(Overriding): 부모 클래스의 메서드를 자식 클래스에서 재정의
• 인터페이스 활용: 다형성을 극대화하여 유연한 코드 작성 가능

2. 추상 클래스와 인터페이스

1. 추상 클래스(Abstract Class)

• abstract 키워드를 사용하여 선언
• 객체를 직접 생성할 수 없고, 반드시 상속하여 사용
• 일부 구현된 메서드를 포함할 수 있음

abstract class Animal {
    abstract void makeSound(); // 추상 메서드
    void sleep() {
        System.out.println("잠자는 중...");
    }
}

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

2. 인터페이스 (Interface)

• interface 키워드를 사용하여 선언
• 모든 메서드는 기본적으로 public abstract
• 다중 구현이 가능하여 유연성이 높음

interface Animal {
    void makeSound();
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("야옹!");
    }
}

3. 오버로딩과 오버라이딩 (메서드 다형성)

1. 오버로딩 (Overloading)

같은 클래스 내에서 메서드 이름은 같지만 매개변수가 다를 경우 사용됩니다.

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

2. 오버라이딩 (Overriding)

부모 클래스의 메서드를 자식 클래스에서 재정의하는 것을 의미합니다.

class Parent {
    void showMessage() {
        System.out.println("부모 클래스");
    }
}

class Child extends Parent {
    @Override
    void showMessage() {
        System.out.println("자식 클래스");
    }
}

4. 다형성을 활용한 설계 패턴

1. 팩토리 패턴 (Factory Pattern)

객체 생성을 캡슐화

interface Shape {
    void draw();
}

class Circle implements Shape {
    public void draw() {
        System.out.println("원을 그립니다.");
    }
}

class ShapeFactory {
    static Shape getShape() {
        return new Circle();
    }
}

2. 전략 패턴 (Strategy Pattern)

동적으로 알고리즘을 변경 가능

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println(amount + "원을 신용카드로 결제합니다.");
    }
}

class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println(amount + "원을 PayPal로 결제합니다.");
    }
}

class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

3. 템플릿 메서드 패턴 (Template Method Pattern)

상위 클래스에서 알고리즘의 구조를 정의하고, 하위 클래스에서 일부를 구현

abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}

class Football extends Game {
    void initialize() { System.out.println("축구 게임 초기화"); }
    void startPlay() { System.out.println("축구 경기 시작"); }
    void endPlay() { System.out.println("축구 경기 종료"); }
}

4. 어댑터 패턴 (AdapterPattern)

서로 다른 인터페이스를 변환하여 호환 가능하게 만듦

interface MediaPlayer {
    void play(String audioType, String fileName);
}

class Mp3Player implements MediaPlayer {
    public void play(String audioType, String fileName) {
        System.out.println("MP3 파일 재생: " + fileName);
    }
}

class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer = new Mp4Player();
        }
    }

    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

interface AdvancedMediaPlayer {
    void playMp4(String fileName);
}

class Mp4Player implements AdvancedMediaPlayer {
    public void playMp4(String fileName) {
        System.out.println("MP4 파일 재생: " + fileName);
    }
}

5. 디코레이터 패턴 (Decorator Pattern)

동적으로 객체의 기능을 확장

interface Coffee {
    String getDescription();
    int cost();
}

class BasicCoffee implements Coffee {
    public String getDescription() { return "기본 커피"; }
    public int cost() { return 3000; }
}

class MilkDecorator implements Coffee {
    private Coffee coffee;
    
    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    public String getDescription() {
        return coffee.getDescription() + ", 우유 추가";
    }

    public int cost() {
        return coffee.cost() + 500;
    }
}

1. 상속(Inheritance)이란

상속(Inheritance)이란 객체 지향 프로그래밍(OOP)에서 기존 클래스의 속성과 메서드를 새로운 클래스에서 재사용할 수 있도록 해주는 기능입니다. 이를 통해 코드의 중복을 줄이고 유지보수성을 높일 수 있습니다.

1. 상속의 주요 특징

• 부모 클래스(상위 클래스)의 기능을 자식 클래스(하위 클래스)가 물려받음
• extends 키워드를 사용하여 상속 구현
• 코드 재사용성과 확장성이 높아짐
• 단일 상속만 지원 (Java에서는 다중 상속이 불가능함)

2. 상속의 키워드

1. extends

class Parent {
    void show() {
        System.out.println("부모 클래스의 메서드");
    }
}

class Child extends Parent {
    void display() {
        System.out.println("자식 클래스의 메서드");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Child child = new Child();
        child.show(); // 부모 클래스의 메서드 호출
        child.display(); // 자식 클래스의 메서드 호출
    }
}

2. super

class Parent {
    String message = "부모 클래스";
}

class Child extends Parent {
    void printMessage() {
        System.out.println(super.message); // 부모 클래스의 변수 호출
    }
}

3. this

자기 자신의 인스턴스를 참조할 때 사용합니다.

3. 상속의 특징과 장점

• 코드 재사용성: 기존 코드를 재활용하여 개발 시간을 단축
• 유지보수 용이: 공통된 코드 수정 시 한 곳에서 변경 가능
• 확장성: 기존 클래스의 기능을 확장하여 새로운 기능 추가 가능

4. 상속의 예제 코드

class Animal {
    void makeSound() {
        System.out.println("동물이 소리를 냅니다");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("멍멍!");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 부모 클래스의 메서드
        dog.bark(); // 자식 클래스의 메서드
    }
}

5. 상속과 다형성의 관계

class Parent {
    void display() {
        System.out.println("부모 클래스");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("자식 클래스");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Parent obj = new Child(); // 업캐스팅 (Upcasting)
        obj.display(); // 자식 클래스의 display()가 실행됨
    }
}

객체 배열이란

래퍼런스 변수에 대한 배열로 동일한 타이의 여러 인스턴스들을 배열로 관리할 수 있다.

Car[] carArray = new Car[5];
carArray[0] = new Car("페라리", 300);
carArray[1] = new Car("람보르기니", 350);
carArray[2] = new Car("롤스로이스", 250);
carArray[3] = new Car("부가티베이론", 400);
carArray[4] = new Car("포터", 500);

for (int i = 0; i < carArray.length; i++) {
	carArray[i].driveMaxSpeed();
}

/*
페라리이(가) 최고시속 300km/h로 달려갑니다.
람보르기니이(가) 최고시속 350km/h로 달려갑니다.
롤스로이스이(가) 최고시속 250km/h로 달려갑니다.
부가티베이론이(가) 최고시속 400km/h로 달려갑니다.
포터이(가) 최고시속 500km/h로 달려갑니다.
*/

Java의 클래스와 객체란

Java는 객체지향 프로그래밍(OOP)을 기반으로 하는 언어로, 클래스(Class)와 객체(Object)가 핵심 개념입니다. 클래스를 설계도로 생각하면, 객체는 그 설계도로 만들어진 실체라고 볼 수 있습니다.

class Car {
    String brand;
    int speed;
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // 객체 생성
        myCar.brand = "Tesla";
        myCar.speed = 100;
        System.out.println(myCar.brand + "의 속도: " + myCar.speed);
    }
}

1. 클래스란

클래스는 객체를 생성하기 위한 청사진(템플릿) 역할을 합니다. 클래스 내부에는 필드(멤버 변수)와 메서드(함수)가 포함될 수 있습니다.

class Animal {
    String name;
    void makeSound() {
        System.out.println("소리를 냅니다.");
    }
}

2. 캡슐화 (Encapsulation)

캡슐화는 객체의 데이터(필드)를 외부에서 직접 접근하지 못하도록 숨기고, 필요한 경우 메서드를 통해 접근하도록 하는 개념입니다.

class BankAccount {
    private int balance;

    public void deposit(int amount) {
        balance += amount;
    }

    public int getBalance() {
        return balance;
    }
}

캡슐화를 사용하는 이유

• 데이터 보호
• 코드 유지보수성 향상
• 객체 간 결합도를 낮춰 유연한 설계 가능

3. 추상화 (Abstraction)

추상화는 불필요한 세부 사항을 숨기고, 객체의 핵심 기능만 노출하는 개념입니다.

abstract class Animal {
    abstract void makeSound();
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("멍멍!");
    }
}

추상화를 사용하는 이유

• 복잡성을 줄이고 코드 가독성을 높임
• 유지보수가 쉬운 구조 설계 가능

4. 생성자 (Constructor)

생성자는 객체가 생성될 때 자동으로 호출되는 메서드입니다.

class Car {
    String brand;
    int speed;

    // 생성자
    Car(String brand, int speed) {
        this.brand = brand;
        this.speed = speed;
    }
}

5. 오버로딩 (Overloading)

오버로딩은 같은 이름의 메서드를 매개변수의 개수나 타입을 다르게 하여 여러 개 정의하는 기법입니다.

class MathUtil {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

6. static과 final 키워드

1. static 키워드

static 키워드는 클래스 수준에서 공유되는 변수나 메서드를 정의할 때 사용합니다.

class Counter {
    static int count = 0;
}

2. final 키워드

final 키워드는 한 번 할당된 값이 변경되지 않도록 할 때 사용합니다.

final class Constants {
    static final double PI = 3.14159;
}

Java 배열이란

Java에서 배열(Array)은 동일한 타입의 여러 값을 저장할 수 있는 자료 구조입니다. 배열을 활용하면 데이터를 효율적으로 관리하고 반복문과 함께 사용할 수 있어 코드의 간결성과 실행 속도를 높일 수 있습니다.

1. 배열의 개요

배열(Array)은 연속된 메모리 공간에 요소를 저장하며, 인덱스를 이용해 접근할 수 있습니다. Java에서 배열은 new키워드를 사용하여 생성됩니다.

int[] numbers = new int[5]; // 크기가 5인 정수형 배열 선언

• 고정된 크기: 배열의 크기는 생성 시 결정되며 이후 변경할 수 없습니다.
• 동일한 데이터 타입: 배열에는 같은 타입의 데이터만 저장할 수 있습니다.
• 인덱스 기반 접근: 배열 요소는 0부터 시작하는 인덱스를 통해 접근합니다.

2. 배열 선언 및 초기화

1. 배열 선언

// 선언과 동시에 크기 할당
int[] arr1 = new int[3];

// 선언과 동시에 값 할당
int[] arr2 = {1, 2, 3, 4, 5};

2. 배열 값 접근 및 변경

int[] numbers = {10, 20, 30};
System.out.println(numbers[1]); // 20 출력

numbers[1] = 50;
System.out.println(numbers[1]); // 50 출력

3. 배열의 복사

1. for 문을 이용한 복사

int[] original = {1, 2, 3, 4, 5};
int[] copy = new int[original.length];

for (int i = 0; i < original.length; i++) {
    copy[i] = original[i];
}

2. System.arraycopy() 메서드 사용

int[] original = {1, 2, 3, 4, 5};
int[] copy = new int[original.length];
System.arraycopy(original, 0, copy, 0, original.length);

3. Arrays.copyOf() 메서드 사용

import java.util.Arrays;
int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, original.length);

4. 배열의 정렬

1. 순차 정렬 (Sequential Sort)

import java.util.Arrays;
int[] numbers = {5, 3, 8, 1, 2};
Arrays.sort(numbers);

2. 선택 정렬 (Selection Sort)

public static void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

3. 버블 정렬 (Bubble Sort)

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

4. 삽입 정렬 (Insertion Sort)

public static void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

5. 다차원 배열

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

System.out.println(matrix[1][2]); // 6 출력