[TIL] 221019 - Java의 Interface

프레임워크를 위한 JAVA(3) - Java의 Interface

 

1.  Interface의 기능

1️⃣ 구현을 강제

 

2️⃣ 다형성 제공

다형성을 고려하지 않은 경우

public class Main {
    public static void main(String[] args) {
        // 다형성이 없을때 - 로그인을 하고싶다. -> 상황에 따라 인스턴스를 두개 만들고 조건에 맞게 호출해줘야한다.
        KakaoLogin KakaoUser = new KakaoLogin();
        NaverLogin NaverUser = new NaverLogin();

        KakaoUser.login();
        NaverUser.login();
    }
}

다형성을 이용해 구현

public class Main {
    public static void main(String[] args) {
        // 다형성을 이용한 구현
        // **호스트 코드** 실행하는 코드만 결정을 한다 -> 설정파일, config
        new Main().run(LoginType.Kakao)
    }

    // **구현코드에서는 아무것도 결정하지 않음** : 수정없이 사용이 가능함
    void run(LoginType loginType){
        Login user = getLogin(loginType);
        user.login();
    }
    private static Login getLogin(LoginType type){
        if (type == LoginType.Kakao){
            return new  KakaoLogin();
        }else{
            return new NaverLogin();
        }
    }
}

 

3️⃣ 결합도를 낮추는 효과 (의존성 역전)

package com.programmers.java.poly;
public class UserService implements Login{
    private Login login; // 캡슐화

    // 의존성을 외부에 맡겨 의존도를 낮춘다. -> 여러 기능을 수행할 잠재성을 가짐
    // 구상체와 결합하면 결합성 강해진다. => 추상체와 결합하여 결합도를 낮춘다.
    public UserService(Login login){ //의존성 주입, Dependency Injection
        this.login = login;
    }

    @Override
    public void login() {
        login.login();
    }
}

package com.programmers.java.poly;
public class Main {
    public static void main(String[] args) {
       UserService s = new UserService(new KakaoLogin());
       s.login();
    }
}

Dependency Inversion : 의존성 역전

class diagram :: Interface를 중심으로 Kakao/naver 와 UserService의 의존성 역전

 

✅ Interface의 모든 변수는 public static final
✅ Interface의 모든 메소드는 public abstract 
✅ 타입으로는 사용 가능. 생성은 X

---

인터페이스의 추가된 기능들 👇 : Java 8 이상부터 기능 강화

2. Default method 기능

default 메소드 : default 키워드를 인터페이스가 구현체를 가질 수 있게 되었다.

 

개념

package com.programmers.java.defualt;

interface MyInterface {
    void method1(); // 추상메소드
    default void sayHello(){ // default 키워드를 통해 구현체를 가짐
        System.out.println("Hello World");
    }
}

public class Main implements MyInterface{
    public static void main(String[] args) {
        new Main().sayHello();
    }
//    @Override // 오버라이드 가능
//    public void sayHello(){
//        System.out.println("override hello");
//    }
//
    @Override
    public void method1() {
        throw new RuntimeException();
    }
}

활용

 

1. Adapter 역할을 하게 되었다.

: interface 메소드중 일부만 필요할 경우 빈메소드를 구현해 놓은 Adapter를 만들어 놓고 상속받으면 빈 메소드들을 구현해둘 필요없어 깔끔하게 구현이 가능하다.

: 하지만 class 는 하나의 class 만 상속할 수 있기때문에 이미 상속을 받은 경우 사용이 불가능하다.

⇒ Default method를 통해 adapter를 만들 필요없어졌다.

 

// MyInterfaceAdapter.java
package com.programmers.java.default2;

public class MyInterfaceAdapter implements MyInterface{
    @Override
    public void method1() {
    }
    @Override
    public void method2() {
    }
}

package com.programmers.java.default2;

