예외 처리하기

try~catch 기본 구조

try {
    (수행할 문장 1);
    (수행할 문장 2);
    ...
} catch(예외 1) {
    (수행할 문장 1);
    ...
} catch(예외 2) {
    (수행할 문장 1);
    ...
}

try 문 안의 수행할 문장에서 예외가 발생하지 않는다면 catch 문에 문장들은 수행되지 않는다. 하지만 try 문 안의 문장을 수행하는 도중 예외 발생하면 예외에 해당되는 catch 문이 수행됨 숫자를 0을로 나누었을 때 발생하는 예외를 처리

public class Sample {
    public static void main(String[] args) {
        int c;
        try {
            c = 4 / 0;
        } catch(ArithmeticException e) {
            c = -1; // 예외가 발생해 이 문장이 수행됨
        }
    }
}

ArithmeticException e에서 e는 ArithmeticException 클래스의 객체, 즉 예외 객체에 해당한다. 이 예외 객체를 통해 해당 예외 클래스의 변수나 메서드를 호출할 수도 있다.

finally

어떤 예외가 발생하더라도 반드시 실행되어야 하는 부분이 있다면, finally 문을 사용한다.

public class Sample {
    public void shouldBeRun() {
        System.out.println("ok thanks");
    }

       public static void main(String[] args) {
        Sample sample = new Sample();
        int c;
        try {
            c = 4 / 0;
        } catch (ArtihmeticException e) {
             c = -1;
        } finally {
            sample.shouldBeRun(); // 예외에 상관없이 무조건적으로 실행
        }
    }
}

ok, thanks

finally문은 try 문장 수행 중 예외 발생 여부에 상관없이 무조건 실행된다. 따라서 코드를 실행하면 sample.shouldBeRun() 메서드가 실행됨

예외 활용하기 - RuntimeException과 Exception

예외는 크게 두 가지로 구분된다

1. RuntimeException : 실행 시 발생하는 예외
2. Exception : 컴파일 시 발생하는 예외

RuntimeException

class FoolException extends RuntimeException{
}

public class Sample {
    public void sayMoon(String moon) {
        if("바보".equals(moon)) {
            throw new FoolException();
        }
        System.out.println("당신의 별명은 "+moon+" 입니다.");
    }

    public static void main(String[] args) {
        Sample sample = new Sample();
        sample.sayMoon("바보");
        sample.sayMoon("야호");
    }
}

이 프로그램을 실행하면 '바보'라는 입력 값으로 sayMoon 메서드 실행 시 다음과 같은 예외가 발생한다.

Exception in thread "main" FoolException
...

Exception

RuntimeException을 상속하는 FoolException을 Exception 상속으로 변경하기만 하면 Sample 클래스에서 컴파일 오류가 발생한다. 이유는 예측 가능한 CheckedException으로 변경되어 예외 처리를 컴파일러가 강제하기 때문. 따라서 try~catch문을 통해 컴파일 오류를 막을 수 있다.

class FoolException extends Exception {}

public class Sample {
    public void sayMoon(String moon) {
        try {
            if("바보".equals(moon)) {
                throw new FoolException();
            }
            System.out.println("당신의 별명은 "+moon+" 입니다.");
        } catch (FoolException e) {
            System.out.println("FoolException이 발생했습니다.");        
        }
     }

    public static void main(String[] args) {
        Sample sample = new Sample();
        sample.sayMoon("바보");
        sample.sayMoon("야호");
    }
}

예외 던지기

앞 예제에서 sayMoon() 메서드에서 FoolException을 발생시키고 예외 처리도 sayMoon() 메서드에서 했다. 하지만 이렇게 하지 않고 sayMoon()메서드를 호출한 곳에서 FoolException을 처리하도록 예외를 위로 던질 수 있는 방법이 있다.

예외를 위로 던지는 예시

public class Sample {
    public void sayMoon(String moon) throws FoolException {
        if("바보".equals(moon)) {
            throw new FoolException();
        }
        System.out.println("당신의 별명은 "+moon+" 입니다.");
    }

    public static void main(String[] args) {
        Sample sample = new Sample();
        try {
            sample.sayMoon("바보");
            sample.sayMoon("야호");
        } catch (FoolException e) {
            System.out.println("FoolException이 발생했습니다.");
        }
    }
}

main 메서드에서 try~catch 문으로 sayMoon 메서드에 대한 FoolException 예외를 처리하였다.

FoolException 처리를 sayMoon() 메서드에서 하는 것이 좋을까? 아니면 throws를 이용하여 예외 처리를 main 메서드에서 하는 것이 좋을까?

예외 처리 방식의 차이

sayMoon() 메서드에서 처리하는 것과 main() 메서드에서 예외 처리 하는 것에는 아주 큰 차이가 존재한다.

• sayMoon() 메서드에서 예외를 처리하는 경우 바보, 야호 두 문장이 모두 수행된다. sample.sayMoon("바보") 문장 수행 시 FoolException이 발생하겠지만 그 다음 문장인 sample.sayMoon("야호") 역시 수행된다.
• 하지만 main() 메서드에서 예외 처리를 한 경우에는 두 번째 문장인 sample.sayMoon("야호")가 수행되지 않는다. 왜냐면 이미 첫 번째 문장에서 예외가 발생해 catch 문으로 빠져버리기 때문

  try {
    sample.sayMoon("바보");
    sample.sayMoon("야호"); // 이 문장 수행 x
  } catch (FoolException e) {
    System.out.println("FoolException이 발생했습니다.");
  }

• 예외 처리를 하는 위치는 매우 중요* 프로그램 수행 여부를 결정하고, 트랜잭션 처리와도 매우 밀접한 관계가 있다.

정리

1. 예외의 종류

(1) Checked Exception (컴파일 타임 예외)

• 컴파일러가 체크하는 예외 (반드시 처리 필요)
• Exception 클래스의 직계 하위 클래스 (ex: IOException, SQLException)
• 예시: 파일을 읽을 때 파일이 없을 경우 (FileNotFoundException)

(2) Unchecked Exception (런타임 예외)

• 컴파일러가 체크하지 않는다 (처리 선택적)
• RuntimeException의 하위 클래스(ex: NullPointerException, ArrayIndexOutOfBoundsException)
• 예시: 배열 범위 초과, null 객체 접근

(3) Error

• 시스템 레벨의 심각한 문제, 개발자가 처리할 수 없고, 애플리케이션 종료 유발

2. 예외 처리 기본 문법

try {
    // 예외가 발생할 수 있는 코드
    FileReader file = new FileReader("test.txt");
} 
catch (FileNotFoundException e) {
    // 특정 예외 처리 (여러 개 사용 가능)
    System.out.println("파일을 찾을 수 없습니다!");
} 
catch (Exception e) {
    // 일반 예외 처리 (가장 마지막에 위치)
    e.printStackTrace();
} 
finally {
    // 예외 발생 여부와 무관하게 실행 (리소스 정리)
    System.out.println("항상 실행됩니다.");
}

3. 주요 키워드

• throw : 예외를 강제로 발생 시키는 키워드

  if (balance < 0) {
    throw new IllegalArgumentException("잔액은 음수일 수 없습니다.");
  }

• throws : 예외를 호출자에게 전파

  public void readFile() throws IOException {
    // 파일 읽기 로직
  }

static 변수 (클래스 변수)

class HouseMoon {
    static String lastName = "문";
}

public class Sample {
    public static void main(String[] args) {
        HouseMoon moon1 = new HouseMoon();
        HouseMoon moon2 = new HouseMoon();
    }
}

lastName 필드는 어떤 객체이든지 동일한 값인 '문'이다. 항상 값이 변하지 않는다면 static을 사용해 메모리 낭비를 줄일 수 있다. static 키워드를 붙이면 자바는 메모리 할당을 딱 한 번만 하게돼 메모리를 적게 사용할 수 있음.

lastName값이 변경되지 않기를 바란다면 final static 키워드를 사용. 자바에서는 상수를 의미한다.

static을 사용하는 또 다른 이유는 값을 공유할 수 있기 때문. static으로 설정하면 같은 메모리 주소만을 바라보기에 static 변수의 값을 공유하게 된다.

class Counter {
    static int count = 0;
    Couter() {
        count++;
        System.out.println(count);
    }
}

public class Sample {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
    }
}

1
2

static 키워드를 붙였더니 count 값이 공유되어 count가 증가되어 출력

static 메서드 (클래스 메서드)

static 키워드가 메서드 앞에 붙으면 static 메서드가 됨.

class Counter {
    static int count = 0;
    public static int getCount() {
        return count;
    }
}

public class Sample {
    System.out.println(Counter.getCount()); // 스태틱 메서드는 클래스를 이용하여 호출
}

