j06-interface.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 인터페이스\n",
    "자바는 정적 타입 언어다.\n",
    "그래서 타입을 드러나 보이게 작성하지 않고 `var`로 변수를 선언하는 경우에도 컴파일러는 각각의 변수가 무슨 타입인지 추론한다.\n",
    "\n",
    "레코드와 같은 여러 사용자 정의 타입을 함께 섞어 일관된 방식으로 사용하려면\n",
    "그런 여러 타입을 아우르는 공통된 타입을 선언해야 하는데, 이럴 때 활용할 수 있는 것이 바로 **인터페이스**(interface)다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 문제 상황\n",
    "아래와 같이 두 레코드 `Circle`와 `Rectangle`에\n",
    "동일한 접근 이름, 제어 권한, 리턴 타입, 파라메터를 지닌 메소드 `area()`가 있다고 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "record Circle(int radius) {\n",
    "  public double area() {\n",
    "    return Math.PI * radius * radius;\n",
    "  }\n",
    "}\n",
    "\n",
    "record Rectangle(int width, int height) {\n",
    "  public double area() {\n",
    "    return width * height;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그리고 각각의 인스턴스를 원소로 포함하는 리스트를 이렇게 만들어서"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "var figures = List.of(new Circle(2), new Rectangle(3, 4));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "아래와 같이 반복문을 통해 리스트의 각 원소의 넓이를 `area()` 메소드를 호출하여 알아보려 하면 컴파일되지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilerException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0m\u001b[1m\u001b[31mCompile error:\u001b[0m",
      "\u001b[0m\u001b[1;30m|    for(var figure: figures) {\u001b[0m",
      "\u001b[0m\u001b[1m|      System.out.println(\u001b[0m\u001b[1m\u001b[48;2;235;145;148mfigure.area\u001b[0m\u001b[1m());\u001b[0m",
      "\u001b[0m\u001b[1;30m|    }\u001b[0m",
      "\u001b[0m\u001b[1m\u001b[34mcannot find symbol\u001b[0m",
      "\u001b[0m\u001b[1m\u001b[34m  symbol:   method area()\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "for(var figure: figures) {\n",
    "  System.out.println(figure.area());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "왜냐하면 `Circle`와 `Rectangle`를 공통으로 아우르는 타입은 `java.lang.Object` 뿐인데,\n",
    "이 `Object` 타입에는 `area()`라는 메소드가 정의되어 있지 않기 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 인터페이스(interface)와 추상 메소드(abstract method)\n",
    "\n",
    "문제를 해결하는 방법은 `Circle`와 `Rectangle`의 공통된 타입이면서 `area()` 메소드도 호출할 수 있도록 하는 것이다.\n",
    "자바에서는 이러한 공통된 타입을 `interface` 키워드를 활용해 선언할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "아래 `Figure`의 `area()` 메소드는 지금까지 보아 왔던 `Circle`나 `Rectangle`의 메소드처럼\n",
    "함수 몸체의 코드가 포함된 메소드와는 달리 함수 몸체에 해당하는 내용이 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "interface Figure {\n",
    "    public abstract double area();\n",
    "    // double area(); // 이렇게 public과 abstract를 생략하더라도 기본적으로 public abstract\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위와 같은 메소드를 추상(`abstract`) 메소드라고 하며,\n",
    "메소드의 형식(이름, 접근 권한, 리턴 타입, 파라메터)만 선언되어 있다.\n",
    "\n",
    "구체적인 실행 내용에 해당하는 부분(함수 몸체)은 인터페이스를 구현하는 각각의 레코드에서 구현되어야 한다.\n",
    "아래와 같이 `implements` 키워드를 활용하여 `Circle`와 `Rectangle` 레코드를 `Figure` 인터페이스를 구현하는 레코드라고 선언할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "record Circle(int radius) implements Figure {\n",
    "    public double area() {\n",
    "        return Math.PI * radius * radius;\n",
    "    }\n",
    "}\n",
    "\n",
    "record Rectangle(int width, int height) implements Figure {\n",
    "    public double area() {\n",
    "        return width * height;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이제는 아무런 다른 정보 없이 그냥 객체(Object)라는 공통점만이 아닌, `Figure`라는 공통된 타입의 리스트(`List<Figure>`)로 처리하면 반복문을 순회하며 `Circle`나 `Rectangle`의 인스턴스인 리스트의 원소에 대해 `area()`를 호출하는 코드가 타입 오류 없이 컴파일되어 실행된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "12.0\n"
     ]
    }
   ],
   "source": [
    "List<Figure> figures = List.of(new Circle(2), new Rectangle(3, 4));\n",
    "\n",
    "for(var figure: figures) {\n",
    "  System.out.println(figure.area());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "인터페이스란 서로 다른 레코드에서 동일한 메소드를 호출하려는 경우 선언하여 활용하는 공통의 타입이다.\n",
    "실행 시간(runtime)에 인터페이스의 메서드를 호출하면 자바 가상 머신이 올바른 구현을 동적으로 연결(dynamic binding)하여 인스턴스의 타입에 맞는 적절한 내용의 메소드를 실행한다. 이를 하위타입 다형성(subtype polymorphism)이라고 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 클래스 메소드\n",
    "Like a record, an interface can have `static` methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "interface Figure {\n",
    "  public abstract double area();\n",
    "  public static Figure createACircle(int radius) {\n",
    "    return new Circle(radius);\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circle[radius=3]\n"
     ]
    }
   ],
   "source": [
    "var aCircle = Figure.createACircle(3);\n",
    "\n",
    "System.out.println(aCircle);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default method\n",
    "Inradius an interface, the instance methods are implicitly abstract,\n",
    "if we want to declare a method with some code in it, we have to use\n",
    "the keyword `default`.\n",
    "By example, we can write a method `isBig` that is true if the area is big enough.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "interface Figure {\n",
    "  public abstract double area();\n",
    "  public default boolean isBig() {\n",
    "    return area() >= 10;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "record Circle(int radius) implements Figure {\n",
    "  public double area() {\n",
    "    return radius * radius;\n",
    "  }\n",
    "}\n",
    "\n",
    "record Rectangle(int width, int height) implements Figure {\n",
    "  public double area() {\n",
    "    return width * height;\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "System.out.println(new Circle(2).isBig());\n",
    "System.out.println(new Rectangle(3, 4).isBig());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because a default method is declared on the interface, all records that\n",
    "implement that interface will have that method. Default methods are named like this\n",
    "because if a record that implements the interface doesn't define the method,\n",
    "the method will be provided by default.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수형 인터페이스\n",
    "추상 함수가 딱 하나만으로 이루어진 인터페이스는 의미상 함수의 타입과도 같다.\n",
    "이런 경우를 **함수형 인터페이스**(functional_ interface)라고 부르며,\n",
    "앞서 살펴본 `implements` 키워드를 활용하는 일반적인 구현 방식 외에\n",
    "또 다른 두 가지 특별한 방식으로 구현할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda\n",
    "자바의 람다식은 괄호 안에 파라메터를 작성하고 `->`를 작성한 다음 리턴값 식 또는 중괄호로 작성하는 함수 몸체를 작성한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "interface Figure {\n",
    "  public abstract double area();\n",
    "}\n",
    "\n",
    "Figure anotherFigure = () -> 4;\n",
    "\n",
    "System.out.println(anotherFigure.area());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and rewrite the method rectangularTriangle()\n",
    "You can notice that a lambda can access to the parameter `width` and `height`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.0\n"
     ]
    }
   ],
   "source": [
    "Figure rectangularTriangle(int width, int height) {\n",
    "  return () -> width * height / 2.0;\n",
    "}\n",
    "var triangle = rectangularTriangle(3, 4);\n",
    "System.out.println(triangle.area());\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 메소드 참조 method reference\n",
    "In case of the method already exists instead of \n",
    "calling it inradius a lambda, we can make a reference on it using the operator `::`\n",
    "(notice that EquilaterlaTriangle doesn't implement Figure)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "record EquilateralTriangle(int radius) {\n",
    "  double area() {\n",
    "    return Math.sqrt(3) * radius * radius / 4.0;\n",
    "  }\n",
    "}\n",
    "\n",
    "var equilateral = new EquilateralTriangle(2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so instead of\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "1.7320508075688772\n"
     ]
    }
   ],
   "source": [
    "var figures = List.<Figure>of(new Circle(2), () -> equilateral.area());\n",
    "\n",
    "for(var figure: figures) {\n",
    "  System.out.println(figure.area());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can use a method reference\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "1.7320508075688772\n"
     ]
    }
   ],
   "source": [
    "var figures = List.<Figure>of(new Circle(2), equilateral::area);\n",
    "\n",
    "for(var figure: figures) {\n",
    "  System.out.println(figure.area());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More about lambdas and method references in the following chapter.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java (rjk 2.1.0)",
   "language": "java",
   "name": "rapaio-jupyter-kernel"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "java",
   "nbconvert_exporter": "script",
   "pygments_lexer": "java",
   "version": "22.0.2+9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}