public class Main {
    public static void main(String[] args) {
        new Service().method1(); // method1만 사용하고 싶음
    
}

// Interface 메소드를 전부 사용하지 않을 경우 Adapter를 만들어(빈 메소드로 구현됨) 상속받아서 원하는 메소드만 오버라이딩 하는 방식을 사용한다.
// Adapter를 사용할 경우 상속은 하나만 받을 수 있기때문에 이미 다른 곳을 상속 받았을 경우 사용하지 못한다.
class Service extends MyInterfaceAdapter{
    @Override
    public void method1(){
        System.out.println("Hello");
    }
}
// => 그럴 경우 interface method를 전부 defualt로 만든 후 원하는 메소드만 오버라이딩 하면 강제성이 없어 코드를 원하는 메소드만 깔끔하게 유지 가능

 

2. interface 추가만으로 기능을 확장할 수 있게 되었다.

package com.programmers.java.default3;

interface Flyable {
    default void fly(){
        System.out.println("fly");
    }
}
interface Swimmable {
    default void swim(){
        System.out.println("swim");
    }
}
interface Wolkable{
    default void wolk(){
        System.out.println(("wolk"));
    }
}

package com.programmers.java.default3;
class Duck implements Flyable,Wolkable,Swimmable{}
class Swan implements Flyable,Swimmable{}

public class Main {
    public static void main(String[] args) {
        new Duck().fly();
        new Swan().swim();
    }
}

 

3. static 메소드를 사용할수 있다. : 함수 제공자(그릇)가 된다. → 유틸리티를 생성할 수 있다.

package com.programmers.java.default3;

interface Ability{
    static void sayHello(){
        System.out.println("Hello");
    }
}

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

 

 

3. Functional Interface

메소드 : class에 종속된 함수

• 추상 메소드가 하나만 존재하는 인터페이스 @FuncionalInterface

package com.programmers.java.func;

@FunctionalInterface
public interface MyRunnable {
    void run(); // 추상메소드가 하나밖에 없는 메소드 == 함수형 인터페이스
}

@FunctionalInterface
interface MyMap{
    void map();
    default void sayHello(){
        System.out.println("Hello World");
    }
    static void sayBye(){
        System.out.println("Bye World");
    }
}

 

 

4. Lambda 표현식

➕ 인터페이스 임시생성

• 익명 클래스를 사용해서 인터체이스의 인스턴스를 생성하고 구현을 바로 정의한다.

: 원래 인터페이스를 사용하기 위해선 무조건 class를 생성해 implements 해줘야 new를 통해 인스턴스를 생성, 사용이 가능했다.

⇒ 익명 클래스를 통해 이름없는 클래스를 생성해여 사용 가능하다.

package com.programmers.java.func;

public class Main {
    public static void main(String[] args) {
        new MyRunnable(){
            @Override
            public void run() {
                System.out.println("run");
            }
        }.run();
    }
}

 

: 인터페이스를 익명으로 생성할 수 있다면 메소드도 익명으로 만들 수 없을까?

• 익명 메소드를 사용해서 표현하는 방법 ⇒ 람다 표현식
• 익명 메소드를 사용해서 간결하게 인터페이스 인스턴스 생성 방법.
• functional interface에서 사용 가능하다.

package com.programmers.java.func;

public class Main2 {
    public static void main(String[] args) {
        // 1. functional interface를 익명 객체로 만들 경우 무조건 하나의 method를 override를 해줘야한다.
        MyRunnable r = new MyRunnable() {
            @Override
            public void run() {
                System.out.println("run");
            }
        };
        r.run();

        // 2. 어차피 하나의 메소드만 override 해줘야하게 때문에 더 간단하게 표현할 수 있다. => 익명메소드
        // 구현부가 한줄일 경우 {} 생략가능. return도 생략가능
        MyRunnable r2 = () -> {
            System.out.println("run~~~");
        };
    }
}

 

• 메소드 레퍼런스

: 람다 표현식에서 입력되는 값을 변경없이 바로 사용하는 경우

: 입력값을 변경하지 말라는 의지의 표현 방식이기도 하다. → 개발자의 개입을 차단하여 안전성 얻기

: 최종적으로 적용될 메소드의 레퍼런스를 지정해 주는 표현 방식

MyConsummer c = (str) -> System.out.println(str);

MyConsummer c = System.out::println;

 

• 제네릭

: 인자 혹은 리턴값을 유동적으로 변경 가능하게 한다.

: reference type만 사용가능

@FunctionalInterface
public interface MyMapper<IN, OUT> {
    OUT map(IN s);
}
@FunctionalInterface
public interface MySupplier<T> {
    T supply();
}

public class Main {
    public static void main(String[] args) {
        MySupplier<String> s = () -> "Hello";
        MyMapper<String,Integer> m = (str) -> str.length(); //reference type만 가능해서 Integer
				Systme.out.println(m.map(s.supply()));
    }
}

 

---

위와 같이 자주 활용할수 있는 Functional Interface들은 java.util.function에서 제공된다.

https://docs.oracle.com/javase/8/docs/api/

Java Platform SE 8

활용 예

package com.programmers.java.lambda;

import java.util.function.Consumer;
import java.util.function.Predicate;

public class Main3 {
    public static void main(String[] args) {
        new Main3().filteredNumbers(30,
                i -> i % 3 == 0 && i > 0,
                System.out::println
        );
       // 기능을 호스트에게 맡겨 다양하게 사용자화 가능하다.
    }
    void filteredNumbers(int max, Predicate<Integer> p, Consumer<Integer> c) {
        for (int i = 0; i < max; i++) {
            if (p.test(i)) c.accept(i);
        }
    }
}