j_8_inheritancepolymorphism.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 7. inheritance\n",
    "\n",
    "Last updated 20190530THR1300 20180602SAT1630 20180520SUN2230\n",
    "\n",
    "## 7.1 학습내용\n",
    "\n",
    "### 7.1.1 목표\n",
    "\n",
    "* 상속을 구현할 수 있다.\n",
    "* 인터페이스 다형성을 사용할 수 있다.\n",
    "* 클래스 다형성을 사용할 수 있다.\n",
    "* 연관관계, 상속관계를 구별해서 사용할 수 있다.\n",
    "\n",
    "목차\n",
    "* 7.1 상속\n",
    "* 7.2 Constructor\n",
    "* 7.3 Fields\n",
    "* 7.4 Interface 상속\n",
    "* 7.5 abstract class\n",
    "* 7.6 Polymorphism\n",
    "* 7.7 equals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.1.2 문제\n",
    "\n",
    "* 문제 oo-1: 도형을 선택하여 그룹을 만들 수 있다. 선택된 도형을 알아내기. (연관 vs 상속)\n",
    "* 문제 oo-2: 상속을 사용하여 거북이를 구현한다 (상속, protected).\n",
    "* 문제 oo-3: 원의 면적을 계산하기 (상속)\n",
    "* 문제 oo-4: 클래스 상속을 사용하여 도형의 면적을 구하기 (abstract class)\n",
    "* 문제 oo-5: 객체를 배열로 저장해서, sayHello() (객체의 배열)\n",
    "* 문제 oo-6: 도형을 다형적으로 면적 계산하기 (다형성, instatnceOf)\n",
    "* 문제 oo-7: equals를 구현한다.\n",
    "* 문제 oo-8: 강의시간표를 구현한다 (NullSubjet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.1.3 연습\n",
    "\n",
    "* mini: **game** 상속을 사용하여 윷놀이, 주사위를 할 수 있게 수정한다.\n",
    "* mini: **shape**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.2 상속\n",
    "\n",
    "### 7.2.1 상속이란?\n",
    "\n",
    "객체지향으로 프로그래밍을 한다면 빼놓을 수 없는 특징이 상속 **inheritance**이다.\n",
    "상속은 한 클래스가 다른 클래스로부터 **모든 특징이나 기능**을 가져오고,\n",
    "거기에 자신의 **새로운 특징이나 기능을 덧붙여 추가**하는 구현 방식이다.\n",
    "이 때 자신의 특징이나 기능을 물려주는 측을 **부모**, 물려받는 측을 **자식**이라고 하고\n",
    "이러한 부모클래스-자식클래스의 계층구조로 상속을 표현할 수 있다.\n",
    "* **부모클래스**는 superclass, base class라고 한다.\n",
    "* **자식클래스**는 subclass, derived class라고 한다.\n",
    "* 이러한 계층구조를 통해 **공통되는 부분을 부모클래스**에서, **다른 부분은 자식클래스**에서 구현한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.2.2 자식은 부모를 대체할 수 있어야 한다.\n",
    "\n",
    "#### 부모 - (부모 $\\cap$자식) = $\\emptyset$\n",
    "\n",
    "상속을 집합으로 이해해 보자.\n",
    "부모와 자식의 공통부분은 부모와 동일하다. 즉, 부모의 **모든 특징이나 기능을 물려받아야** 한다.\n",
    "\n",
    "* 자식클래스는 부모클래스의 모든 요소 element를 가져야 한다. 집합의 요소는 속성, 함수이다.\n",
    "* 부모클래스는 자식클래스와 공통부분을 가진다.\n",
    "* 공통적이지 않은 요소는 자식클래스가 가진다.\n",
    "\n",
    "**LSP Liscov Substitution Principle** 이란 상속에서 지켜야 하는 원칙이다.\n",
    "\n",
    "![alt text](figures/8_liscov.png \"LSP\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 정사각형과 직사각형\n",
    "\n",
    "잘 알려진 예로 직사각형과 정사각형을 들 수 있다.\n",
    "**정사각형이 직사각형을 상속**했다고 하자. 그렇다면 부모 직사각형은 자식 정사각형으로 **대체 substitution 하더라도 아무런 문제가 없어야** 한다.\n",
    "그러나 정사각형은 너비, 높이가 같고 너비가 변경이 되면 높이도 같이 변경이 되는 특징을 가지고 있다.\n",
    "반면에 **직사각형은 너비, 높이가 똑같이 변경되면 직사각형이 아니다**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.2.2 다중상속\n",
    "\n",
    "상속은 **여러 부모**에게서 받을 수 있다.\n",
    "생물학적으로는 여러 부모라는 말이 성립하지 않지만, 객체지향에서는 가능하다.\n",
    "이를 다중 상속이라고 하며, 복수의 부모로부터 특성이나 기능을 물려받는 것을 말한다.\n",
    "상속에서 여러 부모를 가질 수 있지만, **자바에서의 다중 상속은 없다**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "다중상속은 물려받을 재정의된 함수가 여럿 있을 경우 문제가 된다.\n",
    "양서류는 어류와 파충류에서 다중상속을 받고 있다.\n",
    "양서류는 물에서 태어나, 육지생활을 하기 때문에 어류와 파충류의 특징을 부분적으로 가진다.\n",
    "생물학적으로는 설명이 되지만, 자바에서는 문제가 된다. 이런 문제를 **Diamond Problem**이라고 한다.\n",
    "즉 Object클래스의 **toString()** 함수를 호출하려고 하면, 어느 한 쪽을 부정해야 한다.\n",
    "또 부모클래스의 **equals()** 함수를 호출하려하면 어느 한쪽 함수만을 선택적으로 물려받을 수 없다는 문제가 있다.\n",
    "\n",
    "![alt text](figures/8_diamond.png \"Multiple inheritance\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.3 함수\n",
    "\n",
    "### 7.3.1 커피빈 사례\n",
    "\n",
    "커피빈 클래스를 구현해 보자.\n",
    "* 커피빈은 Robusta, Arabica로 나뉜다.\n",
    "* **Robusta**는 **인스턴트** 커피를 만들 때 주로 사용되며, **아프리카**, **아시아** 지역에서 생산된다.\n",
    "* **Arabica**는 **품질이 좋은** 커피를 만드는 재료로 사용되며, 주 생산지는 **라틴 아메리카** 지역이다.\n",
    "* 이 두 클래스는 서로 공통점이 많다. 클래스로 구현하려면, 속성 및 함수가 서로 비슷한 점이 많다.\n",
    "\n",
    "difference | Robusta | Arabica\n",
    "----------|----------|----------\n",
    "altitude(m) | 0-800 | 600-2200\n",
    "caffeine | more (2.2%) | less (1.2%)\n",
    "price | half less | more\n",
    "shape | more circular | oval\n",
    "production area | Africa, Asia (vietnam) | Latin Amerca (Brazail, Colombia)\n",
    "primary use | **instant** | **gourmet**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.3.2 UML로 나타내기\n",
    "\n",
    "상속은 빈삼각형 화살표로 나타낸다.\n",
    "Arabica와 Robusta는 모두 커피빈이므로 **동일한 부모**를 가진다.\n",
    "이를 상속이라고 하고, **부모를 향하는 빈삼각형 화살표**로 표현한다.\n",
    "그러나 서로 다른 특징을 가지며, 커피를 제조하는 공정도 다르기 때문에 분기하여 존재한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"173px\" style=\"width:205px;height:173px;\" version=\"1.1\" viewBox=\"0 0 205 173\" width=\"205px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"103\" x=\"48.5\" y=\"8\"/><ellipse cx=\"63.5\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M63.5938,30.3125 Q60.7344,30.3125 59.1719,28.625 Q57.6094,26.9375 57.6094,23.8594 Q57.6094,20.7969 59.2031,19.1016 Q60.7969,17.4063 63.6875,17.4063 Q66.3281,17.4063 68.4688,17.9531 L68.4688,19.8906 Q65.0313,18.7031 63.6563,18.7031 Q62.6563,18.7031 61.5625,20.0625 Q60.4688,21.4219 60.4688,23.875 Q60.4688,26.2344 61.6406,27.5938 Q62.8125,28.9531 63.8281,28.9531 Q65.5781,28.9531 68.4531,27.4531 L68.4531,29.375 Q66.75,30.3125 63.5938,30.3125 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"71\" x=\"77.5\" y=\"28.4209\">CoffeeBeans</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"49.5\" x2=\"150.5\" y1=\"40\" y2=\"40\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"49.5\" x2=\"150.5\" y1=\"48\" y2=\"48\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"76\" x=\"6\" y=\"116\"/><ellipse cx=\"21\" cy=\"132\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M21.0938,138.3125 Q18.2344,138.3125 16.6719,136.625 Q15.1094,134.9375 15.1094,131.8594 Q15.1094,128.7969 16.7031,127.1016 Q18.2969,125.4063 21.1875,125.4063 Q23.8281,125.4063 25.9688,125.9531 L25.9688,127.8906 Q22.5313,126.7031 21.1563,126.7031 Q20.1563,126.7031 19.0625,128.0625 Q17.9688,129.4219 17.9688,131.875 Q17.9688,134.2344 19.1406,135.5938 Q20.3125,136.9531 21.3281,136.9531 Q23.0781,136.9531 25.9531,135.4531 L25.9531,137.375 Q24.25,138.3125 21.0938,138.3125 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"44\" x=\"35\" y=\"136.4209\">Arabica</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"81\" y1=\"148\" y2=\"148\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"81\" y1=\"156\" y2=\"156\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"79\" x=\"117.5\" y=\"116\"/><ellipse cx=\"132.5\" cy=\"132\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M132.5938,138.3125 Q129.7344,138.3125 128.1719,136.625 Q126.6094,134.9375 126.6094,131.8594 Q126.6094,128.7969 128.2031,127.1016 Q129.7969,125.4063 132.6875,125.4063 Q135.3281,125.4063 137.4688,125.9531 L137.4688,127.8906 Q134.0313,126.7031 132.6563,126.7031 Q131.6563,126.7031 130.5625,128.0625 Q129.4688,129.4219 129.4688,131.875 Q129.4688,134.2344 130.6406,135.5938 Q131.8125,136.9531 132.8281,136.9531 Q134.5781,136.9531 137.4531,135.4531 L137.4531,137.375 Q135.75,138.3125 132.5938,138.3125 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"47\" x=\"146.5\" y=\"136.4209\">Robusta</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"118.5\" x2=\"195.5\" y1=\"148\" y2=\"148\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"118.5\" x2=\"195.5\" y1=\"156\" y2=\"156\"/><path d=\"M78.2902,74.0936 C70.84,88.1958 62.7633,103.4838 56.3208,115.6784 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"72.317,70.4144,87.8488,56,84.6957,76.9542,72.317,70.4144\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M122.098,74.0936 C129.681,88.1958 137.902,103.4838 144.459,115.6784 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"115.675,76.9304,112.368,56,128.005,70.2999,115.675,76.9304\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class CoffeeBeans\n",
    "class Arabica\n",
    "class Robusta\n",
    "CoffeeBeans <|-- Arabica\n",
    "CoffeeBeans <|-- Robusta\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.3.3 상속 구현\n",
    "\n",
    "커피빈 클래스 **CoffeeBeans**를 구현한다.\n",
    "상속을 이해하기 위해 단순한 사례를 사용한다.\n",
    "* CoffeeBeans는 부모클래스, Arabica는 자식클래스이다.\n",
    "* 그 관계는 **```extends```**로 구현한다.\n",
    "\n",
    "```java\n",
    "class Arabica extends CoffeeBeans\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class CoffeeBeans {\r\n",
      "     String species=\"Coffee\";\r\n",
      "     void print() {\r\n",
      "         System.out.println(species);\r\n",
      "     }\r\n",
      "     void setSpecies(String s) {\r\n",
      "         species=s;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class CoffeeBeans\r\n",
      "\r\n",
      " class Arabica extends CoffeeBeans  {\r\n",
      " \r\n",
      " }\r\n",
      "|  Added class Arabica\r\n",
      "\r\n",
      " class Robusta extends CoffeeBeans {\r\n",
      "     String species=\"Robusta\";\r\n",
      " }\r\n",
      "|  Added class Robusta\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class CoffeeBeans {\n",
    "    String species=\"Coffee\";\n",
    "    void print() {\n",
    "        System.out.println(species);\n",
    "    }\n",
    "    void setSpecies(String s) {\n",
    "        species=s;\n",
    "    }\n",
    "}\n",
    "class Arabica extends CoffeeBeans  {\n",
    "\n",
    "}\n",
    "class Robusta extends CoffeeBeans {\n",
    "    String species=\"Robusta\";\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "각 클래스의 객체 instance를 생성해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " CoffeeBeans c=new CoffeeBeans();\r\n",
      "|  Added variable c of type CoffeeBeans with initial value CoffeeBeans@598067a5\r\n",
      "\r\n",
      " Arabica a=new Arabica();\r\n",
      "|  Added variable a of type Arabica with initial value Arabica@42dafa95\r\n",
      "\r\n",
      " Robusta r=new Robusta();\r\n",
      "|  Added variable r of type Robusta with initial value Robusta@402a079c\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "CoffeeBeans c=new CoffeeBeans();\n",
    "Arabica a=new Arabica();\n",
    "Robusta r=new Robusta();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**getClass()** 함수로 어떤 클래스에서 객체가 생성되었는지 알아볼 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.println(\"c의 클래스는: \"+c.getClass());\r\n",
      "c의 클래스는: class REPL.$REPL9$CoffeeBeans\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"c의 클래스는: \"+c.getClass());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "instanceof 연산자는 객체가 어느 클래스에서 생성되었는지 알아볼 수 있다.\n",
    "instanceof 연산자의 결과는 boolean으로 true, false를 반환한다.\n",
    "상속관계로 맺어진 **부모 CoffeeBeans의 객체이면서 또한 Arabica의 객체**이기도 하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " if(a instanceof CoffeeBeans || a instanceof Arabica ) {\r\n",
      "     System.out.println(\"a는 CoffeeBeans클래스이거나 Arabica의 객체이다\");\r\n",
      " } else {\r\n",
      "     System.out.println(\"a는 CoffeeBeans클래스 또는 Arabica의 객체가 아니다\");\r\n",
      " }\r\n",
      "a는 CoffeeBeans클래스이거나 Arabica의 객체이다\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "if(a instanceof CoffeeBeans || a instanceof Arabica ) {\n",
    "    System.out.println(\"a는 CoffeeBeans클래스이거나 Arabica의 객체이다\");\n",
    "} else {\n",
    "    System.out.println(\"a는 CoffeeBeans클래스 또는 Arabica의 객체가 아니다\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.3.4 슈퍼클래스 함수를 호출\n",
    "\n",
    "자식클래스는 부모클래스의 함수를 사용할 수 있다.\n",
    "앞서 부모 CoffeeBeans는 **```print()```** 함수를 정의했지만, Arabica 및 Robusta는 자신의 ```print()``` 함수를 정의하지 않았다.\n",
    "상속관계인 경우, **부모클래스의 ```print()``` 함수**를 호출한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " c.print();\r\n",
      "Coffee\r\n",
      "\r\n",
      " a.print();\r\n",
      "Coffee\r\n",
      "\r\n",
      " r.print();\r\n",
      "Coffee\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "c.print();\n",
    "a.print();\n",
    "r.print();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.3.5 슈퍼클래스 함수를 재정의\n",
    "\n",
    "앞서 **```print()```** 함수를 자식클래스에서 구현해보자.\n",
    "즉 부모클래스 CoffeeBeans가 가지고 있는 print() 함수를 자식클래스에서 구현한다.\n",
    "부모클래스의 함수이름, 함수입력변수, 반환변수를 동일하게 한다.\n",
    "이 경우 부모클래스와 함수를 동일하게 구현하려면 **```@Override```**라고 붙여준다.\n",
    "이를 **java annotation**이라고 한다.\n",
    "\n",
    "> 자바 **annotations**\n",
    ">\n",
    "> 1.5부터 도입된 문법이다.\n",
    "> **```@```**로 시작하고, 현재 기본으로 제공하는 annotations는 **```@Override, @Deprecated, @SuppressWarnings```**이다.\n",
    "> 프로그램에 직접적 영향은 없다.\n",
    "> 소스코드에 넣어 사용하면 함수이름 및 시그니처를 잘못써서 발생하는 문법 오류 및 오타를 막아준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Arabica extends CoffeeBeans  {\r\n",
      "     @Override\r\n",
      "     void setSpecies(String s) {\r\n",
      "         species=s;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     void print() {\r\n",
      "         System.out.println(\"Arabia coffee..\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Arabica\r\n",
      "|    Update replaced variable a, reset to null\r\n",
      "|    Update overwrote class Arabica\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Arabica extends CoffeeBeans  {\n",
    "    @Override\n",
    "    void setSpecies(String s) {\n",
    "        species=s;\n",
    "    }\n",
    "    @Override\n",
    "    void print() {\n",
    "        System.out.println(\"Arabica coffee..\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Arabica 객체의 ```print()``` 함수를 호출하여 보자.\n",
    "* Arabica 클래스의 경우, ```print()``` 함수를 재정의하였고, 이 함수가 호출된다.\n",
    "* Robusta 클래스는 재정의한 함수가 없으므로 부모클래스의 ```print()``` 함수를 호출한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Arabica a1=new Arabica();\r\n",
      "|  Added variable a1 of type Arabica with initial value Arabica@1ce92674\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Arabica a1=new Arabica();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " a1.print();\r\n",
      "Arabia coffee..\r\n",
      "\r\n",
      " r.print();\r\n",
      "Coffee\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "a1.print();\n",
    "r.print();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "이를 **```재정의 overriding```**라고 하며 앞서 설명했던 overloading과 비교해보자.\n",
    "* 상속관계에서 함수를 정의할 때, **함수 명은 같지만 입력변수가 다른** 경우 overloading이라고 한다. 자식클래스에서 부모클래스의 ```print()``` 함수를 다르게 ```print(String s)```로 구현하는 경우이다.\n",
    "* 부모클래스의 ```print()```를 자식클래스에서 재정의하는 경우는 앞서 설명한 overriding이다. 이럴 경우, 컴파일 시점에 어느 함수를 사용할지 결정될 수 없고, **실행하면서 해당하는 객체가 결정**된다.\n",
    "\n",
    "구분 | overriding | overloading\n",
    "--------|--------|--------\n",
    "함수이름 | 같다 | 같다\n",
    "입력변수 argument | 같다 | 다르다\n",
    "구별 시점 | 실행 runtime | 컴파일 compile time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Arabica extends CoffeeBeans  {\r\n",
      "     @Override\r\n",
      "     void setSpecies(String s) {\r\n",
      "         species=s;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     void print() {\r\n",
      "         System.out.println(\"Arabica coffee..\");\r\n",
      "     }\r\n",
      "     void print(String s) {\r\n",
      "         System.out.printf(\"%s: %s\", species, s);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Arabica\r\n",
      "|    Update replaced variable a, reset to null\r\n",
      "|    Update replaced variable a1, reset to null\r\n",
      "|    Update overwrote class Arabica\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Arabica extends CoffeeBeans  {\n",
    "    @Override\n",
    "    void setSpecies(String s) {\n",
    "        species=s;\n",
    "    }\n",
    "    @Override\n",
    "    void print() {\n",
    "        System.out.println(\"Arabica coffee..\");\n",
    "    }\n",
    "    void print(String s) {\n",
    "        System.out.printf(\"%s: %s\", species, s);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Overloading 함수 **```print(\"gourmet quality\")```**를 호출한다.\n",
    "아직 부모클래스 CoffeeBeans의 species 값을 출력하고 있다.\n",
    "```Coffee: instant quality```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Arabica a2=new Arabica();\r\n",
      "|  Added variable a2 of type Arabica with initial value Arabica@56ac3a89\r\n",
      "\r\n",
      " a2.print(\"gourmet quality\");\r\n",
      "Coffee: gourmet quality\r\n"
     ]
    }
   ],
   "source": [
    "Arabica a2=new Arabica();\n",
    "a2.print(\"gourmet quality\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "이번에는 overriding 함수 **```setSpecies(\"Arabica\")```**를 실행한 후 위와 동일한 출력을 해보자. ```Arabica: instant quality```로 변경된 값 Arabica로 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " a2.setSpecies(\"Arabica\");\r\n",
      "\r\n",
      " a2.print(\"qourmet quality\");\r\n",
      "Arabica: qourmet quality\r\n"
     ]
    }
   ],
   "source": [
    "a2.setSpecies(\"Arabica\");\n",
    "a2.print(\"qourmet quality\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### casting\n",
    "\n",
    "앞서 print() 함수의 overriding을 설명하면서 객체가 실행시점에 결정한다는 설명을 하였다.\n",
    "아래와 같이 **```CoffeeBeans ca```**라고 선언하면 **ca에 어느 객체가 할당이 되는지** 아직 모른다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " CoffeeBeans ca;\r\n",
      "|  Added variable ca of type CoffeeBeans\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "CoffeeBeans ca;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "아래와 같이 ca는 부모클래스의 객체이고, 여기에 Arabica를 넣는다.\n",
    "그렇다면 부모클래스로 **upcasting**을 하는 것이다.\n",
    "그리고 재정의함수를 호출하는 경우, 부모의 함수를 호출할까? 자신의 함수를 호출할까?\n",
    "함수가 재정의 되어 있는 경우, **자신의 재정의된 함수를 호출**한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ca = new Arabica();\r\n",
      "|  Variable ca has been assigned the value Arabica@5702b3b1\r\n",
      "\r\n",
      " ca.print();\r\n",
      "Arabica coffee..\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ca = new Arabica();\n",
    "ca.print();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "그러나 부모클래스가 가지고 있지 않고 **Arabica 고유 함수는 ca로 upcasting하면서 제거**된다는 점에 주의한다.\n",
    "따라서 **```ca.print(\"instant quality\")```**는 제거되었기 때문에 오류가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ca.print(\"gourmet quality\");\r\n",
      "|  Error:\r\n",
      "|  method print in class CoffeeBeans cannot be applied to given types;\r\n",
      "|    required: no arguments\r\n",
      "|    found: java.lang.String\r\n",
      "|    reason: actual and formal argument lists differ in length\r\n",
      "|  ca.print(\"gourmet quality\");\r\n",
      "|  ^------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ca.print(\"gourmet quality\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "ca라는 instance는 CoffeeBeans일 수도 있고 Arabica이기도 하다.\n",
    "```instanceof```를 사용해서 출력을 하면 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.println(\"ca의 클래스:\"+ca.getClass());\r\n",
      "ca의 클래스:class REPL.$REPL10E$Arabica\r\n",
      "\r\n",
      " if (ca instanceof CoffeeBeans || ca instanceof Arabica) {\r\n",
      "     System.out.println(\"ca는 CoffeeBeans클래스이거나 Arabica의 객체이다.\");\r\n",
      " } else {\r\n",
      "     System.out.println(\"ca는 CoffeeBeans클래스 또는 Arabica의 객체가 아니다.\");\r\n",
      " }\r\n",
      "ca는 CoffeeBeans클래스이거나 Arabica의 객체이다.\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"ca의 클래스:\"+ca.getClass());\n",
    "if (ca instanceof CoffeeBeans || ca instanceof Arabica) {\n",
    "    System.out.println(\"ca는 CoffeeBeans클래스이거나 Arabica의 객체이다.\");\n",
    "} else {\n",
    "    System.out.println(\"ca는 CoffeeBeans클래스 또는 Arabica의 객체가 아니다.\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### visibility\n",
    "\n",
    "부모클래스의 함수를 **```private```**으로 하는 경우는 자식클래스라고 해도 사용할 수 없다.\n",
    "상속관계에서 부모클래스의 속성을 protected로 해서 자식클래스가 사용할 수 있게 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class CoffeeBeans {\r\n",
      "     String species=\"Coffee\";\r\n",
      "     void print() {\r\n",
      "         System.out.println(species);\r\n",
      "     }\r\n",
      "     private void setSpecies(String s) {\r\n",
      "         species=s;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class CoffeeBeans\r\n",
      "|    Update replaced variable ca, reset to null\r\n",
      "|    Update replaced class Arabica which cannot be referenced until this error is corrected: \r\n",
      "|      method does not override or implement a method from a supertype\r\n",
      "|          @Override\r\n",
      "|          ^-------^\r\n",
      "|    Update replaced class Robusta\r\n",
      "|    Update replaced variable c, reset to null\r\n",
      "|    Update replaced variable a2 which cannot be referenced until class Arabica is declared\r\n",
      "|    Update replaced variable a which cannot be referenced until class Arabica is declared\r\n",
      "|    Update replaced variable a1 which cannot be referenced until class Arabica is declared\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "|    Update overwrote class CoffeeBeans\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " class Robusta extends CoffeeBeans {\r\n",
      "     @Override\r\n",
      "     void print() {\r\n",
      "         System.out.println(\"Robusta coffee..\");\r\n",
      "     }\r\n",
      "     void print(String s) {\r\n",
      "         System.out.printf(\"%s: %s\", species, s);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Robusta\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "|    Update overwrote class Robusta\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class CoffeeBeans {\n",
    "    String species=\"Coffee\";\n",
    "    void print() {\n",
    "        System.out.println(species);\n",
    "    }\n",
    "    private void setSpecies(String s) {\n",
    "        species=s;\n",
    "    }\n",
    "}\n",
    "\n",
    "class Robusta extends CoffeeBeans {\n",
    "    @Override\n",
    "    void print() {\n",
    "        System.out.println(\"Robusta coffee..\");\n",
    "    }\n",
    "    void print(String s) {\n",
    "        System.out.printf(\"%s: %s\", species, s);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**```setSpecies()```** 함수는 private으로 설정되었기 때문에 사용할 수 없다.\n",
    "따라서 Robusta가 자식클래스라고 해도 사용할 수 없고, **Coffee: instant quality**로 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Robusta r1=new Robusta();\r\n",
      "|  Added variable r1 of type Robusta with initial value Robusta@1e127982\r\n",
      "\r\n",
      " r1.setSpecies(\"Robusta\");\r\n",
      "|  Error:\r\n",
      "|  cannot find symbol\r\n",
      "|    symbol:   method setSpecies(java.lang.String)\r\n",
      "|  r1.setSpecies(\"Robusta\");\r\n",
      "|  ^-----------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Robusta r1=new Robusta();\n",
    "r1.setSpecies(\"Robusta\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "따라서 **```r1.print(\"instant quality\")```** 출력에서 species는 변경되지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " r1.print(\"instant quality\");\r\n",
      "Coffee: instant quality\r\n"
     ]
    }
   ],
   "source": [
    "r1.print(\"instant quality\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "그렇다면 속성의 권한을 **protected**로 변경해 보자.\n",
    "권한의 변경은 **번호키를 사용하는 현관문**으로 비유하면 쉽게 이해할 수 있다.\n",
    "현관문 비밀번호는 가족이나 같은 집에 사는 사람들만 사용권한을 가질 수 있다.\n",
    "\n",
    "비유 | 설명\n",
    "-----|-----\n",
    "가족 | 상속관계의 자식클래스는 protected를 사용하는 권한이 있다.\n",
    "같은 집에 사는 사람 | 동일한 패키지에 속하는 클래스는 protected를 사용하는 권한이 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class CoffeeBeans {\r\n",
      "     String species=\"Coffee\";\r\n",
      "     void print() {\r\n",
      "         System.out.println(species);\r\n",
      "     }\r\n",
      "     protected void setSpecies(String s) {\r\n",
      "         species=s;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class CoffeeBeans\r\n",
      "|    Update replaced variable ca, reset to null\r\n",
      "|    Update modified class Arabica which cannot be referenced until this error is corrected: \r\n",
      "|      setSpecies(java.lang.String) in Arabica cannot override setSpecies(java.lang.String) in CoffeeBeans\r\n",
      "|        attempting to assign weaker access privileges; was protected\r\n",
      "|          @Override\r\n",
      "|          ^--------...\r\n",
      "|    Update replaced class Robusta\r\n",
      "|    Update replaced variable c, reset to null\r\n",
      "|    Update modified variable a2 which cannot be referenced until class Arabica is declared\r\n",
      "|    Update modified variable a which cannot be referenced until class Arabica is declared\r\n",
      "|    Update modified variable a1 which cannot be referenced until class Arabica is declared\r\n",
      "|    Update replaced variable r1, reset to null\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "|    Update overwrote class CoffeeBeans\r\n",
      "\r\n",
      " class Robusta extends CoffeeBeans {\r\n",
      "     @Override\r\n",
      "     void print() {\r\n",
      "         System.out.println(\"Robusta coffee..\");\r\n",
      "     }\r\n",
      "     void print(String s) {\r\n",
      "         System.out.printf(\"%s: %s\", species, s);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class Robusta\r\n",
      "|    Update overwrote class Robusta\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class CoffeeBeans {\n",
    "    String species=\"Coffee\";\n",
    "    void print() {\n",
    "        System.out.println(species);\n",
    "    }\n",
    "    protected void setSpecies(String s) {\n",
    "        species=s;\n",
    "    }\n",
    "}\n",
    "class Robusta extends CoffeeBeans {\n",
    "    @Override\n",
    "    void print() {\n",
    "        System.out.println(\"Robusta coffee..\");\n",
    "    }\n",
    "    void print(String s) {\n",
    "        System.out.printf(\"%s: %s\", species, s);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**protected** 속성을 사용하면 재정의한 **```setSpecies()```** 함수를 호출할 수 있다. 따라서 출력문도 Robusta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Robusta r2=new Robusta();\r\n",
      "|  Added variable r2 of type Robusta with initial value Robusta@2ac273d3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Robusta r2=new Robusta();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " r2.setSpecies(\"Robusta\");\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "r2.setSpecies(\"Robusta\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " r2.print(\"instant quality\");\r\n",
      "Robusta: instant quality\r\n"
     ]
    }
   ],
   "source": [
    "r2.print(\"instant quality\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.4 Constructor\n",
    "\n",
    "생성자는 **상속되지 않는다**.\n",
    "생성자는 객체를 생성하는 목적으로 사용하며, 클래스명과 동일한 명칭의 함수이다.\n",
    "생각해 보면, 부모 생성자가 동일한 명칭으로 자식에서 사용될 수가 없는 것이다.\n",
    "상속관계에서 생성자를 정의할 경우, **자식 클래스는 생성자를 새로 정의**해야 하고 부모클래스의 생성자를 사용하려면 **super** 명령어를 사용할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.4.1 도형 사례\n",
    "\n",
    "도형 사례를 통해 생성자를 이해해 보자.\n",
    "부모클래스 **사각형**을 구현해 보자. 사각형은 너비, 높이를 가진다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"129px\" style=\"width:208px;height:129px;\" version=\"1.1\" viewBox=\"0 0 208 129\" width=\"208px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"112.0234\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"193\" x=\"6\" y=\"8\"/><ellipse cx=\"66.75\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M69.7188,29.6406 Q69.1406,29.9375 68.5,30.0859 Q67.8594,30.2344 67.1563,30.2344 Q64.6563,30.2344 63.3359,28.5859 Q62.0156,26.9375 62.0156,23.8125 Q62.0156,20.6875 63.3359,19.0313 Q64.6563,17.375 67.1563,17.375 Q67.8594,17.375 68.5078,17.5313 Q69.1563,17.6875 69.7188,17.9844 L69.7188,20.7031 Q69.0938,20.125 68.5,19.8516 Q67.9063,19.5781 67.2813,19.5781 Q65.9375,19.5781 65.25,20.6484 Q64.5625,21.7188 64.5625,23.8125 Q64.5625,25.9063 65.25,26.9766 Q65.9375,28.0469 67.2813,28.0469 Q67.9063,28.0469 68.5,27.7734 Q69.0938,27.5 69.7188,26.9219 L69.7188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"63\" x=\"87.25\" y=\"28.1543\">Rectangle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"198\" y1=\"40\" y2=\"40\"/><polygon fill=\"none\" points=\"17,46.9023,21,50.9023,17,54.9023,13,50.9023\" style=\"stroke: #B38D22; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"77\" x=\"26\" y=\"54.2104\">length:double</text><polygon fill=\"none\" points=\"17,59.707,21,63.707,17,67.707,13,63.707\" style=\"stroke: #B38D22; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"72\" x=\"26\" y=\"67.0151\">width:double</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"198\" y1=\"73.6094\" y2=\"73.6094\"/><ellipse cx=\"17\" cy=\"85.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"167\" x=\"26\" y=\"87.8198\">Rectangle(l:double, w:double)</text><ellipse cx=\"17\" cy=\"98.3164\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"106\" x=\"26\" y=\"100.6245\">getLength():double</text><ellipse cx=\"17\" cy=\"111.1211\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"98\" x=\"26\" y=\"113.4292\">getWidth():double</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Rectangle {\n",
    "    length:double\n",
    "    width:double\n",
    "    +Rectangle(l:double, w:double)\n",
    "    +getLength():double\n",
    "    +getWidth():double\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Rectangle {\r\n",
      "     double length;\r\n",
      "     double width;\r\n",
      "     public Rectangle(double l, double w) {\r\n",
      "         this.length=l;\r\n",
      "         this.width=w;\r\n",
      "     }\r\n",
      "     public double getLength() {\r\n",
      "         return length;\r\n",
      "     }\r\n",
      "     public double getWidth() {\r\n",
      "         return width;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Rectangle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Rectangle {\n",
    "    double length;\n",
    "    double width;\n",
    "    public Rectangle(double l, double w) {\n",
    "        this.length=l;\n",
    "        this.width=w;\n",
    "    }\n",
    "    public double getLength() {\n",
    "        return length;\n",
    "    }\n",
    "    public double getWidth() {\n",
    "        return width;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Cube** 하위클래스를 만들어 보자.\n",
    "사각형 클래스로부터 **Cube 클래스를 상속**해서 만들어 보자.\n",
    "덧붙여 **높이를 추가**하면 육면체가 된다.\n",
    "**직육면체**는 Length × Width × Height가 서로 다른다.\n",
    "**정육면체 (Square Prism)**는 Length × Width × Height가 모두 동일하다.\n",
    "생성자를 정의해서 부모클래스 **Rectangle의 길이, 너비를 사용**할 수 있게 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"275px\" style=\"width:239px;height:275px;\" version=\"1.1\" viewBox=\"0 0 239 275\" width=\"239px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"112.0234\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"193\" x=\"21.5\" y=\"8\"/><ellipse cx=\"82.25\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M85.2188,29.6406 Q84.6406,29.9375 84,30.0859 Q83.3594,30.2344 82.6563,30.2344 Q80.1563,30.2344 78.8359,28.5859 Q77.5156,26.9375 77.5156,23.8125 Q77.5156,20.6875 78.8359,19.0313 Q80.1563,17.375 82.6563,17.375 Q83.3594,17.375 84.0078,17.5313 Q84.6563,17.6875 85.2188,17.9844 L85.2188,20.7031 Q84.5938,20.125 84,19.8516 Q83.4063,19.5781 82.7813,19.5781 Q81.4375,19.5781 80.75,20.6484 Q80.0625,21.7188 80.0625,23.8125 Q80.0625,25.9063 80.75,26.9766 Q81.4375,28.0469 82.7813,28.0469 Q83.4063,28.0469 84,27.7734 Q84.5938,27.5 85.2188,26.9219 L85.2188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"63\" x=\"102.75\" y=\"28.1543\">Rectangle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"22.5\" x2=\"213.5\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"77\" x=\"27.5\" y=\"54.2104\">length:double</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"72\" x=\"27.5\" y=\"67.0151\">width:double</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"22.5\" x2=\"213.5\" y1=\"73.6094\" y2=\"73.6094\"/><ellipse cx=\"32.5\" cy=\"85.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"167\" x=\"41.5\" y=\"87.8198\">Rectangle(l:double, w:double)</text><ellipse cx=\"32.5\" cy=\"98.3164\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"106\" x=\"41.5\" y=\"100.6245\">getLength():double</text><ellipse cx=\"32.5\" cy=\"111.1211\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"98\" x=\"41.5\" y=\"113.4292\">getWidth():double</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"86.4141\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"224\" x=\"6\" y=\"180\"/><ellipse cx=\"97.75\" cy=\"196\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M100.7188,201.6406 Q100.1406,201.9375 99.5,202.0859 Q98.8594,202.2344 98.1563,202.2344 Q95.6563,202.2344 94.3359,200.5859 Q93.0156,198.9375 93.0156,195.8125 Q93.0156,192.6875 94.3359,191.0313 Q95.6563,189.375 98.1563,189.375 Q98.8594,189.375 99.5078,189.5313 Q100.1563,189.6875 100.7188,189.9844 L100.7188,192.7031 Q100.0938,192.125 99.5,191.8516 Q98.9063,191.5781 98.2813,191.5781 Q96.9375,191.5781 96.25,192.6484 Q95.5625,193.7188 95.5625,195.8125 Q95.5625,197.9063 96.25,198.9766 Q96.9375,200.0469 98.2813,200.0469 Q98.9063,200.0469 99.5,199.7734 Q100.0938,199.5 100.7188,198.9219 L100.7188,201.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"32\" x=\"118.25\" y=\"200.1543\">Cube</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"229\" y1=\"212\" y2=\"212\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"77\" x=\"12\" y=\"226.2104\">height:double</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"229\" y1=\"232.8047\" y2=\"232.8047\"/><ellipse cx=\"17\" cy=\"244.707\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"198\" x=\"26\" y=\"247.0151\">Cube(l:double, w:double, h:double)</text><ellipse cx=\"17\" cy=\"257.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"104\" x=\"26\" y=\"259.8198\">getHeight():double</text><path d=\"M118,140.611 C118,154.156 118,167.8152 118,179.9736 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"111,140.352,118,120.352,125,140.352,111,140.352\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Rectangle {\n",
    "    length:double\n",
    "    width:double\n",
    "    +Rectangle(l:double, w:double)\n",
    "    +getLength():double\n",
    "    +getWidth():double\n",
    "}\n",
    "class Cube {\n",
    "    height:double\n",
    "    +Cube(l:double, w:double, h:double)\n",
    "    +getHeight():double\n",
    "}\n",
    "Rectangle <|-- Cube\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "자식클래스 Cube의 생성자는 매개변수가 3개이다.\n",
    "이 가운데 2개는 부모클래스의 요소이다.\n",
    "앞서 설명한 바와 같이 부모 생성자는 상속되지 않는다.\n",
    "**super()**로 부모클래스의 생성자를 호출한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/select/Cube.java\n",
    "package com.sd.select;\n",
    "public class Cube extends Rectangle {\n",
    "    double height;\n",
    "    public Cube(double l, double w, double h) {\n",
    "        super(l,w);\n",
    "        this.height=h;\n",
    "    }\n",
    "    public double getHeight() {\n",
    "        return height;\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Cube c=new Cube(10.0,20.0,30.0);\r\n",
      "|  Replaced variable c of type Cube with initial value Cube@4e9ba398\r\n",
      "|    Update overwrote variable c\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Cube c=new Cube(10.0,20.0,30.0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 상속받은 함수도 모두 호출할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " c.getLength();\r\n",
      "|  Expression value is: 10.0\r\n",
      "|    assigned to temporary variable $31 of type double\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "c.getLength();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.5 Fields\n",
    "\n",
    "클래스가 가지는 속성 또는 함수는 자신의 것이므로, **자신 외에는 누구도 사용할 수 없게** 하는 것이 좋다.\n",
    "다른 클래스가 사용한다면 최소한으로 허락되도록, **Least Privilege**를 지켜서 설정해야 한다.\n",
    "상속관계에서 자식클래스는 부모의 속성을 사용할 수 있다.\n",
    "그러나 가시성을 제한하면, 자식클래스에서 사용할 수 없다.\n",
    "\n",
    "권한의 구분 | 설명\n",
    "-----|-----\n",
    "private | 상속관계에서 자식클래스가 사용할 수 없다.\n",
    "protected | 상속관계에서 자식클래스가 사용할 수 있다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.3.1 protected 상속\n",
    "\n",
    "protected 속성은 **동일한 패키지** 또는 **상속관계**에서 사용할 수 있다.\n",
    "앞서 구현한 CoffeeBeans의 속성을 **private**으로 구현하면 자식클래스에서 사용할 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class CoffeeBeans {\r\n",
      "     private String species=\"Coffee\";\r\n",
      "     void print() {\r\n",
      "         System.out.println(species);\r\n",
      "     }\r\n",
      "     void setSpecies(String s) {\r\n",
      "         species=s;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class CoffeeBeans\r\n",
      "|    Update overwrote class CoffeeBeans\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class CoffeeBeans {\n",
    "    private String species=\"Coffee\";\n",
    "    void print() {\n",
    "        System.out.println(species);\n",
    "    }\n",
    "    void setSpecies(String s) {\n",
    "        species=s;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "자식클래스 **```Robusta print()```** 함수에서 **private**인 species를 사용하면 **오류**가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " }\r\n",
      "|  Error:\r\n",
      "|  cannot find symbol\r\n",
      "|    symbol:   class CoffeeBeans\r\n",
      "|  class Robusta extends CoffeeBeans {\r\n",
      "|                        ^---------^\r\n",
      "|  Error:\r\n",
      "|  method does not override or implement a method from a supertype\r\n",
      "|      @Override\r\n",
      "|      ^-------^\r\n",
      "|  Error:\r\n",
      "|  cannot find symbol\r\n",
      "|    symbol:   variable species\r\n",
      "|          System.out.printf(\"Exception in thread \"main\" java.util.MissingFormatArgumentException: Format specifier '%s'\r\n",
      "\tat java.util.Formatter.format(java.base@9-internal/Formatter.java:2524)\r\n",
      "\tat java.io.PrintStream.format(java.base@9-internal/PrintStream.java:974)\r\n",
      "\tat java.io.PrintStream.printf(java.base@9-internal/PrintStream.java:873)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.rawout(jdk.jshell@9-internal/JShellTool.java:230)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.hard(jdk.jshell@9-internal/JShellTool.java:240)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.lambda$handleEvent$70(jdk.jshell@9-internal/JShellTool.java:1832)\r\n",
      "\tat java.util.ArrayList$ArrayListSpliterator.forEachRemaining(java.base@9-internal/ArrayList.java:1477)\r\n",
      "\tat java.util.stream.ReferencePipeline$Head.forEach(java.base@9-internal/ReferencePipeline.java:591)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.handleEvent(jdk.jshell@9-internal/JShellTool.java:1832)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.processCompleteSource(jdk.jshell@9-internal/JShellTool.java:1799)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.processSource(jdk.jshell@9-internal/JShellTool.java:1784)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.processSourceCatchingReset(jdk.jshell@9-internal/JShellTool.java:686)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.run(jdk.jshell@9-internal/JShellTool.java:666)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.start(jdk.jshell@9-internal/JShellTool.java:473)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.start(jdk.jshell@9-internal/JShellTool.java:447)\r\n",
      "\tat jdk.internal.jshell.tool.JShellTool.main(jdk.jshell@9-internal/JShellTool.java:437)\r\n",
      "Restarting java"
     ]
    }
   ],
   "source": [
    "class Robusta extends CoffeeBeans {\n",
    "    @Override\n",
    "    void print() {\n",
    "        System.out.printf(\"%s overriding coffee..\",species);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/select/Rectangle.java\n",
    "package com.sd.select;\n",
    "public class Rectangle {\n",
    "    protected double length;\n",
    "    protected double width;\n",
    "    protected boolean isSelected;\n",
    "    public Rectangle(double l, double w) {\n",
    "        this.length=l;\n",
    "        this.width=w;\n",
    "    }\n",
    "    public double getLength() {\n",
    "        return length;\n",
    "    }\n",
    "    public double getWidth() {\n",
    "        return width;\n",
    "    }\n",
    "    public void setSelected(boolean b) {\n",
    "        isSelected=b;\n",
    "    }\n",
    "    public boolean getSelected() {\n",
    "        return isSelected;\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle myrect=new Rectangle(10.0, 20.0)\r\n",
      "|  Added variable myrect of type Rectangle with initial value Rectangle@239963d8\r\n",
      "\r\n",
      " myrect.getLength();\r\n",
      "|  Expression value is: 10.0\r\n",
      "|    assigned to temporary variable $3 of type double\r\n",
      "\r\n",
      " myrect.setSelected(false);\r\n",
      "\r\n",
      " myrect.getSelected();\r\n",
      "|  Expression value is: false\r\n",
      "|    assigned to temporary variable $5 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle myrect=new Rectangle(10.0, 20.0)\n",
    "myrect.getLength();\n",
    "myrect.setSelected(false);\n",
    "myrect.getSelected();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**protected field**는 다른 클래스에서 출력할 수 있을까? 상속관계에서는 출력할 수 있다. \n",
    "또는 동일한 패키지에서도 사용할 수 있다. **Pyramid 클래스**는 Rectangle 클래스와 **동일한 패키지**에 있고, 따라서 **protected로 설정된 length 속성을 사용**할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Pyramid {\r\n",
      "     Rectangle myrect=new Rectangle(10.0, 20.0);\r\n",
      "     void printLength() {\r\n",
      "         System.out.println(\"Rectangle length:\"+myrect.getLength());\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Pyramid\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Pyramid {\n",
    "    Rectangle myrect=new Rectangle(10.0, 20.0);\n",
    "    void printLength() {\n",
    "        System.out.println(\"Rectangle length:\"+myrect.getLength());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Pyramid p=new Pyramid();\r\n",
      "|  Added variable p of type Pyramid with initial value Pyramid@1ce92674\r\n",
      "\r\n",
      " p.printLength();\r\n",
      "Rectangle length:10.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Pyramid p=new Pyramid();\n",
    "p.printLength();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 oo-1: 도형을 선택하여 그룹을 만들 수 있다. 선택된 도형을 알아내기.\n",
    "\n",
    "### 문제\n",
    "그림판 프로그램에서 도형을 선택하는 경우가 있다.\n",
    "선택한 도형을 **그룹으로 만들어 이동하거나, 삭제, 복사**하려면 필요한 기능이다.\n",
    "이러한 **선택은 누가 해야** 하는지 생각해보자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 해결\n",
    "\n",
    "#### 출석\n",
    "\n",
    "출석문제를 생각해보자. 학생은 수강하는 강좌에 출석을 한다. 교수는 강좌가 시작하면 호명을 해서 출석부에 기재를 할 뿐 실제 지각하거나 결석하는지는 학생 당사자가 알 수 있다.\n",
    "\n",
    "참여객체 | 설명\n",
    "-----|-----\n",
    "학생 | 학생이 출석을 한다.\n",
    "교수 | 교수는 학생의 출석을 학생을 통해서 알고, 출석부 기재를 한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 도형선택\n",
    "\n",
    "도형선택의 문제로 옮겨보자.\n",
    "\n",
    "참여객체 | 설명\n",
    "-----|-----\n",
    "도형 | 출석문제에서 학생과 같은 역할을 한다. 도형 자신이 선택되었는지는 스스로 아는 것이 자연스럽다.\n",
    "선택 | 출석문제에서 출석부와 같이, 선택된 것을 기록하는 객체이다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 도형의 구현\n",
    "\n",
    "* 도형은 상속으로 구현할 수 있다.\n",
    "\n",
    "구분 | isa | hasa\n",
    "-------|-------|-------\n",
    "관계 | 상속 | 연관, 포함\n",
    "언제 사용 | 모든 것을 사용할 경우 | 일부만 사용할 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"211px\" style=\"width:393px;height:211px;\" version=\"1.1\" viewBox=\"0 0 393 211\" width=\"393px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"86.4141\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"184\" x=\"200.5\" y=\"8\"/><ellipse cx=\"256.75\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M259.7188,29.6406 Q259.1406,29.9375 258.5,30.0859 Q257.8594,30.2344 257.1563,30.2344 Q254.6563,30.2344 253.3359,28.5859 Q252.0156,26.9375 252.0156,23.8125 Q252.0156,20.6875 253.3359,19.0313 Q254.6563,17.375 257.1563,17.375 Q257.8594,17.375 258.5078,17.5313 Q259.1563,17.6875 259.7188,17.9844 L259.7188,20.7031 Q259.0938,20.125 258.5,19.8516 Q257.9063,19.5781 257.2813,19.5781 Q255.9375,19.5781 255.25,20.6484 Q254.5625,21.7188 254.5625,23.8125 Q254.5625,25.9063 255.25,26.9766 Q255.9375,28.0469 257.2813,28.0469 Q257.9063,28.0469 258.5,27.7734 Q259.0938,27.5 259.7188,26.9219 L259.7188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"63\" x=\"277.25\" y=\"28.1543\">Rectangle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"201.5\" x2=\"383.5\" y1=\"40\" y2=\"40\"/><polygon fill=\"none\" points=\"211.5,46.9023,215.5,50.9023,211.5,54.9023,207.5,50.9023\" style=\"stroke: #B38D22; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"108\" x=\"220.5\" y=\"54.2104\">isSelected:boolean</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"201.5\" x2=\"383.5\" y1=\"60.8047\" y2=\"60.8047\"/><ellipse cx=\"211.5\" cy=\"72.707\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"158\" x=\"220.5\" y=\"75.0151\">setSelected(b:boolean):void</text><ellipse cx=\"211.5\" cy=\"85.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"124\" x=\"220.5\" y=\"87.8198\">getSelected():boolean</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"64\" x=\"260.5\" y=\"154\"/><ellipse cx=\"275.5\" cy=\"170\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M278.4688,175.6406 Q277.8906,175.9375 277.25,176.0859 Q276.6094,176.2344 275.9063,176.2344 Q273.4063,176.2344 272.0859,174.5859 Q270.7656,172.9375 270.7656,169.8125 Q270.7656,166.6875 272.0859,165.0313 Q273.4063,163.375 275.9063,163.375 Q276.6094,163.375 277.2578,163.5313 Q277.9063,163.6875 278.4688,163.9844 L278.4688,166.7031 Q277.8438,166.125 277.25,165.8516 Q276.6563,165.5781 276.0313,165.5781 Q274.6875,165.5781 274,166.6484 Q273.3125,167.7188 273.3125,169.8125 Q273.3125,171.9063 274,172.9766 Q274.6875,174.0469 276.0313,174.0469 Q276.6563,174.0469 277.25,173.7734 Q277.8438,173.5 278.4688,172.9219 L278.4688,175.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"32\" x=\"289.5\" y=\"174.1543\">Cube</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"261.5\" x2=\"323.5\" y1=\"186\" y2=\"186\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"261.5\" x2=\"323.5\" y1=\"194\" y2=\"194\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"60.8047\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"159\" x=\"6\" y=\"20.5\"/><ellipse cx=\"52.25\" cy=\"36.5\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M55.2188,42.1406 Q54.6406,42.4375 54,42.5859 Q53.3594,42.7344 52.6563,42.7344 Q50.1563,42.7344 48.8359,41.0859 Q47.5156,39.4375 47.5156,36.3125 Q47.5156,33.1875 48.8359,31.5313 Q50.1563,29.875 52.6563,29.875 Q53.3594,29.875 54.0078,30.0313 Q54.6563,30.1875 55.2188,30.4844 L55.2188,33.2031 Q54.5938,32.625 54,32.3516 Q53.4063,32.0781 52.7813,32.0781 Q51.4375,32.0781 50.75,33.1484 Q50.0625,34.2188 50.0625,36.3125 Q50.0625,38.4063 50.75,39.4766 Q51.4375,40.5469 52.7813,40.5469 Q53.4063,40.5469 54,40.2734 Q54.5938,40 55.2188,39.4219 L55.2188,42.1406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"58\" x=\"72.75\" y=\"40.6543\">Selection</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"164\" y1=\"52.5\" y2=\"52.5\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"164\" y1=\"60.5\" y2=\"60.5\"/><ellipse cx=\"17\" cy=\"72.4023\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"133\" x=\"26\" y=\"74.7104\">select(r:Rectangle):void</text><path d=\"M292.5,114.495 C292.5,128.489 292.5,142.4833 292.5,153.6717 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"285.5,114.3193,292.5,94.319,299.5,114.3193,285.5,114.3193\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M165.146,51 C175.172,51 185.198,51 195.224,51 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0; stroke-dasharray: 7.0,7.0;\"/><polygon fill=\"#A80036\" points=\"200.467,51,191.467,47,195.467,51,191.467,55,200.467,51\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Rectangle {\n",
    "    #isSelected:boolean\n",
    "    +setSelected(b:boolean):void\n",
    "    +getSelected():boolean\n",
    "}\n",
    "class Cube\n",
    "Rectangle <|-- Cube\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### selection의 구현\n",
    "\n",
    "\n",
    "* Selection클래스는 도형을 변경하기 위해 선택하는 기능을 가지고 있다.\n",
    "* 도형을 선택한 경우, setSelected()함수를 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Rectangle {\n",
    "    #isSelected:boolean\n",
    "    +setSelected(b:boolean):void\n",
    "    +getSelected():boolean\n",
    "}\n",
    "class Cube\n",
    "class Selection {\n",
    "    +select(r:Rectangle):void\n",
    "}\n",
    "Rectangle <|-- Cube\n",
    "Selection .right.> Rectangle\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Selection {\r\n",
      "     Selection(){}\r\n",
      "     public void select(Rectangle r) {\r\n",
      "         r.setSelected(true);\r\n",
      "         System.out.println(\"selected: \"+r.isSelected);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Selection\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Selection {\n",
    "    Selection(){}\n",
    "    public void select(Rectangle r) {\n",
    "        r.setSelected(true);\n",
    "        System.out.println(\"selected: \"+r.isSelected);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Selection s=new Selection();\r\n",
      "|  Added variable s of type Selection with initial value Selection@6d7b4f4c\r\n",
      "|    Update modified class CoffeeBeans\r\n",
      "|    Update modified class Arabica\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Selection s=new Selection();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle r=new Rectangle(20,30);\r\n",
      "|  Modified variable r of type Rectangle with initial value Rectangle@731a74c\r\n",
      "|    Update overwrote variable r\r\n",
      "\r\n",
      " s.select(r);\r\n",
      "selected: true\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle r=new Rectangle(20,30);\n",
    "s.select(r);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 도형이 선택되었는지 getSelected()를 사용해서 알 수 있다.\n",
    "* boolean을 반환할 경우, 함수명이 isSelected()로 변경할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " r.getSelected();\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $50 of type boolean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "r.getSelected();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Selection의 선택그룹\n",
    "\n",
    "구현의 관점에서 생각해 보기. 선택은 관련 클래스로 구현할 수 있다. **Selection** 클래스를 구현한다.\n",
    "Selection 클래스는 **선택된 도형그룹을 배열**로 가진다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/select/Selection.java\n",
    "package com.sd.select;\n",
    "import java.util.ArrayList;\n",
    "public class Selection {\n",
    "    ArrayList<Rectangle> sArr=new ArrayList<Rectangle>();\n",
    "    Selection(){}\n",
    "    public void select(Rectangle r) {\n",
    "        r.setSelected(true);\n",
    "        sArr.add(r);\n",
    "        System.out.println(\"selected: \"+r.isSelected);\n",
    "    }\n",
    "    public void print() {\n",
    "        for(Rectangle r:sArr)\n",
    "            System.out.println(r.toString());\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle r=new Rectangle(20,30);\r\n",
      "|  Modified variable r of type Rectangle with initial value Rectangle@5bcab519\r\n",
      "|    Update overwrote variable r\r\n",
      "\r\n",
      " Selection s=new Selection();\r\n",
      "|  Modified variable s of type Selection with initial value Selection@e45f292\r\n",
      "|    Update overwrote variable s\r\n",
      "\r\n",
      " s.select(r);\r\n",
      "selected: true\r\n",
      "\r\n",
      " s.print();\r\n",
      "REPL.$REPL9$Rectangle@5bcab519\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle r=new Rectangle(20,30);\n",
    "Selection s=new Selection();\n",
    "s.select(r);\n",
    "s.print();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "추가: 선택된 도형의 길이 합계를 구해보자. 반복문을 사용해서 해보자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 7.5.2 private의 상속\n",
    "\n",
    "**거북이** 클래스를 만들어, 속성이 어떻게 상속되는지 배워보자.\n",
    "거북이는 바다와 육지에 거주하는 종류로 구분된다.\n",
    "**바다거북**은 바다에 주로 거주하고, 수영을 할 수 있고 물갈퀴가 발달해 있다. 해조류를 주로 먹는다.\n",
    "반면에 **육지거북**은 수영은 할 수 있지만, 건조한 지역에 살며 풀이나 선인장을 먹는다.\n",
    "\n",
    "특징 | 바다거북 | 육지거북\n",
    "-----|-----|-----\n",
    "거주 | 주로 바다 | 건조한 지역\n",
    "수영 | 수영할 수 있다 | 수영할 수 없다\n",
    "먹이 | 해조류 | 풀, 선인장\n",
    "발모양 | 물갈퀴 | 물갈퀴 퇴화\n",
    "발톱 | 퇴화 | 발달"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "거북이를 완전하게 구현하지 않고, 속성이 상속되는지 알아보기 위해\n",
    "거북이는 다리의 수 **```nLimbs```**, **```food```**를 가지도록 한다.\n",
    "**nLimbs는 private**으로, **food는 protected**로 설정하여 놓는다.\n",
    "서로 다른 종의 생태를 반영하여, 바다거북은 **```swim()```**, 육지거북은 **```walk()```**를 구현한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"236px\" style=\"width:240px;height:236px;\" version=\"1.1\" viewBox=\"0 0 240 236\" width=\"240px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"99.2188\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"148\" x=\"43\" y=\"8\"/><ellipse cx=\"94.75\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M97.7188,29.6406 Q97.1406,29.9375 96.5,30.0859 Q95.8594,30.2344 95.1563,30.2344 Q92.6563,30.2344 91.3359,28.5859 Q90.0156,26.9375 90.0156,23.8125 Q90.0156,20.6875 91.3359,19.0313 Q92.6563,17.375 95.1563,17.375 Q95.8594,17.375 96.5078,17.5313 Q97.1563,17.6875 97.7188,17.9844 L97.7188,20.7031 Q97.0938,20.125 96.5,19.8516 Q95.9063,19.5781 95.2813,19.5781 Q93.9375,19.5781 93.25,20.6484 Q92.5625,21.7188 92.5625,23.8125 Q92.5625,25.9063 93.25,26.9766 Q93.9375,28.0469 95.2813,28.0469 Q95.9063,28.0469 96.5,27.7734 Q97.0938,27.5 97.7188,26.9219 L97.7188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"36\" x=\"115.25\" y=\"28.1543\">Turtle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"44\" x2=\"190\" y1=\"40\" y2=\"40\"/><rect fill=\"none\" height=\"6\" style=\"stroke: #C82930; stroke-width: 1.0;\" width=\"6\" x=\"51\" y=\"48.9023\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"79\" x=\"63\" y=\"54.2104\">int nLimbs=4;</text><ellipse cx=\"54\" cy=\"64.707\" fill=\"none\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"63\" x=\"63\" y=\"67.0151\">food:String</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"44\" x2=\"190\" y1=\"73.6094\" y2=\"73.6094\"/><ellipse cx=\"54\" cy=\"85.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"122\" x=\"63\" y=\"87.8198\">setFood(f:String):void</text><ellipse cx=\"54\" cy=\"98.3164\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"53\" x=\"63\" y=\"100.6245\">eat():void</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"60.8047\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"92\" x=\"6\" y=\"167\"/><ellipse cx=\"21\" cy=\"183\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M23.9688,188.6406 Q23.3906,188.9375 22.75,189.0859 Q22.1094,189.2344 21.4063,189.2344 Q18.9063,189.2344 17.5859,187.5859 Q16.2656,185.9375 16.2656,182.8125 Q16.2656,179.6875 17.5859,178.0313 Q18.9063,176.375 21.4063,176.375 Q22.1094,176.375 22.7578,176.5313 Q23.4063,176.6875 23.9688,176.9844 L23.9688,179.7031 Q23.3438,179.125 22.75,178.8516 Q22.1563,178.5781 21.5313,178.5781 Q20.1875,178.5781 19.5,179.6484 Q18.8125,180.7188 18.8125,182.8125 Q18.8125,184.9063 19.5,185.9766 Q20.1875,187.0469 21.5313,187.0469 Q22.1563,187.0469 22.75,186.7734 Q23.3438,186.5 23.9688,185.9219 L23.9688,188.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"60\" x=\"35\" y=\"187.1543\">SeaTurtle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"97\" y1=\"199\" y2=\"199\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"97\" y1=\"207\" y2=\"207\"/><ellipse cx=\"17\" cy=\"218.9023\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"65\" x=\"26\" y=\"221.2104\">swim():void</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"60.8047\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"98\" x=\"133\" y=\"167\"/><ellipse cx=\"148\" cy=\"183\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M150.9688,188.6406 Q150.3906,188.9375 149.75,189.0859 Q149.1094,189.2344 148.4063,189.2344 Q145.9063,189.2344 144.5859,187.5859 Q143.2656,185.9375 143.2656,182.8125 Q143.2656,179.6875 144.5859,178.0313 Q145.9063,176.375 148.4063,176.375 Q149.1094,176.375 149.7578,176.5313 Q150.4063,176.6875 150.9688,176.9844 L150.9688,179.7031 Q150.3438,179.125 149.75,178.8516 Q149.1563,178.5781 148.5313,178.5781 Q147.1875,178.5781 146.5,179.6484 Q145.8125,180.7188 145.8125,182.8125 Q145.8125,184.9063 146.5,185.9766 Q147.1875,187.0469 148.5313,187.0469 Q149.1563,187.0469 149.75,186.7734 Q150.3438,186.5 150.9688,185.9219 L150.9688,188.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"66\" x=\"162\" y=\"187.1543\">LandTurtle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"134\" x2=\"230\" y1=\"199\" y2=\"199\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"134\" x2=\"230\" y1=\"207\" y2=\"207\"/><ellipse cx=\"144\" cy=\"218.9023\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"60\" x=\"153\" y=\"221.2104\">walk():void</text><path d=\"M85.5338,125.305 C78.6859,139.8438 71.7767,154.5125 66.024,166.726 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"79.2284,122.264,94.0834,107.154,91.8938,128.2299,79.2284,122.264\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M148.466,125.305 C155.314,139.8438 162.223,154.5125 167.976,166.726 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"142.106,128.2299,139.917,107.154,154.772,122.264,142.106,128.2299\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Turtle {\n",
    "    -int nLimbs=4;\n",
    "    #food:String\n",
    "    +setFood(f:String):void\n",
    "    +eat():void\n",
    "}\n",
    "class SeaTurtle {\n",
    "    +swim():void\n",
    "}\n",
    "class LandTurtle {\n",
    "    +walk():void\n",
    "}\n",
    "Turtle <|-- SeaTurtle\n",
    "Turtle <|-- LandTurtle\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "위 설계에 따라 구현을 해보자.\n",
    "함수는 단순하게 수영하거나, 걷는 동작의 출력문으로 대신하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Turtle {\r\n",
      "     private int nLimbs=4;\r\n",
      "     protected String food;\r\n",
      "     public void setFood(String f) {\r\n",
      "         this.food=f;\r\n",
      "     }\r\n",
      "     public void eat() {\r\n",
      "         System.out.print(\"Turtle eats \"+food);\r\n",
      "     }   \r\n",
      " }\r\n",
      "|  Replaced class Turtle\r\n",
      "|    Update replaced class SeaTurtle\r\n",
      "|    Update replaced class LandTurtle\r\n",
      "|    Update replaced variable st, reset to null\r\n",
      "|    Update overwrote class Turtle\r\n",
      "\r\n",
      " class SeaTurtle extends Turtle {\r\n",
      "     public void swim() {\r\n",
      "         System.out.print(\"A sea turtle swims...\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class SeaTurtle\r\n",
      "|    Update overwrote class SeaTurtle\r\n",
      "\r\n",
      " class LandTurtle extends Turtle {\r\n",
      "     public void walk() {\r\n",
      "         System.out.print(\"A land turtle walks...\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class LandTurtle\r\n",
      "|    Update overwrote class LandTurtle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Turtle {\n",
    "    private int nLimbs=4;\n",
    "    protected String food;\n",
    "    public void setFood(String f) {\n",
    "        this.food=f;\n",
    "    }\n",
    "    public void eat() {\n",
    "        System.out.print(\"Turtle eats \"+food);\n",
    "    }   \n",
    "}\n",
    "class SeaTurtle extends Turtle {\n",
    "    public void swim() {\n",
    "        System.out.print(\"A sea turtle swims...\");\n",
    "    }\n",
    "}\n",
    "class LandTurtle extends Turtle {\n",
    "    public void walk() {\n",
    "        System.out.print(\"A land turtle walks...\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**```nLimbs```**를 바다거북에서 읽어보자.\n",
    "가시성 **private은 상속할 수 없다**.\n",
    "\"nLimbs has private access in Turtle\" 즉 **nLimbs는 private으로 설정되어 있어 사용할 수 없다는 오류**가 발생하게 된다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " SeaTurtle st=new SeaTurtle();\r\n",
      "|  Modified variable st of type SeaTurtle with initial value SeaTurtle@6e1ec318\r\n",
      "|    Update overwrote variable st\r\n",
      "\r\n",
      " System.out.println(\"바다거북의 다리 갯수: \"+st.nLimbs);\r\n",
      "|  Error:\r\n",
      "|  nLimbs has private access in Turtle\r\n",
      "|  System.out.println(\"바다거북의 다리 갯수: \"+st.nLimbs);\r\n",
      "|                                     ^-------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "SeaTurtle st=new SeaTurtle();\n",
    "System.out.println(\"바다거북의 다리 갯수: \"+st.nLimbs);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 oo-2: 상속을 사용하여 거북이를 구현한다. \n",
    "\n",
    "### 문제\n",
    "\n",
    "객체지향이란 데이터를 꼭 필요한 경우에만 한정하여 허용하도록 구현할 수 있다.\n",
    "거북이 사례에서 **```nLimbs```** 다리 갯수를 private으로 하면 자식클래스에서 사용할 수 없다.\n",
    "\n",
    "### 해결\n",
    "\n",
    "이 문제를 해결하려면, **```protected```**로 재설정하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Turtle {\r\n",
      "     protected int nLimbs=4;\r\n",
      "     protected String food;\r\n",
      "     public int getNLimbs() {\r\n",
      "         return this.nLimbs;\r\n",
      "     }\r\n",
      "     public void setFood(String f) {\r\n",
      "         this.food=f;\r\n",
      "     }\r\n",
      "     public void eat() {\r\n",
      "         System.out.print(\"Turtle eats \"+food);\r\n",
      "     }  \r\n",
      " }\r\n",
      "|  Added class Turtle\r\n",
      "\r\n",
      " class SeaTurtle extends Turtle {\r\n",
      "     public void swim() {\r\n",
      "         System.out.print(\"A sea turtle swims...\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class SeaTurtle\r\n",
      "\r\n",
      " class LandTurtle extends Turtle {\r\n",
      "     public void walk() {\r\n",
      "         System.out.print(\"A land turtle walks...\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class LandTurtle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Turtle {\n",
    "    protected int nLimbs=4;\n",
    "    protected String food;\n",
    "    public int getNLimbs() {\n",
    "        return this.nLimbs;\n",
    "    }\n",
    "    public void setFood(String f) {\n",
    "        this.food=f;\n",
    "    }\n",
    "    public void eat() {\n",
    "        System.out.print(\"Turtle eats \"+food);\n",
    "    }  \n",
    "}\n",
    "class SeaTurtle extends Turtle {\n",
    "    public void swim() {\n",
    "        System.out.print(\"A sea turtle swims...\");\n",
    "    }\n",
    "}\n",
    "class LandTurtle extends Turtle {\n",
    "    public void walk() {\n",
    "        System.out.print(\"A land turtle walks...\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " SeaTurtle st=new SeaTurtle();\r\n",
      "|  Modified variable st of type SeaTurtle with initial value SeaTurtle@5ce81285\r\n",
      "|    Update overwrote variable st\r\n",
      "\r\n",
      " System.out.println(\"바다거북의 다리 갯수: \"+st.getNLimbs());\r\n",
      "바다거북의 다리 갯수: 4\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "SeaTurtle st=new SeaTurtle();\n",
    "System.out.println(\"바다거북의 다리 갯수: \"+st.getNLimbs());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 oo-3: 원의 면적을 계산하기.\n",
    "\n",
    "### 문제\n",
    "\n",
    "모든 도형은 점을 가지고 있으므로 **```Point```** 클래스를 구현하고, **```Circle```** 클래스를 자식클래스로 구현한다고 하자. 이런 상속관계에서 원의 면적을 계산해 보자.\n",
    "\n",
    "### 해결\n",
    "\n",
    "* 속성 설정: **부모 Point 클래스**는 **위치(x,y)**를 가진다. 자식 Circle 클래스는 위치(x,y)를 사용한다. Circle은 **반지름**을 추가한다. 자식클래스에서 **사용하지 않는 속성은 private**으로 한다.\n",
    "\n",
    "* 함수 설정: 자식클래스에 특화된 함수가 있는지 찾는다. Point 클래스는 면적을 계산하지 않지만, **Circle 클래스는 면적을 계산**한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"224px\" style=\"width:135px;height:224px;\" version=\"1.1\" viewBox=\"0 0 135 224\" width=\"135px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"73.6094\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"64\" x=\"34\" y=\"8\"/><ellipse cx=\"49\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M51.9688,29.6406 Q51.3906,29.9375 50.75,30.0859 Q50.1094,30.2344 49.4063,30.2344 Q46.9063,30.2344 45.5859,28.5859 Q44.2656,26.9375 44.2656,23.8125 Q44.2656,20.6875 45.5859,19.0313 Q46.9063,17.375 49.4063,17.375 Q50.1094,17.375 50.7578,17.5313 Q51.4063,17.6875 51.9688,17.9844 L51.9688,20.7031 Q51.3438,20.125 50.75,19.8516 Q50.1563,19.5781 49.5313,19.5781 Q48.1875,19.5781 47.5,20.6484 Q46.8125,21.7188 46.8125,23.8125 Q46.8125,25.9063 47.5,26.9766 Q48.1875,28.0469 49.5313,28.0469 Q50.1563,28.0469 50.75,27.7734 Q51.3438,27.5 51.9688,26.9219 L51.9688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"32\" x=\"63\" y=\"28.1543\">Point</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"35\" x2=\"97\" y1=\"40\" y2=\"40\"/><rect fill=\"none\" height=\"6\" style=\"stroke: #C82930; stroke-width: 1.0;\" width=\"6\" x=\"42\" y=\"48.9023\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"28\" x=\"54\" y=\"54.2104\">x:int;</text><rect fill=\"none\" height=\"6\" style=\"stroke: #C82930; stroke-width: 1.0;\" width=\"6\" x=\"42\" y=\"61.707\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"28\" x=\"54\" y=\"67.0151\">y:int;</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"35\" x2=\"97\" y1=\"73.6094\" y2=\"73.6094\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"73.6094\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"120\" x=\"6\" y=\"142\"/><ellipse cx=\"45.3\" cy=\"158\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M48.2688,163.6406 Q47.6906,163.9375 47.05,164.0859 Q46.4094,164.2344 45.7063,164.2344 Q43.2063,164.2344 41.8859,162.5859 Q40.5656,160.9375 40.5656,157.8125 Q40.5656,154.6875 41.8859,153.0313 Q43.2063,151.375 45.7063,151.375 Q46.4094,151.375 47.0578,151.5313 Q47.7063,151.6875 48.2688,151.9844 L48.2688,154.7031 Q47.6438,154.125 47.05,153.8516 Q46.4563,153.5781 45.8313,153.5781 Q44.4875,153.5781 43.8,154.6484 Q43.1125,155.7188 43.1125,157.8125 Q43.1125,159.9063 43.8,160.9766 Q44.4875,162.0469 45.8313,162.0469 Q46.4563,162.0469 47.05,161.7734 Q47.6438,161.5 48.2688,160.9219 L48.2688,163.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"34\" x=\"64.7\" y=\"162.1543\">Circle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"125\" y1=\"174\" y2=\"174\"/><rect fill=\"none\" height=\"6\" style=\"stroke: #C82930; stroke-width: 1.0;\" width=\"6\" x=\"14\" y=\"182.9023\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"82\" x=\"26\" y=\"188.2104\">radius:double;</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"125\" y1=\"194.8047\" y2=\"194.8047\"/><ellipse cx=\"17\" cy=\"206.707\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"94\" x=\"26\" y=\"209.0151\">getArea():double</text><path d=\"M66,102.379 C66,115.796 66,129.7553 66,141.974 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"59.0001,102.07,66,82.07,73.0001,102.07,59.0001,102.07\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Point {\n",
    "    -x:int;\n",
    "    -y:int;\n",
    "    +Point()\n",
    "    +Point(int xnew, int ynew)\n",
    "    +getX():int\n",
    "    +getY():int\n",
    "    +toString():String\n",
    "}\n",
    "class Circle {\n",
    "    -radius:double;\n",
    "    +getArea():double\n",
    "}\n",
    "\n",
    "Point <|-- Circle\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Point {\r\n",
      "     protected int x;\r\n",
      "     protected int y;\r\n",
      "     public Point() {}\r\n",
      "     public Point(int xnew, int ynew) {\r\n",
      "         this.x=xnew;\r\n",
      "         this.y=ynew;\r\n",
      "     }\r\n",
      "     public int getX() {\r\n",
      "         return x;\r\n",
      "     }\r\n",
      "     public int getY() {\r\n",
      "         return y;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public String toString() {\r\n",
      "         String msg=\"(\"+x+\",\"+y+\")\";\r\n",
      "         return msg;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Point\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Point {\n",
    "    protected int x;\n",
    "    protected int y;\n",
    "    public Point() {}\n",
    "    public Point(int xnew, int ynew) {\n",
    "        this.x=xnew;\n",
    "        this.y=ynew;\n",
    "    }\n",
    "    public int getX() {\n",
    "        return x;\n",
    "    }\n",
    "    public int getY() {\n",
    "        return y;\n",
    "    }\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        String msg=\"(\"+x+\",\"+y+\")\";\n",
    "        return msg;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Circle extends Point {\r\n",
      "     private double radius;\r\n",
      "     public Circle(){}\r\n",
      "     public Circle(int xnew, int ynew, double rnew) {\r\n",
      "         super(xnew, ynew);\r\n",
      "         this.radius=rnew;\r\n",
      "     }\r\n",
      "     public double getRadius() {\r\n",
      "         return radius;\r\n",
      "     }\r\n",
      "     public double getCircumference() {\r\n",
      "         return 2*Math.PI*getRadius();\r\n",
      "     }\r\n",
      "     public double getArea() {\r\n",
      "         return Math.PI*getRadius()*getRadius();\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Circle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Circle extends Point {\n",
    "    private double radius;\n",
    "    public Circle(){}\n",
    "    public Circle(int xnew, int ynew, double rnew) {\n",
    "        super(xnew, ynew);\n",
    "        this.radius=rnew;\n",
    "    }\n",
    "    public double getRadius() {\n",
    "        return radius;\n",
    "    }\n",
    "    public double getCircumference() {\n",
    "        return 2*Math.PI*getRadius();\n",
    "    }\n",
    "    public double getArea() {\n",
    "        return Math.PI*getRadius()*getRadius();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Circle myCircle=new Circle(10,10,5);\r\n",
      "|  Modified variable myCircle of type Circle with initial value (10,10)\r\n",
      "|    Update overwrote variable myCircle\r\n",
      "\r\n",
      " Double myArea=myCircle.getArea();\r\n",
      "|  Modified variable myArea of type Double with initial value 78.53981633974483\r\n",
      "|    Update overwrote variable myArea\r\n",
      "\r\n",
      " System.out.println(\"원 면적:\"+myArea);\r\n",
      "원 면적:78.53981633974483\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Circle myCircle=new Circle(10,10,5);\n",
    "Double myArea=myCircle.getArea();\n",
    "System.out.println(\"원 면적:\"+myArea);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Double의 소수 출력이 길어서 마음에 들지 않는다면, 형식을 맞출 수 있다.\n",
    "**```%.1f```**는 float로 소수 1자리를 출력한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.printf(\"%.2f\",myArea);\r\n",
      "78.54|  Expression value is: java.io.PrintStream@3b0143d3\r\n",
      "|    assigned to temporary variable $35 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.printf(\"%.2f\",myArea);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "또는 **```NumberFormat```**을 사용하여 형식을 맞출 수 있다.\n",
    "소수점 2자리로 형식을 설정한다. **```new DecimalFormat(\"#0.00\")```**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.text.NumberFormat;\r\n",
      "\r\n",
      " import java.text.DecimalFormat;\r\n",
      "\r\n",
      " NumberFormat formatter = new DecimalFormat(\"#0.00\");\r\n",
      "|  Added variable formatter of type NumberFormat with initial value java.text.DecimalFormat@674dc\r\n",
      "\r\n",
      " System.out.println(\"원 면적:\"+formatter.format(myArea));\r\n",
      "원 면적:78.54\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.text.NumberFormat;\n",
    "import java.text.DecimalFormat;\n",
    "NumberFormat formatter = new DecimalFormat(\"#0.00\");\n",
    "System.out.println(\"원 면적:\"+formatter.format(myArea));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.4 Interface\n",
    "\n",
    "### 7.4.1 interface란 \n",
    "\n",
    "자바의 인터페이스는 **함수의 선언**만을 정의하고, **구현은 비워 놓도록** **```abstract method```**로 만들어졌다.\n",
    "이와 같이 함수의 선언만 **인터페이스로 분리하는 이유**는 무엇일까?\n",
    "**함수선언은 지켜서 구현하라는 약속**이다.\n",
    "함수를 구현할 때 함수명, 입력, 출력을 정하고 이를 지켜서 구현하도록 하면\n",
    "구현하는 코드는 변경될 수 있어도 함수의 선언은 바뀌지 않게 된다.\n",
    "즉 인터페이스에서 정한 함수의 선언을 지켜서 자식클래스에서 자신의 필요에 따라 구현하게 된다.\n",
    "선언을 지키면 함수의 선언은 고정할 수 있어, 이를 **사용하는 측의 코드 변경이 최소화될 수 있다**.\n",
    "\n",
    "따라서 인터페이스는 (abstract method로서 구현이 비워져 있기 때문에)**객체를 생성할 수 없고, Object에서 로부터 물려 받는 보통 클래스와 같은 특징을 가지지 않는다**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.4.2 다중상속\n",
    "\n",
    "자바는 다중상속을 할 수 없다. 즉 클래스를 다중상속 할 수 없다. **다중상속을 하려면 인터페이스를 활용**하여 구현한다.\n",
    "클래스A는 클래스B를 확장한다. 추가적인 확장은 할 수 없다. 인터페이스 C,D를 사용하여 다중구현을 해서 보완한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class A\n",
    "class B\n",
    "interface C\n",
    "interface D\n",
    "B <|-- A \n",
    "C <|.. A\n",
    "D <|.. A\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " interface C {}\r\n",
      "|  Added interface C\r\n",
      "\r\n",
      " class B {}\r\n",
      "|  Added class B\r\n",
      "\r\n",
      " class A extends B implements C {}\r\n",
      "|  Added class A\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "interface C {}\n",
    "class B {}\n",
    "class A extends B implements C {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "인터페이스는 다른 인터페이스를 상속할 수 있다.\n",
    "```interface D```는 ```inteface C```를 상속한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " interface C {}\r\n",
      "|  Modified interface C\r\n",
      "|    Update overwrote interface C\r\n",
      "\r\n",
      " interface D extends C {}\r\n",
      "|  Added interface D\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "interface C {}\n",
    "interface D extends C {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "위와 같이 인터페이스 간에 상속을 하기 보다는 아래와 같이 **두 인터페이스 C, D를 같이 구현**할 수 있다.\n",
    "이와 같이 하면 2개의 인터페이스를 동시에 같이 구현하는 효과를 얻을 수 있다.\n",
    "아래 예제에서 ```Cloneable```, ```Comparable```을 동시에 구현하는 볼 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " interface C {}\r\n",
      "|  Added interface C\r\n",
      "\r\n",
      " class B {}\r\n",
      "|  Added class B\r\n",
      "\r\n",
      " class A extends B implements C {}\r\n",
      "|  Added class A\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "interface C {}\n",
    "class B {}\n",
    "class A extends B implements C {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.4.3 인터페이스 구현 예제\n",
    "\n",
    "Rectangle클래스는 Shape 인터페이스를 구현한다.\n",
    "\n",
    "```java\n",
    "class Rectangle implements Shape\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "interface IShape {\n",
    "    +calcArea():double\n",
    "    +calcPerimeter():double\n",
    "}\n",
    "class Rectangle {\n",
    "    -final width:double\n",
    "    -final height:double\n",
    "    -final area:double\n",
    "    -final perimeter:double\n",
    "}\n",
    "Rectangle .right.|> Shape\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/IShape.java\n",
    "interface IShape {\n",
    "    public double calcArea();\n",
    "    public double calcPerimeter();\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/Rectangle.java\n",
    "class Rectangle implements IShape {\n",
    "  private final double width, height;\n",
    "  public Rectangle(double width, double height) {\n",
    "    this.width = width;\n",
    "    this.height= height;\n",
    "  }\n",
    "  @Override\n",
    "  public double calcArea() {\n",
    "    return width * height;\n",
    "  }\n",
    "\n",
    "  @Override\n",
    "  public double calcPerimeter() {\n",
    "    return 2 * (width + height);\n",
    "  }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "인터페이스 및 자바 파일은 하나씩 파일명과 동일하게 저장하여 컴파일한다.\n",
    "RectangleMain에서 인터페이스 IShape, 클래스 Rectangle을 사용하게 된다.\n",
    "\n",
    "컴파일 및 실행 | 명령어\n",
    "-----|-----\n",
    "interface 컴파일 | javac -d classes/ -sourcepath src/ src/IShape.java \n",
    "Rectangle 컴파일 | javac -d classes/ -sourcepath src/ src/Rectangle.java \n",
    "RectangleMain 컴파일 | javac -d classes/ -sourcepath src/ src/RectangleMain.java \n",
    "RectangleMain 실행 | java -cp classes/ RectangleMain\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# %load src/RectangleMain.java\n",
    "class RectangleMain {\n",
    "    public static void main(String[] args) {\n",
    "        Rectangle r=new Rectangle(10.,20.);\n",
    "        System.out.println(r.calcArea());\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "물론 jshell에서도 불러 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle r=new Rectangle(10.,20.);\r\n",
      "|  Added variable r of type Rectangle with initial value Rectangle@57fffcd7\r\n",
      "\r\n",
      " System.out.println(r.calcArea());\r\n",
      "200.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle r=new Rectangle(10.,20.);\n",
    "System.out.println(r.calcArea());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 7.4.4 default methods\n",
    "\n",
    "자바 버전 8에 **```Default 함수```**, **```Static 함수```**가 추가되었고\n",
    "9에 **```Private 함수```**, **```private static 함수```**가 새로이 추가 되었다.\n",
    "\n",
    "\n",
    "버전 | 인터페이스에 추가하는 함수\n",
    "-----|-----\n",
    "8 | default, static\n",
    "9 | private, private static"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "예를 들어, 아래와 같이 **인터페이스에 ```print()``` 함수를 추가**해보자.\n",
    "이런 경우, 그 인터페이스를 구현한 Rectangle 클래스는 print() 함수를, 버전 1.8이전에는, 반드시 구현했어야 했다. \n",
    "**default로 선언해 놓으면 이를 구현하지 않아도** 된다.\n",
    "즉 이미 그 인터페이스 함수를 구현한 클래스가 있다 하더라도, 수정하지 않아도 된다는 말이다.\n",
    "즉 후방으로 호환성 **backward compatibility**가 보장된다.\n",
    "단 default로 선언하면 그 함수의 body는 구현해 놓아야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " interface IShape {\r\n",
      "     public double calcArea();\r\n",
      "     public double calcPerimeter();\r\n",
      "     default void print() {\r\n",
      "         System.out.println(\"Hello default\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added interface IShape\r\n",
      "|    Update replaced class Rectangle\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "interface IShape {\n",
    "    public double calcArea();\n",
    "    public double calcPerimeter();\n",
    "    default void print() {\n",
    "        System.out.println(\"Hello default\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle r=new Rectangle(10.,20.);\r\n",
      "|  Modified variable r of type Rectangle with initial value Rectangle@72d818d1\r\n",
      "|    Update overwrote variable r\r\n",
      "\r\n",
      " System.out.println(r.calcArea());\r\n",
      "200.0\r\n",
      "\r\n",
      " r.print();\r\n",
      "Hello default\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle r=new Rectangle(10.,20.);\n",
    "System.out.println(r.calcArea());\n",
    "r.print();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 7.4.5 Clone 예제\n",
    "\n",
    "객체는 **참조**를 통해 실제 값을 가리키고 있다.\n",
    "따라서 앞서 설명한 바와 같이 복사할 경우 문제가 발생할 수 있다.\n",
    "\n",
    "즉 참조만을 복사하기 때문에 **실제 값이 원래대로 유지되지 않을 위험**이 있다.\n",
    "자바는 reference를 통한 참조. 복사는 C와 달리 clone()함수를 사용.\n",
    "\n",
    "앞서 복사한 것\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "shallow copying | primitive data만 복사.\n",
    "deep copying | primitive data + object ref까지 복사.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Dog {\r\n",
      "     String name;\r\n",
      "     String breed;\r\n",
      "     public Dog(String name, String breed) {\r\n",
      "         this.name = name;\r\n",
      "         this.breed = breed;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Dog\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Dog {\n",
    "    String name;\n",
    "    String breed;\n",
    "    public Dog(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Object 클래스는 clone() 함수를 가지고 있다.\n",
    "이 함수를 사용하여 객체를 복사할 수 있다.\n",
    "```java\n",
    "protected Object clone()\n",
    "```\n",
    "\n",
    "그러나 **clone() 함수를 직접 호출하면 예외**가 발생한다.\n",
    "**클래스 Object에서 상속받는 함수이지만** 반드시 자바는 **Cloneable 인터페이스를 구현**해서 객체를 복사한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Dog d=new Dog(\"js\",\"robot\");\r\n",
      "|  Added variable d of type Dog with initial value Dog@3159c4b8\r\n",
      "\r\n",
      " d.clone();\r\n",
      "|  Error:\r\n",
      "|  clone() has protected access in java.lang.Object\r\n",
      "|  d.clone();\r\n",
      "|  ^-----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Dog d=new Dog(\"js\",\"robot\");\n",
    "d.clone();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Dog implements Cloneable {\r\n",
      "     String name;\r\n",
      "     String breed;\r\n",
      "     public Dog(String name, String breed) {\r\n",
      "         this.name = name;\r\n",
      "         this.breed = breed;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     protected Object clone() throws CloneNotSupportedException {\r\n",
      "         return super.clone();\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Dog\r\n",
      "|    Update replaced variable d, reset to null\r\n",
      "|    Update overwrote class Dog\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Dog implements Cloneable {\n",
    "    String name;\n",
    "    String breed;\n",
    "    public Dog(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "    }\n",
    "    @Override\n",
    "    protected Object clone() throws CloneNotSupportedException {\n",
    "        return super.clone();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Dog myDog=new Dog(\"Salgu\",\"mixed\");\r\n",
      "|  Added variable myDog of type Dog with initial value Dog@5025a98f\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Dog myDog=new Dog(\"Salgu\",\"mixed\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```clone()```은 클래스 Object를 return한다. 따라서 사용하는 측이 맞게 형변환을 해야 한다.\n",
    "따라서 myDog이 **원하는 클래스 Dog으로 형변환 cast**를 한다.\n",
    "이경우 Cloneable이 아니면 ```CloneNotSupportedException``` 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Dog copiedDog=myDog.clone();\r\n",
      "|  Error:\r\n",
      "|  incompatible types: java.lang.Object cannot be converted to Dog\r\n",
      "|  Dog copiedDog=myDog.clone();\r\n",
      "|                ^-----------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Dog copiedDog=myDog.clone();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Dog copiedDog=(Dog)myDog.clone();\r\n",
      "|  Added variable copiedDog of type Dog with initial value Dog@20322d26\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Dog copiedDog=(Dog)myDog.clone();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "발생할 수 있는 예외는 try-catch문으로 ```CloneNotSupportedException```을 처리할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " try {\r\n",
      "     copiedDog=(Dog)myDog.clone();\r\n",
      " } catch (CloneNotSupportedException e) {\r\n",
      "     e.printStackTrace();\r\n",
      "     System.out.println(\"Hello\");\r\n",
      " }\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "try {\n",
    "    copiedDog=(Dog)myDog.clone();\n",
    "} catch (CloneNotSupportedException e) {\n",
    "    e.printStackTrace();\n",
    "    System.out.println(\"Hello\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "복사본과 원본은 서로 다르다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " copiedDog.hashCode();\r\n",
      "|  Expression value is: 1690254271\r\n",
      "|    assigned to temporary variable $15 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "copiedDog.hashCode();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " myDog.hashCode();\r\n",
      "|  Expression value is: 1344645519\r\n",
      "|    assigned to temporary variable $16 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "myDog.hashCode();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 7.4.6   Comparable 예제\n",
    "\n",
    "객체를 서로 비교할 경우, 문제가 간단하지 않다.\n",
    "**자동차를 비교**한다고 하자.\n",
    "자동차의 **속도**가 빠르다, 느리다라고 할 수 있다.\n",
    "또한 자동차의 **가격**을 기준으로 비교하면 높다, 낮다라고 할 수 있다.\n",
    "이와 같이 객체를 서로 비교한다는 것은 **기준을 정해야** 한다.\n",
    "\n",
    "객체는 compareTo() 함수를 사용해서 비교한다.\n",
    "인터페이스 **```Comparable```**은 **```compareTo()```** 함수를 가지고 있고 이를 구현해서 비교한다.\n",
    "\n",
    "**```int compareTo(T o)```**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 정렬할 경우 ```compareTo()``` 미구현하면 예외가 발생\n",
    "\n",
    "위에서 선언했던 Dog 클래스를 비교하면 앞서 설명했던 예외가 발생한다.\n",
    "즉 Dog을 비교한다면 그 **기준이 무엇인지 불분명**하므로 **예외**의 원인이 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Dog {\r\n",
      "     String name;\r\n",
      "     String breed;\r\n",
      "     public Dog(String name, String breed) {\r\n",
      "         this.name = name;\r\n",
      "         this.breed = breed;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Modified class Dog\r\n",
      "|    Update overwrote class Dog\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Dog {\n",
    "    String name;\n",
    "    String breed;\n",
    "    public Dog(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Dog[] dogs=new Dog[3];\r\n",
      "|  Added variable dogs of type Dog[] with initial value [LDog;@60c6f5b\r\n",
      "\r\n",
      " dogs[0]=new Dog(\"d1\",\"Poodle\");\r\n",
      "|  Expression value is: Dog@3c0f93f1\r\n",
      "|    assigned to temporary variable $20 of type Dog\r\n",
      "\r\n",
      " dogs[1]=new Dog(\"d2\",\"Husky\");\r\n",
      "|  Expression value is: Dog@544fe44c\r\n",
      "|    assigned to temporary variable $21 of type Dog\r\n",
      "\r\n",
      " dogs[2]=new Dog(\"d3\",\"Shih Tzu\");\r\n",
      "|  Expression value is: Dog@71318ec4\r\n",
      "|    assigned to temporary variable $22 of type Dog\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Dog[] dogs=new Dog[3];\n",
    "dogs[0]=new Dog(\"d1\",\"Poodle\");\n",
    "dogs[1]=new Dog(\"d2\",\"Husky\");\n",
    "dogs[2]=new Dog(\"d3\",\"Shih Tzu\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "d1, d2, d3는 Dog의 객체이다. 정렬을 해보면 예외가 발생한다.\n",
    "객체를 서로 비교할 수 없는 경우 **```ClassCastException```** 예외가 발생한다.\n",
    "객체를 비교할 경우, compareTo()를 호출한다.\n",
    "이 compareTo() 함수는 인터페이스 Comparable에서 구현하지만, 미구현되었을 겨우 예외가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Arrays.sort(dogs);\r\n",
      "|  java.lang.ClassCastException thrown: REPL.$REPL17E$Dog (in module: Unnamed Module) cannot be cast to java.lang.Comparable (in module: java.base)\r\n",
      "|        at ComparableTimSort.countRunAndMakeAscending (ComparableTimSort.java:320)\r\n",
      "|        at ComparableTimSort.sort (ComparableTimSort.java:188)\r\n",
      "|        at Arrays.sort (Arrays.java:1248)\r\n",
      "|        at (#29:1)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Arrays.sort(dogs);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### ```compareTo()```를 구현해서 정렬\n",
    "\n",
    "Dog은 어떤 기준으로 정렬을 해야 옳을까?\n",
    "그 기준은 Dog이 가진 속성이 후보가 된다.\n",
    "이름 'name' 또는 종 'breed'을 기준으로 삼을 수 있다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | 인터페이스 ```Comparable```을 구현\n",
    "8 ~ 12 | ```Comparable```의 ```compareTo()```를 재정의\n",
    "11 | Dog의 name으로 비교. String객체는 **```compareTo()```**를 사용하여 비교\n",
    "13 ~ 17 | 클래스 ```Object```의 ```toString()```을 재정의."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class DogV1 implements Comparable {\r\n",
      "     String name;\r\n",
      "     String breed;\r\n",
      "     public DogV1(String name, String breed) {\r\n",
      "         this.name = name;\r\n",
      "         this.breed = breed;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public int compareTo(Object o) {\r\n",
      "         DogV1 d=(DogV1)o;\r\n",
      "         return this.name.compareTo(d.name);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public String toString() {\r\n",
      "         String msg=name+\" \"+breed;\r\n",
      "         return msg;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class DogV1\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class DogV1 implements Comparable {\n",
    "    String name;\n",
    "    String breed;\n",
    "    public DogV1(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "    }\n",
    "    @Override\n",
    "    public int compareTo(Object o) {\n",
    "        DogV1 d=(DogV1)o;\n",
    "        return this.name.compareTo(d.name);\n",
    "    }\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        String msg=name+\" \"+breed;\n",
    "        return msg;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " DogV1[] myDogs=new DogV1[3];\r\n",
      "|  Added variable myDogs of type DogV1[] with initial value [LDogV1;@5ec0a365\r\n",
      "\r\n",
      " myDogs[0]=new DogV1(\"d1\",\"Poodle\");\r\n",
      "|  Expression value is: d1 Poodle\r\n",
      "|    assigned to temporary variable $26 of type DogV1\r\n",
      "\r\n",
      " myDogs[1]=new DogV1(\"d2\",\"Husky\");\r\n",
      "|  Expression value is: d2 Husky\r\n",
      "|    assigned to temporary variable $27 of type DogV1\r\n",
      "\r\n",
      " myDogs[2]=new DogV1(\"d3\",\"Shih Tzu\");\r\n",
      "|  Expression value is: d3 Shih Tzu\r\n",
      "|    assigned to temporary variable $28 of type DogV1\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "DogV1[] myDogs=new DogV1[3];\n",
    "myDogs[0]=new DogV1(\"d1\",\"Poodle\");\n",
    "myDogs[1]=new DogV1(\"d2\",\"Husky\");\n",
    "myDogs[2]=new DogV1(\"d3\",\"Shih Tzu\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "앞서 ```Comparable```의 ```compareTo()```를 재정의 하였다.\n",
    "**```Arrays.sort()```는 자동으로 ```compareTo()```를 호출**하여 정렬한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Arrays.sort(myDogs);\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Arrays.sort(myDogs);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "앞서 정의한 바와 같이 ```toString()``` 함수를 반복문으로 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(DogV1 d:myDogs)\r\n",
      "     System.out.println(d.toString());\r\n",
      "d1 Poodle\r\n",
      "d2 Husky\r\n",
      "d3 Shih Tzu\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(DogV1 d:myDogs)\n",
    "    System.out.println(d.toString());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "클래스로 완성해보자.\n",
    "앞서 DogV1은 그대로 사용한다.\n",
    "main()함수는 별도로 구현한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DogV1 implements Comparable {\n",
    "    String name;\n",
    "    String breed;\n",
    "    public DogV1(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "    }\n",
    "    @Override\n",
    "    public int compareTo(Object o) {\n",
    "        DogV1 d=(DogV1)o;\n",
    "        return this.name.compareTo(d.name);\n",
    "    }\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        String msg=name+\" \"+breed;\n",
    "        return msg;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import java.util.Arrays;\n",
    "\n",
    "public class DogV1SorterMainV1 {\n",
    "    public static void main(String[] args){\n",
    "        DogV1[] myDogs=new DogV1[3];\n",
    "        myDogs[0]=new DogV1(\"d1\",\"Poodle\");\n",
    "        myDogs[1]=new DogV1(\"d2\",\"Husky\");\n",
    "        myDogs[2]=new DogV1(\"d3\",\"Shih Tzu\");\n",
    "        Arrays.sort(dogs);\n",
    "        for(DogV1 d:myDogs)\n",
    "            System.out.println(d.toString());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 Dog class를 deep clone한다.\n",
    "\n",
    "### 문제\n",
    "\n",
    "앞서 객체의 복사는 문제가 될 수 있다고 했다.\n",
    "원시타잎과 달리 객체는 참조만을 복사해서 사용하기 때문에 원본이 변경될 위험이 항상 있다.\n",
    "그런 위험을 제거하기 위한 복사를 구현하자.\n",
    "\n",
    "### 해결\n",
    "원본이 변경되어도 그런 위험이 없도록 하려면 deep copy를 해야 한다.\n",
    "Dog 클래스 속성 가운데 객체를 복사해서 넘겨준다.\n",
    "\n",
    "\n",
    "shallow copy는 단순히 부모클래스 Object의 super.clone() 함수를 호출한다.\n",
    "\n",
    "```java\n",
    "@Override\n",
    "protected Object clone() throws CloneNotSupportedException {\n",
    "    return super.clone();\n",
    "}\n",
    "```\n",
    "\n",
    "그러나 deep copy는 아래와 같다. 즉 Date 객체인 birthDay까지 clone()을 만들어야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class DogV2 implements Comparable, Cloneable {\r\n",
      "     String name=null;\r\n",
      "     String breed=null;\r\n",
      "     private java.util.Date birthDay;\r\n",
      "     public DogV2(String name, String breed) {\r\n",
      "         this.name = name;\r\n",
      "         this.breed = breed;\r\n",
      "         this.birthDay = new Date();  //현재시점\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     protected Object clone() throws CloneNotSupportedException {\r\n",
      "         try {\r\n",
      "             DogV2 dogClone = (DogV2)super.clone();\r\n",
      "             //Deep copy on birthDay\r\n",
      "             dogClone.birthDay = (java.util.Date)(birthDay.clone());\r\n",
      "             return dogClone;\r\n",
      "         } catch (CloneNotSupportedException e) {\r\n",
      "             e.printStackTrace();\r\n",
      "             return null;\r\n",
      "         }\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public int compareTo(Object o) {\r\n",
      "         DogV2 d=(DogV2)o;\r\n",
      "         return this.name.compareTo(d.name);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public String toString() {\r\n",
      "         String msg=name+\":\"+breed+\":\"+birthDay.toString();\r\n",
      "         return msg;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class DogV2\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class DogV2 implements Comparable, Cloneable {\n",
    "    String name=null;\n",
    "    String breed=null;\n",
    "    private java.util.Date birthDay;\n",
    "    public DogV2(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "        this.birthDay = new Date();  //현재시점\n",
    "    }\n",
    "    @Override\n",
    "    protected Object clone() throws CloneNotSupportedException {\n",
    "        try {\n",
    "            DogV2 dogClone = (DogV2)super.clone();\n",
    "            //Deep copy on birthDay\n",
    "            dogClone.birthDay = (java.util.Date)(birthDay.clone());\n",
    "            return dogClone;\n",
    "        } catch (CloneNotSupportedException e) {\n",
    "            e.printStackTrace();\n",
    "            return null;\n",
    "        }\n",
    "    }\n",
    "    @Override\n",
    "    public int compareTo(Object o) {\n",
    "        DogV2 d=(DogV2)o;\n",
    "        return this.name.compareTo(d.name);\n",
    "    }\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        String msg=name+\":\"+breed+\":\"+birthDay.toString();\n",
    "        return msg;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " DogV2 dogv2=new DogV2(\"js\",\"Poodle\");\r\n",
      "|  Added variable dogv2 of type DogV2 with initial value js:Poodle:Sat Jun 02 16:24:32 KST 2018\r\n",
      "\r\n",
      " DogV2 copiedDogV2=(DogV2)dogv2.clone();\r\n",
      "|  Added variable copiedDogV2 of type DogV2 with initial value js:Poodle:Sat Jun 02 16:24:32 KST 2018\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "DogV2 dogv2=new DogV2(\"js\",\"Poodle\");\n",
    "DogV2 copiedDogV2=(DogV2)dogv2.clone();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.println(\"Dog객체: \"+copiedDogV2.toString());\r\n",
      "Dog객체: js:Poodle:Sat Jun 02 16:24:32 KST 2018\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Dog객체: \"+copiedDogV2.toString());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.5 abstract class\n",
    "\n",
    "abstract class는 **하나 이상의 함수**를 선언만 하고 비워서 **구현하지 않는 abstract method**를 가진다.\n",
    "따라서 abstract class에서 객체를 생성할 수 없다.\n",
    "abstract class를 상속하고 자식클래스에서 실제 구현을 채우게 된다.\n",
    "이를 **overriding**이라고 한다.\n",
    "\n",
    "* abstract으로 선언하고, 자식클래스에서 재정의할 수 있다.\n",
    "* abstract으로 선언하지 않으면, 자식클래스에서 선택적으로 재정의할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.5.1 인터페이스와 비교\n",
    "\n",
    "추상클래스는 '인터페이스'와 자주 비교된다.\n",
    "요약하면, 추상클래스에서 **속성을 제외하고, 모든 함수를 추상으로 정의하는 경우에는 인터페이스와 동일**하다\n",
    "그렇지 않은 경우에는 서로 다르다.\n",
    "\n",
    "구분 | 인터페이스 | 추상클래스\n",
    "-------|-------|-------\n",
    "속성을 가질 수 있다 |  없다 | 있다\n",
    "함수를 가질 수 있다 | 있다 | 있다\n",
    "함수를 구현할 수 있다 | 없다 (default method가 아닌 경우) | 있다\n",
    "객체를 생성할 수 있다 | 없다 | 없다 (추상클래스인 경우)\n",
    "\n",
    "어느 경우, 추상클래스 또는 인터페이스를 사용하는가?\n",
    "* **인터페이스**는 **함수 API를 정의**하는 목적으로 사용한다. 어떤 입력을 사용해서, 어떤 결과를 반환해야 하는지를 결정하고 구현하도록 강제한다는 점에서 '**marker**'라고 한다.\n",
    "* 반면, **추상클래스**는 함수의 구현을 상속할 수 있다. 자식클래스에서 재정의하지 않으면, 부모의 것을 default로 사용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Shape**의 사례를 추상클래스를 사용하여 구현한다.\n",
    "\n",
    "선언부에 클래스를 abstract으로 정의한다.\n",
    "\n",
    "```java\n",
    "abstract class Shape\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 oo-4: 클래스 상속을 사용하여 도형의 면적을 구하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "앞서 추상클래스와 인터페이스를 비교하여 설명하였다.\n",
    "인터페이스로 구현한 IShape을 추상클래스로 변경하여 구현해 보자.\n",
    "\n",
    "### 해결\n",
    "\n",
    "calArea(), calcPerimeter() 함수를 **abstract**으로 선언한다.\n",
    "비교를 쉽게 하기 위해 인터페이스 IShape과 동일하게 유지하여 구현한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "abstract class Shape {\n",
    "    +abstract calcArea():double\n",
    "    +abstract calcPerimeter():double\n",
    "}\n",
    "class Rectangle {\n",
    "    -final width:double\n",
    "    -final height:double\n",
    "    -final area:double\n",
    "    -final perimeter:double\n",
    "}\n",
    "Rectangle -right-|> Shape\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public abstract class Shape {\r\n",
      "     public String name=\"Shape\";\r\n",
      "     public abstract double calcArea();\r\n",
      "     public abstract double calcPerimeter();\r\n",
      "     public String getName() { return this.name; }\r\n",
      "     public String toString() {\r\n",
      "         return \"Shape...\"+super.toString();\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public abstract class Shape {\r\n",
      "|  ^-------------^\r\n",
      "|  Added class Shape this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public abstract class Shape {\r\n",
      "|      ^-------------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public abstract class Shape {\n",
    "    public String name=\"Shape\";\n",
    "    public abstract double calcArea();\n",
    "    public abstract double calcPerimeter();\n",
    "    public String getName() { return this.name; }\n",
    "    public String toString() {\n",
    "        return \"Shape...\"+super.toString();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "위에 구현한 Rectangle을 다시 Shape을 확장하여 만들어 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public class Rectangle extends Shape {\r\n",
      "     private final double width, height, area, perimeter;\r\n",
      "     public Rectangle(double width, double height) {\r\n",
      "         this.width = width;\r\n",
      "         this.height= height;\r\n",
      "         this.area = width * height;\r\n",
      "         this.perimeter = 2 * (width + height);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public double calcArea() {\r\n",
      "         return this.area;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public double calcPerimeter() {\r\n",
      "         return this.perimeter;\r\n",
      "     }\r\n",
      "     public String toString() {\r\n",
      "         return \"Rectangle...\"+super.toString();\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class Rectangle extends Shape {\r\n",
      "|  ^----^\r\n",
      "|  Replaced class Rectangle this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class Rectangle extends Shape {\r\n",
      "|      ^----^\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "|    Update overwrote class Rectangle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public class Rectangle extends Shape {\n",
    "    private final double width, height, area, perimeter;\n",
    "    public Rectangle(double width, double height) {\n",
    "        this.width = width;\n",
    "        this.height= height;\n",
    "        this.area = width * height;\n",
    "        this.perimeter = 2 * (width + height);\n",
    "    }\n",
    "    @Override\n",
    "    public double calcArea() {\n",
    "        return this.area;\n",
    "    }\n",
    "    @Override\n",
    "    public double calcPerimeter() {\n",
    "        return this.perimeter;\n",
    "    }\n",
    "    public String toString() {\n",
    "        return \"Rectangle...\"+super.toString();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public class Circle extends Shape {\r\n",
      "     private final double radius, area, perimeter;\r\n",
      " \r\n",
      "     public Circle(double radius) {\r\n",
      "         this.radius = radius;\r\n",
      "         this.area = Math.PI * radius * radius;\r\n",
      "         this.perimeter = 2 * Math.PI * radius;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public double calcArea() {\r\n",
      "         return this.area;\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public double calcPerimeter() {\r\n",
      "         return this.perimeter;\r\n",
      "     }\r\n",
      "     public String toString() {\r\n",
      "         return \"Circle...\"+super.toString();\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class Circle extends Shape {\r\n",
      "|  ^----^\r\n",
      "|  Added class Circle this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class Circle extends Shape {\r\n",
      "|      ^----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public class Circle extends Shape {\n",
    "    private final double radius, area, perimeter;\n",
    "\n",
    "    public Circle(double radius) {\n",
    "        this.radius = radius;\n",
    "        this.area = Math.PI * radius * radius;\n",
    "        this.perimeter = 2 * Math.PI * radius;\n",
    "    }\n",
    "    @Override\n",
    "    public double calcArea() {\n",
    "        return this.area;\n",
    "    }\n",
    "    @Override\n",
    "    public double calcPerimeter() {\n",
    "        return this.perimeter;\n",
    "    }\n",
    "    public String toString() {\n",
    "        return \"Circle...\"+super.toString();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle r=new Rectangle(3,4);\r\n",
      "|  Added variable r of type Rectangle with initial value Rectangle...Shape ...Rectangle@4bec1f0c\r\n",
      "\r\n",
      " Circle c=new Circle(5);\r\n",
      "|  Added variable c of type Circle with initial value Circle...Shape ...Circle@2d928643\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle r=new Rectangle(3,4);\n",
    "Circle c=new Circle(5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " r.calcArea();\r\n",
      "|  Expression value is: 12.0\r\n",
      "|    assigned to temporary variable $18 of type double\r\n",
      "\r\n",
      " c.calcArea();\r\n",
      "|  Expression value is: 78.53981633974483\r\n",
      "|    assigned to temporary variable $19 of type double\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "r.calcArea();\n",
    "c.calcArea();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.5.2 다중상속\n",
    "\n",
    "```java\n",
    "public class Circle extends Shape implements Cloneable\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.6 Polymorphism\n",
    "\n",
    "### 7.6.1 다형성이란?\n",
    "다형성은 변수나 객체 등에 **여러 타잎이 할당될 수 있다**는 것을 말한다.\n",
    "예를 들어 ```int x```라고 선언하면 x에는 정수타잎만 허용된다. 이런 경우는 다형적이 아니라 **단형적**이다.\n",
    "반면에 ```Object x```라고 선언하면 x에는 어느 타잎이나 허용된다.\n",
    "String, Integer 등 어떤 참조 타잎이든 할당할 수 있다. 이런 특징을 **다형적**이라고 한다.\n",
    "이러한 특징을 잘 활용하면 **객체지향스러운 프로그래밍**을 할 수 있게 된다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 7.6.2 동적바인딩\n",
    "\n",
    "다형성을 사용하려면:\n",
    "* 객체들이 **상속관계**에 있어야 한다. 이러한 상속계층에서 suptype, supertype의 전환 casting을 할 수 있게 된다.\n",
    "* 또한 **overriding 함수**가 있어야 한다. subtype 고유의 함수는 upcasting하면서 사라짐 (losing access to subtype features)\n",
    "\n",
    "즉 객제지향의 다형성은:\n",
    "* 부모클래스의 참조가 자식클래스를 가리키고 있을 때, 자식클래스의 함수가 호출될 수 있다.\n",
    "* 런타임에 자식클래스의 호출할 함수가 결정된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "이를 동적바인딩이라고 한다. C++에서는 RTTI (Run Time Type Identification)라고 한다. 반면에 정적바인딩은 한 번 타잎이 할당되면 변경할 수 없는 경우를 말한다.\n",
    "* 동적바인딩은 '**런타임 시점**'에 객체에 **할당된 참조에 따라** 사용할 함수를 '**동적**'으로 결정한다.\n",
    "* 정적바인딩은 '**컴파일 시점**'에 **클래스 타잎에 따라** '**정적**'으로 결정한다.\n",
    "\n",
    "구분 | dynamic binding | static binding\n",
    "-------|-------|-------\n",
    "발생시점 | 런타임 | 컴파일타임\n",
    "적용 | 재정의 함수 | 재정의되지 않은 경우. private, final, static\n",
    "사용정보 | 객체 | 클래스"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 7.6.3 거북이 다형성 예제\n",
    "\n",
    "다형성을 사용하기 위해 부모클래스에 자식클래스의 객체를 할당한다.\n",
    "* 자식클래스 SeaTurtle의 객체가 부모클래스 Turtle에 할당\n",
    "* upcasting을 하면, 부모클래스가 자식클래스의 참조를 가진다.\n",
    "* 재정의한 함수를 다형적으로 호출 할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Turtle t=new SeaTurtle();\r\n",
      "|  Added variable t of type Turtle with initial value SeaTurtle@4566e5bd\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Turtle t=new SeaTurtle();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 이런 경우, 자식클래스 SeaTurtle 고유의 함수 swim()은 사라짐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " t.swim();\r\n",
      "|  Error:\r\n",
      "|  cannot find symbol\r\n",
      "|    symbol:   method swim()\r\n",
      "|  t.swim();\r\n",
      "|  ^----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "t.swim();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* upcasting한 후, 다시 downcasting할 수 있다.\n",
    "    * upcasting한 객체에서 downcasting해야 한다.\n",
    "    * downcast는 '명시적'으로 해야 한다 (upcast는 자동으로 이루어진다)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " SeaTurtle stFromTurtle = (SeaTurtle)t;\r\n",
      "|  Added variable stFromTurtle of type SeaTurtle with initial value SeaTurtle@4566e5bd\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "SeaTurtle stFromTurtle = (SeaTurtle)t;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " stFromTurtle.swim();\r\n",
      "A sea turtle swims...\r\n"
     ]
    }
   ],
   "source": [
    "stFromTurtle.swim();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* supertype의 함수를 실행할 수 있다. 이 함수를 overriding하는 경우 subtype의 eat()이 실행된다.\n",
    "List에 넣어 다형적으로 함수를 실행한다.\n",
    "//st.eat();\n",
    "//lt.eat();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ArrayList<Turtle> turtle=new ArrayList<>();\r\n",
      "|  Added variable turtle of type ArrayList<Turtle> with initial value []\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " SeaTurtle st=new SeaTurtle();\r\n",
      "|  Added variable st of type SeaTurtle with initial value SeaTurtle@69ea3742\r\n",
      "\r\n",
      " LandTurtle lt=new LandTurtle();\r\n",
      "|  Added variable lt of type LandTurtle with initial value LandTurtle@3159c4b8\r\n",
      "\r\n",
      " st.setFood(\"seaweeds\");\r\n",
      "\r\n",
      " lt.setFood(\"plants\");\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " turtle.add(t);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $25 of type boolean\r\n",
      "\r\n",
      " turtle.add(st);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $26 of type boolean\r\n",
      "\r\n",
      " turtle.add(lt);\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $27 of type boolean\r\n",
      "\r\n",
      " for(Turtle my:turtle)\r\n",
      "     my.eat();\r\n",
      "Turtle eats nullTurtle eats seaweedsTurtle eats plants\r\n",
      " //st.eat();\r\n",
      "\r\n",
      " //lt.eat();\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "ArrayList<Turtle> turtle=new ArrayList<>();\n",
    "\n",
    "SeaTurtle st=new SeaTurtle();\n",
    "LandTurtle lt=new LandTurtle();\n",
    "st.setFood(\"seaweeds\");\n",
    "lt.setFood(\"plants\");\n",
    "\n",
    "turtle.add(t);\n",
    "turtle.add(st);\n",
    "turtle.add(lt);\n",
    "for(Turtle my:turtle)\n",
    "    my.eat();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " t.eat();\r\n",
      "Turtle eats null\r\n"
     ]
    }
   ],
   "source": [
    "t.eat();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class SeaTurtle extends Turtle {\r\n",
      "     public void swim() {\r\n",
      "         System.out.print(\"A sea turtle swims...\");\r\n",
      "     }\r\n",
      "     public void eat(){\r\n",
      "         System.out.print(\"A sea turtle eats \"+food);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class SeaTurtle\r\n",
      "|    Update overwrote class SeaTurtle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class SeaTurtle extends Turtle {\n",
    "    public void swim() {\n",
    "        System.out.print(\"A sea turtle swims...\");\n",
    "    }\n",
    "    public void eat(){\n",
    "        System.out.print(\"A sea turtle eats \"+food);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* setFood()는 supertype의 함수\n",
    "* supertype의 setFood()를 실행해서 먹이를 설정한다.\n",
    "    ```\n",
    "    t.setFood(\"seaweeds\");\n",
    "    ```\n",
    "\n",
    "* t.eat()은 다형성이 실행된다.\n",
    "    * supertyep의 eat()이 실행될지, suptype의 eat()이 실행될지 모른다.\n",
    "    * late binding이란 실행시점에 subtype seaturtle의 eat()이 실행된다.\n",
    "    ```\n",
    "    t.eat();\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " t.setFood(\"seaweeds\");\r\n",
      "\r\n",
      " t.eat();\r\n",
      "Turtle eats seaweeds\r\n"
     ]
    }
   ],
   "source": [
    "t.setFood(\"seaweeds\");\n",
    "t.eat();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제  oo-5: 여러나라 언어로 sayHello 하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "여러나라 말로 **```sayHello()```**를 호출하는 문제이다.\n",
    "\n",
    "### 해결\n",
    "\n",
    "배열은 원시 타잎, 객체 타잎 모두 저장할 수 있다.\n",
    "**배열**에 객체를 저장하여, 다형적으로 호출하여 보자.\n",
    "즉 객체배열을 사용하여, 다국적 언어로 출력하는 sayHello() 함수를 반복문에서 일괄 호출한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Hello 클래스\n",
    "\n",
    "sayHello() 함수를 **추상화**하고, 실제 사용하는 언어에서 구현하기로 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " abstract class Hello {\r\n",
      "     protected String name;\r\n",
      "     public Hello(String name) {\r\n",
      "         this.name=name;\r\n",
      "     }\r\n",
      "     abstract public void sayHello();\r\n",
      " }\r\n",
      "|  Replaced class Hello\r\n",
      "|    Update overwrote class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "abstract class Hello {\n",
    "    protected String name;\n",
    "    public Hello(String name) {\n",
    "        this.name=name;\n",
    "    }\n",
    "    abstract public void sayHello();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class HelloChinese extends Hello {\r\n",
      "     public HelloChinese(String name) {\r\n",
      "         super(name);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public void sayHello() {\r\n",
      "         System.out.println(\"你好 \"+ name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class HelloChinese\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class HelloChinese extends Hello {\n",
    "    public HelloChinese(String name) {\n",
    "        super(name);\n",
    "    }\n",
    "    @Override\n",
    "    public void sayHello() {\n",
    "        System.out.println(\"你好 \"+ name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class HelloJapanese extends Hello {\r\n",
      "     public HelloJapanese(String name) {\r\n",
      "         super(name);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public void sayHello() {\r\n",
      "         System.out.println(\"こんにちは \"+ name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class HelloJapanese\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class HelloJapanese extends Hello {\n",
    "    public HelloJapanese(String name) {\n",
    "        super(name);\n",
    "    }\n",
    "    @Override\n",
    "    public void sayHello() {\n",
    "        System.out.println(\"こんにちは \"+ name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class HelloKorean extends Hello {\r\n",
      "     public HelloKorean(String name) {\r\n",
      "         super(name);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public void sayHello() {\r\n",
      "         System.out.println(\"안녕하세요 \"+ name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class HelloKorean\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class HelloKorean extends Hello {\n",
    "    public HelloKorean(String name) {\n",
    "        super(name);\n",
    "    }\n",
    "    @Override\n",
    "    public void sayHello() {\n",
    "        System.out.println(\"안녕하세요 \"+ name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 다형적 호출\n",
    "\n",
    "객체의 배열을 선언한다. 배열은 저장 갯수를 미리 정해야 한다. 갯수를 임의로 늘릴 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello[] h=new Hello[3];\r\n",
      "|  Modified variable h of type Hello[] with initial value [LHello;@4e1d422d\r\n",
      "|    Update overwrote variable h\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " h[0]=new HelloChinese(\"js1\");\r\n",
      "|  Expression value is: HelloChinese@52a86356\r\n",
      "|    assigned to temporary variable $27 of type Hello\r\n",
      "\r\n",
      " h[1]=new HelloJapanese(\"js2\");\r\n",
      "|  Expression value is: HelloJapanese@78c03f1f\r\n",
      "|    assigned to temporary variable $28 of type Hello\r\n",
      "\r\n",
      " h[2]=new HelloKorean(\"js3\");\r\n",
      "|  Expression value is: HelloKorean@4fe3c938\r\n",
      "|    assigned to temporary variable $29 of type Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello[] h=new Hello[3];\n",
    "\n",
    "h[0]=new HelloChinese(\"js1\");\n",
    "h[1]=new HelloJapanese(\"js2\");\n",
    "h[2]=new HelloKorean(\"js3\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* h를 출력하면 toString을 호출하게 됨. 객체의 hash code를 출력한다.\n",
    "* 저장된 객체가 없는 경우에는 null을 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<3;i++)\r\n",
      "     System.out.println(h[i]);\r\n",
      "REPL.$REPL22$HelloChinese@52a86356\r\n",
      "REPL.$REPL21$HelloJapanese@78c03f1f\r\n",
      "REPL.$REPL28$HelloKorean@4fe3c938\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<3;i++)\n",
    "    System.out.println(h[i]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 다형적으로 함수를 호출한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(int i=0;i<h.length;i++)\r\n",
      "     h[i].sayHello();\r\n",
      "你好 js1\r\n",
      "こんにちは js2\r\n",
      "안녕하세요 js3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(int i=0;i<h.length;i++)\n",
    "    h[i].sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 객체를 출력하는 반복문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Hello e:h)\r\n",
      "     e.sayHello();\r\n",
      "你好 js1\r\n",
      "こんにちは js2\r\n",
      "안녕하세요 js3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Hello e:h)\n",
    "    e.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 문제 oo-6:  도형을 다형적으로 면적 계산하기\n",
    "\n",
    "### 문제\n",
    "\n",
    "도형은 삼각형, 사각형 등에 따라 면적을 계산식이 다르다.\n",
    "객체지향 방식으로 프로그래밍하여 아닌 방식과 비교해 보자.\n",
    "\n",
    "### 해결\n",
    "\n",
    "* 버전 1: instanceof\n",
    "* 버전 2: 다형성\n",
    "\n",
    "* 부모클래스 Shape[]에 자식클래스를 저장하고 (예: Circle, Rectangle)\n",
    "* 부모클래스 Shape.draw()를 호출하면 자식클래스 subtype.draw()가 실행되는 것.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 버전 1: if문으로 구별\n",
    "\n",
    "위 oo-4에서 구현한 Rectangle, Circle 클래스를 사용한다.\n",
    "instanceof를 사용해서 도형에 따른 구분을 해보자.\n",
    "\n",
    "* instanceof vs getClass\n",
    "\n",
    "함수 | 설명 | 예제\n",
    "----------|----------|----------\n",
    "instanceof | 좌측(참조값)이 우측(클래스 또는 하위)의 객체이면 1, 아니면 0 | r instanceof Rectangle\n",
    "getClass() | ==를 사용. 좌측(클래스)이 우측(클래스)과 동일한 타잎이면 1, 아니면 0 | r.getClass() == Rectangle.class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* r은 Rectangle이면서 Shape(r의 superclass)의 객체"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Rectangle r=new Rectangle(3,4);\r\n",
      "|  Modified variable r of type Rectangle with initial value Rectangle...Shape...Rectangle@6b09bb57\r\n",
      "|    Update overwrote variable r\r\n",
      "\r\n",
      " Circle c=new Circle(5);\r\n",
      "|  Added variable c of type Circle with initial value Circle...Shape...Circle@3e9b1010\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Rectangle r=new Rectangle(3,4);\n",
    "Circle c=new Circle(5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " if(r instanceof Shape && r instanceof Rectangle) {\r\n",
      "     System.out.print(r.toString());\r\n",
      " }\r\n",
      "Rectangle...Shape...REPL.$REPL10E$Rectangle@6b09bb57\r\n"
     ]
    }
   ],
   "source": [
    "if(r instanceof Shape && r instanceof Rectangle) {\n",
    "    System.out.print(r.toString());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* r.getClass()는 r의 클래스를 돌려준다.\n",
    "```java\n",
    "public final Class getClass()\n",
    "```\n",
    "    * 우측에는 클래스를 적어준다. instanceof와 달리 클래스가 같아야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " r.getClass() == Rectangle.class;\r\n",
      "|  Expression value is: true\r\n",
      "|    assigned to temporary variable $42 of type boolean\r\n",
      "\r\n",
      " r.getClass() == Shape.class;\r\n",
      "|  Error:\r\n",
      "|  incomparable types: java.lang.Class<capture#1 of ? extends Rectangle> and java.lang.Class<Shape>\r\n",
      "|  r.getClass() == Shape.class;\r\n",
      "|  ^-------------------------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "r.getClass() == Rectangle.class;\n",
    "r.getClass() == Shape.class;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "배열에 사각형과 원 객체를 저장하고 instanceof로 면적계산을 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Shape[] s=new Shape[2];\r\n",
      "|  Added variable s of type Shape[] with initial value [LShape;@210366b4\r\n",
      "\r\n",
      " s[0]=r;\r\n",
      "|  Expression value is: Rectangle...Shape...Rectangle@6b09bb57\r\n",
      "|    assigned to temporary variable $44 of type Shape\r\n",
      "\r\n",
      " s[1]=c;\r\n",
      "|  Expression value is: Circle...Shape...Circle@3e9b1010\r\n",
      "|    assigned to temporary variable $45 of type Shape\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Shape[] s=new Shape[2];\n",
    "s[0]=r;\n",
    "s[1]=c;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Shape my:s) {\r\n",
      "     if(my instanceof Rectangle) {\r\n",
      "         System.out.println(my.calcArea());\r\n",
      "     } else if (my instanceof Circle) {\r\n",
      "         System.out.println(my.calcArea());    \r\n",
      "     }\r\n",
      " }\r\n",
      "12.0\r\n",
      "78.53981633974483\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Shape my:s) {\n",
    "    if(my instanceof Rectangle) {\n",
    "        System.out.println(my.calcArea());\n",
    "    } else if (my instanceof Circle) {\n",
    "        System.out.println(my.calcArea());    \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 버전 2: 다형성\n",
    "\n",
    "* subtype 다형성을 사용하면, intanceof를 사용하지 않게 된다.\n",
    "\n",
    "```\n",
    "if (superclass instanceof Subclass) {\n",
    "   Subclass subclass = (Subclass) superclass;\n",
    "   subclass.method();\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(Shape my:s)\r\n",
      "     System.out.println(my.calcArea());\r\n",
      "12.0\r\n",
      "78.53981633974483\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(Shape my:s)\n",
    "    System.out.println(my.calcArea());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 7.7 Object 클래스\n",
    "\n",
    "자바의 모든 클래스는 Object 클래스와 부모-자식 관계이다.\n",
    "즉 **모든 클래스는 Object에서 만들어**지고 있다.\n",
    "\n",
    "Object 클래스는 다음과 같은 함수를 가지고 있다.\n",
    "\n",
    "Method | Description\n",
    "-----|-----\n",
    "public final Class getClass() | 객체가 어느 클래스에서 만들어졌는지\n",
    "public int hashCode() | 해시코드를 반환\n",
    "public boolean equals(Object obj) | 같은지 비교\n",
    "protected Object clone() throws CloneNotSupportedException | 객체를 복사해서 반환\n",
    "public String toString() | 객체를 문자열 표현을 반환\n",
    "public final void notify() | wakes up single thread, waiting on this object's monitor.\n",
    "public final void notifyAll() | wakes up all the threads, waiting on this object's monitor.\n",
    "public final void wait(long timeout)throws InterruptedException | causes the current thread to wait for the specified milliseconds, until another thread notifies (invokes notify() or notifyAll() method).\n",
    "public final void wait(long timeout,int nanos)throws InterruptedException | causes the current thread to wait for the specified milliseconds and nanoseconds, until another thread notifies (invokes notify() or notifyAll() method).\n",
    "public final void wait()throws InterruptedException | causes the current thread to wait, until another thread notifies (invokes notify() or notifyAll() method).\n",
    "protected void finalize()throws Throwable | is invoked by the garbage collector before object is being garbage collected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"271px\" style=\"width:265px;height:271px;\" version=\"1.1\" viewBox=\"0 0 265 271\" width=\"265px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><polygon fill=\"#FFFFFF\" filter=\"url(#f1)\" points=\"22,24,107,24,114,46.29,258,46.29,258,264,22,264,22,24\" style=\"stroke: #000000; stroke-width: 2.0;\"/><line style=\"stroke: #000000; stroke-width: 2.0;\" x1=\"22\" x2=\"114\" y1=\"46.29\" y2=\"46.29\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"14\" font-weight=\"bold\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"70\" x=\"26\" y=\"39.3027\">java.lang</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"188.7925\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"205\" x=\"37.5\" y=\"59\"/><ellipse cx=\"116.75\" cy=\"75\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M116.8438,81.3125 Q113.9844,81.3125 112.4219,79.625 Q110.8594,77.9375 110.8594,74.8594 Q110.8594,71.7969 112.4531,70.1016 Q114.0469,68.4063 116.9375,68.4063 Q119.5781,68.4063 121.7188,68.9531 L121.7188,70.8906 Q118.2813,69.7031 116.9063,69.7031 Q115.9063,69.7031 114.8125,71.0625 Q113.7188,72.4219 113.7188,74.875 Q113.7188,77.2344 114.8906,78.5938 Q116.0625,79.9531 117.0781,79.9531 Q118.8281,79.9531 121.7031,78.4531 L121.7031,80.375 Q120,81.3125 116.8438,81.3125 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"38\" x=\"137.25\" y=\"79.4209\">Object</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"38.5\" x2=\"241.5\" y1=\"91\" y2=\"91\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"38.5\" x2=\"241.5\" y1=\"99\" y2=\"99\"/><polygon fill=\"#FFFF44\" points=\"48.5,105.8997,52.5,109.8997,48.5,113.8997,44.5,109.8997\" style=\"stroke: #B38D22; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"75\" x=\"57.5\" y=\"113.4521\">clone():Object</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"144\" x=\"57.5\" y=\"126.2515\">equals(obj:Object):boolean</text><polygon fill=\"#FFFF44\" points=\"48.5,131.4983,52.5,135.4983,48.5,139.4983,44.5,135.4983\" style=\"stroke: #B38D22; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"72\" x=\"57.5\" y=\"139.0508\">finalize():void</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"86\" x=\"57.5\" y=\"151.8501\">getClass():Class</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"79\" x=\"57.5\" y=\"164.6494\">hashCode():int</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"65\" x=\"57.5\" y=\"177.4487\">notify():void</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"79\" x=\"57.5\" y=\"190.248\">notifyAll():void</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"86\" x=\"57.5\" y=\"203.0474\">toString():String</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"55\" x=\"57.5\" y=\"215.8467\">wait():void</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"123\" x=\"57.5\" y=\"228.646\">wait(timeout:long):void</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"179\" x=\"57.5\" y=\"241.4453\">wait(timeout:long, nanos:int):void</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class java.lang.Object{\n",
    "    #clone():Object\n",
    "    equals(obj:Object):boolean\n",
    "    #finalize():void\n",
    "    getClass():Class\n",
    "    hashCode():int\n",
    "    notify():void\n",
    "    notifyAll():void\n",
    "    toString():String\n",
    "    wait():void\n",
    "    wait(timeout:long):void\n",
    "    wait(timeout:long, nanos:int):void\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### HashCode\n",
    "\n",
    "어느 존재이든 자신의 식별자가 있다. 학생은 학번, 한국인은 주민번호, 외국인은 여권번호 등이 그렇다.\n",
    "객체는 이런 다른 것과 자신을 구별할 수 있는, 즉 id와 같이 다른 것과 식별할 수 있는 능력만 있다.\n",
    "\n",
    "#### 해시코드 알아보기\n",
    "\n",
    "객체를 사용할 때는 인식자가 있어야 한다. hash code값은 객체를 생성하면 JVM이 부여하는 정수 값 (주소값이 아니다)\n",
    "객체가 생성한 HashCode값을 알아보자.\n",
    "\n",
    "```java\n",
    "System.identityHashCode()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Hello 객체 h1을 만들고, 객체의 HashCode를 16진수로 출력하여 확인할 수 있다.\n",
    "\n",
    "함수 | 설명\n",
    "-----|-----\n",
    "System.identityHashCode() | hash code를 10진수로 출력\n",
    "Integer.toHexString() | 10진수를 16진수로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {};\r\n",
      "|  Added class Hello\r\n",
      "\r\n",
      " Hello h1=new Hello();\r\n",
      "|  Added variable h1 of type Hello with initial value Hello@57fffcd7\r\n",
      "\r\n",
      " System.out.println(Integer.toHexString(System.identityHashCode(h1)));\r\n",
      "57fffcd7\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {};\n",
    "Hello h1=new Hello();\n",
    "System.out.println(Integer.toHexString(System.identityHashCode(h1)));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 해시코드와 Equals\n",
    "\n",
    "hash code는 객체 고유의 번호이다. 그러나 중복될 수 있다는 점에 주의해야 한다.\n",
    "**동일한 객체는 반드시 hash code가 같아야** 한다.\n",
    "\n",
    "```java\n",
    "if x.equals(y) then x.hashCode() == y.hashCode()\n",
    "```\n",
    "\n",
    "그러나, **다른 객체도 동일한 hash code 값을 가질 수** 있다. 다른 객체가 동일한 hash code를 가질 수 있는 이유는 hash code가 양의 정수 값으로 32비트로 제한되어 있기 때문에 그렇다고 생각하자.\n",
    "* 요약하면, **두 객체가 같으면 hashCode는 같다 (그러나 그 반대도 참이지는 않는다)** 그렇기 때문에 객체 고유의 번호라고 할 수 없다.\n",
    "* hash code 값이 동일하면 해시기반의 collection 클래스(HashMap, HashSet, Hashtable)에 문제가 발생한다.\n",
    "* 따라서 equals()를 재정의하려면, 반드시 hashCode()함수를 구현해서 hash code를 다르게 해야 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 해쉬코드생성방법\n",
    "    - ‘0’ 아닌 임의값을 hash로 사용 (여기서는 7)\n",
    "    - 멤버값을 사용할 것 (무작위 값을 사용하면 다음 호출에 다른 값 반환하므로 일관성 해침)\n",
    "    - 정수해쉬값에 31 연산\n",
    "    - 해쉬값 반환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### equals\n",
    "\n",
    "* 다형성은 어느 객체를 사용할 것인지 판별하는 것이 필요하다.\n",
    "* 상속관계의 부모클래스와 자식클래스는 같지 않아야 한다.\n",
    "* 판별하는 함수는 instanceof와 getClass()가 있다.\n",
    "    * instanceOf는 부모클래스와 자식클래스를 동일한 객체로 본다.\n",
    "    * getClass()는 부모클래스와 자식클래스라고 하더라도, 동일한 객체가 아니다.\n",
    "\n",
    "* equals의 5가지 조건\n",
    "\n",
    "특징 | 설명 | 예\n",
    "-------|-------|-------\n",
    "reflexivity | 자신과 비교하면 동일 | x.equals(x)는 true\n",
    "symmetry | x=y이면 y=x | x.equals(y)이면 y.equals(x)\n",
    "transitivity | x=y, y=z이면 z=x | x.equals(y) y.equals(z), z.equals(y)\n",
    "consistency | 상태가 변경이 되어도 true | hashCode()가 다른 경우, 시점이 지나면 다를 수 있다.\n",
    "non-nullity | x==not null | x.equals(null)\n",
    "\n",
    "* equals를 override할 경우, hashcode도 override한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* reflexive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SeaTurtle st=new SeaTurtle();\n",
    "\n",
    "st.equals(st);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* symmetric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Turtle t=new Turtle();\n",
    "\n",
    "t.equals(st);\n",
    "\n",
    "st.equals(t);\n",
    "\n",
    "st.getClass();\n",
    "\n",
    "t.getClass();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 클래스-1: hashCode(), equals()를 구현"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Java 1.7부터는 Objects.hash()함수를 사용할 수 있다.\n",
    "hash()에 멤버속성을 모두 넣어 해쉬코드를 생성하는 것이다.\n",
    "```java\n",
    "static int hash(Object... values)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class DogV3 implements Comparable, Cloneable {\r\n",
      "     String name=null;\r\n",
      "     String breed=null;\r\n",
      "     private java.util.Date birthDay;\r\n",
      "     public DogV3(String name, String breed) {\r\n",
      "         this.name = name;\r\n",
      "         this.breed = breed;\r\n",
      "         this.birthDay = new Date();  //현재시점\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     public boolean equals(Object o) {\r\n",
      "         if (o == null) return false;\r\n",
      "         if (!(o instanceof DogV3)) {\r\n",
      "             return false;\r\n",
      "         }\r\n",
      "         DogV3 d = (DogV3) o;\r\n",
      "         System.out.printf(\"EQUALS: name %s==%s breed %s==%s birth %s==%s %b\", \r",
      "\r\n",
      "         d.name,name,d.breed,breed,d.birthDay.toString(),\r\n",
      "             birthDay.toString(),\r\n",
      "         (d.name==name && d.breed.equals(breed) &&\r\n",
      "             d.birthDay.equals(birthDay)));\r\n",
      "         return d.name==name && d.breed.equals(breed) &&\r\n",
      "             d.birthDay.equals(birthDay);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     //change from DogV2\r\n",
      "     public int hashCode() {\r\n",
      "         /*int hash = 7;   //an arbitrary non-zero constant integer value\r\n",
      "         hash = 31 * hash + (null == name ? 0 : name.hashCode());\r\n",
      "         hash = 31 * hash + (null == breed ? 0 : breed.hashCode());\r\n",
      "         hash = 31 * hash + (null == birthDay ? 0 : birthDay.hashCode());\r\n",
      "         return hash;*/\r\n",
      "         return Objects.hash(name,breed,birthDay);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     //same as DogV2. only change in DogV3.\r\n",
      "     protected Object clone() throws CloneNotSupportedException {\r\n",
      "         try {\r\n",
      "             DogV3 dogClone = (DogV3)super.clone();\r\n",
      "             //Deep copy on birthDay\r\n",
      "             dogClone.birthDay = (java.util.Date)(birthDay.clone());\r\n",
      "             return dogClone;\r\n",
      "         } catch (CloneNotSupportedException e) {\r\n",
      "             e.printStackTrace();\r\n",
      "             return null;\r\n",
      "         }\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     //same as DogV2 only change in DogV3.\r\n",
      "     public int compareTo(Object o) {\r\n",
      "         DogV3 d=(DogV3)o;\r\n",
      "         return this.name.compareTo(d.name);\r\n",
      "     }\r\n",
      "     @Override\r\n",
      "     //same as DogV2\r\n",
      "     public String toString() {\r\n",
      "         String msg=name+\":\"+breed+\":\"+birthDay.toString();\r\n",
      "         return msg;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class DogV3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class DogV3 implements Comparable, Cloneable {\n",
    "    String name=null;\n",
    "    String breed=null;\n",
    "    private java.util.Date birthDay;\n",
    "    public DogV3(String name, String breed) {\n",
    "        this.name = name;\n",
    "        this.breed = breed;\n",
    "        this.birthDay = new Date();  //현재시점\n",
    "    }\n",
    "    @Override\n",
    "    public boolean equals(Object o) {\n",
    "        if (o == null) return false;\n",
    "        if (!(o instanceof DogV3)) {\n",
    "            return false;\n",
    "        }\n",
    "        DogV3 d = (DogV3) o;\n",
    "        System.out.printf(\"EQUALS: name %s==%s breed %s==%s birth %s==%s %b\",\n",
    "        d.name,name,d.breed,breed,d.birthDay.toString(),\n",
    "            birthDay.toString(),\n",
    "        (d.name==name && d.breed.equals(breed) &&\n",
    "            d.birthDay.equals(birthDay)));\n",
    "        return d.name==name && d.breed.equals(breed) &&\n",
    "            d.birthDay.equals(birthDay);\n",
    "    }\n",
    "    @Override\n",
    "    //change from DogV2\n",
    "    public int hashCode() {\n",
    "        /*int hash = 7;   //an arbitrary non-zero constant integer value\n",
    "        hash = 31 * hash + (null == name ? 0 : name.hashCode());\n",
    "        hash = 31 * hash + (null == breed ? 0 : breed.hashCode());\n",
    "        hash = 31 * hash + (null == birthDay ? 0 : birthDay.hashCode());\n",
    "        return hash;*/\n",
    "        return Objects.hash(name,breed,birthDay);\n",
    "    }\n",
    "    @Override\n",
    "    //same as DogV2. only change in DogV3.\n",
    "    protected Object clone() throws CloneNotSupportedException {\n",
    "        try {\n",
    "            DogV3 dogClone = (DogV3)super.clone();\n",
    "            //Deep copy on birthDay\n",
    "            dogClone.birthDay = (java.util.Date)(birthDay.clone());\n",
    "            return dogClone;\n",
    "        } catch (CloneNotSupportedException e) {\n",
    "            e.printStackTrace();\n",
    "            return null;\n",
    "        }\n",
    "    }\n",
    "    @Override\n",
    "    //same as DogV2 only change in DogV3.\n",
    "    public int compareTo(Object o) {\n",
    "        DogV3 d=(DogV3)o;\n",
    "        return this.name.compareTo(d.name);\n",
    "    }\n",
    "    @Override\n",
    "    //same as DogV2\n",
    "    public String toString() {\n",
    "        String msg=name+\":\"+breed+\":\"+birthDay.toString();\n",
    "        return msg;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "같은 데이터를 가지고 있는 객체이더라도, hashCode값이 다르면 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " DogV3 d31=new DogV3(\"d31\",\"Poodle\");\r\n",
      "|  Added variable d31 of type DogV3 with initial value d31:Poodle:Sat Jun 02 16:26:10 KST 2018\r\n",
      "\r\n",
      " DogV3 d32=new DogV3(\"d31\",\"Poodle\");\r\n",
      "|  Added variable d32 of type DogV3 with initial value d31:Poodle:Sat Jun 02 16:26:10 KST 2018\r\n",
      "\r\n",
      " DogV3 d33=new DogV3(\"d3\",\"Shih Tzu\");\r\n",
      "|  Added variable d33 of type DogV3 with initial value d3:Shih Tzu:Sat Jun 02 16:26:10 KST 2018\r\n",
      "\r\n",
      " System.out.printf(\"d31 hashCode: %d %d\\n\", d31.hashCode(), System.identityHas \r",
      "hCode(d31));\r\n",
      "d31 hashCode: 279244382 473581465\r\n",
      "|  Expression value is: java.io.PrintStream@23faf8f2\r\n",
      "|    assigned to temporary variable $39 of type PrintStream\r\n",
      "\r\n",
      " System.out.printf(\"d32 hashCode: %d %d\\n\", d32.hashCode(), System.identityHas \r",
      "hCode(d32));\r\n",
      "d32 hashCode: 279243934 1316864772\r\n",
      "|  Expression value is: java.io.PrintStream@23faf8f2\r\n",
      "|    assigned to temporary variable $40 of type PrintStream\r\n",
      "\r\n",
      " System.out.printf(\"d33 hashCode: %d %d\\n\", d33.hashCode(), System.identityHas \r",
      "hCode(d33));\r\n",
      "d33 hashCode: 1796068309 280744458\r\n",
      "|  Expression value is: java.io.PrintStream@23faf8f2\r\n",
      "|    assigned to temporary variable $41 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "DogV3 d31=new DogV3(\"d31\",\"Poodle\");\n",
    "DogV3 d32=new DogV3(\"d31\",\"Poodle\");\n",
    "DogV3 d33=new DogV3(\"d3\",\"Shih Tzu\");\n",
    "System.out.printf(\"d31 hashCode: %d %d\\n\", d31.hashCode(), System.identityHashCode(d31));\n",
    "System.out.printf(\"d32 hashCode: %d %d\\n\", d32.hashCode(), System.identityHashCode(d32));\n",
    "System.out.printf(\"d33 hashCode: %d %d\\n\", d33.hashCode(), System.identityHashCode(d33));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.printf(\"\\n...d31 equals d32: %b\",d31.equals(d32));\r\n",
      "EQUALS: name d31==d31 breed Poodle==Poodle birth Sat Jun 02 16:26:10 KST 2018==Sat Jun 02 16:26:10 KST 2018 false\r\n",
      "...d31 equals d32: false|  Expression value is: java.io.PrintStream@23faf8f2\r\n",
      "|    assigned to temporary variable $42 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.printf(\"\\n...d31 equals d32: %b\",d31.equals(d32));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 oo-8: 강의시간표를 구현한다.\n",
    "\n",
    "\n",
    "### 문제\n",
    "강의시간표는 빈 칸이 있을 수 있다. 강의명을 가져올 때, 강의가 없는 경우 문제가 될 수 있다.\n",
    "\n",
    "### 해결\n",
    "\n",
    "Subject와 NullSubject로 구분한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"199px\" style=\"width:230px;height:199px;\" version=\"1.1\" viewBox=\"0 0 230 199\" width=\"230px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"73.6094\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"174\" x=\"20.5\" y=\"8\"/><ellipse cx=\"54.4\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M57.3688,29.6406 Q56.7906,29.9375 56.15,30.0859 Q55.5094,30.2344 54.8063,30.2344 Q52.3063,30.2344 50.9859,28.5859 Q49.6656,26.9375 49.6656,23.8125 Q49.6656,20.6875 50.9859,19.0313 Q52.3063,17.375 54.8063,17.375 Q55.5094,17.375 56.1578,17.5313 Q56.8063,17.6875 57.3688,17.9844 L57.3688,20.7031 Q56.7438,20.125 56.15,19.8516 Q55.5563,19.5781 54.9313,19.5781 Q53.5875,19.5781 52.9,20.6484 Q52.2125,21.7188 52.2125,23.8125 Q52.2125,25.9063 52.9,26.9766 Q53.5875,28.0469 54.9313,28.0469 Q55.5563,28.0469 56.15,27.7734 Q56.7438,27.5 57.3688,26.9219 L57.3688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"100\" x=\"72.6\" y=\"28.1543\">AbstractSubject</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"21.5\" x2=\"193.5\" y1=\"40\" y2=\"40\"/><polygon fill=\"none\" points=\"31.5,46.9023,35.5,50.9023,31.5,54.9023,27.5,50.9023\" style=\"stroke: #B38D22; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"70\" x=\"40.5\" y=\"54.2104\">name:String</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"21.5\" x2=\"193.5\" y1=\"60.8047\" y2=\"60.8047\"/><ellipse cx=\"31.5\" cy=\"72.707\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"148\" x=\"40.5\" y=\"75.0151\">abstract getName():String</text><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"79\" x=\"6\" y=\"142\"/><ellipse cx=\"21\" cy=\"158\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M23.9688,163.6406 Q23.3906,163.9375 22.75,164.0859 Q22.1094,164.2344 21.4063,164.2344 Q18.9063,164.2344 17.5859,162.5859 Q16.2656,160.9375 16.2656,157.8125 Q16.2656,154.6875 17.5859,153.0313 Q18.9063,151.375 21.4063,151.375 Q22.1094,151.375 22.7578,151.5313 Q23.4063,151.6875 23.9688,151.9844 L23.9688,154.7031 Q23.3438,154.125 22.75,153.8516 Q22.1563,153.5781 21.5313,153.5781 Q20.1875,153.5781 19.5,154.6484 Q18.8125,155.7188 18.8125,157.8125 Q18.8125,159.9063 19.5,160.9766 Q20.1875,162.0469 21.5313,162.0469 Q22.1563,162.0469 22.75,161.7734 Q23.3438,161.5 23.9688,160.9219 L23.9688,163.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"47\" x=\"35\" y=\"162.1543\">Subject</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"84\" y1=\"174\" y2=\"174\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"84\" y1=\"182\" y2=\"182\"/><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"48\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"102\" x=\"119.5\" y=\"142\"/><ellipse cx=\"134.5\" cy=\"158\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M137.4688,163.6406 Q136.8906,163.9375 136.25,164.0859 Q135.6094,164.2344 134.9063,164.2344 Q132.4063,164.2344 131.0859,162.5859 Q129.7656,160.9375 129.7656,157.8125 Q129.7656,154.6875 131.0859,153.0313 Q132.4063,151.375 134.9063,151.375 Q135.6094,151.375 136.2578,151.5313 Q136.9063,151.6875 137.4688,151.9844 L137.4688,154.7031 Q136.8438,154.125 136.25,153.8516 Q135.6563,153.5781 135.0313,153.5781 Q133.6875,153.5781 133,154.6484 Q132.3125,155.7188 132.3125,157.8125 Q132.3125,159.9063 133,160.9766 Q133.6875,162.0469 135.0313,162.0469 Q135.6563,162.0469 136.25,161.7734 Q136.8438,161.5 137.4688,160.9219 L137.4688,163.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"70\" x=\"148.5\" y=\"162.1543\">NullSubject</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"120.5\" x2=\"220.5\" y1=\"174\" y2=\"174\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"120.5\" x2=\"220.5\" y1=\"182\" y2=\"182\"/><path d=\"M79.3086,100.1093 C71.6621,114.7857 63.7857,129.9032 57.5611,141.8505 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"73.2806,96.5295,88.7297,82.027,85.6965,102.9983,73.2806,96.5295\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M136.146,100.1093 C143.916,114.7857 151.919,129.9032 158.244,141.8505 \" fill=\"none\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><polygon fill=\"none\" points=\"129.744,102.9779,126.573,82.027,142.117,96.4274,129.744,102.9779\" style=\"stroke: #A80036; stroke-width: 1.0;\"/></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class AbstractSubject {\n",
    "    #name:String\n",
    "    +abstract getName():String\n",
    "}\n",
    "class Subject\n",
    "class NullSubject\n",
    "AbstractSubject <|-- Subject\n",
    "AbstractSubject <|-- NullSubject\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public abstract class AbstractSubject {\r\n",
      "    protected String name;\r\n",
      "    public abstract String getName();\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public abstract class AbstractSubject {\r\n",
      "|  ^-------------^\r\n",
      "|  Added class AbstractSubject this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public abstract class AbstractSubject {\r\n",
      "|      ^-------------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public abstract class AbstractSubject {\n",
    "   protected String name;\n",
    "   public abstract String getName();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public class Subject extends AbstractSubject {\r\n",
      "     public Subject(String n) {\r\n",
      "         this.name=n;\r\n",
      "     }\r\n",
      "     public String getName() {\r\n",
      "         return this.name;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class Subject extends AbstractSubject {\r\n",
      "|  ^----^\r\n",
      "|  Added class Subject this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class Subject extends AbstractSubject {\r\n",
      "|      ^----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public class Subject extends AbstractSubject {\n",
    "    public Subject(String n) {\n",
    "        this.name=n;\n",
    "    }\n",
    "    public String getName() {\n",
    "        return this.name;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public class NullSubject extends AbstractSubject {\r\n",
      "     public String getName() {\r\n",
      "         return \"\";\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class NullSubject extends AbstractSubject {\r\n",
      "|  ^----^\r\n",
      "|  Added class NullSubject this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class NullSubject extends AbstractSubject {\r\n",
      "|      ^----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public class NullSubject extends AbstractSubject {\n",
    "    public String getName() {\n",
    "        return \"\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " AbstractSubject ns=new NullSubject();\r\n",
      "|  Added variable ns of type AbstractSubject with initial value NullSubject@598067a5\r\n",
      "\r\n",
      " ns.getName();\r\n",
      "|  Expression value is: \"\"\r\n",
      "|    assigned to temporary variable $5 of type String\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "AbstractSubject ns=new NullSubject();\n",
    "ns.getName();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 강의시간표에는 매 시간 강의가 있을 수 있다.\n",
    "* 시간표를 2차원으로 구성한다.\n",
    "    * 행은 8시간\n",
    "    * 열은 5일\n",
    "* NullSubject으로 초기화한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " AbstractSubject[][] subjects=new NullSubject[8][5]; \r\n",
      "|  Modified variable subjects of type AbstractSubject[][] with initial value [[LNullSubject;@2b9627bc\r\n",
      "|    Update overwrote variable subjects\r\n",
      "\r\n",
      " for(int i=0;i<subjects.length;i++) {\r\n",
      "     for(int j=0;j<subjects[i].length;j++) {\r\n",
      "         subjects[i][j]=new NullSubject();\r\n",
      "         System.out.printf(\"subjects[%d][%d]=%s...\",i,j,subjects[i][j].toStrin \r",
      "g());\r\n",
      "     }\r\n",
      " }\r\n",
      "subjects[0][0]=REPL.$REPL11$NullSubject@4f970963...subjects[0][1]=REPL.$REPL11$NullSubject@61f8bee4...subjects[0][2]=REPL.$REPL11$NullSubject@7b49cea0...subjects[0][3]=REPL.$REPL11$NullSubject@887af79...subjects[0][4]=REPL.$REPL11$NullSubject@7fac631b...subjects[1][0]=REPL.$REPL11$NullSubject@5b87ed94...subjects[1][1]=REPL.$REPL11$NullSubject@6e0e048a...subjects[1][2]=REPL.$REPL11$NullSubject@5bc79255...subjects[1][3]=REPL.$REPL11$NullSubject@47ef968d...subjects[1][4]=REPL.$REPL11$NullSubject@23e028a9...subjects[2][0]=REPL.$REPL11$NullSubject@3dd4520b...subjects[2][1]=REPL.$REPL11$NullSubject@5ae63ade...subjects[2][2]=REPL.$REPL11$NullSubject@610694f1...subjects[2][3]=REPL.$REPL11$NullSubject@43814d18...subjects[2][4]=REPL.$REPL11$NullSubject@5c5a1b69...subjects[3][0]=REPL.$REPL11$NullSubject@3701eaf6...subjects[3][1]=REPL.$REPL11$NullSubject@627551fb...subjects[3][2]=REPL.$REPL11$NullSubject@2b552920...subjects[3][3]=REPL.$REPL11$NullSubject@2758fe70...subjects[3][4]=REPL.$REPL11$NullSubject@1f36e637...subjects[4][0]=REPL.$REPL11$NullSubject@578486a3...subjects[4][1]=REPL.$REPL11$NullSubject@551aa95a...subjects[4][2]=REPL.$REPL11$NullSubject@35d176f7...subjects[4][3]=REPL.$REPL11$NullSubject@1dfe2924...subjects[4][4]=REPL.$REPL11$NullSubject@6ebc05a6...subjects[5][0]=REPL.$REPL11$NullSubject@6e6c3152...subjects[5][1]=REPL.$REPL11$NullSubject@50b494a6...subjects[5][2]=REPL.$REPL11$NullSubject@3cef309d...subjects[5][3]=REPL.$REPL11$NullSubject@32709393...subjects[5][4]=REPL.$REPL11$NullSubject@3d99d22e...subjects[6][0]=REPL.$REPL11$NullSubject@49fc609f...subjects[6][1]=REPL.$REPL11$NullSubject@cd2dae5...subjects[6][2]=REPL.$REPL11$NullSubject@3a883ce7...subjects[6][3]=REPL.$REPL11$NullSubject@4973813a...subjects[6][4]=REPL.$REPL11$NullSubject@6321e813...subjects[7][0]=REPL.$REPL11$NullSubject@79be0360...subjects[7][1]=REPL.$REPL11$NullSubject@22a67b4...subjects[7][2]=REPL.$REPL11$NullSubject@57855c9a...subjects[7][3]=REPL.$REPL11$NullSubject@3b084709...subjects[7][4]=REPL.$REPL11$NullSubject@3224f60b...\r\n"
     ]
    }
   ],
   "source": [
    "AbstractSubject[][] subjects=new NullSubject[8][5]; \n",
    "for(int i=0;i<subjects.length;i++) {\n",
    "    for(int j=0;j<subjects[i].length;j++) {\n",
    "        subjects[i][j]=new NullSubject();\n",
    "        System.out.printf(\"subjects[%d][%d]=%s...\",i,j,subjects[i][j].toString());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 월요일 1교시는 'English'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " subjects[0][0]\r\n",
      "|  Expression value is: NullSubject@4f970963\r\n",
      "|    assigned to temporary variable $18 of type AbstractSubject\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "subjects[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* ??왜 ArrayStoreException"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " subjects[0][0]=new Subject(\"English\");\r\n",
      "|  java.lang.ArrayStoreException thrown: REPL.$REPL10$Subject\r\n",
      "|        at (#24:1)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "subjects[0][0]=new Subject(\"English\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " subjects[0][1]=new NullSubject();\r\n",
      "|  Expression value is: NullSubject@68bbe345\r\n",
      "|    assigned to temporary variable $21 of type AbstractSubject\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "subjects[0][1]=new NullSubject();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " subjects[0][1].getName();\r\n",
      "|  Expression value is: \"\"\r\n",
      "|    assigned to temporary variable $22 of type String\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "subjects[0][1].getName();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(AbstractSubject[] e:subjects) {\r\n",
      "     for(AbstractSubject ee:e) {\r\n",
      "         //ee=new NullSubject();\r\n",
      "         System.out.printf(\"-%s-\",ee.getName());\r\n",
      "     }\r\n",
      " }\r\n",
      "--------------------------------------------------------------------------------\r\n"
     ]
    }
   ],
   "source": [
    "for(AbstractSubject[] e:subjects) {\n",
    "    for(AbstractSubject ee:e) {\n",
    "        //ee=new NullSubject();\n",
    "        System.out.printf(\"-%s-\",ee.getName());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " for(AbstractSubject[] e:subjects) {\r\n",
      "     for(AbstractSubject ee:e) {\r\n",
      "         System.out.println(ee);\r\n",
      "     }\r\n",
      " }\r\n",
      "REPL.$REPL11$NullSubject@4f970963\r\n",
      "REPL.$REPL11$NullSubject@68bbe345\r\n",
      "REPL.$REPL11$NullSubject@7b49cea0\r\n",
      "REPL.$REPL11$NullSubject@887af79\r\n",
      "REPL.$REPL11$NullSubject@7fac631b\r\n",
      "REPL.$REPL11$NullSubject@5b87ed94\r\n",
      "REPL.$REPL11$NullSubject@6e0e048a\r\n",
      "REPL.$REPL11$NullSubject@5bc79255\r\n",
      "REPL.$REPL11$NullSubject@47ef968d\r\n",
      "REPL.$REPL11$NullSubject@23e028a9\r\n",
      "REPL.$REPL11$NullSubject@3dd4520b\r\n",
      "REPL.$REPL11$NullSubject@5ae63ade\r\n",
      "REPL.$REPL11$NullSubject@610694f1\r\n",
      "REPL.$REPL11$NullSubject@43814d18\r\n",
      "REPL.$REPL11$NullSubject@5c5a1b69\r\n",
      "REPL.$REPL11$NullSubject@3701eaf6\r\n",
      "REPL.$REPL11$NullSubject@627551fb\r\n",
      "REPL.$REPL11$NullSubject@2b552920\r\n",
      "REPL.$REPL11$NullSubject@2758fe70\r\n",
      "REPL.$REPL11$NullSubject@1f36e637\r\n",
      "REPL.$REPL11$NullSubject@578486a3\r\n",
      "REPL.$REPL11$NullSubject@551aa95a\r\n",
      "REPL.$REPL11$NullSubject@35d176f7\r\n",
      "REPL.$REPL11$NullSubject@1dfe2924\r\n",
      "REPL.$REPL11$NullSubject@6ebc05a6\r\n",
      "REPL.$REPL11$NullSubject@6e6c3152\r\n",
      "REPL.$REPL11$NullSubject@50b494a6\r\n",
      "REPL.$REPL11$NullSubject@3cef309d\r\n",
      "REPL.$REPL11$NullSubject@32709393\r\n",
      "REPL.$REPL11$NullSubject@3d99d22e\r\n",
      "REPL.$REPL11$NullSubject@49fc609f\r\n",
      "REPL.$REPL11$NullSubject@cd2dae5\r\n",
      "REPL.$REPL11$NullSubject@3a883ce7\r\n",
      "REPL.$REPL11$NullSubject@4973813a\r\n",
      "REPL.$REPL11$NullSubject@6321e813\r\n",
      "REPL.$REPL11$NullSubject@79be0360\r\n",
      "REPL.$REPL11$NullSubject@22a67b4\r\n",
      "REPL.$REPL11$NullSubject@57855c9a\r\n",
      "REPL.$REPL11$NullSubject@3b084709\r\n",
      "REPL.$REPL11$NullSubject@3224f60b\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "for(AbstractSubject[] e:subjects) {\n",
    "    for(AbstractSubject ee:e) {\n",
    "        System.out.println(ee);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}