week_04 JAVA 9/11

체인호출 (Chaining)

: 객체 지향 프로그래밍에서 메서드 호출을 연속적으로 연결하는 기법.
메서드 호출 결과를 다시 같은 객체나 다른 객체의 메서드 호출에 사용하는 것으로,
코드를 간결하게 만들고 여러 메서드를 순차적으로 호출하면서 작업을 수행할 수 있음.

package com.ll;

public class Main {
    public static void main(String[] args) {
        Article article = new Article();

        // Article article_ = article.setTitle("제목");
        // article_.setWriter("작가");

        article
                .setTitle("제목")
                .setWriter("작가"); // 이 뒤에 더 잇고 싶으면 → **
    }
}

class Article {
    String title;
    String writer;

    public String getTitle() {
        return title;
    }

    public Article setTitle(String title) {
        this.title = title;
        return this;
    }

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    /*
    // ** → 위 대신 이거 활성화
    public Article setWriterName(String writerName) {
        this.writerName = writerName;
        return this;
    }
    */

    // 이건 결국 개발자가 객체 확인하기 좋게 하는 방법임...
    @Override
    public String toString() {
        return "Article{" +
                "title='" + title + '\'' +
                ", writerName='" + writer + '\'' +
                '}';
    }
}

 

인터페이스

인터페이스의 모든 메서드는 public abstract가 생략된 추상 메서드.
그런데 추상 메서드는 반드시 오버라이드(override) 해야 함.
따라서, 인터페이스를 상속할 때는 해당 인터페이스의 모든 메서드를 필수적으로 오버라이드 해야 함.

한편, 추상 클래스는 추상 메서드와 일반 메서드 둘 다 가질 수 있는데, 이를 상속받을 때에도 추상 메서드는 반드시 오버라이드 해야 함.

익명 클래스를 만들면 인터페이스 / 추상 클래스의 객체도 만들 수 있다.
익명 클래스는 static 함수 아래에만 만들 수 있다.
익명 클래스는 인터페이스나 추상 클래스의 추상 메서드를 구현하는데 유용.
특히 해당 구현이 일회성이거나 재사용될 일이 없을 때 주로 익명 클래스를 활용.

람다 표현식

인터페이스에 메서드가 하나일 때 익명 클래스로 객체를 만들 경우, 익명 클래스를 생성하고 객체를 인스턴스화하는 번거로움을 피하는 방법으로 람다식이 있다.

• 이러한 익명 클래스로 객체를 만드는 경우의 람다식은 클래스 객체 = (인자) -> {수행문}; 형태가 기본적.
• 인자 타입 생략 가능.
• 인자가 하나면 소괄호, 수행문이 하나일 경우 중괄호도 생략 가능.
• 수행문이 아니라 리턴값이 하나가 있어도 return 생략하고 클래스 객체 = 인자 -> 리턴값; 형태 가능.
• 어떤 값을 매개인자로 주어 수행하는 메서드의 경우 클래스 객체 = (인자) -> 메서드(인자);형태가 가능하지만, 여기서 할당하는 인자와 메서드가 받는 매개인자가 동일하다면 클래스 객체 = 클래스::메서드; 형태도 가능. → 이를 메서드 참조라고 함.

// 1: 기본적인 람다식 (new()를 통한 생성 과정 생략)
Consumer<String> consumer = (String s) -> { System.out.println(s); };

// 2: 인자 타입 생략
Consumer<String> consumer = (s) -> { System.out.println(s); };

// 3: 괄호 생략
Consumer<String> consumer = s -> System.out.println(s);

// 4: 메서드 참조
Consumer<String> consumer = System.out::println;

 

Stream

: 데이터 컬렉션을 다루고 처리하는데 사용되는 시퀀스(데이터의 연속적인 흐름)를 나타내는 인터페이스.
filter -> map -> collect 순서로 진행되는데, 데이터를 변환하기엔 좋으나 사용은 불편한 편. 사용을 위해서는 collect 필수.
( IntelliJ에서는 이 과정을 마지막 함수 부분에서 디버그* 해서 -> Trace current stream ...으로 확인할 수 있음. )

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        // 1부터 10까지 출력하기
        // 1. for문 사용
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }

        // 2. IntStream 사용 forEach문으로 변환
        IntStream.rangeClosed(1, 10)
                .forEach((int i) -> {
                    System.out.println(i);
                });

        // 3. 람다식으로 축약
        IntStream.rangeClosed(1, 10)
                .forEach(i -> {
                    System.out.println(i);
                });

        // 4. 람다식 축약222
        IntStream.rangeClosed(1, 10)
                .forEach(System.out::println);

        // 5. 짝수만 출력하고 싶다면? filter 사용
        IntStream.rangeClosed(1, 10)
                .filter(i -> i % 2 == 0)
                .forEach(System.out::println);

        // 6. filter된 값을 map으로 재가공
        IntStream.rangeClosed(1, 10)
                .filter(i -> i % 2 == 0)
                .map(i -> i * 10)
                .forEach(System.out::println);

        // 7. 형변환 시에는 mapToObj 사용
        IntStream.rangeClosed(1, 10)
                .filter(i -> i % 2 == 0)
                .map(i -> i * 10)
                .mapToObj(i -> i + "점")
                .map(s -> "[" + s + "]")
                .forEach(System.out::println);

        // 8. 한번에
        IntStream.rangeClosed(1, 10)
                .filter(i -> i % 2 == 0)
                .mapToObj(i -> "[" + i * 10 + "점]")
                .forEach(System.out::println); // 여기 포커스해서 디버깅*
    }
}

 

Optional

: 값이 존재하거나 존재하지 않을 수 있는 값을 나타내는 래퍼 클래스.
Optional은 주로 null 값을 처리하거나, 값이 없을 때의 예외를 방지하여 코드의 안정성을 높이는 데 사용함.
-> Optional은 리스트 처럼 인덱스 같은 거 없음. 값은 없(null)거나, 하나만 있으니까.
if(객체 != null) { // 이거 대용으로 쓰이는... }
ex/ Optional<클래스> 객체 = Optional.ofNllable(new 클래스());
getter 대신 객체.orElse(null); 로 써서 객체 없으면 에러 띄우지 말고 null 받기 가능.

 

+@
try { 실행문 } catch(Exception ignored) {}; → 오류

생까기

무시하기