메서드 앞에 static 키워드를 붙이면 Counter.getCount()와 같이 객체 생성 없이도 클래스를 통해 메서드를 직접 호출 가능. static method 안에서는 인스턴스 변수 접근 불가능. 위의 코드는 클래스 변수이기에 static method에서 접근이 가능했다.

싱글톤 패턴

자바의 디자인 패턴 중 하나인 싱글톤(singleton). 싱글톤은 단 하나의 객체만을 생성하게 강제하는 디자인 패턴 다시 말해, 클래스를 통해 생성할 수 있는 객체가 한 개만 되도록 만드는 것

디자인 패턴은 소프트웨어 설계에서 반복적으로 나타나는 문제들을 효과적으로 해결하는 데 사용되는 검증된 설계 방법론

class Singleton {
    private static Singleton one;
    private Singleton() {
    }

    public static Singleton getInstance() {
        if (one == null) {
            one = new Singleton();
        }
        return one;
    }
}

public class Sample {
    public static void main(Stirng[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // true
    }
}

Singleton 클래스에 one이라는 static 변수를 작성하고, getInstance() 메서드에서 one값이 null인 경우에만 객체를 생성하도록 해 one 객체가 딱 한 번만 만들어지도록 함.

• private
• default
• protected
• public

접근 제어자는 private < default < protected < public순으로 많은 접근을 허용

private

접근 제어자가 private으로 설정되어있으면 private이 붙은 변수나 메서드는 해당 클래스 안에서만 접근 가능

public class Student {
    private int studentNo;
    private String name;
}

default

접근 제어자를 별도로 설정하지 않으면 변수나 메서드는 default 접근 제어자가 자동으로 설정돼 동일한 패키지 안에서만 접근 가능

house/HouseMoon.java

package house;

public class HouseMoon {
    String lastName = "Moon"; // lastName은 default
}

house/HouseYoun.java

package house;

public class HouseYoun {
    String lastName = "Youn";

    public static void main(String[] args) {
        HouseMoon moon = new HouseMoon();
        System.out.println(moon.lastName); // HouseMoon 클래스의 lastName 변수 사용 가능
    }
}

protected

접근 제어자가 protected로 설정되어있다면 protected가 붙은 변수나 메서드는 동일 패키지의 클래스 또는 해당 클래스를 상속받은 클래스에서만 접근이 가능

house/HouseMoon.java

package house;

public class HouseMoon {
    protected String lastName = "Moon";
}

house/person/ShMon.java

package house.person; //  패키지 다름

public class ShMon extends HouseMoon { // HouseMoon 상속
    public static void main(String[] args) {
        ShMon shm = new ShMon();
        System.out.println(shm.lastName); // 상속한 클래스의 protected 접근 가능
    }
}

public

접근 제어자가 public이면 어떤 클래스에서도 접근이 가능하다.

패키지 알아보기

house/HouseKim.java

package house;

public class HouseKim{
}

house/HousePark.java

package house;

public class HousePark{
}

package는 이 파일이 어떤 패키지의 파일인지를 알려주는 역할

서브 패키지란?

house/person/ShMon.java

package house.person;

public class ShMon {
}

ShMon 클래스의 package가 house.person으로 생성됨 이렇게 패키지는 도트(.)를 이용하여 서브 패키지를 표시한다. 다시 말해, house.person은 house 패키지의 서브 패키지이다.

패키지 사용하기

다른 클래스에서 ShMon 클래스를 사용하려면 다음과 같이 import 해야함

import house.person.ShMon;

public class Sample {
    public static void main(String[] args) {
        ShMon shmon = new ShMon();
    }
}

같은 패키지 내에 있는 클래스는 import 없이 사용 가능

패키지를 사용하는 이유

패키지를 사용하면 비슷한 클래스끼리 묶어 클래스 분류가 용이함 패키지명이 다른 경우 클래스명이 동일해도 충돌 없이 사용할 수 있음

Predator 인터페이스 -> 추상 클래스

abstract class Predator extends Animal {
    abstract String getFood();
    void printFood() { // default 제거
        System.out.printf("my food is %s\n", getFood());
    }
}

추상 클래스를 만들려면 class 앞에 abstract를 표기해야 한다. 또한 인터페이스의 메서드와 같은 역할을 하는 메서드에도 abstract를 붙여야 한다. abstract 메서드는 인터페이스의 메서드와 마찬가지로 구현체가 없다. Animal 클래스의 기능을 유지하기 위해 Animal 클래스를 상속하였다.

추상 클래스는 일반 클래스와 달리 단독으로 객체를 생성할 수 없음 반드시 추상 클래스를 상속한 실제 클래스를 통해서만 객체를 생성할 수 있다.

class Tiger extends Predator implements Barkable {
    (...생략)
}
class Lion extends Predator implemnts Barkable {
    (...생략)
}

추상 클래스에 abstract로 선언된 메서드는 인터페이스의 메서드와 마찬가지로 반드시 구현 해야한다. 추상 클래스에는 abstract 메서드 외에 실제 메서드도 사용할 수 있다. 추상 클래스에 실제 메서드를 추가하면 Tiger, Lion 등으로 만들어진 객체에서 그 메서드들을 모두 사용할 수 있게 된다. 즉, 인터페이스의 default 메서드가 추상 클래스의 일반 메서드임

인터페이스와 추상 클래스의 차이

추상 클래스는 인터페이스와 달리 일반 클래스처럼 객체 변수, 생성자, private 메서드 등을 가질 수 있다.

1. 목적

• 추상 클래스: "IS-A" 관계를 나타냄,공통 기능의 상속과 기본 구현 제공에 초점.
  예) Animal 추상 클래스를 상속 받은 Dog,Cat은 동물 공통 특성을 공유
• 인터페이스: "CAN-DO" 관계를 나타냄, 다양한 객체의 특정 행위 강제에 초점 예) Flyable 인터페이스를 구현한 Bird, Airplane은 서로 다른 종류지만 "날 수 있음"이라는 기능을 보장

2. 구성 요소

3. 상속/구현 방식

• 추상 클래스: 단일 상속만 지원 (extends 키워드 사용)

  public abstract class Animal { ... }
  public class Dog extends Animal { ... } // 단일 상속

• 인터페이스: 다중 구현 가능(implements 키워드 사용)

  public interface Swimmable { ... }
  public interface Barkable { ... }
  public class Duck implements Swimmable, Barkable { ... } // 다중 구현

4. 접근 제어자

• 추상 클래스: public, protected, default 등 다양한 접근 제어자 사용 가능
• 인터페이스: 모든 메서드는 public

interface Predator {
    String getFood();
}

interface Barkable {
    void bark();
}

class Animal {
    String name;

    void setName(String name) {
        this.name = name;
    }
}

class Tiger extends Animal implements Predator, Barkable{
    @Override
    public String getFood() {
        return "apple";
    }

    @Override
    public void bark() {
        System.out.println("어흥");
    }
}

class Lion extends Animal implements Predator, Barkable{
    @Override
    public String getFood() {
        return "banana";
    }

    @Override
    public void bark() {
        System.out.println("으르렁");
    }
}

class ZooKeeper {
    void feed(Predator predator) {
        System.out.println("feed" + predator.getFood());
    }
}

// 주목!!
class Bouncer {
    void barkAnimal (Barkable animal) { // Animal 대신 Barkable 사용
        animal.bark();
    }
}

public class Sample {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ZooKeeper zk = new ZooKeeper();
        Tiger tiger = new Tiger();
        Lion lion = new Lion();
        zk.feed(tiger);
        zk.feed(lion);
    }

}

Bouncer 클래스의 barkAnimal 메서드에 주목하자. barkAnimal 메서드의 입력 자료형이 Animal에서 Barkable로 변경되었다. 그리고 bark 메서드를 호출하도록 코드를 구성하였다.

위 코드에서 tiger, lion 객체는 각각 Tiger, Lion 클래스의 객체이면서 Animal 클래스의 객체이기도 하고, Barkable과 Predator 인터페이스의 객체이기도 하다. 이러한 이유로 barkAnimal 메서드의 입력 자료형을 Animal에서 Barkable로 바꾸어 사용할 수 있는 것이다.

이렇게 하나의 객체가 여러 개의 자료형 타입을 가질 수 있는 것을 객체 지향 세계에서는 다형성이라 한다.

그러므로 Tiger 클래스의 객체는 여러 가지 자료형으로 표현 가능하다.

Tiger tiger = new Tiger();  // Tiger is a Tiger
Animal animal = new Tiger();  // Tiger is a Animal
Predator predator = new Tiger();  // Tiger is a Predator
Barkable barkable = new Tiger();  // Tiger is a Barkable

