<div id="readability-page-1" class="page"><div><h2 id="java">JAVA</h2>
<h2 id="interface">Interface</h2>
<ul>
<li>모든 메서드가 추창 메서드로 구현되어있는 클래스 즉 구현부가 있으면 안됨</li>
</ul>
<h3 id="interface의-기능">Interface의 기능</h3>
<ul>
<li>구현을 강제화 한다.</li>
<li>다형성을 제공한다.</li>
</ul>
<pre><code>interface MyRunnable {
 void myRun();
}

interface YourRunnable {
 void yourRun();
}

public class Main implements MyRunnable, YourRunnable {

 public static void main(String[] args) {
 Main m = new Main();
 m.myRun();
 m.yourRun();

 MyRunnable myRunnable = new Main();
 myRunnable.myRun();

 YourRunnable yourRunnable = new Main();
 yourRunnable.yourRun();
 }

 @Override
 public void myRun() {
 System.out.println("Hello myRun!");
 }

 @Override
 public void yourRun() {
 System.out.println("Hello yourRun!");
 }
 
}</code></pre>
<ul>
<li>
결합도를 낮춘다(로그인 인터페이스가 있고 / 네이버, 카카오 로그인 구현체가 있을 경우)
<blockquote>
구체화에 의존하는 경우 
<img src="https://media.vlpt.us/images/gudnr1451/post/a9d3093a-1b99-4bcd-ae9c-bb246fccd759/img.png">
</blockquote>
<blockquote>
추상화에 의존하는 경우 
<img src="https://media.vlpt.us/images/gudnr1451/post/1f5c42f1-17b7-40cf-85f4-0d5ef088a452/img_1.png">
</blockquote>
</li>
</ul>
<h3 id="default-method-기능">default method 기능</h3>
<ul>
<li>자바 8부터 인터페이스의 아쉬움이 있어서 강화되었다.</li>
<li>인터페이스가 구현체를 가질 수 있게 된 것입니다.</li>
</ul>
<pre><code>interface MyInterface { // 추상메서드로만 이뤄진 클래스 == 인터페이스

 // 구현이 있다.
 // 추상메서드가 아니라는 얘기는 인터페이스 안에 구현체가 들어간다.
 default void sayHello() {
 System.out.println("Hello World");
 }

 void method(); // 구현이 X

}

public class Main implements MyInterface{
 public static void main(String[] args) {
 Main m = new Main();
 m.sayHello();
 }

 // 물론 오버라이드도 가능하다.
 @Override
 public void sayHello() {
 System.out.println("Bye World");
 }
 
 @Override
 public void method() {
 throw new RuntimeException();
 }
}
</code></pre>
<ul>
<li>Adapter 역할을 하게 되었다.</li>
<li>인터페이스 추가만으로 기능을 확장할 수 있게 되었다.</li>
<li>static 메서드를 가질 수 있게 되었다. : 함수 제공자가 된다.</li>
<li>메서드는 클래스 안에 종속된 함수를 메서드라 부른다. 자바8 이상부터 함수형인터페이스가 생겨났다.</li>
</ul>
<h3 id="functional-interface">Functional Interface</h3>
<pre><code>@FunctionalInterface
interface MyMap {
 void map(); 

 default void sayHello() {
 System.out.println("SayHello");
 }

 static void sayBye() {
 System.out.println("ByeHello");
 }
}</code></pre>
<ul>
<li>추상메서드가 하나만 존재하는 인터페이스<ul>
<li>default나 static은 상관없다.</li>
</ul></li>
<li>@FunctionalInterface 애노테이션을 명시해줘야 한다.</li>
</ul>
<h4 id="인터페이스-임시-생성하기">인터페이스 임시 생성하기</h4>
<ul>
<li>익명클래스를 사용하여 인터페이스 인스턴스를 생성하고 구현을 바로 정의하여 사용한다.</li>
</ul>
<h3 id="lambda-표현식">Lambda 표현식</h3>
<ul>
<li>메서드도 익명으로 만들 수 없을까??</li>
<li>익명 메서드를 사용해서 간결한 인터페이스 인스턴스 생성 방법</li>
</ul>
<pre><code>public class Main2 {
 public static void main(String[] args) {

 // 익명 클래스 사용
 new MyRunnable() {
 @Override
 public void run() {
 System.out.println("hello");
 }
 }.run();

 // 익명메서드를 사용해서 표현하는 방식 : 람다 표현식
 // 생략할 수 있게 만들어준다 어차피 오버라이드를 해줄것이기 때문이다.
 // 함수형 인터페이스라면 어차피 메서드는 하나이기 때문에
 MyRunnable myRunnable = () -&gt; System.out.println("hello");

 }
}</code></pre>
<ul>
<li>람다표현식은 함수형 인터페이스에서만 사용이 가능하다. 추상메서드가 하나일 경우엔 결국 구현할 메서드는 하나지만 두개 이상이 되버리면 어떤 메서드에 적용할 것인지 모르기 때문이다.</li>
<li>간결하게 표현이 가능하다.</li>
</ul>
<pre><code> MyMapper m = (str) -&gt; str.length();

 MyConsumer c = i -&gt; System.out.println(i);</code></pre>
