[Java] 13.2. 인터페이스

1. 행위 제약

package ex07.ch01;

// 어떤 것을 노출시킬지 먼저 결정
/*
삼성 리모컨, 엘지 리모컨
기능 : on, off
 */

interface Remocon { // new 불가능
    public abstract void on(); // 무조건 public -> 노출되어있어야 하니까 / 노출x면 굳이 interface일 이유 없음

    void off(); // 추상 클래스는 생략 안되지만 interface는 public abstract 생략 가능 (기본값이라서)
    // 변수 만들 수 있음 - static 생략되어있음
}

class SamsunRemocon implements Remocon {
    public void on() {
        System.out.println("삼성 리모컨 On");
    }

    public void off() {
        System.out.println("삼성 리모컨 Off");
    }
}

class LGRemocon implements Remocon {

    public void on() {
        System.out.println("엘지 리모컨 On");
    }

    public void off() {
        System.out.println("엘지 리모컨 Off");
    }
}


public class Inter01 {
    
    static void start(Remocon r) {
        r.on();
    }

    public static void main(String[] args) {
        Remocon lg = new LGRemocon();
        start(lg);
    }
}

2. 행위 전달

1. 명시적 클래스 사용

1. new하기 위해 의미 없는 class를 만드는 방법이다.

2. 인터페이스를 구현하는 클래스를 직접 만들어서 사용한다

package ex07.ch02;

interface Can1 {
    void run();
}

// 행위 전달 방법 1: 별도의 클래스를 만들어서 사용
class Can2 implements Can1 {
    @Override
    public void run() {
        System.out.println("Can2 run");
    }
}

public class Beh01_Method1 {
    static void start(Can1 can1) {
        can1.run();
    }

    public static void main(String[] args) {
        start(new Can2()); // 별도의 클래스를 인스턴스화하여 전달
    }
}

2. 익명 클래스 사용

1. 클래스를 만들지 않고, 바로 인터페이스를 구현한다. ( = 익명 클래스)
1. 익명 클래스란 객체를 한 번만 생성하여 사용하기 위한 클래스이다.
2. 익명 클래스 선언 방법

인터페이스명 변수명 = new 인터페이스명() {
		인터페이스의 메서드 재정의 
}

package ex07.ch02;

interface Can1 {
    void run();
}

public class Beh01_Method2 {
    static void start(Can1 can1) {
        can1.run();
    }

    public static void main(String[] args) {
        // 행위 전달 방법 2: 익명 클래스 사용
        start(new Can1() {
            @Override
            public void run() {
                System.out.println("익명 클래스의 run 메서드 실행");
            }
        });
    }
}

3. 람다 표현식 사용

1. 구현하고자 하는 인터페이스에 추상 메서드가 1개만 있을 때 (함수형 인터페이스일 때)만 사용 가능하다.

2. () : run의 인수자리 {}: run의 구현체

package ex07.ch02;

interface Can1 {
    void run();
}

public class Beh01_Method3 {
    static void start(Can1 can1) {
        can1.run();
    }

    public static void main(String[] args) {
        // 행위 전달 방법 3: 람다 표현식 사용
        start(() -> System.out.println("람다 표현식 실행 - 달리자1"));
        start(() -> System.out.println("람다 표현식 실행 - 달리자2"));
    }
}

package ex07.ch02;

interface Can1 { // 클래스는 new 해서 obj 만드는 거니까 X
    void run(); // 전달하고 싶은 메서드 하나만 만듦 -> 행위 전달
}

/*
행위 전달 방법1 - new하기 위해 의미 없는 class를 만듦
class Can2 implements Can1{
    public void run(){
        System.out.println("Can2 run");
    }
}*/

public class Beh01 {
    static void start(Can1 can1) { // run은 타입이 없지만 인터페이스는 타입이 있으니까
        can1.run();
    }

    public static void main(String[] args) {
        //start(new Can2());
        /* 행위 전달 방법2
        start(new Can1() { // 익명 클래스
            @Override
            public void run() {

            }
        });
        can1.run();
         */

        // 행위 전달 방법3 - 람다표현식 (내부적으로는 익명 클래스)
        // 행위 전달 표현식 = 람다식
        // () : run의 인수자리 {}: run의 구현체
        start(() -> {
            System.out.println("달리자1");
        });

        start(() -> {
            System.out.println("달리자2");
        });
    }
}