여기서 중요한 점은 Predator로 선언된 predator 객체와 Barkable로 선언된 barkable 객체는 사용할 수 있는 메서드가 서로 다르다. predator 객체는 getFood() 메서드만 호출이 가능하고 마찬가지로 barkable 객체는 bark() 메서드만 호출이 가능하다.

만약 getFood() 메서드와 bark() 메서드를 모두 사용하고 싶다면 어떻게 할까?

1. Predator, Barkable 인터페이스를 구현한 Tiger로 선언된 tigert 객체를 사용한다.
2. getFood, bark 메서드를 모두 포함하는 새로운 인터페이스를 만들어 사용한다.

interface Predator {
    String getFood();
}

interface Barkable {
    void bark();
}

interface BarkablePredator extends Predator, Barkable {}

코드를 보면 알겠지만 인터페이스는 일반 클래스와 달리 extends를 이용하여 여러 개의 인터페이스를 동시에 상속할 수 있다. 즉 인터페이스는 다중 상속이 지원된다.

인터페이스 다중상속 코드 적용 예시

class Lion extends Animal implements BarkablePredator {
    public String getFood() {
        return "banana";
    }

    public void bark() {
        System.out.println("으르렁");
    }
}

자식 인터페이스로 생성한 객체의 자료형은 부모 인터페이스로 사용하는 것이 가능하다.

인터페이스가 왜 필요할까?

동물 클래스의 종류만큼 feed 메서드가 필요했던 ZooKeeper 클래스를 Predator 인터페이스를 이용하여 구현했더니 단 한 개의 feed 메서드로 구현이 가능해졌다. 여기서 핵심은 메서드가 줄어든 것이 아닌 ZooKeeper 클래스가 동물 클래스에 의존적인 클래스에서 동물 클래스와 상관없는 독립적인 클래스가 되었다는 점이다. 이것이 인터페이스의 핵심이다.

상속 vs 인터페이스

Predator 인터페이스 대신 Animal 클래스에서 getFood 메서드를 추가하고 오버라이딩 해서 사용 가능. 하지만 상속은 자식 클래스가 부모 클래스의 메서드를 오버라이딩 하지 않고 사용 가능하기에 해당 메서드를 반드시 구현해야 한다는 강제성 을 가지 못한다. 여기서 기억해야 할 점은 인터페이스는 인터페이스의 메서드를 반드시 구현해야 하는 강제성을 가짐

디폴트 메서드

자바 8 버전 이후로 디폴트 메서드 (default method)를 사용할 수 있다. 인터페이스의 메서드는 구현체를 가질 수 없지만 디폴트 메서드를 사용하면 실제 구현된 형태의 메서드를 가질 수 있다.

interface Predator {
    String getFood();

    default void printFood() {
        System.out.printf("my food is %s\n", getFood());
    }
}

디폴트 메서드는 메서드명 가장 앞에 default라고 표기해야 함. 인터페이스에 디폴트 메서드를 구현하면 인터페이스를 구현한 실제 클래스는 printFood() 메서드를 구현하지 않아도 사용 가능함. 디폴트 메서드 또한 오버라이딩 가능함.

메서드명이 클래스명과 동일하고 리턴 자료형을 정의하지 않는 메서드

class HouseDog extends Dog {
    // 생성자 코드 에시
    HouseDog (String name) {
        this.setName(name);
    }
}

생성자 규칙

• 클래스명과 메서드명이 같다.
• 리턴 타입을 정의하지 않는다. (void도 사용하지 않는다.)

디폴트 생성자

class Dog extends Animal {
    // 디폴트 생성자
    Dog() {
    }

    void sleep() {
        System.out.println(this.name + " zzz");
    }
}

생성자의 입력 항목이 없고 생성자 내부에 아무 내용이 없는 생성자를 디폴트 생성자라고 부른다. 만약 클래스에 생성자가 하나도 없다면 컴파일러는 자동으로 이와 같은 디폴트 생성자를 추가 한다. 하지만 사용자가 작성한 생성자가 하나라도 구현되어 있다면 컴파일러는 디폴트 생성자를 추가하지 않는다.

생성자 오버로딩

class HouseDog extends Dog {
    HouseDog(String name) {
        this.setName(name);
    }

    HouseDog() {}

    HouseDog(int type) {
        if (type == 1) {
            this.setName("bulldog");
        } else {
            this.setName("jindo");
        }
    }
}

입력 항목이 다른 생성자를 여러 개 만들 수 있는데 이러한 방식을 생성자 오버로딩 (constructor overloading) 이라 한다.

HouseDog 클래스에 주목하자

첫 번째 메서드: Dog 클래스에 있는 sleep 메서드를 HouseDog 클래스에 다시 구현하였다. 이렇게 부모 클래스의 메서드를 자식 클래스가 동일한 형태(즉, 입출력이 동일)로 또다시 구현하는 행위를 메서드 오버라이딩 (method overriding, 메서드 덮어쓰기) 라고 한다.

두 번째 메서드: 이미 sleep이라는 메서드가 있지만 동일한 이름의 sleep 메서드를 또 생성할 수 있다. 단, 메서드의 입력 항목이 다를 경우만 가능 이렇듯 입력 항목이 다른 경우 동일한 이름의 메서드를 만들 수 있는데 이를 메서드 오버로딩 (method overloading) 이라 부른다.

참고

자바는 다중 상속을 지원하지 않는다

Animal dog = new Dog(); // Dog is a Animal

• 주의점: Dog 객체를 Animal 자료형으로 사용할 경우 Dog 클래스에만 존재하는 메서드는 사용 불가

public class Sample {
    int sum (int x, int y) { // x, y는 매개 변수(parameter)
        return x + y;
    }

    public static void main(String[] args) {
        Sample sample = new Sample();
        int z = sample.sum(5, 10); // 5, 10는 인수 (arguments)
    }
}

git restore:

• 스테이징된 변경 사항이나 작업 디렉터리의 변경 사항을 되돌릴 때 사용
• git restore <파일명>을 사용하여 특정 파일의 변경 사항을 취소할 수 있다
• git restore --staged <파일명>을 사용하면 스테이징된 변경 사항만 복원

git revert:

• 이전 커밋을 되돌리면서 새로운 커밋을 생성
• 기존 커밋을 그대로 유지하면서 되돌리는 방법, 프로젝트의 이력을 보존하면서 수정할 수 있다

  $ git revert <커밋 해시>

git reset:

• 특정 커밋으로 되돌아가면서, 그 이후의 변경 사항을 완전히 제거한다.
• git reset --hard 명령어를 사용하면 작업 디렉터리와 스테이징 영역의 모든 변경 사항이 삭제된다.

  $ git reset --hard <커밋 해시>

git init 을 실행하면 해당 디렉터리(그리고 하위 디렉터리)에서 Git 리퍼지터리가 생성

.git 이라는 숨김 폴더가 생성되며, 이 폴더에 Git이 사용하는 메타데이터와 설정 정보가 저장됨

이미 파일이 있는 디렉터리에서 실행했을 때:

디렉터리에 있는 기존 파일들은 Git의 추적 대상에서 제외.

즉, 바로 버전관리되지 않는다.

git status 를 실행하면 해당 디렉터리에 있는 파일들이 "Untracked files"로 표시

다음 단계 : Git으로 파일 추적 시작:

• 추적할 파일 추가

  • 현재 디렉터리의 모든 파일과 폴더를 Git의 추적 대상으로 추가

  • 특정 파일만 추가하려면 파일명을 명시: git add 파일명

git add .

• 커밋 생성

  • 현재 추가된 모든 파일의 상태를 기록하며, "Initial commit" 이라는 메시지를 남긴다 

git commit -m "Initial commit"

.gitignore 파일 작성 방법

.gitignore 파일은 프로젝트 루트 디렉터리에 생성하며, 무시할 파일 또는 디렉터리의 패턴을 한 줄씩 작성한다.

# 로그 파일 제외
logs/
*.log

# 빌드 결과물 제외
/build/
*.o
*.class

# 환경 설정 파일 제외
.env
config/local.json

자주 사용하는 .gitignore 패턴

• 특정 파일 확장자 제외

# 모든 .log 파일 제외
*.log
# 모든 .tmp 파일 제외
*.tmp

• 특정 디렉터리 제외

# npm 패키지 디렉터리 제외
node_modules/
# Python 가상 환경 제외
venv/

• 특정 파일 포함 예외

# important.log 파일은 추적
*.log
!important.log

.gitignore가 적용되지 않는 경우

이미 Git에 추가된 파일은 .gitignore 에 추가해도 무시되지 않는다.

이 경우, 아래 명령어로 해당 파일을 추적 목록에서 제거한 후 커밋해야 한다.

git rm --cached <파일명>
git commit -m "Remove tracked file"