<h4 id="메서드-레퍼런스">메서드 레퍼런스</h4>
<ul>
<li>입력되는 람다 표현식에서 입력되는 값을 변경없이 바로 사용하는 경우</li>
<li>최종으로 적용될 메서드의 레퍼런스를 지정해 주는 표현방식</li>
<li>값에 변형이 일어나면 사용하지 못함.</li>
</ul>
<pre><code> MyMapper m = String::length;

 MyConsumer c = System.out::println;</code></pre>
<ul>
<li>메서드 레퍼런스를 사용하면 좋은 점은 들어오는 값을 변경하지 말고 그대로 사용한다는 의미를 가지게 된다.</li>
<li>개발자의 개입을 차단하며 안정성을 얻을 수 있다.</li>
</ul></div></div>

UkJJang

HyoungUk

JAVA
Interface
모든 메서드가 추창 메서드로 구현되어있는 클래스 즉 구현부가 있으면 안됨
Interface의 기능
구현을 강제화 한다.
다형성을 제공한다.
interface MyRunnable {
  void myRun();
}
interface YourRunnable {
    void yourRun();
}
public class Main implements MyRunnable, YourRunnable {
public static void main(String[] args) {
    Main m = new Main();
    m.myRun();
    m.yourRun();
    MyRunnable myRunnable = new Main();
    myRunnable.myRun();
    YourRunnable yourRunnable = new Main();
    yourRunnable.yourRun();
}
@Override
public void myRun() {
    System.out.println("Hello myRun!");
}
@Override
public void yourRun() {
    System.out.println("Hello yourRun!");
}
}
* 결합도를 낮춘다(로그인 인터페이스가 있고 / 네이버, 카카오 로그인 구현체가 있을 경우)
> 구체화에 의존하는 경우
>![](https://images.velog.io/images/gudnr1451/post/a9d3093a-1b99-4bcd-ae9c-bb246fccd759/img.png)
   > 추상화에 의존하는 경우
> ![](https://images.velog.io/images/gudnr1451/post/1f5c42f1-17b7-40cf-85f4-0d5ef088a452/img_1.png)
### default method 기능
* 자바 8부터 인터페이스의 아쉬움이 있어서 강화되었다.
* 인터페이스가 구현체를 가질 수 있게 된 것입니다.
```java
interface MyInterface { // 추상메서드로만 이뤄진 클래스 == 인터페이스
    // 구현이 있다.
    // 추상메서드가 아니라는 얘기는 인터페이스 안에 구현체가 들어간다.
    default void sayHello() {
        System.out.println("Hello World");
    }
    void method(); // 구현이 X
}
public class Main implements MyInterface{
    public static void main(String[] args) {
        Main m = new Main();
        m.sayHello();
    }
    // 물론 오버라이드도 가능하다.
    @Override
    public void sayHello() {
        System.out.println("Bye World");
    }
    @Override
    public void method() {
        throw new RuntimeException();
    }
}
Adapter 역할을 하게 되었다.
인터페이스 추가만으로 기능을 확장할 수 있게 되었다.
static 메서드를 가질 수 있게 되었다. : 함수 제공자가 된다.
메서드는 클래스 안에 종속된 함수를 메서드라 부른다. 자바8 이상부터 함수형인터페이스가 생겨났다.
Functional Interface
@FunctionalInterface
interface MyMap {
    void map(); 
    default void sayHello() {
        System.out.println("SayHello");
    }
    static void sayBye() {
        System.out.println("ByeHello");
    }
}
추상메서드가 하나만 존재하는 인터페이스
default나 static은 상관없다.
@FunctionalInterface 애노테이션을 명시해줘야 한다.
인터페이스 임시 생성하기
익명클래스를 사용하여 인터페이스 인스턴스를 생성하고 구현을 바로 정의하여 사용한다.
Lambda 표현식
메서드도 익명으로 만들 수 없을까??
익명 메서드를 사용해서 간결한 인터페이스 인스턴스 생성 방법
public class Main2 {
  public static void main(String[] args) {
      // 익명 클래스 사용
      new MyRunnable() {
          @Override
          public void run() {
              System.out.println("hello");
          }
      }.run();
      // 익명메서드를 사용해서 표현하는 방식 : 람다 표현식
      // 생략할 수 있게 만들어준다 어차피 오버라이드를 해줄것이기 때문이다.
      // 함수형 인터페이스라면 어차피 메서드는 하나이기 때문에
      MyRunnable myRunnable = () -> System.out.println("hello");
  }
}
람다표현식은 함수형 인터페이스에서만 사용이 가능하다. 추상메서드가 하나일 경우엔 결국 구현할 메서드는 하나지만 두개 이상이 되버리면 어떤 메서드에 적용할 것인지 모르기 때문이다.
간결하게 표현이 가능하다.
      MyMapper m = (str) -> str.length();
      MyConsumer c = i -> System.out.println(i);
메서드 레퍼런스
입력되는 람다 표현식에서 입력되는 값을 변경없이 바로 사용하는 경우
최종으로 적용될 메서드의 레퍼런스를 지정해 주는 표현방식
값에 변형이 일어나면 사용하지 못함.
      MyMapper m = String::length;
      MyConsumer c = System.out::println;
메서드 레퍼런스를 사용하면 좋은 점은 들어오는 값을 변경하지 말고 그대로 사용한다는 의미를 가지게 된다.
개발자의 개입을 차단하며 안정성을 얻을 수 있다.

[데브코스 2주차 - 3] TIL

댓글