.gitignore 파일 적용 여부 확인

.gitignore 가 제대로 작동하는지 확인하는 명령어

git check-ignore -v <파일명>

글로벌 .gitignore 설정

모든 Git 프로젝트에 공통적으로 적용할 무시 패턴을 설정

git config --global core.excludesfile ~/.gitignore_global

이 후 ~/.gitignore_global 파일을 생성하고 패턴을 추가한다.

# macOS 시스템 파일 제외
.DS_Store
# Windows 썸네일 캐시 제외 
Thumbs.db

자바스크립트 엔진이 함수 호출을 관리하는 스택 자료구조

이벤트 루프는 제일 먼저 콜 스택의 작업을 처리한다.

콜 스택에는 현재 실행 중인 동기적인 코드가 쌓이고, 이 작업들이 모두 완료되어 콜 스택이 비워질 때까지 다른 큐로 이동하지 않는다.

즉, 콜 스택이 최우선

콜 스택의 역할

• 함수가 호출되면 해당 함수의 실행 컨텍스트(Execution Context) 가 콜 스택에 push된다.

• 스택의 맨 위에 있는 함수가 실행됨

• 함수 실행 종료시 pop

예제 코드

function foo() {
    console.log('foo');
}

function bar() {
    foo();
    console.log('bar');
}

bar();

실행 순서

1. bar()가 호출되면 콜 스택에 bar가 push됨

2. bar 안에서 foo()가 콜 스택에 push

3. foo가 실행돼 'foo'가 출력되고, 스택에서 pop

4. bar가 'bar'를 출력하고 스택에서 pop

2. 마이크로태스크 큐(Microtask Queue)

우선순위가 높은 비동기 작업의 콜백이 대기하는 큐

콜 스택이 비면, 이벤트 루프는 마이크로태스크 큐로 이동한다. (태스크 큐보다 먼저 처리)

여기에는 주로 Promise의 then, catch, finally 핸들러나 MutationObserver 같은 작업이 대기한다.

마이크로태스크 큐는 모든 작업이 처리될 때까지 계속 실행되며, 큐가 완전히 비워질 때까지 다음 단계로 넘어가지 않는다.

마이크로태스크 큐의 역할

• 마이크로태스크:Promise의 then,catch,finally 핸들러, MutationObserver 콜백 등

• 처리 순서: 이벤트 루프는 콜 스택이 비어 있을 때, 마이크로태스크 큐를 먼저 처리하고, 그 다음 태스크 큐를 처리한다.

예제 코드

console.log('Start');

Promise.resolve().then(() => {
    console.log('Promise');
});

setTimeout(() => {
    console.log('Timeout');
}, 0);

console.log('End');

실행 순서

1. Start가 출력

2. Promise.resolve()가 호출되고, then 핸들러가 마이크로태스크 큐에 들어감

3. setTimeout이 Web APIs로 넘어가 0초 후에 실행 대기 상태로 전환

4. End출력

5. 콜 스택이 비었으므로, 이벤트 루프가 마이크로태스크 큐를 먼저 처리

   • 마이크로태스크 큐에서 Promise 콜백이 꺼내져 콜 스택에 푸쉬

   • Promise가 출력된다.

6. 그 후 태스크 큐로 넘어가 Timeout 콜백이 처리된다.

마이크로태스크 큐는 태스크 큐보다 우선순위가 높아, Promise가 setTimeout보다 먼저 실행된다.

3. 태스크 큐(Task Queue)

우선 순위가 낮은 비동기 작업의 콜백 함수가 대기하는 큐

마이크로태스크 큐가 비어 있으면, 이벤트 루프는 태스크 큐에서 하나의 작업을 꺼내 콜 스택에 넣고 실행한다.

태스크 큐에는 setTimeout, setInterval, HTTP 요청 등의 비동기 콜백이 대기한다.

태스크 큐는 한 번에 하나의 작업만 처리하고, 작업이 끝나면 다시 콜 스택과 마이크로태스크 큐를 확인한다.

태스크 큐의 역할

• 비동기 작업: setTimeout, setInterval, HTTP 요청 등의 작업

• 콜백 함수: 비동기 작업이 끝난 후 실행될 함수가 태스크 큐에 저장

• 이벤트 루프가 콜 스택이 비어 있을 때 태스크 큐에서 작업을 꺼내 실행

예제 코드

console.log('Start');

setTimeout(() => {
    console.log('Timeout');
}, 0);

console.log('End');

실행 순서

1. 'Start'가 출력된다. (콜 스택: [console.log] → [])
2. setTimeout이 호출되지만, 즉시 실행되지 않고 Web APIs로 넘어가 0초 후에 실행 대기 상태가 된다.
   • 콜 스택: []
3. 'End'가 출력된다. (콜 스택: [console.log] → [])
4. 타이머(0초)가 만료되면 콜백 함수 () => console.log('Timeout')가 태스크 큐에 들어간다.
   • 태스크 큐: [Timeout 콜백]
5. 이벤트 루프가 콜 스택이 비어 있는 것을 확인하고, 태스크 큐에서 콜백을 꺼내 콜 스택에 push.
   • 콜 스택: [Timeout 콜백]
6. 'Timeout'이 출력되고 콜백이 제거된다.
   • 콜 스택: []

**참고: setTimeout의 시간이 0초라도 바로 실행되지 않는다. Web APIs에서 처리된 후 태스크 큐로 이동하기 때문

1. 람다식 정의와 핵심 개념
2. 람다식은 왜 사용할까? (사용 이유와 장점)
3. 람다식 문법 완벽 분석
   • 람다 파라미터 (Parameter)
   • 화살표 토큰 (Arrow Token ->)
   • 람다 몸체 (Body)
     • 표현식 (Expression Body)
     • 블록 (Block Body)
4. 함수형 인터페이스 (Functional Interface), 람다식의 핵심 퍼즐 조각
   • 함수형 인터페이스란 무엇일까?
   • @FunctionalInterface 어노테이션
   • 자바에서 제공하는 주요 함수형 인터페이스 (예: Runnable, Comparator, Predicate, Function, Consumer, Supplier)
5. 람다식 활용 예제
   • 익명 내부 클래스 대체 (익명 함수처럼 간결하게!)
     • 쓰레드 (Thread) 생성
     • 이벤트 핸들러 (Event Handler) 구현
   • 컬렉션 (Collection) 처리 간결화 (Stream API와 함께 더욱 강력하게!)
     • forEach (각 요소 순회)
     • map (요소 변환)
     • filter (요소 필터링)
     • reduce (요소 집계)
     • sort (정렬)
6. 람다식의 강력한 장점 (코드 간결성, 가독성, 생산성 향상)
   • 코드 간결성 및 가독성 향상
   • 함수형 프로그래밍 패러다임 지원
   • 병렬 처리 효율 증대 (Stream API와 함께)
7. 람다식 사용 시 주의사항 (제약 사항 및 한계점)
8. 람다식 vs 익명 내부 클래스 (차이점 명확 비교)
9. 람다식, 언제 어디에 사용해야 할까요? (활용 가이드라인)
10. 마무리

1. 람다식 정의와 핵심 개념

람다식 (Lambda Expression) 은 "익명 함수 (Anonymous Function)" 를 간결하게 표현하는 방법이다. 익명 함수란 이름 없이 정의되는 함수를 의미하며, 람다식을 사용하면 클래스 선언 없이 함수 자체를 값처럼 사용할 수 있다.

핵심 개념:

• 익명 함수 (Anonymous Function): 이름이 없는 함수, 클래스 없이 함수 자체를 표현
• 함수형 프로그래밍 (Functional Programming): 함수를 값처럼 다루는 프로그래밍 패러다임
• 코드 간결성: 불필요한 코드 (클래스 선언, 메소드 이름 등) 를 줄여 코드 라인 수 감소
• 유연성: 함수를 변수에 할당, 메소드 인자로 전달, 메소드 반환 값으로 사용 가능

기존 방식 (클래스와 메소드):

// 1. 요리책 (클래스) 만들기
class 요리책 {
    // 2. 레시피 (메소드) 만들기
    public void 라면레시피() {
        // ... 복잡한 라면 레시피 ...
    }
}

// 3. 요리책 보고 요리하기
요리책 myCookBook = new 요리책();
myCookBook.라면레시피();

람다식 (익명 함수):

// 1. 레시피 (람다식) 만들기 (요리책 없이 레시피만!)
() -> { // 람다식 시작
    // ... 간단한 라면 레시피 ...
} // 람다식 끝

// 2. 레시피 (람다식) 사용하기 (레시피 자체를 값처럼!)
요리사.요리하기( () -> { /* 간단한 라면 레시피 */ } ); // 요리사에게 람다식 레시피 전달

기존 방식은 요리책(클래스)을 먼저 만들고, 그 안에 레시피(메소드)를 넣어야 했다. 하지만 람다식은 요리책 없이 레시피 자체만을 간단하게 만들어서 요리사에게 바로 전달할 수 있는 것처럼, 함수 자체를 간결하게 표현하고 값처럼 사용할 수 있게 해준다.

2. 람다식은 왜 사용할까? (사용 이유와 장점)

람다식을 사용하는 주된 이유는 다음과 같다.

• 코드 간결성 향상: 불필요한 코드를 줄여 코드 라인 수를 줄이고, 코드를 더욱 간결하게 만든다. 특히 짧은 함수 로직을 표현할 때 람다식의 장점이 두드러진다.
• 가독성 향상: 코드가 간결해지면서 코드의 의도를 명확하게 드러내고, 코드 가독성을 높여준다.
• 유지보수성 향상: 코드가 간결해지면 코드 변경 및 유지보수가 더욱 쉬워진다.
• 함수형 프로그래밍 지원: Java를 함수형 프로그래밍 방식으로 코딩할 수 있도록 지원하여, 컬렉션 처리, 병렬 처리 등 다양한 분야에서 효율적인 코드 작성을 가능하게 한다.
• Stream API 활용 극대화: Java 8에서 함께 도입된 Stream API 와 람다식을 함께 사용하면 컬렉션 데이터를 더욱 효율적이고 간결하게 처리할 수 있다.

람다식의 핵심 가치: "코드를 더 짧고, 더 읽기 쉽고, 더 유연하게 만들어준다!"

3. 람다식 문법 완벽 분석 (작성 방법 상세 가이드)

람다식은 다음과 같은 기본 문법 구조를 가진다.

(파라미터) -> { 람다 몸체 }

람다식은 크게 세 부분으로 구성된다.

1. 람다 파라미터 (Parameter): 메소드의 매개변수와 유사. 람다식으로 전달될 입력 값을 정의한다.
2. 화살표 토큰 (Arrow Token ->): 람다 파라미터와 람다 몸체를 구분하는 화살표 기호. "~을 받아서 (파라미터) ~을 실행한다 (람다 몸체)" 라는 의미를 가진다.
3. 람다 몸체 (Body): 실제로 실행될 코드 블록. 람다 파라미터를 이용하여 특정 연산을 수행하고 결과를 반환하거나, 특정 동작을 실행한다.

각 구성 요소를 좀 더 자세히 알아보자

3.1. 람다 파라미터 (Parameter)

람다 파라미터는 람다식으로 전달될 입력 값을 정의한다. 메소드의 매개변수 선언과 유사하지만, 람다식에서는 몇 가지 문법적 특징이 있다.

• 소괄호 () 로 묶어서 선언: 파라미터 목록은 항상 소괄호 () 로 묶어서 선언한다.
• 타입 생략 가능 (타입 추론): 람다 파라미터 타입을 명시적으로 선언하지 않아도 컴파일러가 타입 추론 (Type Inference) 을 통해 자동으로 타입을 판단한다. 타입을 생략하면 코드를 더 간결하게 만들 수 있다.
• 파라미터가 하나인 경우 소괄호 생략 가능: 람다 파라미터가 하나인 경우에는 소괄호 () 를 생략할 수 있다. 하지만 파라미터가 없거나, 여러 개인 경우에는 소괄호 () 를 반드시 사용해야 한다.
• final 키워드 자동 적용 (effectively final): 람다 파라미터는 암묵적으로 final 로 선언된 것처럼 동작한다. 람다식 내부에서 파라미터 값을 변경하려고 하면 컴파일 에러가 발생한다. (람다 캡처링과 관련)

람다 파라미터 선언 예시:

3.2. 화살표 토큰 (Arrow Token ->)

화살표 토큰 -> 은 람다 파라미터와 람다 몸체를 구분하는 핵심적인 기호이다. 람다식에서 "~을 받아서 (파라미터) ~을 실행한다 (람다 몸체)" 라는 의미를 명확하게 나타낸다. 화살표 토큰은 람다식 문법에서 반드시 사용해야 한다.

3.3. 람다 몸체 (Body)

람다 몸체는 람다식의 핵심 로직이 구현되는 부분이다. 람다 파라미터를 이용하여 특정 연산을 수행하고 결과를 반환하거나, 특정 동작을 실행한다. 람다 몸체는 크게 표현식 (Expression Body) 과 블록 (Block Body) 두 가지 형태를 가질 수 있다.

3.3.1. 표현식 (Expression Body)

표현식 람다 몸체는 단일한 실행문으로 구성된 경우에 사용된다. 실행문이 return 문인 경우, return 키워드와 {} 중괄호를 생략하고 표현식만 작성할 수 있다. 표현식 람다 몸체는 코드를 더욱 간결하게 만들어준다.

표현식 람다 몸체 문법:

(파라미터) -> 표현식 // return 키워드, {} 중괄호 생략

표현식 람다 몸체 예시:

// 1. 덧셈 람다식 (표현식 몸체)
(a, b) -> a + b // return 키워드, {} 중괄호 생략

// 2. 문자열 길이 반환 람다식 (표현식 몸체)
name -> name.length() // return 키워드, {} 중괄호 생략

// 3. 숫자 짝수 판별 람다식 (표현식 몸체)
num -> num % 2 == 0 // return 키워드, {} 중괄호 생략

3.3.2. 블록 (Block Body)

블록 람다 몸체는 여러 개의 실행문 또는 복잡한 로직을 포함하는 경우에 사용된다. 실행문들을 {} 중괄호로 묶어서 블록 형태로 작성하며, return 문을 사용하여 명시적으로 반환값을 지정해야 한다. 블록 람다 몸체는 좀 더 복잡한 함수 로직을 표현할 수 있도록 유연성을 제공한다.

블록 람다 몸체 문법:

(파라미터) -> { // {} 중괄호 블록 시작
    // 실행문 1;
    // 실행문 2;
    // ...
    return 반환값; // return 키워드 명시
} // {} 중괄호 블록 끝

블록 람다 몸체 예시:

// 1. 덧셈 후 로그 출력 람다식 (블록 몸체)
(a, b) -> {
    System.out.println("덧셈 연산 시작");
    int sum = a + b;
    System.out.println("덧셈 결과: " + sum);
    return sum; // return 키워드 명시
}

// 2. 문자열 검증 및 길이 반환 람다식 (블록 몸체)
name -> {
    if (name == null || name.isEmpty()) {
        System.out.println("이름이 유효하지 않습니다.");
        return 0; // return 키워드 명시
    }
    System.out.println("이름 길이 계산");
    return name.length(); // return 키워드 명시
}

// 3. 숫자 짝수 판별 및 메시지 출력 람다식 (블록 몸체)
num -> {
    boolean isEven = num % 2 == 0;
    if (isEven) {
        System.out.println(num + "은 짝수입니다.");
    } else {
        System.out.println(num + "은 홀수입니다.");
    }
    return isEven; // return 키워드 명시
}

람다 몸체 선택 가이드:

• 단일 실행문 (return 문): 표현식 람다 몸체 (더 간결)
• 여러 실행문 또는 복잡한 로직: 블록 람다 몸체 (유연성 확보)

4. 함수형 인터페이스 (Functional Interface), 람다식의 핵심 퍼즐 조각

람다식은 함수형 인터페이스 (Functional Interface) 라는 특별한 인터페이스와 함께 사용될 때 진정한 힘을 발휘한다. 함수형 인터페이스는 람다식을 "담는 그릇" 역할을 하며, 람다식이 어떤 형태로 사용될지를 정의힌다.

4.1. 함수형 인터페이스란 무엇일까?

함수형 인터페이스 (Functional Interface) 는 "추상 메소드 (Abstract Method) 를 딱 하나만 가지고 있는 인터페이스" 를 의미한다. 인터페이스는 원래 여러 개의 추상 메소드를 가질 수 있지만, 함수형 인터페이스는 오직 하나의 추상 메소드만 허용된다.

함수형 인터페이스 조건:

• 인터페이스 (Interface): @interface 로 선언되는 타입
• 추상 메소드 (Abstract Method) 1개: 구현체가 없는 추상 메소드를 단 하나만 가짐
• default 메소드, static 메소드 허용: 추상 메소드 외에 default 메소드나 static 메소드는 여러 개 포함될 수 있습니다. (하지만 추상 메소드는 반드시 1개!)

함수형 인터페이스 예시:

// 1. Runnable 인터페이스 (Java 기본 제공, 함수형 인터페이스)
@FunctionalInterface // 함수형 인터페이스임을 명시하는 어노테이션 (선택 사항)
public interface Runnable {
    void run(); // 추상 메소드 1개 (매개변수, 반환값 없음)
}

// 2. Comparator 인터페이스 (Java 기본 제공, 함수형 인터페이스)
@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2); // 추상 메소드 1개 (매개변수 2개, int 반환값)
    // ... default 메소드, static 메소드 ...
}

// 3. MyFunctionalInterface (사용자 정의 함수형 인터페이스)
@FunctionalInterface
interface MyFunctionalInterface {
    int calculate(int a, int b); // 추상 메소드 1개 (매개변수 2개, int 반환값)
}

4.2. @FunctionalInterface 어노테이션

@FunctionalInterface 어노테이션은 인터페이스가 함수형 인터페이스임을 명시적으로 선언하는 데 사용된다. @FunctionalInterface 어노테이션은 선택 사항이지만, 함수형 인터페이스를 만들 때는 붙여주는 것을 권장한다.

@FunctionalInterface 어노테이션의 장점:

• 가독성 향상: 인터페이스가 함수형 인터페이스임을 명확하게 알려주어 코드 이해도를 높임.
• 컴파일 에러 방지: @FunctionalInterface 어노테이션이 붙은 인터페이스가 함수형 인터페이스 조건을 만족하지 못하면 (추상 메소드가 2개 이상인 경우), 컴파일 에러를 발생시켜 개발자가 실수하는 것을 방지해 준다.

4.3. 자바에서 제공하는 주요 함수형 인터페이스

Java 8 에서는 람다식과 함께 다양한 용도로 활용할 수 있는 java.util.function 패키지를 통해 여러 종류의 함수형 인터페이스를 기본적으로 제공한다. 주요 함수형 인터페이스 몇 가지를 살펴보자.

함수형 인터페이스 활용:

• 람다식은 함수형 인터페이스 타입으로만 대입될 수 있다.
• 람다식은 함수형 인터페이스의 추상 메소드를 구현하는 익명 구현 객체를 생성.
• 함수형 인터페이스를 인자로 받는 메소드는 람다식을 인자로 받을 수 있다.

함수형 인터페이스는 람다식을 효과적으로 사용하기 위한 핵심적인 타입 시스템을 제공한다. 람다식을 통해 간결하게 표현된 익명 함수를 함수형 인터페이스 타입으로 다루면서, Java는 함수형 프로그래밍 패러다임을 더욱 강력하게 지원할 수 있게 되었다.

5. 람다식 활용 예제 (실전 코드 완벽 분석)

람다식이 실제로 어떻게 활용되는지 다양한 예제 코드를 통해 자세히 살펴보자.

5.1. 익명 내부 클래스 대체 (익명 함수처럼 간결하게!)

람다식은 익명 내부 클래스를 대체하여 코드를 더욱 간결하게 만들 수 있다. 특히 익명 내부 클래스가 함수형 인터페이스를 구현하는 경우, 람다식으로 훨씬 짧고 명료하게 코드를 작성할 수 있다.

5.1.1. 쓰레드 (Thread) 생성

쓰레드 생성 시 Runnable 함수형 인터페이스를 익명 내부 클래스로 구현하던 코드를 람다식으로 간결하게 바꿀 수 있다.

기존 코드 (익명 내부 클래스):

// 쓰레드 생성 (익명 내부 클래스)
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("쓰레드 실행 (익명 내부 클래스)");
    }
});
thread.start();

람다식 코드:

// 쓰레드 생성 (람다식)
Thread thread = new Thread(() -> { // Runnable 함수형 인터페이스를 람다식으로 구현
    System.out.println("쓰레드 실행 (람다식)");
});
thread.start();

람다식으로 코드가 훨씬 간결해진 것을 확인할 수 있다. 익명 내부 클래스 선언, @Override 어노테이션, 메소드 이름(run) 등 불필요한 코드를 줄이고, 핵심 로직 (System.out.println()) 에 집중할 수 있도록 코드를 개선했다.

5.1.2. 이벤트 핸들러 (Event Handler) 구현

GUI 프로그래밍 (Swing, JavaFX) 또는 웹 프로그래밍 (JavaScript) 에서 이벤트 핸들러를 구현할 때 익명 내부 클래스를 많이 사용하는데, 이 또한 람다식으로 대체하여 코드를 간결하게 만들 수 있다. (JavaFX 예시)

기존 코드 (익명 내부 클래스):

Button button = new Button("클릭!");
button.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("버튼 클릭 이벤트 발생 (익명 내부 클래스)");
    }
});

람다식 코드:

Button button = new Button("클릭!");
button.setOnAction(event -> { // EventHandler 함수형 인터페이스를 람다식으로 구현
    System.out.println("버튼 클릭 이벤트 발생 (람다식)");
});

람다식을 사용하면 이벤트 핸들러 코드를 훨씬 짧고 읽기 쉽게 만들 수 있다. 이벤트 처리 로직 (System.out.println()) 에 더욱 집중할 수 있도록 코드를 개선하고, 불필요한 코드 작성을 줄여 개발 생산성을 향상시켰다.

5.2. 컬렉션 (Collection) 처리 간결화 (Stream API와 함께 더욱 강력하게!)

람다식은 Java 8 에서 함께 도입된 Stream API 와 함께 사용할 때 컬렉션 데이터 처리를 더욱 강력하고 효율적으로 만들어준다. Stream API 는 컬렉션 데이터를 선언형 (declarative) 방식으로 처리할 수 있도록 지원하며, 람다식은 Stream API 에서 데이터 처리 로직을 간결하게 표현하는 데 핵심적인 역할을 한다.

5.2.1. forEach (각 요소 순회)

컬렉션의 각 요소에 대해 특정 동작을 수행할 때 forEach 메소드와 람다식을 함께 사용하면 코드를 간결하게 만들 수 있습니다.

기존 코드 (for-each 루프):

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

// for-each 루프를 사용한 요소 순회
for (String name : names) {
    System.out.println("이름: " + name);
}

람다식 코드 (forEach 메소드):

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

// forEach 메소드와 람다식을 사용한 요소 순회
names.forEach(name -> { // Consumer 함수형 인터페이스를 람다식으로 구현
    System.out.println("이름 (forEach + 람다식): " + name);
});

람다식을 사용하면 컬렉션 요소 순회 코드를 한 줄로 간결하게 표현할 수 있다. for-each 루프에 비해 코드 라인 수를 줄이고, 코드 가독성을 높여준다.

5.2.2. map (요소 변환)

컬렉션의 각 요소를 특정 기준으로 변환하여 새로운 컬렉션을 만들 때 map 메소드와 람다식을 함께 사용한다.

기존 코드 (for-each 루프 + 새로운 리스트 생성):

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

// for-each 루프를 사용한 요소 변환
for (String name : names) {
    nameLengths.add(name.length()); // 이름 길이를 새로운 리스트에 추가
}
System.out.println("이름 길이 리스트: " + nameLengths);

람다식 코드 (map 메소드):

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

// map 메소드와 람다식을 사용한 요소 변환
List<Integer> nameLengths = names.stream() // Stream 생성
        .map(name -> name.length()) // Function 함수형 인터페이스를 람다식으로 구현 (이름 -> 이름 길이)
        .collect(Collectors.toList()); // List로 수집
System.out.println("이름 길이 리스트 (map + 람다식): " + nameLengths);

람다식을 사용하면 컬렉션 요소 변환 코드를 더욱 간결하고 선언적으로 표현할 수 있다. Stream API 의 map 메소드는 각 요소에 람다식을 적용하여 변환된 요소들을 새로운 Stream 으로 반환하고, collect(Collectors.toList()) 메소드는 Stream 을 다시 List 로 변환한다. 복잡한 데이터 변환 로직을 짧은 코드로 구현할 수 있다.

5.2.3. filter (요소 필터링)

컬렉션에서 특정 조건을 만족하는 요소만 골라 새로운 컬렉션을 만들 때 filter 메소드와 람다식을 함께 사용한다.

기존 코드 (for-each 루프 + 조건 검사 + 새로운 리스트 생성):

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

// for-each 루프와 조건 검사를 사용한 요소 필터링
for (String name : names) {
    if (name.length() > 5) { // 이름 길이가 5보다 큰 경우
        longNames.add(name); // 새로운 리스트에 추가
    }
}
System.out.println("긴 이름 리스트: " + longNames);

람다식 코드 (filter 메소드):

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

// filter 메소드와 람다식을 사용한 요소 필터링
List<String> longNames = names.stream() // Stream 생성
        .filter(name -> name.length() > 5) // Predicate 함수형 인터페이스를 람다식으로 구현 (이름 길이 > 5)
        .collect(Collectors.toList()); // List로 수집
System.out.println("긴 이름 리스트 (filter + 람다식): " + longNames);

람다식을 사용하면 컬렉션 요소 필터링 코드를 매우 간결하고 직관적으로 표현할 수 있다. Stream API 의 filter 메소드는 각 요소에 람다식을 적용하여 조건이 참인 요소만 Stream 으로 반환하고, collect(Collectors.toList()) 메소드는 Stream 을 다시 List 로 변환합니다. 복잡한 조건 필터링 로직을 짧은 코드로 구현할 수 있다.

5.2.4. reduce (요소 집계)

컬렉션의 요소들을 특정 연산을 통해 하나의 값으로 집계할 때 reduce 메소드와 람다식을 함께 사용한다.

기존 코드 (for-each 루프 + 누적 변수):

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;

// for-each 루프를 사용한 요소 합계 계산
for (int number : numbers) {
    sum += number; // 누적 변수에 합산
}
System.out.println("숫자 합계: " + sum);

람다식 코드 (reduce 메소드):

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// reduce 메소드와 람다식을 사용한 요소 합계 계산
int sum = numbers.stream() // Stream 생성
        .reduce(0, (a, b) -> a + b); // BinaryOperator 함수형 인터페이스를 람다식으로 구현 (누적 연산)
System.out.println("숫자 합계 (reduce + 람다식): " + sum);

람다식을 사용하면 컬렉션 요소 집계 코드를 매우 간결하고 유연하게 표현할 수 있다. Stream API 의 reduce 메소드는 초기값 (0) 과 람다식을 인자로 받아서, 각 요소에 대해 람다식을 누적 적용하여 최종 결과값을 반환한다. 합계, 평균, 최대/최소값, 사용자 정의 집계 등 다양한 연산을 간결하게 구현할 수 있다.

5.2.5. sort (정렬)

컬렉션을 특정 기준으로 정렬할 때 sort 메소드와 람다식 (Comparator 함수형 인터페이스 구현) 을 함께 사용합니다.

기존 코드 (익명 내부 클래스 Comparator 구현):

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

// 익명 내부 클래스를 사용한 Comparator 구현 (이름 길이 기준 오름차순 정렬)
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length()); // 이름 길이 비교
    }
});
System.out.println("정렬된 이름 리스트 (익명 내부 클래스): " + names);

람다식 코드 (sort 메소드 + 람다식 Comparator 구현):

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

// sort 메소드와 람다식을 사용한 Comparator 구현 (이름 길이 기준 오름차순 정렬)
Collections.sort(names, (s1, s2) -> Integer.compare(s1.length(), s2.length())); // Comparator 함수형 인터페이스를 람다식으로 구현
System.out.println("정렬된 이름 리스트 (람다식): " + names);

// 더 간결하게 메소드 참조 사용 가능
names.sort(Comparator.comparingInt(String::length)); // Comparator.comparingInt 메소드 + 메소드 참조
System.out.println("정렬된 이름 리스트 (메소드 참조): " + names);

람다식을 사용하면 컬렉션 정렬 기준을 훨씬 간결하고 직관적으로 표현할 수 있다. Collections.sort 메소드 또는 List 자체의 sort 메소드에 람다식으로 구현된 Comparator 를 전달하여 정렬 기준을 유연하게 정의할 수 있다. 메소드 참조 (String::length) 를 함께 사용하면 코드를 더욱 간결하게 만들 수 있다.

Stream API 와 람다식을 함께 사용하면 컬렉션 데이터 처리 코드를 극적으로 간결하고 효율적으로 만들 수 있다. 데이터 필터링, 변환, 집계, 정렬 등 복잡한 데이터 처리 로직을 짧고 가독성 높은 코드로 구현하여 개발 생산성을 크게 향상시킬 수 있다.

6. 람다식의 강력한 장점 (코드 간결성, 가독성, 생산성 향상!)

람다식은 Java 코드 작성 방식을 혁신적으로 변화시키고, 다양한 장점을 제공한다.

• 코드 간결성 및 가독성 향상:

  • 익명 내부 클래스에 비해 코드를 훨씬 짧고 간결하게 표현 가능
  • 불필요한 코드 (클래스 선언, 메소드 이름 등) 를 줄여 코드 라인 수 감소
  • 코드의 핵심 로직에 집중할 수 있도록 가독성 향상
  • 특히 짧은 함수 로직이나 콜백 함수를 표현할 때 효과적

• 함수형 프로그래밍 패러다임 지원:

  • Java 를 함수형 프로그래밍 방식으로 코딩할 수 있도록 지원
  • 불변성 (Immutability), 순수 함수 (Pure Function), 고차 함수 (Higher-Order Function) 와 같은 함수형 프로그래밍 개념 활용 가능
  • Stream API 와 함께 데이터 처리 로직을 선언형 (declarative) 방식으로 표현 가능
  • side effect 를 줄이고, 코드의 예측 가능성 및 테스트 용이성 향상

• 병렬 처리 효율 증대 (Stream API와 함께):

  • Stream API 와 람다식을 함께 사용하면 컬렉션 데이터를 병렬로 처리하는 코드를 쉽게 작성 가능
  • 병렬 스트림 (parallelStream()) 을 사용하여 멀티 코어 CPU 환경에서 데이터 처리 성능 극대화
  • 대용량 데이터 처리, 빅데이터 분석 등 성능이 중요한 분야에서 람다식과 Stream API 의 장점 극대화

• 개발 생산성 향상:

  • 코드 작성 시간 단축, 코드 리뷰 및 유지보수 효율 증가
  • 버그 발생 가능성 감소, 코드 품질 향상

7. 람다식 사용 시 주의사항 (제약 사항 및 한계점)

람다식은 강력한 기능이지만, 몇 가지 주의사항과 한계점도 존재한다.  

• this 키워드 동작 방식 차이:
  • 익명 내부 클래스의 this 는 익명 내부 클래스 객체 자신을 가리키지만, 람다식의 this 는 람다식을 감싸는 외부 클래스 객체를 가리킨다. 람다식 내부에서 this 를 사용하는 경우, 익명 내부 클래스와 다른 동작 방식에 주의해야 한다.
• 디버깅 (Debugging) 어려움:
  • 람다식은 익명 함수이기 때문에, 디버깅 시 스택 트레이스 (stack trace) 를 추적하기 어려울 수 있다. 특히 복잡한 람다식 체인 (Stream API 파이프라인) 에서 에러가 발생하면 디버깅이 까다로워질 수 있다.
• 과도한 사용은 오히려 가독성 저하:
  • 람다식을 너무 과도하게 사용하거나, 너무 복잡한 로직을 람다식 하나로 표현하려고 하면 오히려 코드 가독성이 떨어질 수 있다. 람다식은 간결하고 짧은 함수 로직에 적합하며, 복잡한 로직은 적절히 메소드로 분리하는 것이 좋다.
• 모든 인터페이스에 람다식을 사용할 수 있는 것은 아님:
  • 람다식은 함수형 인터페이스 타입으로만 대입될 수 있다. 함수형 인터페이스가 아닌 일반적인 인터페이스나 클래스에는 람다식을 사용할 수 없다.

8. 람다식 vs 익명 내부 클래스 (차이점 명확 비교)

람다식은 익명 내부 클래스를 간결하게 대체하는 기능이지만, 몇 가지 중요한 차이점이 존재한다.

람다식과 익명 내부 클래스 선택 가이드:

• 함수형 인터페이스 구현, 간단한 함수 로직: 람다식 (더 간결하고 효율적)
• 함수형 인터페이스 구현, 복잡한 함수 로직, 상태 관리, 다중 메소드 인터페이스 구현: 익명 내부 클래스 또는 일반 클래스 (유연성 확보)
• 익명 객체 생성, 클래스 상속/구현: 익명 내부 클래스 (람다식으로 대체 불가능)

9. 람다식, 언제 어디에 사용해야 할까? (활용 가이드라인)

람다식을 무분별하게 사용하는 것은 오히려 코드 가독성을 해치고 유지보수를 어렵게 만들 수 있다. 여기서는 람다식을 효과적으로 사용하기 위한 가이드라인을 제시한다.

• 람다식을 사용하는 것이 효과적인 경우:
  • 함수형 인터페이스를 구현하는 익명 객체를 간결하게 생성하고 싶을 때
  • 짧고 간단한 함수 로직 (1~2 줄) 을 표현할 때 (표현식 람다 몸체 활용)
  • 컬렉션 데이터 처리 (Stream API) 와 함께 사용하여 데이터 변환, 필터링, 집계 등 연산을 간결하게 표현하고 싶을 때
  • 콜백 함수, 이벤트 핸들러 등 함수를 인자로 전달하는 상황에서 코드 간결성을 높이고 싶을 때
• 람다식 사용을 지양해야 하거나 신중해야 하는 경우:
  • 람다 몸체가 너무 길거나 복잡한 로직을 포함하는 경우: 람다식을 메소드로 분리하여 코드 가독성을 높이는 것이 좋다.
  • 람다식 내부에서 this 키워드를 사용하는 경우: 람다식의 this 와 익명 내부 클래스의 this 동작 방식이 다르므로, this 사용에 주의해야 한다.
  • 디버깅이 어려워질 수 있는 복잡한 람다식 체인 (Stream API 파이프라인) 을 사용하는 경우: 코드 가독성을 해치지 않도록 적절히 코드를 분리하고, 디버깅 전략을 미리 고려해야 한다.
  • 함수형 인터페이스가 아닌 일반적인 인터페이스나 클래스를 구현해야 하는 경우: 람다식으로는 구현할 수 없으므로 익명 내부 클래스 또는 일반 클래스를 사용해야 한다.

람다식 활용 핵심: "코드 간결성, 가독성, 유지보수성 향상" 에 긍정적인 효과를 줄 수 있는 경우에 람다식을 적극적으로 활용하고, 그렇지 않은 경우에는 기존 방식 (익명 내부 클래스, 일반 클래스) 과 람다식을 적절히 혼용하여 사용하는 것이 좋다.

10. 마무리 (정리)

Java 람다식에 대한 모든 것을 자세하게 알아보았다. 람다식은 Java 개발 방식을 혁신적으로 변화시키고, 코드를 더욱 간결하고 유연하며 강력하게 만들어주는 핵심 기능이다.

핵심 정리:

• 람다식: 익명 함수를 간결하게 표현하는 방법, 함수형 프로그래밍 지원
• 문법: (파라미터) -> { 람다 몸체 } (표현식 몸체, 블록 몸체)
• 함수형 인터페이스: 람다식을 담는 그릇, 추상 메소드 1개 인터페이스
• 활용: 익명 내부 클래스 대체, Stream API 와 함께 컬렉션 처리 간결화, 이벤트 핸들러, 콜백 함수 등
• 장점: 코드 간결성, 가독성, 생산성 향상, 함수형 프로그래밍, 병렬 처리 효율 증대
• 주의사항: this 동작 방식, 디버깅, 과도한 사용, 함수형 인터페이스 타입 제한
• 람다식 vs 익명 내부 클래스: 목적, 코드 스타일, this, 변수 캡처링, 성능 등 차이점 존재

주요 특징 및 동작 방식

1. HTTP Body 파싱
   요청의 본문(body)을 읽어 Java 객체로 변환한다.
   예: 클라이언트가 {"name": "John", "age": 30}을 전송하면, User 객체의 필드에 매핑된다.

2. MessageConverter 사용
   Spring은 요청의 Content-Type 헤더를 기반으로 적절한 HttpMessageConverter를 선택한다.

   • JSON ➡️ MappingJackson2HttpMessageConverter (Jackson 라이브러리 사용)
   • XML ➡️ Jaxb2RootElementHttpMessageConverter
   • (Spring Boot는 자동으로 Jackson을 설정한다.)

3. 사용 예시 (컨트롤러)

   @PostMapping("/users")
   public ResponseEntity<User> createUser(@RequestBody User user) {
       // user 객체 활용 (ex: DB 저장)
       return ResponseEntity.ok(user);
   }

4. 유효성 검증
   @Valid와 결합해 객체의 유효성을 검사할 수 있다.

   @PostMapping("/users")
   public ResponseEntity<?> createUser(@Valid @RequestBody User user) {
       // 유효성 통과 시 로직 실행
   }

주의사항

• HTTP 메서드: 주로 POST, PUT, PATCH와 같이 본문이 필요한 메서드에서 사용합니다. GET에서는 권장되지 않는다.
• Content-Type: 클라이언트는 요청 시 올바른 Content-Type(ex: application/json)을 헤더에 명시해야 한다.
• 에러 처리: 잘못된 형식의 데이터 전송 시 HttpMessageNotReadableException이 발생하므로, 예외 핸들링이 필요하다.

활용 시나리오

• REST API 개발: 클라이언트(React, Angular 등)가 JSON 데이터를 전송할 때.
• 마이크로서비스 통신: 서비스 간 데이터를 객체로 직렬화/역직렬화할 때.
• 유효성 검증: 전송 데이터의 필수 값, 형식 등을 검증할 때 @Valid와 함께 사용.

예제 코드 (JSON 요청)

요청

POST /users HTTP/1.1
Content-Type: application/json

{
  "name": "Alice",
  "email": "alice@example.com"
}

컨트롤러

@RestController
public class UserController {
    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        // user 객체 처리
        return user;
    }
}

User 클래스

public class User {
    private String name;
    private String email;
    // getter, setter, 생성자
}

이렇게 하면 Spring이 자동으로 JSON을 User 객체로 변환해 전달한다.

즉, @RequestBody란? 클라이언트가 전송한 사용자 정보를 DTO로 매핑하여 메서드의 매개변수로 전달하는 것이다.

1. 구성 요소별 역할

2. 동작 흐름

1. 사용자 입력: View를 통해 입력(예: 버튼 클릭)이 발생하면 Controller로 전달됩니다.

2. 입력 처리: Controller는 입력을 해석하고, 필요한 경우 Model을 업데이트하거나 데이터를 요청합니다.

3. 데이터 변경: Model은 데이터 변경 후 관련 View를 자동으로 갱신하거나(Observer 패턴) Controller에 알립니다.

4. UI 갱신: Controller는 최신 데이터를 기반으로 View를 선택하거나 업데이트하여 사용자에게 표시합니다.

3. 장점

• 관심사 분리(Separation of Concerns): 각 컴포넌트가 독립적으로 작동하여 코드 복잡도 감소.

• 재사용성: Model은 UI 변경 없이 재사용 가능하며, View는 다른 데이터 소스와 연결 가능합니다.

• 유지보수 용이: 기능 수정 시 해당 컴포넌트만 변경하면 됩니다.

• 협업 효율성: 프론트엔드/백엔드 개발자의 병렬 작업이 용이합니다.

4. 단점

• 초기 복잡성: 간단한 애플리케이션에는 과도한 구조일 수 있습니다.

• 의존성 관리: View와 Model이 직접 통신하면 결합도 증가 (이를 해결하기 위해 MVVM 등 파생 패턴 등장).

• 컨트롤러 과부하: 로직이 Controller에 집중되면 "뚱뚱한 컨트롤러" 문제 발생 가능.

주요 특징

1. 가변 길이 인코딩:

   • UTF-8은 1바이트 에서 4바이트까지 가변 길이로 문자를 인코딩한다. 기본 ASCII 문자는 1바이트로 표현되고, 그 외의 문자는 2바이트에서 4바이트로 표현된다.

2. ASCII 호환성:

   • UTF-8은 ASCII와 호환된다. 즉, ASCII 코드의 0~127번까지의 문자는 UTF-8로 표현할 때 동일한 바이트 값을 가진다. 이는 기존의 ASCII 기반 시스템과의 호환성을 제공한다.

3. 다양한 문자 지원:

   • UTF-8은 전 세계의 다양한 문자를 지원하며, 모든 유니코드 문자를 표현할 수 있다. 이는 다국어 웹사이트 및 애플리케이션 개발에 유리하다.

사용 예

• 웹 페이지, 데이터베이스 , 파일 등 다양한 분야에서 UTF-8 인코딩이 널리 사용된다.

• HTML에서 태그를 통해 UTF-8 인코딩을 설정할 수 있다.

• 정의 : IP 주소는 네트워크에 연결된 장치의 고유한 주소 를 의미한다. 인터넷 상에서 장치들이 서로를 식별하고 통신하기 위해 필요하다.

• 형식 :

  • IPv4 : 192.168.1.1과 같은 형식으로, 4개의 8비트 숫자로 구성

  • IPv6 : 2001:0db8:85a3:0000:0000:8a2e:0370:7334와 같은 형식으로, 128비트 주소

포트 번호

• 정의 : 포트 번호는 특정 IP 주소 내에서 어떤 서비스나 애플리케이션이 실행되고 있는지를 구분하는 번호. 각 서비스는 고유한 포트 번호를 사용한다.

• 형식 : 포트 번호는 0부터 65535 까지의 값을 가질 수 있다. 0~1023번 포트는 잘 알려진 서비스가 사용한다. (HTTP: 80번, HTTPS: 443번 등)

IP 주소와 포트 번호의 조합

• 형식 : IP 주소와 포트 번호는 함께 사용되어 특정 장치 내의 특정 서비스에 접근하는 데 사용된다. 예를 들어 192.168.1.1:8080은 IP 주소 192.168.1.1의 8080번 포트에서 실행 중인 서비스에 접근하는 것을 의미한다.