j_2_classObject.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 2. Class and Objects\n",
    "\n",
    "Last updated 20190319TUE1200 20180328WEB1730 20180325SUN0830\n",
    "\n",
    "## 2.1 학습내용\n",
    "\n",
    "### 2.1.1 목표\n",
    "\n",
    "* 간단한 Hello Class를 만들 수 있다.\n",
    "* 객체를 사용할 수 있다.\n",
    "* 클래스를 구성하는 필드, 멤버함수를 사용할 수 있다.\n",
    "* 클래스의 생성자, 가시성을 사용할 수 있다.\n",
    "* 클래스를 참조하여 사용할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 2.1.2 문제\n",
    "\n",
    "* 문제 2-1: Hello 인사하는 프로그램을 객체지향, 함수방식 비교하기\n",
    "* 문제 2-2: 지하철 몇 호선인지 정해서 운행하는 클래스, 절차를 정해서 만들기\n",
    "* 문제 2-3: 커피 원산지를 넣어서, 객체를 생성할 때 원산지를 가지고 있도록 구현한다\n",
    "* 문제 2-4: 몸무게를 자신 이외에는 알 수 없도록 구현한다.\n",
    "* 문제 2-5: 사각형의 면적을 계산하기, 데이터를 보호하는 방식으로 구현\n",
    "* 연습문제 주사위 만들기\n",
    "\n",
    "+ this, garbage collection, finalize\n",
    "+ 미로 http://crpit.com/confpapers/CRPITV30Nevison.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2.2 글쎄 클래스가 뭐지?\n",
    "\n",
    "\n",
    "### 2.2.1 프로그래밍하는 방법 2가지\n",
    "\n",
    "객체지향을 쉽게 이해하는 경우는 보기 어렵다.\n",
    "프로그래밍을 배운 경험이 있어도 '객체가 도대체 뭐지?'라고 어려워한다.\n",
    "프로그래밍을 배운 적이 없는 초보자는 더 말할 나위가 없다.\n",
    "쉽게 생각하자. 객체지향을 **프로그래밍하는 스타일**로 이해하자.\n",
    "한식은 젓가락으로, 스파게티는 포크로 스테이크는 포크와 나이프를 사용하는 그런 스타일로 보자는 말이다.\n",
    "\"한식을 왜 젓가락으로 먹어야 하나요?\" 또는 스파게티는 왜 포크로, 스테이크는 왜 칼이 필요한지는 그 음식의 특성이 이유를 자연스럽게 말해주고 있다. 그 도구가 그 음식에 제일 편하기 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "프로그램은 2가지 요소, 즉 **데이터**와 **코드**로 구성된다.\n",
    "* **데이터**는 입출력에 쓰이는 값으로 코드가 실행될 경우 사용된다.\n",
    "* **코드**는 컴퓨터가 실행하는 소스코드로서 명령문을 말한다.\n",
    "\n",
    "절차중심의 프로그래밍은 6,70년대부터 주로 쓰였던 COBOL, Fortran, C와 같은 언어를 말한다. 절차를 순서대로 실행하게 된다. 그러면서 데이터가 절차에 따라 사용된다. 반면 8,90년대 쓰이게 되는 C++, Java 같은 객체지향언어는 데이터와 코드가 객체 안, 즉 멤버로 들어가게 된다. 데이터와 코드가 따로 떨어져 있는 절차중심의 언어는 데이터를 관리하기 어렵다는 문제를 가지고 있다. 반면에 객체지향은 데이터와 코드가 붙어 있어 데이터가 잘 관리될 수 있다는 장점이 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "객체지향은 하나의 스타일이다. **데이터를 보호**하기 위한 방식이다. 전통적으로 데이터와 함수는 서로 떨어져 있었다. 데이터는 메모리에 저장되고 프로그램에서 쉽게 읽고 수정할 수 있다. 이런 특성으로 인해 그 유명한 **Y2K**문제를 일으키고 말았다. 연도를 2자리로 정의해 놓으니 1999년에서 2000년으로 가는 경우 그 99, 00이 된다. 이 경우 년도의 순서가 어긋나게 된다. 00이 1000인지 2000인지 구분이 불가능해지게 되었다. 데이터가 올바르게 보호, 관리될 수 있었다면 밀레니엄버그가 발생하지 않을 수 있었다.\n",
    "\n",
    "기업 시스템을 구축하면서 **전역변수**를 신입사원에게까지 수정할 수 있는 권한을 가진 것을 보고 놀란 적이 있다. 그 파일을 실수로 또는 악의로 변경할 경우 전체가, 조그만 실수라 할지라도, 오작동할 수 있는 가능성이 충분하기 때문이다. 객체지향에서는 전역데이터, 즉 누구든지 읽고, 수정할 수 있는 데이터가 존재하지 않는다. 모든 데이터가 보호되는 **encapsulation 스타일이 객체지향**이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "절차중심 프로그래밍 | 객체지향 프로그래밍\n",
    "-----|-----\n",
    "C, Cobol, Fortran | C++, Java\n",
    "절차를 순서대로 실행, 코드와 데이터가 별도 | 객체를 만들어 실행, 코드와 데이터가 묶여있고 데이터를 보호"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2.2.2 왜 객체지향\n",
    "\n",
    "객체지향은 왜 필요한 것이며, 이와 같이 빠르게 퍼지게 된 이유는 무엇일까?\n",
    "1986년 C++가 발표 되었다.\n",
    "이 언어가 운영체제를 만드는데 사용되면서 관심을 끌었다.\n",
    "그러나 본격적으로 객체지향이 퍼지게된 것은 선이 자바를 발표하게 되면서였다.\n",
    "자바의 특성이 **웹**과 잘 어울리면서 널리 보급되었다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "그렇다면 객체지향이 **왜 필요한지** 생각해 보자. 새로운 기술은 과거 보다 낫다고 증명되어야 한다.\n",
    "객체지향은 프로그램이 커지면서 빠르게 퍼지게 되었다.\n",
    "객체지향은 60년대에 개념이 소개되었지만, 프로그램이 커지게 되면서 80년대에 들어와 개발방법이 필요하게 되었고 지금 많이 쓰이는 UML, 반복적 개발방법과 더불어 적용되고 있다. 즉 **프로그램이 커지고 복잡해지면서 바로 개발하기보다는 구조를 설계**해야 하는 필요가 있고 객체지향이 들어맞고 있다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "다음은 생산성 측면에서 객체지향이 필요한 이유를 설명해 보자.\n",
    "객체지향은 프로그래밍하는 새로운 방식이다. 왜 새로운 방식이 필요할까? 물론 **기존의 방식에 비해 빠르게** 만들면서, **품질이 뛰어난** 결과, 즉 프로그램을 만들어 내기 때문이다. 이미 비객체지향에 익숙한 프로그래머를 어떻게 객체지향이라는, 새로 배워야 하는 방식으로 설득할 수 있을까? 결코 쉽지 않다. 객체지향은 태어날 때부터 1) 빠르게, 2) 품질 좋은 제품, 프로그램을 만든다고 마케팅을 했다. 객체지향은 **재사용**을 위한 언어이다. 또 쓰게 하려면 설계가 필요하다. 상속은 대표적인 재사용 스타일이다. \n",
    "\n",
    "객체지향은 트렌드이다. C를 제외하고는 거의 모든 언어가 객체지향이다. 객체지향을 모르고서는 프로그래밍이 가능하지 못하게 되어 있다. Python, Javascript가 객체지향이다. C도 객체지향으로 C++를 사용할 수 있다.\n",
    "\n",
    "요약하면, 객체지향은 하나의 스타일이다. 프로그램을 만드는 단위가 클래스이다. 이러한 객체지향은 데이터를 보호하기 위해서, 재사용하기 위한 방법이다. 이제는 프로그램의 방식으로 객체지향은 트렌드이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2.2.3 객체지향은 객체로 프로그래밍한다.\n",
    "\n",
    "객체지향은 단어가 의미하듯 **객체로 구성**한다. 즉, 객체지향 프로그램은 객체를 만들지 않고서는 실행될 수 없다.\n",
    "아무리 단순하더라도 객체를 만들어야 한다. 프로그래밍을 구성하는 단위가 객체이다. 기능적 프로그램은 함수가 단위가 된다.\n",
    "\n",
    "기능적 프로그램 | 객체지향 프로그램\n",
    "-----|-----\n",
    "C, Python, PHP | Java, C++\n",
    "**명령문을 함수로 구성**하여 컴퓨터 프로그램을 만든다. | **명령문을 클래스로 구성**하여 컴퓨터 프로그램을 만든다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "더하기를 기능적 프로그램으로 구현해 보자. 함수 add()는 숫자 2개를 받아서 합산한 후 반환한다.\n",
    "\n",
    "```Python\n",
    "def add(a,b):\n",
    "    return a+b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "객체지향 프로그램으로는 간단한 기능이더라도 클래스를 만들어야 한다. Number 클래스를 만들어 add() 멤버함수를 구현하면 다음과 같다. 숫자 2개를 받아서, 합산하는 기능은 위 add()와 차이가 없다.\n",
    "\n",
    "```Java\n",
    "class Number {\n",
    "    int add(int a, int b) {\n",
    "        return a+b;\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스 형식\n",
    "\n",
    "```java\n",
    "class 클래스명 {\n",
    "     타잎 변수명;\n",
    "     ...\n",
    "     타잎 함수명(인자...) {\n",
    "          \n",
    "     }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "객체지향 프로그램은 클래스로 만들어야 한다. **class 명령어로 시작해야** 한다.\n",
    "클래스는 멤버변수와 멤버함수를 가지고 있다.\n",
    "함수는 변수를 사용한다. 즉, 함수에 의해 사용되지 않는 변수는 멤버 자격이 없다고 말할 수 있다.\n",
    "\n",
    "명령어 | 설명\n",
    "-----|-----\n",
    "class | class 선언. 앞에 가시성 public, private과 같은 가시성, static을 사용할 수 있다.\n",
    "클래스명 | class의 이름을 적는다. 이름은 camel case로 정한다.\n",
    "변수 | 변수의 이름을 적는다. 객체지향에서는 클래스에 속한 변수를 멤버변수, 멤버필드라고 하기도 한다.\n",
    "함수 | 함수의 이름을 적는다. 멤버함수라고 한다. main()함수를 가질 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> 알아두기:\n",
    "> **Camel case**\n",
    ">\n",
    "> 낙타 등의 혹을 닮았다는 뜻으로, 프로그래밍에서는 이름지을 때 사용한다.\n",
    "> 함수일 경우 calcualteArea()와 같이 두 단어 이상인 경우 연결단어의 첫 글자를 대문자로 한다.\n",
    "> 변수 또는 클래스를 명명할 때도 자바는 Camel case를 사용한다.\n",
    "> 참고로 c 언어는 underscore를 사용하는데 calculate_area()가 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2.2.2 객체는 무엇일까?\n",
    "\n",
    "객체지향은 우리가 살아가는 세상에서 **실제로 일어나는 일을 흉내**내어 프로그래밍한다.\n",
    "우리 주변에 있는 모든 것이 클래스가 될 수 있고, 프로그래밍 될 수 있다.\n",
    "주위를 둘러 보자. 사람, 자동차, 집, 커피 등이 클래스가 될 수 있다.\n",
    "오히려 클래스가 될 수 없는 것을 골라내기가 더 힘들다.\n",
    "\n",
    "무엇이든 클래스가 될 수 있다면, 잘 만드는 것이 초점이 된다.\n",
    "**좋은 클래스**를 만드는 것이 중요하다. 객체지향에서는 '닥프'가 아니라 **설계를 먼저**하는 것이 필요하다.\n",
    "어떻게 좋은 클래스를 만드는지는 차츰 학습하게 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**목적에 따라 클래스가 되기도, 되지 않을 수**도 있다.\n",
    "자동차는 판매상에 전시된 경우와 개인이 소유한 경우에 서로 데이터와 함수가 다를 수 밖에 없다. 판매용 자동차는 차번호, 소유자가 없다. 개인소유 자동차는 이런 데이터가 있다.\n",
    "커피를 유통할지, 매장에서 아메리카노와 같은 상품으로 만들지에 따라 다를 수 있다.\n",
    "따라서 **좋은 클래스란 응집성이 있게** 만들어져야 한다.\n",
    "\n",
    "> 알아두기:\n",
    "> **응집성 cohesion**\n",
    "> \n",
    "> 컴퓨터 프로그램의 용어로, 모듈이 잘 만들어진 것인지 판단하는 기준으로 결합성과 같이 널리 쓰인다. 클래스가 데이터와 함수가 서로 속하도록 그 목적에 부합하도록 만들어진 경우 응집성이 높다고 한다. 예를 들어, 사각형 계산의 경우 너비, 높이는 응집성이 높은 데이터이다. 반면에 불필요한 데이터, 생뚱맞지만 파이는 불필요한 데이터로서 응집성을 해치게 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "객체가 무엇인지 알려면 클래스를 먼저 이해해야 한다.\n",
    "위에서 Number라는 클래스를 만들었다. 두 수를 더하는 add()는 객체 'num'을 만들어 사용한다.\n",
    "\n",
    "```Java\n",
    "-> /set feedback off\n",
    "-> class Number {\n",
    ">>     int add(int a, int b) {\n",
    ">>         return a+b;\n",
    ">>     }\n",
    ">> }\n",
    "-> Number num=new Number();\n",
    "-> System.out.println(num.add(2,3));\n",
    "5\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Number 클래스는 'num' 객체를 만들어 내는 역할을 한다. 클래스는 몇 개라도 객체 1, 2,...를 만들어 낼 수 있다.\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",
    "구분 | 클래스 | 객체\n",
    "-----|-----|-----\n",
    "수 | Number | 객체 'n'으로 실제 더하기를 할 수 있다.\n",
    "자동차 | 버스, 택시, 화물차 어느 것이나 될 수 있다 | 내가 타는 자동차, 등록번호를 가지고 있어 특정할 수 있다.\n",
    "커피 | 케냐AA, 브라질 | 내가 주문해서 지금 마시고 있는 커피\n",
    "문서 | 이력서 서식, 논문 서식 | 내가 작성한 'myreport.doc'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "클래스는 개념이다. 실제로 내 앞에 존재하는 것은 객체이다.\n",
    "\n",
    "![alt text](figures/2_1_class_object.png \"Title\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 2.2.3 클래스는 객체의 속성과 함수를 정의한다.\n",
    "\n",
    "클래스는 객체의 **속성과 함수를 정의**한다.\n",
    "앞서 설명한 바와 같이 데이터와 코드가 함께 묶여 있는 스타일이다.\n",
    "객체는 클래스에서 만들어진다. 말이 어렵겠지만\n",
    "자동차라고 하면 어떤 것이라고 알고 있다. 자동차를 구매해서 내 자동차는 좀 더 구체적이다.\n",
    "자동차는 년식이 있겠지만 2010년식이든, 2020년식이든 상관없다.\n",
    "그러나 내 자동차는 구매한 년도의 년식이다.\n",
    "자동차의 배기량은 2000cc, 3000cc 무관하다.\n",
    "내 자동차는, 즉 내가 구매할 때는 규모에 맞는 배기량을 선택하기 구매한다.\n",
    "\n",
    "클래스 | 속성 | 함수\n",
    "-----|-----|-----\n",
    "자동차 | 년식=2018<br>배기량=2000cc | 등록한다\n",
    "커피 | 품종=케냐AA | 추출한다\n",
    "\n",
    "요약하면\n",
    "* 클래스는 객체의 정의, 멤버 변수와 멤버 함수를 가지고 있다.\n",
    "* 객체는 클래스에서 만들어진 실제 인스턴스\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스 UML\n",
    "\n",
    "커피를 클래스로 만들어 보자.\n",
    "생각나는대로 자판으로 가서 프로그램을 바로 작성하기 보다는 그림, UML을 그려보자.\n",
    "클래스는 3칸 서랍으로 구성되어 있다고 본다.\n",
    "* 첫째 서랍에는 클래스 명\n",
    "* 둘째 서랍에는 속성\n",
    "* 세째 서람에는 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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=\"90px\" style=\"width:82px;height:90px;\" version=\"1.1\" viewBox=\"0 0 82 90\" width=\"82px\" 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=\"67\" x=\"6\" y=\"8\"/><ellipse cx=\"21\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M23.9688,29.6406 Q23.3906,29.9375 22.75,30.0859 Q22.1094,30.2344 21.4063,30.2344 Q18.9063,30.2344 17.5859,28.5859 Q16.2656,26.9375 16.2656,23.8125 Q16.2656,20.6875 17.5859,19.0313 Q18.9063,17.375 21.4063,17.375 Q22.1094,17.375 22.7578,17.5313 Q23.4063,17.6875 23.9688,17.9844 L23.9688,20.7031 Q23.3438,20.125 22.75,19.8516 Q22.1563,19.5781 21.5313,19.5781 Q20.1875,19.5781 19.5,20.6484 Q18.8125,21.7188 18.8125,23.8125 Q18.8125,25.9063 19.5,26.9766 Q20.1875,28.0469 21.5313,28.0469 Q22.1563,28.0469 22.75,27.7734 Q23.3438,27.5 23.9688,26.9219 L23.9688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"35\" x=\"35\" y=\"28.1543\">name</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"72\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"25\" x=\"12\" y=\"54.2104\">data</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"72\" y1=\"60.8047\" y2=\"60.8047\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"35\" x=\"12\" y=\"75.0151\">code()</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class name {\n",
    "    data\n",
    "    code()\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "자, 연녹색 생두를 볶고 갈아서 테이블에 놓여진 향기나는 커피를 생각해 보자.\n",
    "위 그림과 같이 데이터와 코드로 나누어 생각해 보자.\n",
    "데이터는 멤버속성, 코드는 멤버함수라고 한다.\n",
    "* 데이터 또는 멤버속성\n",
    "    * 원산지 - 위키피디아 \"적도지방 라틴 아메리카, 동남아시아, 남 아시아 그리고 아프리카의 70여개국에서 재배되는 커피나무에서 얻을 수 있다.\"\n",
    "    * 볶은 정도 - light, medium, dark\n",
    "    * grade - 커피 콩의 크기를 참조하여 grade를 판정한다 http://www.coffeeresearch.org/coffee/grade.htm\n",
    "* 코드 또는 멤버함수\n",
    "    * 볶기 roast\n",
    "    * 갈기 grind\n",
    "    * 내리기 brew\n",
    "\n",
    "이렇게 커피를 만든 것은 **'요구사항'** 때문이다. 즉 요구가 달라지면 다르게 된다. **커피 산지에서는 '볶은 정도'가 있을 수 없다. 따라서 '볶기', '갈기', '내리기' 모두 필요하지 않은 기능 또는 함수이다**. 나중에 배우겠지만 이런 커피는 우유 등을 넣어 Latte 또는 Macchiato를 만들 수 있다. 이 경우를 **상속**이라고 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"141px\" style=\"width:112px;height:141px;\" version=\"1.1\" viewBox=\"0 0 112 141\" width=\"112px\" 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=\"124.8281\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"97\" x=\"6\" y=\"8\"/><ellipse cx=\"32.7\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M35.6688,29.6406 Q35.0906,29.9375 34.45,30.0859 Q33.8094,30.2344 33.1063,30.2344 Q30.6063,30.2344 29.2859,28.5859 Q27.9656,26.9375 27.9656,23.8125 Q27.9656,20.6875 29.2859,19.0313 Q30.6063,17.375 33.1063,17.375 Q33.8094,17.375 34.4578,17.5313 Q35.1063,17.6875 35.6688,17.9844 L35.6688,20.7031 Q35.0438,20.125 34.45,19.8516 Q33.8563,19.5781 33.2313,19.5781 Q31.8875,19.5781 31.2,20.6484 Q30.5125,21.7188 30.5125,23.8125 Q30.5125,25.9063 31.2,26.9766 Q31.8875,28.0469 33.2313,28.0469 Q33.8563,28.0469 34.45,27.7734 Q35.0438,27.5 35.6688,26.9219 L35.6688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"39\" x=\"49.3\" y=\"28.1543\">coffee</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"102\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"32\" x=\"12\" y=\"54.2104\">origin</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"85\" x=\"12\" y=\"67.0151\">degreeOfRoast</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"33\" x=\"12\" y=\"79.8198\">grade</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"102\" y1=\"86.4141\" y2=\"86.4141\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"38\" x=\"12\" y=\"100.6245\">roast()</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"37\" x=\"12\" y=\"113.4292\">grind()</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"36\" x=\"12\" y=\"126.2339\">brew()</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Coffee {\n",
    "    origin\n",
    "    degreeOfRoast\n",
    "    grade\n",
    "    roast()\n",
    "    grind()\n",
    "    brew()\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 생각 바꾸기: 클래스도 명령문으로 구성되어 있다.\n",
    "\n",
    "앞서 객체지향은 프로그래밍 **스타일**로 보자고 했다.\n",
    "객체지향에서는 클래스를 사용하여 프로그램을 구현한다.\n",
    "프로그램은 명령문으로 이루어져 있다. 명령문은 컴퓨터에게 작업을 지시한다.\n",
    "**결국에는 프로그램은 따져 들어가면, 컴퓨터가 하는 '말' - 즉 2진 수 0,1로 되어 있다**.\n",
    "객체지향에서는 0,1로 구성된 명령문을 클래스를 사용하여 만드는 것과 다르지 않다는 말이다.\n",
    "\n",
    "즉 객체지향도 명령문으로 구성되고 그 스타일이 다르다고 쉽게 생각하자.\n",
    "* 객체지향프로그래밍 이전에는 함수를 사용한다.\n",
    "    * 순서대로 명령문을 구성하고, 입출력이 관련있는 경우 묶어서 함수로 만든다.\n",
    "* 객체지향에서는 **명령문을 구성하는 방법이 다르다**.\n",
    "    * 명령문을 구성해서 함수로 만들고, 필요한 데이터는 멤버로 구성한다.\n",
    "    * 함수를 구성해서 객체로 만든다.\n",
    "    * 객체는 함수를 가지고 있다.\n",
    "\n",
    "모든 명령문은 클래스에 있어야 한다. 왜 그래야 하나? 자바는 '순수' 객체지향언어이고, 과거 방식으로 함수를 만들어 실행하는 방식이 아니라, 객체를 만들어 실행한다. C++언어는 그렇지 않아도 된다는 점에서 순수 객체지향 언어는 아니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "몇 가지 예제를 들어, 쉬운 클래스 만들어 보자. 지금은 jshell을 이용해서 한다.\n",
    "* jshell은 source -> compile -> run과정을 편리하게 해준다.\n",
    "* 나중에 jshell이 아니고 편집기를 사용한다. source -> compile -> run 과정을 우리가 직접한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 2-1: Hello 인사하는 프로그램을 객체지향, 함수방식 비교하기\n",
    "\n",
    "함수방식으로 만들어보고, 어떻게 객체지향으로 바뀔 수 있는지 또는 어떻게 다른 것인지 비교해 보자.\n",
    "함수 sayHello()는 매우 간단히 구현할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void sayHello() {\r\n",
      "     System.out.println(\"hello\");\r\n",
      " }\r\n",
      "|  Added method sayHello()\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void sayHello() {\n",
    "    System.out.println(\"hello\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " sayHello();\r\n",
      "hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "객체지향방식은 클래스 '틀'을 만들고 난 후, 함수를 구현한다.\n",
    "우선 UML로 만들어 본다. 앞서 설명한 바와 같이 UML에서 클래스를 3칸으로 구성한다.\n",
    "* 첫 칸은 클래스 이름, Hello\n",
    "* 두번째는 속성으로 없으므로 비워둔다.\n",
    "* 세번째는 함수는 sayHello()\n",
    "\n",
    "지금은 시작하는 초보 단계라서 객체지향에서 쓰일 수 있는 가시성, 데이터타잎 등은 넣지 않았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"77px\" style=\"width:110px;height:77px;\" version=\"1.1\" viewBox=\"0 0 110 77\" width=\"110px\" 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=\"60.8047\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"95\" x=\"6\" y=\"8\"/><ellipse cx=\"35.4\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M38.3688,29.6406 Q37.7906,29.9375 37.15,30.0859 Q36.5094,30.2344 35.8063,30.2344 Q33.3063,30.2344 31.9859,28.5859 Q30.6656,26.9375 30.6656,23.8125 Q30.6656,20.6875 31.9859,19.0313 Q33.3063,17.375 35.8063,17.375 Q36.5094,17.375 37.1578,17.5313 Q37.8063,17.6875 38.3688,17.9844 L38.3688,20.7031 Q37.7438,20.125 37.15,19.8516 Q36.5563,19.5781 35.9313,19.5781 Q34.5875,19.5781 33.9,20.6484 Q33.2125,21.7188 33.2125,23.8125 Q33.2125,25.9063 33.9,26.9766 Q34.5875,28.0469 35.9313,28.0469 Q36.5563,28.0469 37.15,27.7734 Q37.7438,27.5 38.3688,26.9219 L38.3688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"31\" x=\"52.6\" y=\"28.1543\">Hello</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"100\" y1=\"40\" y2=\"40\"/><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"100\" y1=\"48\" y2=\"48\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"83\" x=\"12\" y=\"62.2104\">void sayHello()</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Hello {\n",
    "  void sayHello()\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 위 UML을 클래스로 구현해 본다. 불과 5줄로 구현될 수 있다. 괄호를 제외하면 3줄.\n",
    "* 함수프로그램과 비교하면, 클래스로 시작하는 한 줄이 더해졌고, 그 클래스가 함수를 가지고 있는 점이 다를 뿐이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "      void sayHello() {\r\n",
      "          System.out.println(\"hello\");\r\n",
      "      }\r\n",
      " }\r\n",
      "|  Added class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "     void sayHello() {\n",
    "         System.out.println(\"hello\");\n",
    "     }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 클래스 '틀'이 등록되어 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " /classes\r\n",
      "|    class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "/classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2.3 Object\n",
    "\n",
    "클래스 Hello를 **실행하려면 객체를 만들어서** 해야 한다.\n",
    "객체는 변수를 생성해서, 정수를 저장하는 것과 비교해서 이해할 수 있다.\n",
    "변수를 설정해서 값을 넣을 경우, 오른편에는 그 값, 왼편에는 그 값을 저장하는 메모리를 가리키는 이름을 적는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int a=1;\r\n",
      "|  Added variable a of type int with initial value 1\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int a=1;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 객체를 만들 때도 같은 방식이다.\n",
    "```java\n",
    "DataType name = new 클래스 생성자\n",
    "```\n",
    "\n",
    "* 변수의 경우 오른편에는 값, 왼편에는 이름을 가진다.\n",
    "* 객체의 경우 오른 편은 클래스의 **객체를 생성하는 'new' 명령어**이다.\n",
    "    * 객체를 생성하는 'new' 명령어를 사용하면 객체의 id를 볼 수 있다.\n",
    "    * 객체의 id는 hashCode라고 하며 서로 다르다 (여권번호와 같이).\n",
    "\n",
    "* Hello()에 괄호가 있다는 것에 주의하자. 즉 Hello()라는 함수를 호출하여 객체를 만들고 있다.\n",
    "* Hello()라는 함수는 생략되어 있지만 **생성자**라고 한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " new Hello();\r\n",
      "|  Expression value is: Hello@239963d8\r\n",
      "|    assigned to temporary variable $2 of type Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "new Hello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* new 명령어\n",
    "    * 객체에 메모리를 할당.\n",
    "\n",
    "```java\n",
    "클래스변수 = new 클래스명();\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 변수a의 경우, 값만을 저장한다.\n",
    "* 아래 예에서 객체h는 Hello의 객체를 저장한다. 값만을 저장하는 변수의 경우와 달리 객체는 값뿐만 아니라 함수도 저장하고 있다.\n",
    "* 이 때 dot operator를 사용한다. dot 앞에는 객체, dot 뒤에는 객체의 속성/함수를 사용한다.\n",
    "    ```\n",
    "    h.sayHello();\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello();\r\n",
      "|  Added variable h of type Hello with initial value Hello@14bf9759\r\n",
      "\r\n",
      " h.sayHello();\r\n",
      "hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello();\n",
    "h.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "인사하는 사람의 이름을 넣어 본다.\n",
    "* 클래스에 속성을 넣어 수정한다.\n",
    "\n",
    "이름은 클래스 다이어그램 속성 칸에 추가된다.\n",
    "형식은 콜론을 중심으로 좌측에 속성명을, 우측에 데이터타잎을 적는다.\n",
    "함수의 UML표현은 **`함수명:반환하는 데이터타잎`**으로 적는다.\n",
    "데이터타잎은 다음 장에 자세히 배우게 된다.\n",
    "\n",
    "```java\n",
    "속성명:데이터타잎\n",
    "```\n",
    "\n",
    "데이터속성에 사용된 요소 | 설명\n",
    "-----|-----\n",
    "toWhom | 속성명으로 첫글자는 소문자 단어의 시작은 대문자, 즉 Camel Case로 의미있게 지음\n",
    ": | 속성명과 데이터타잎의 분리\n",
    "String | 데이터타잎\n",
    "\"world\" | 값을 생성시점 초기화\n",
    "\n",
    "\n",
    "또 **기본생성자 Hello()**를 추가했다. 기본생성자는 객체를 생성하는 기능만 있고, 구현하지 않아도 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"90px\" style=\"width:160px;height:90px;\" version=\"1.1\" viewBox=\"0 0 160 90\" width=\"160px\" 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=\"145\" x=\"6\" y=\"8\"/><ellipse cx=\"58.75\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M61.7188,29.6406 Q61.1406,29.9375 60.5,30.0859 Q59.8594,30.2344 59.1563,30.2344 Q56.6563,30.2344 55.3359,28.5859 Q54.0156,26.9375 54.0156,23.8125 Q54.0156,20.6875 55.3359,19.0313 Q56.6563,17.375 59.1563,17.375 Q59.8594,17.375 60.5078,17.5313 Q61.1563,17.6875 61.7188,17.9844 L61.7188,20.7031 Q61.0938,20.125 60.5,19.8516 Q59.9063,19.5781 59.2813,19.5781 Q57.9375,19.5781 57.25,20.6484 Q56.5625,21.7188 56.5625,23.8125 Q56.5625,25.9063 57.25,26.9766 Q57.9375,28.0469 59.2813,28.0469 Q59.9063,28.0469 60.5,27.7734 Q61.0938,27.5 61.7188,26.9219 L61.7188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"31\" x=\"79.25\" y=\"28.1543\">Hello</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"150\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"133\" x=\"12\" y=\"54.2104\">toWhom:String=&quot;world&quot;</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"150\" y1=\"60.8047\" y2=\"60.8047\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"83\" x=\"12\" y=\"75.0151\">void sayHello()</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Hello {\n",
    "  toWhom:String=\"world\"\n",
    "  Hello()\n",
    "  sayHello():void\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "     String toWhom=\"world\";\r\n",
      "     Hello() {}\r\n",
      "     void sayHello() {\r\n",
      "         System.out.println(\"hello \"+toWhom);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "    String toWhom=\"world\";\n",
    "    Hello() {}\n",
    "    void sayHello() {\n",
    "        System.out.println(\"hello \"+toWhom);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello();\r\n",
      "|  Added variable h of type Hello with initial value Hello@239963d8\r\n",
      "\r\n",
      " h.sayHello();\r\n",
      "hello world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello();\n",
    "h.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "인사를 다른 사람과 하고 싶다면 클래스에 어떤 변화가 있어야 할까?\n",
    "데이터를 직접 수정하지 않고 함수를 통해서 하는 것이 좋다.\n",
    "**데이터를 보호한다면 다른 누구도 수정하지 못하게 사적정보 private으로 만들고, 함수만 공개**하면 된다.\n",
    "\n",
    "함수가 앞서 sayHello()와 다른 점에 주목하자.\n",
    "매개변수 whom이 setWhom(whom:String)이 전달되고 있다.\n",
    "이 경우 객체가 사용되고 있다. 나중에 차츰 배우게 된다.\n",
    "\n",
    "매개변수 역시 앞서 UML표기법과 같이 콜론을 중심으로 **'명:데이터타잎'**으로 적는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"103px\" style=\"width:186px;height:103px;\" version=\"1.1\" viewBox=\"0 0 186 103\" width=\"186px\" 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=\"171\" x=\"6\" y=\"8\"/><ellipse cx=\"71.75\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M74.7188,29.6406 Q74.1406,29.9375 73.5,30.0859 Q72.8594,30.2344 72.1563,30.2344 Q69.6563,30.2344 68.3359,28.5859 Q67.0156,26.9375 67.0156,23.8125 Q67.0156,20.6875 68.3359,19.0313 Q69.6563,17.375 72.1563,17.375 Q72.8594,17.375 73.5078,17.5313 Q74.1563,17.6875 74.7188,17.9844 L74.7188,20.7031 Q74.0938,20.125 73.5,19.8516 Q72.9063,19.5781 72.2813,19.5781 Q70.9375,19.5781 70.25,20.6484 Q69.5625,21.7188 69.5625,23.8125 Q69.5625,25.9063 70.25,26.9766 Q70.9375,28.0469 72.2813,28.0469 Q72.9063,28.0469 73.5,27.7734 Q74.0938,27.5 74.7188,26.9219 L74.7188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"31\" x=\"92.25\" y=\"28.1543\">Hello</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"176\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"133\" x=\"12\" y=\"54.2104\">toWhom:String=&quot;world&quot;</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"176\" y1=\"60.8047\" y2=\"60.8047\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"159\" x=\"12\" y=\"75.0151\">setWhom(whom:String):void</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"83\" x=\"12\" y=\"87.8198\">sayHello():void</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Hello {\n",
    "  toWhom:String=\"world\"\n",
    "  setWhom(whom:String):void\n",
    "  sayHello():void\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "     private String toWhom=\"world\";\r\n",
      "     Hello() {}\r\n",
      "     void setWhom(String whom) {\r\n",
      "         toWhom=whom;\r\n",
      "     }\r\n",
      "     void sayHello() {\r\n",
      "         System.out.println(\"hello \"+toWhom);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "    private String toWhom=\"world\";\n",
    "    Hello() {}\n",
    "    void setWhom(String whom) {\n",
    "        toWhom=whom;\n",
    "    }\n",
    "    void sayHello() {\n",
    "        System.out.println(\"hello \"+toWhom);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h1=new Hello();\r\n",
      "|  Added variable h1 of type Hello with initial value Hello@239963d8\r\n",
      "\r\n",
      " h1.sayHello();\r\n",
      "hello world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h1=new Hello();\n",
    "h1.sayHello();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h2=new Hello();\r\n",
      "|  Added variable h2 of type Hello with initial value Hello@31a5c39e\r\n",
      "\r\n",
      " h2.sayHello();\r\n",
      "hello world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h2=new Hello();\n",
    "h2.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**private**으로 'toWhom'을 데이터를 보호하지 않았다면 바로 변경이 가능했을 것이다.\n",
    "이렇게 멤버변수를 **public**으로 하고 누구나 직접 사용하게 한다면 `캡슐화`를 하지 못하게 된다.\n",
    "\n",
    "```java\n",
    "h2.toWhom=\"jsl\";\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " h2.setWhom(\"jsl\");\r\n",
      "\r\n",
      " h2.sayHello();\r\n",
      "hello jsl\r\n",
      "\r\n",
      " h1.sayHello();\r\n",
      "hello world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "h2.setWhom(\"jsl\");\n",
    "h2.sayHello();\n",
    "h1.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**객체는 참조**이다. 실제 데이터가 저장되어 있는 위치정보라고 생각하자.\n",
    "따라서 h1에 h2를 복사하면 단순히 참조만 복사가 된다. 참조 복사를 하면 h2의 변경이 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " h1=h2;\r\n",
      "|  Variable h1 has been assigned the value Hello@31a5c39e\r\n",
      "\r\n",
      " h1.sayHello();\r\n",
      "hello jsl\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "h1=h2;\n",
    "h1.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 2-2: 지하철 몇 호선인지 정해서 운행하는 클래스, 절차를 정해서 만들기\n",
    "\n",
    "절차를 정해서 만들어 보자.\n",
    "단순한 클래스이므로 코드가 어렵지 않다.\n",
    "\n",
    "절차 | 설명\n",
    "-----|-----\n",
    "클래스 명 짓기 | 우선 클래스의 목적에 부합하게 이름을 짓는다. 지하철 노선별 운행이라는 목적에 맞게 'Subway' 클래스 명을 정한다.\n",
    "필요한 데이터 생각하기 | 가능한 호선은 1 ~ 9까지이다. 정수 타잎이다.\n",
    "필요한 함수 생각하기 | 운행이라는 의미를 잘 나타낼 수 있는 run()으로 명칭을 정한다. 시그니처는 입력은 '호선'으로, 출력은 없게 만든다.\n",
    "\n",
    "위 생각을 UML로 먼저 그려본다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"90px\" style=\"width:94px;height:90px;\" version=\"1.1\" viewBox=\"0 0 94 90\" width=\"94px\" 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=\"79\" x=\"6\" y=\"8\"/><ellipse cx=\"21\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M23.9688,29.6406 Q23.3906,29.9375 22.75,30.0859 Q22.1094,30.2344 21.4063,30.2344 Q18.9063,30.2344 17.5859,28.5859 Q16.2656,26.9375 16.2656,23.8125 Q16.2656,20.6875 17.5859,19.0313 Q18.9063,17.375 21.4063,17.375 Q22.1094,17.375 22.7578,17.5313 Q23.4063,17.6875 23.9688,17.9844 L23.9688,20.7031 Q23.3438,20.125 22.75,19.8516 Q22.1563,19.5781 21.5313,19.5781 Q20.1875,19.5781 19.5,20.6484 Q18.8125,21.7188 18.8125,23.8125 Q18.8125,25.9063 19.5,26.9766 Q20.1875,28.0469 21.5313,28.0469 Q22.1563,28.0469 22.75,27.7734 Q23.3438,27.5 23.9688,26.9219 L23.9688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"47\" x=\"35\" y=\"28.1543\">Subway</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"84\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"42\" x=\"12\" y=\"54.2104\">int line;</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"84\" y1=\"60.8047\" y2=\"60.8047\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"54\" x=\"12\" y=\"75.0151\">void run()</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Subway {\n",
    "  int line;\n",
    "  void run()\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 몇 호선 지하철인지는 아직 정해지지 않았다. 출력하면 0이다.\n",
    "* 즉 초기화 하지 않아도 가지고 있는 기본 값이다.\n",
    "* 이런 값을 **기본 값, default value**이라고 하며, 각 데이터 타잎별로 다음과 같다.\n",
    "\n",
    "데이터 타잎 | 기본 값 (default value)\n",
    "----------|----------\n",
    "byte, short, int, long, float, double | **0** (소수점일 경우 **0.0**)\n",
    "char | **u0000**\n",
    "String (또는 객체) | **null**\n",
    "boolean | **false**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Subway {\r\n",
      "     int line;\r\n",
      "     void run() {\r\n",
      "         System.out.println(line+\" line runs\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Subway\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Subway {\n",
    "    int line;\n",
    "    void run() {\n",
    "        System.out.println(line+\" line runs\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Subway mySub=new Subway();\r\n",
      "|  Added variable mySub of type Subway with initial value Subway@5cb9f472\r\n",
      "\r\n",
      " mySub.run()\r\n",
      "0 line runs\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Subway mySub=new Subway();\n",
    "mySub.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 몇 호선인지 정하는 속성이 필요한지 생각해 본다.\n",
    "* 함수를 사용해서 객체의 상태를 변경하고, 그 변경된 상태를 호출한다.\n",
    "* 예를 들어, 장기Chest에서 왕과 병졸은 자신의 신분(상태)에 따라 이동하는 방법이 다르게 정해진다.\n",
    "* 아래 setLine()함수는 상태를 변경하고, run()은 변경된 상태를 호출한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Subway {\r\n",
      "     int line;\r\n",
      "     void run() {\r\n",
      "         System.out.println(line+\" line runs\");\r\n",
      "     }\r\n",
      "     void setLine(int l) {\r\n",
      "         line=l;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Subway\r\n",
      "|    Update replaced variable mySub, reset to null\r\n",
      "|    Update overwrote class Subway\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Subway {\n",
    "    int line;\n",
    "    void run() {\n",
    "        System.out.println(line+\" line runs\");\n",
    "    }\n",
    "    void setLine(int l) {\n",
    "        line=l;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Subway mySub=new Subway();\r\n",
      "|  Modified variable mySub of type Subway with initial value Subway@3159c4b8\r\n",
      "|    Update overwrote variable mySub\r\n",
      "\r\n",
      " mySub.setLine(3)\r\n",
      "\r\n",
      " mySub.run()\r\n",
      "3 line runs\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Subway mySub=new Subway();\n",
    "mySub.setLine(3)\n",
    "mySub.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2.4 constructor\n",
    "\n",
    "생성자는 함수이지만, 보통 함수와 달리 그 목적은 객체를 생성하는 것이다.\n",
    "생성자는 객체를 만들 때 처음 실행되면서 필요한 작업, 초기 데이터를 설정하던지 등을 한다.\n",
    "* **기본 생성자, default constructor**를 사용하거나\n",
    "* 새로 constructor를 만들 수 있다. **constructor overloading**이라고 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 기본 생성자\n",
    "\n",
    "* Hello 클래스는 다시 쓰면 다음과 같다. 즉 Hello()가 생략되어 있었다. 이를 default constructor라고 한다.\n",
    "* default constructor의 특징\n",
    "    * **매개변수가 없는 생성자는 기본**으로 제공된다. 사용자가 만들지 않아도 된다.\n",
    "    * 시그니처\n",
    "        * **클래스 명과 동일**하다.\n",
    "        * **반환이 없다**. void도 쓰지 않는다.\n",
    "        * public, private 등 가시성을 가질 수 있다. abstract, final, static 등은 사용할 수 없다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "     Hello() {}\r\n",
      "     void sayHello() {\r\n",
      "         System.out.println(\"hello\");\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Hello\r\n",
      "|    Update replaced variable h, reset to null\r\n",
      "|    Update overwrote class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "    Hello() {}\n",
    "    void sayHello() {\n",
    "        System.out.println(\"hello\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello();\r\n",
      "|  Modified variable h of type Hello with initial value Hello@4b952a2d\r\n",
      "|    Update overwrote variable h\r\n",
      "\r\n",
      " h.sayHello();\r\n",
      "hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello();\n",
    "h.sayHello();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### **constructor overloading**\n",
    "\n",
    "* 생성자 이름은 동일하지만, 매개변수가 다르다.\n",
    "* 앞서 구현한 방식과 달리, 생성자를 사용하여 sayHello()\n",
    "* 아래는 생성자가 몇 개인 것일까? 답:2개\n",
    "\n",
    "> 알아두기\n",
    "> **Overloading**\n",
    ">\n",
    "> 같은 클래스에서 함수 이름은 같게, 그러나 매개변수만을 다르게 해서 구현하는 것을 오버로딩이라고 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "     String name;\r\n",
      "     Hello(String name) {\r\n",
      "         this.name=name;\r\n",
      "     }\r\n",
      "     void sayHello() {\r\n",
      "         System.out.println(\"hello \" + name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Hello\r\n",
      "|    Update replaced variable h1 which cannot be referenced until this error is corrected: \r\n",
      "|      constructor Hello in class Hello cannot be applied to given types;\r\n",
      "|        required: java.lang.String\r\n",
      "|        found: no arguments\r\n",
      "|        reason: actual and formal argument lists differ in length\r\n",
      "|      Hello h1=new Hello();\r\n",
      "|               ^---------^\r\n",
      "|    Update replaced variable h2 which cannot be referenced until this error is corrected: \r\n",
      "|      constructor Hello in class Hello cannot be applied to given types;\r\n",
      "|        required: java.lang.String\r\n",
      "|        found: no arguments\r\n",
      "|        reason: actual and formal argument lists differ in length\r\n",
      "|      Hello h2=new Hello();\r\n",
      "|               ^---------^\r\n",
      "|    Update overwrote class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "    String name;\n",
    "    Hello(String name) {\n",
    "        this.name=name;\n",
    "    }\n",
    "    void sayHello() {\n",
    "        System.out.println(\"hello \" + name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 객체 h를 생성할 경우, 앞서와 다르게 인자를 넣어준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello(\"world\");\r\n",
      "|  Added variable h of type Hello with initial value Hello@5025a98f\r\n",
      "\r\n",
      " h.sayHello();\r\n",
      "hello world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello(\"world\");\n",
    "h.sayHello();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " h.getClass()\r\n",
      "|  Expression value is: class Hello\r\n",
      "|    assigned to temporary variable $21 of type Class<? extends Hello>\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "h.getClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 2-3: 커피 원산지를 넣어서, 객체를 생성할 때 원산지를 가지고 있도록 구현한다.\n",
    "\n",
    "이번 문제는 원두를 볶고, 갈아서 내리는 기능을 가진 **커피자판기**라고 생각하자.\n",
    "\n",
    "### 생성자가 필요할까?\n",
    "\n",
    "또는 생성자 - 그러나 한 번 정해지면 거의 변경이 없는 성격인지 생각해 본다.\n",
    "속성 가운데 '브라질' 원산지 origin은 **변경되지 않는 객체고유의 특징**을 가지고 있으므로, 생성자에 넣는다.\n",
    "반면에 degreeOfRoast는 roast()가 실행되어야 결정될 수 있다. 이와 같이 생성 후에 결정되는 데이터를 생성자에서 초기화하는 것은 올바르지 않다.\n",
    "\n",
    "### 속성에 대한 생각\n",
    "\n",
    "여기서는 속성이 여러개 있다. 이들 멤버속성은 멤버함수에서 사용되어야 한다. **사용하지 않는 속성은 멤버로서 불필요**할 수 있다.\n",
    "\n",
    "멤버 속성 | 설명\n",
    "-----|-----\n",
    "origin | 생성자에서 만들어지는 속성\n",
    "degreeOfRoast | roast()하고 나면 결정된다. grind()할 때 사용된다. 약배전은 굵게, 강배전은 보다 곱게 간다.\n",
    "grade | 어느 함수에서도 사용되지 않으면 속성에서 제외될 수 있다. \n",
    "\n",
    "### 함수는 void로 만든다.\n",
    "\n",
    "자판기의 기능에 따라 제어기능이 포함될 수 있지만, 간단한 출력으로 대신한다.\n",
    "\n",
    "> 쉬어가기:\n",
    "> **볶기**\n",
    ">\n",
    "> 볶기, 로스팅 roasting, 배전 모두 같은 말이다.\n",
    "> 볶은 정도는 약 (light 또는 Cinnamon), 중 (medium 또는 city), 강 (dark 또는 full city)로 나뉘고 드립커피는 약배전을 굵게 갈아서, 에스프레소는 강배전을 곱게 갈아서 사용한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"141px\" style=\"width:130px;height:141px;\" version=\"1.1\" viewBox=\"0 0 130 141\" width=\"130px\" 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=\"124.8281\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"115\" x=\"6\" y=\"8\"/><ellipse cx=\"25.95\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M28.9188,29.6406 Q28.3406,29.9375 27.7,30.0859 Q27.0594,30.2344 26.3563,30.2344 Q23.8563,30.2344 22.5359,28.5859 Q21.2156,26.9375 21.2156,23.8125 Q21.2156,20.6875 22.5359,19.0313 Q23.8563,17.375 26.3563,17.375 Q27.0594,17.375 27.7078,17.5313 Q28.3563,17.6875 28.9188,17.9844 L28.9188,20.7031 Q28.2938,20.125 27.7,19.8516 Q27.1063,19.5781 26.4813,19.5781 Q25.1375,19.5781 24.45,20.6484 Q23.7625,21.7188 23.7625,23.8125 Q23.7625,25.9063 24.45,26.9766 Q25.1375,28.0469 26.4813,28.0469 Q27.1063,28.0469 27.7,27.7734 Q28.2938,27.5 28.9188,26.9219 L28.9188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"72\" x=\"41.05\" y=\"28.1543\">BrazilCoffee</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"120\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"70\" x=\"12\" y=\"54.2104\">origin:String</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"103\" x=\"12\" y=\"67.0151\">degreeOfRoast:int</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"51\" x=\"12\" y=\"79.8198\">grade:int</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"120\" y1=\"86.4141\" y2=\"86.4141\"/><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=\"65\" x=\"26\" y=\"100.6245\">roast():void</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=\"64\" x=\"26\" y=\"113.4292\">grind():void</text><ellipse cx=\"17\" cy=\"123.9258\" 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=\"63\" x=\"26\" y=\"126.2339\">brew():void</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class BrazilCoffee {\n",
    "    origin:String\n",
    "    degreeOfRoast:int\n",
    "    grade:int\n",
    "    +roast():void\n",
    "    +grind():void\n",
    "    +brew():void\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class BrazilCoffee {\r\n",
      "     String origin;\r\n",
      "     int degreeOfRoast;\r\n",
      "     int grade;\r\n",
      "     BrazilCoffee(String o) {\r\n",
      "         origin=o;\r\n",
      "     }\r\n",
      "     public void roast() {\r\n",
      "         System.out.println(\"roasting...\"+origin);\r\n",
      "     }\r\n",
      "     public void grind() {\r\n",
      "         System.out.println(\"grinding...\"+origin);\r\n",
      "     }\r\n",
      "     public void brew() {\r\n",
      "         System.out.println(\"brewing...\"+origin);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class BrazilCoffee\r\n",
      "|    Update overwrote class BrazilCoffee\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class BrazilCoffee {\n",
    "    String origin;\n",
    "    int degreeOfRoast;\n",
    "    int grade;\n",
    "    BrazilCoffee(String o) {\n",
    "        origin=o;\n",
    "    }\n",
    "    public void roast() {\n",
    "        System.out.println(\"roasting...\"+origin);\n",
    "    }\n",
    "    public void grind() {\n",
    "        System.out.println(\"grinding...\"+origin);\n",
    "    }\n",
    "    public void brew() {\n",
    "        System.out.println(\"brewing...\"+origin);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " BrazilCoffee brazil=new BrazilCoffee(\"Brazil\");\r\n",
      "|  Added variable brazil of type BrazilCoffee with initial value BrazilCoffee@64bfbc86\r\n",
      "\r\n",
      " brazil.roast();\r\n",
      "roasting...Brazil\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "BrazilCoffee brazil=new BrazilCoffee(\"Brazil\");\n",
    "brazil.roast();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2.5 visibility\n",
    "\n",
    "* 캡슐화 encapsulation\n",
    "    * 객체지향에서는 데이터와 함수가 같이 묶여 있다.\n",
    "    * 함수프로그램에서는 이들 데이터, 함수가 분리되어 있다. 함수 안에서는 지역변수, 함수 밖에서는 전역변수가 있다. 전역변수는 누구나 사용할 수 있다.\n",
    "    * 객체지향에서는 클래스 '틀'이 **데이터를 가지고 있고, 사용권한을 제어**한다. 이를 **캡슐화**라고 한다.\n",
    "    * 캡슐화는 **데이터를 직접 사용하지 못하게 하고, 그 권한을 가시성을 통해 제어**한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 가시성의 종류에는 4가지가 있다. 여기서는 public, private을 사용해 본다.\n",
    "    * public field\n",
    "    * private field\n",
    "\n",
    "구분 | UML 표현 | 설명 | class | package | subclass | any class\n",
    "------|------|------|------|------|------|------\n",
    "public | + | 누구나 사용할 수 있다 | Y | Y | Y | Y\n",
    "protected | # | 패밀리, 패키지 | Y | Y | Y | N\n",
    "package private | ~ | 패키지 | Y | Y | N | N\n",
    "private | - | 나 자신만 | Y | N | N | N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* private field는 캡슐화를 잘 보여주고 있다 (public field는 캡슐화의 특징을 보여주는 것이 아니다.)\n",
    "    * 함수를 사용하지 않으면 private field의 값을 볼 수 없다.\n",
    "    * 함수는 값을 설정하는 경우, 값을 조회하는 경우로 구분할 수 있다.\n",
    "        * get필드 (예: float getWeight())\n",
    "        * set필드 (예: void setWeight(float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"103px\" style=\"width:147px;height:103px;\" version=\"1.1\" viewBox=\"0 0 147 103\" width=\"147px\" 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=\"132\" x=\"6\" y=\"8\"/><ellipse cx=\"52.25\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M55.2188,29.6406 Q54.6406,29.9375 54,30.0859 Q53.3594,30.2344 52.6563,30.2344 Q50.1563,30.2344 48.8359,28.5859 Q47.5156,26.9375 47.5156,23.8125 Q47.5156,20.6875 48.8359,19.0313 Q50.1563,17.375 52.6563,17.375 Q53.3594,17.375 54.0078,17.5313 Q54.6563,17.6875 55.2188,17.9844 L55.2188,20.7031 Q54.5938,20.125 54,19.8516 Q53.4063,19.5781 52.7813,19.5781 Q51.4375,19.5781 50.75,20.6484 Q50.0625,21.7188 50.0625,23.8125 Q50.0625,25.9063 50.75,26.9766 Q51.4375,28.0469 52.7813,28.0469 Q53.4063,28.0469 54,27.7734 Q54.5938,27.5 55.2188,26.9219 L55.2188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"31\" x=\"72.75\" y=\"28.1543\">Hello</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"137\" y1=\"40\" y2=\"40\"/><ellipse cx=\"17\" cy=\"51.9023\" 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=\"70\" x=\"26\" y=\"54.2104\">name:String</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"137\" y1=\"60.8047\" y2=\"60.8047\"/><ellipse cx=\"17\" 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=\"106\" x=\"26\" y=\"75.0151\">Hello(name:String)</text><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=\"83\" x=\"26\" y=\"87.8198\">sayHello():void</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Hello {\n",
    "    +name:String\n",
    "    +Hello(name:String)\n",
    "    +sayHello():void\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 필드를 public으로 하면, 누구나 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "     public String name;\r\n",
      "     Hello(String name) {\r\n",
      "         this.name=name;\r\n",
      "     }\r\n",
      "     void sayHello() {\r\n",
      "         System.out.println(\"hello \" + name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Hello\r\n",
      "|    Update replaced variable h, reset to null\r\n",
      "|    Update overwrote class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "    public String name;\n",
    "    Hello(String name) {\n",
    "        this.name=name;\n",
    "    }\n",
    "    void sayHello() {\n",
    "        System.out.println(\"hello \" + name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello(\"world\");\r\n",
      "|  Modified variable h of type Hello with initial value Hello@5f2108b5\r\n",
      "|    Update overwrote variable h\r\n",
      "\r\n",
      " System.out.println(h.name);\r\n",
      "world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello(\"world\");\n",
    "System.out.println(h.name);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* public을 모두 사용한다. 누구나 사용할 수 있다는 의미이다.\n",
    "    * class가 public이란 클래스를 누구나 사용할 수 있다. 나중에 보겠지만, 클래스 파일이름이 클래스 이름과 같아야 한다. jshell에서는 클래스를 public으로 하는 것이 의미가 없다.\n",
    "    * 생성자가 public이란 누구나 객체를 생성할 수 있다.\n",
    "    * 함수가 public이란 누구나 함수를 호출할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " public class Hello {\r\n",
      "     public String name;\r\n",
      "     public Hello(String name) {\r\n",
      "         this.name=name;\r\n",
      "     }\r\n",
      "     public void sayHello() {\r\n",
      "         System.out.println(\"hello \" + name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Warning:\r\n",
      "|  Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|  public class Hello {\r\n",
      "|  ^----^\r\n",
      "|  Added class Hello this error is corrected: \r\n",
      "|      Modifier 'public'  not permitted in top-level declarations, ignored\r\n",
      "|      public class Hello {\r\n",
      "|      ^----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "public class Hello {\n",
    "    public String name;\n",
    "    public Hello(String name) {\n",
    "        this.name=name;\n",
    "    }\n",
    "    public void sayHello() {\n",
    "        System.out.println(\"hello \" + name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello(\"world\");\r\n",
      "|  Modified variable h of type Hello with initial value Hello@3f49dace\r\n",
      "|    Update overwrote variable h\r\n",
      "\r\n",
      " System.out.println(h.name);\r\n",
      "world\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello(\"world\");\n",
    "System.out.println(h.name);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* private을 사용하면, 속성을 사용할 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Hello {\r\n",
      "     private String name;\r\n",
      "     Hello(String name) {\r\n",
      "         this.name=name;\r\n",
      "     }\r\n",
      "     void sayHello() {\r\n",
      "         System.out.println(\"hello \" + name);\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Hello\r\n",
      "|    Update replaced variable h, reset to null\r\n",
      "|    Update overwrote class Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Hello {\n",
    "    private String name;\n",
    "    Hello(String name) {\n",
    "        this.name=name;\n",
    "    }\n",
    "    void sayHello() {\n",
    "        System.out.println(\"hello \" + name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hello h=new Hello(\"world\");\r\n",
      "|  Modified variable h of type Hello with initial value Hello@6adede5\r\n",
      "|    Update overwrote variable h\r\n",
      "\r\n",
      " h.name;\r\n",
      "|  Error:\r\n",
      "|  name has private access in Hello\r\n",
      "|  h.name;\r\n",
      "|  ^----^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Hello h=new Hello(\"world\");\n",
    "h.name;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 2-4: 몸무게를 자신 이외에는 알 수 없도록 구현한다.\n",
    "\n",
    "이 문제에서는 객체지향의 캡슐화를 이해해 보자.\n",
    "\n",
    "### private vs public\n",
    "\n",
    "클래스의 데이터는 아무나 사용할 수 없도록 권한을 제한해야 한다.\n",
    "특히 몸무게는 사적 정보로서 감추고 자신만이 알려줄 수 있다고 하자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### setter, getter\n",
    "\n",
    "속성에 대해 getter, setter를 가진다.\n",
    "\n",
    "구분 | 설명 | 예제\n",
    "-----|-----|-----\n",
    "getter | get+속성, 반환이 있고, 매개변수는 없다. | getWeight():float\n",
    "setter | set+속성, 반환이 없고, 매개변수가 있다. | setWeight(float):void\n",
    "\n",
    "![alt text](figures/2_2_setterGetter.png \"setter getter\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "생성자에 몸무게를 초기화하면 어떨지 생각해 보자.\n",
    "몸무게는 태어날 때 결정되지 않고, 바뀌기 마련이다.\n",
    "이런 데이터는 생성자에 넣는 것이 올바르지 않다.\n",
    "아래 클래스에는 'weight' 외에는 넣지 않았지만, 생년월일은 Person에 필요한 속성이고, 이런 데이터는 생성자에서 초기화하면 적절하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Person {\n",
    "    -weight:float\n",
    "    +setWeight(float):void\n",
    "    +getWeight():float\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Person {\r\n",
      "     private float weight;\r\n",
      "     public void setWeight(float w) {\r\n",
      "         this.weight=w;\r\n",
      "     }\r\n",
      "     public float getWeight() {\r\n",
      "         return weight;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Person\r\n",
      "|    Update overwrote class Person\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private float weight;\n",
    "    public void setWeight(float w) {\n",
    "        this.weight=w;\n",
    "    }\n",
    "    public float getWeight() {\n",
    "        return weight;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* private으로 해 놓았으니 몸무게를 볼 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Person me=new Person();\r\n",
      "|  Modified variable me of type Person with initial value Person@5cb9f472\r\n",
      "|    Update overwrote variable me\r\n",
      "\r\n",
      " me.setWeight((float)60.0);\r\n",
      "\r\n",
      " System.out.println(me.weight)\r\n",
      "|  Error:\r\n",
      "|  weight has private access in Person\r\n",
      "|  System.out.println(me.weight)\r\n",
      "|                     ^-------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Person me=new Person();\n",
    "me.setWeight((float)60.0);\n",
    "System.out.println(me.weight);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 그러나 getWeight()를 사용하면 몸무게를 읽어낼 수 있다.\n",
    "* 어떻게 하면 좋을까? 함수를 private으로 만든다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Person me=new Person();\r\n",
      "|  Modified variable me of type Person with initial value Person@13805618\r\n",
      "|    Update overwrote variable me\r\n",
      "\r\n",
      " me.setWeight((float)60.0);\r\n",
      "\r\n",
      " System.out.println(me.getWeight());\r\n",
      "60.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Person me=new Person();\n",
    "me.setWeight((float)60.0);\n",
    "System.out.println(me.getWeight());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* getWeight()를 private으로 해 놓으면 그 함수를 자신 외에는 누구도 사용할 수 없다.\n",
    "* 즉, 클래스 내부에서만 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Person {\r\n",
      "     private float weight;\r\n",
      "     public void setWeight(float w) {\r\n",
      "         this.weight=w;\r\n",
      "     }\r\n",
      "     private float getWeight() {\r\n",
      "         return weight;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Person\r\n",
      "|    Update replaced variable me, reset to null\r\n",
      "|    Update overwrote class Person\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private float weight;\n",
    "    public void setWeight(float w) {\n",
    "        this.weight=w;\n",
    "    }\n",
    "    private float getWeight() {\n",
    "        return weight;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Person me=new Person();\r\n",
      "|  Modified variable me of type Person with initial value Person@5025a98f\r\n",
      "|    Update overwrote variable me\r\n",
      "\r\n",
      " me.setWeight((float)60.0);\r\n",
      "\r\n",
      " System.out.println(me.getWeight());\r\n",
      "|  Error:\r\n",
      "|  getWeight() has private access in Person\r\n",
      "|  System.out.println(me.getWeight());\r\n",
      "|                     ^----------^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Person me=new Person();\n",
    "me.setWeight((float)60.0);\n",
    "System.out.println(me.getWeight());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/j_1_Person.java\n",
    "public class j_1_Person {\n",
    "    private String name;\n",
    "    private float weight;\n",
    "    public j_1_Person(String name){\n",
    "        this.name=name;\n",
    "    }\n",
    "    public String getName() {\n",
    "        return name;\n",
    "    }\n",
    "    public float getWeight() {\n",
    "        return weight;\n",
    "    }\n",
    "    public void setWeight(float weight) {\n",
    "        this.weight=weight;\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        j_1_Person p=new j_1_Person(\"Kim\");\n",
    "        p.setWeight((float)65.0);\n",
    "        System.out.println(p.getName() + \" \" + p.getWeight() + \"Kg\");\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 2-5: 사각형의 면적을 계산하기, 데이터를 보호하는 방식으로 구현\n",
    "\n",
    "앞서 절차언어는 데이터와 코드가 분리되어 있고, 객체지향언어는 그 두 요소가 묶여 있다고 했다. 그 차이를 비교해 보자.\n",
    "\n",
    "세 가지 버전으로 구현해 보자.\n",
    "* 버전 1: Python으로 면적계산 함수를 구현\n",
    "* 버전 2: 객체지향이지만 부자연스러움, 면적계산에 필요한 너비, 높이를 호출할 때마다 제공함.\n",
    "* 버전 3: 객체지향, 면적계산은 사각형 자신의 너비, 높이를 사용함\n",
    "\n",
    "버전1: 비객체지향 | 버전2: 데이터가 없는 객체지향 | 버전3: 객체지향\n",
    "------|------|------\n",
    "computeArea(width, height)<br>함수 | 단순히 함수를 가진 클래스 | 데이터와 함수를 같이 가지고 있다"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 버전 1: 비객체지향\n",
    "\n",
    "Python으로 함수 computeArea(width, height)를 구현하였다.\n",
    "너비와 높이 데이터는 외부에서 제공하고 있다.\n",
    "잠깐 함수명에 대하여 생각해보자.\n",
    "삼각형을 계산한다면 함수이름을 어떻게 정해야 할까? 동일한 이름은 사용할 수 없다.\n",
    "computeTriangleArea()가 적절하다. 그렇다면 사각형 면적계산은 computeRectangleArea()가 되어야 일관성이 유지된다.\n",
    "함수프로그램에서는 overloading이 되지 않는다.\n",
    "\n",
    "```python\n",
    ">>> def computeArea(width, height):\n",
    "...    return width*height\n",
    "...\n",
    ">>> computeArea(4,3)\n",
    "12\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 버전 2: 데이터가 없는 객체지향\n",
    "\n",
    "자바에서 구현한 버전이다. 버전 1과 비교해서 매개변수가 외부에서 제공되고 있다는 점에서 부자연스럽다.\n",
    "너비, 높이는 사각형 자신의 데이터라는 점을 기억하자. 자신의 데이터를 사용해서 면적계산을 하는 것이 객체지향스럽다.\n",
    "\n",
    "```java\n",
    "-> /set feedback off\n",
    "-> class Rectangle {\n",
    ">>     int computeArea(int width, int height) {\n",
    ">>         return width*height;\n",
    ">>     }\n",
    ">> }\n",
    "-> Rectangle r=new Rectangle();\n",
    "-> System.out.println(r.computeArea(4,3));\n",
    "12\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 버전 3: 객체지향\n",
    "\n",
    "\n",
    "```java\n",
    "-> /set feedback off\n",
    "-> class Rectangle {\n",
    ">>     int width;\n",
    ">>     int height;\n",
    ">>     Rectangle(int w, int h) {\n",
    ">>         width=w;\n",
    ">>         height=h;\n",
    ">>     }\n",
    ">>     int computeArea() {\n",
    ">>         return width*height;\n",
    ">>     }\n",
    ">> }\n",
    "-> Rectangle r=new Rectangle(4,3);\n",
    "-> System.out.println(r.computeArea());\n",
    "12\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 사각형을 화면에 그리려면 클래스가 수정된다.\n",
    "\n",
    "실제 화면에 그림을 그리는 사각형을 만들어 보자.\n",
    "실제 화면에 그리려면 좌표가 필요하다.\n",
    "너비, 높이가 화소 정보로 변경되어야 하는 것이다.\n",
    "여기서의 면적은 화소너비, 화소높이로 계산하면 올바르지 않게 된다.\n",
    "클래스는 **요구사항에 따라 다르게** 만들어 질 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 패키지 설치\n",
    "    * download http://www.aplu.ch/home/download.jsp\n",
    "    * lib/ 라이브러리 디렉토리에 복사\n",
    "       \n",
    "* turtle 사용하기\n",
    "    * classpath는 jar까지 넣어준다.\n",
    "    * 패키지를 import한다.\n",
    "    * 객체 t1을 생성한다.\n",
    "    * 반복문을 사용하여, turtle 4각형 이동하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/turtle/Square.java\n",
    "/*\n",
    " * @author jsl\n",
    " * @since 20160305\n",
    " *\n",
    " * aim: to understand association between shape and turtle\n",
    " *\n",
    " * javac -sourcepath src/ -d classes/ -cp lib/aplu5.jar\n",
    " *   src/com/sd/turtle/Square.java \n",
    " * java -cp ./classes/:./lib/aplu5.jar com.sd.turtle.Square\n",
    " */\n",
    "\n",
    "package com.sd.turtle;\n",
    "import ch.aplu.turtle.*;\n",
    "import java.awt.Color;\n",
    "\n",
    "public class Square {\n",
    "    private double xcoord;\n",
    "    private double ycoord;\n",
    "    private double size;\n",
    "    Turtle pen;\n",
    "    public Square(double x, double y, double s) {\n",
    "        xcoord=x;\n",
    "        ycoord=y;\n",
    "        size=s;\n",
    "        pen = new Turtle();\n",
    "        pen.setColor(Color.red);\n",
    "        pen.setPenColor(Color.green);\n",
    "    }\n",
    "    public void draw() {\n",
    "        pen.penUp();\n",
    "        pen.moveTo(xcoord,ycoord);\n",
    "        pen.penDown();\n",
    "        for (int i = 0; i < 4; i++) {\n",
    "            pen.forward(size);\n",
    "            pen.right(90);\n",
    "        }\n",
    "    }\n",
    "//    public static void main(String[] args) {\n",
    "//        Square s = new Square(0.0, 100.0, 100.0);\n",
    "//        s.draw();\n",
    "//    }\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### main() 함수 넣기\n",
    "\n",
    "JVM을 실행할 경우, 클래스에서 처음 찾는 함수는 main()이다.\n",
    "main() 함수를 넣고, 컴파일 해보자.\n",
    "패키지가 있어서 명령어에 반영한다.\n",
    "\n",
    "\n",
    "```java\n",
    "public class Hello {} {}\n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(\"Hello\");\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "\n",
    "요소 | 설명\n",
    "-----|-----\n",
    "public | 누구나 사용할 수 있다\n",
    "static | 객체를 만들지 않고 사용할 수 있다.\n",
    "void | return이 없다\n",
    "main | 클래스를 실행할 때 처음 찾는 함수\n",
    "(String[] args) | arguments\n",
    "System.out | standard output\n",
    "; | statment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2.6 요약\n",
    "\n",
    "* 클래스는 객체를 만드는 '템플릿'이다.\n",
    "* 클래스는 사용할 수 없고, 객체를 사용한다. 자바파일을 컴파일 하면 '.class'가 생성되어 하드디스크에 파일로 저장된다. 이것이 '클래스'이다. 그리고 프로그램에서 'new' 명령어를 통해 **메모리에 클래스의 객체로 생성**된다. 프로그램에서 사용하는 것은 '객체'이다. 왜 클래스프로그램이 아니라, 객체지향프로그램이라고 할까? 그 대답은 '클래스'가 아니라 '객체'로 프로그래밍한다는 의미이다.\n",
    "* 클래스는 코드와 데이터로 구성한다.\n",
    "* UML은 클래스를 3칸으로 구획하여 클래스명, 멤버속성, 멤버함수를 표현한다.\n",
    "* 클래스는 생성자, constructor를 통해 객체를 만든다. 메모리 할당은 JVM에서 하고 메모리 해제에 필요한 destructor는 필요하지 않다. JVM이 정기적으로 사용하지 않는 메모리를 회수한다, garbage collection.\n",
    "* 객체지향은 데이터를 보호하기 위한 스타일이다. 가시성으로 사용권한을 제어한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2.7 연습문제\n",
    "\n",
    "### 주사위 클래스\n",
    "\n",
    "우리가 사용하는 **주사위**를 클래스로 만들어 보자.\n",
    "주사위는 굴리면 **1 ~ 6 사이의 수**가 나온다.\n",
    "\n",
    "우선 UML 클래스로 그려본다. 명칭, 속성, 함수를 생각해 본다.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "클래스 명 | 'Dice'가 목적에 부합하는 명칭이다. 클래스 첫 글자는 대문자이다.\n",
    "속성 | 주사위에서 나오는 결과는 1부터 6까지의 정수. 'int' 이다.\n",
    "함수 | 주사위를 굴리는 함수 roll(), 매개변수와 반환변수가 없다. 주사위 던진 결과는 속성 number에 저장한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"90px\" style=\"width:119px;height:90px;\" version=\"1.1\" viewBox=\"0 0 119 90\" width=\"119px\" 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=\"104\" x=\"6\" y=\"8\"/><ellipse cx=\"41.25\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M44.2188,29.6406 Q43.6406,29.9375 43,30.0859 Q42.3594,30.2344 41.6563,30.2344 Q39.1563,30.2344 37.8359,28.5859 Q36.5156,26.9375 36.5156,23.8125 Q36.5156,20.6875 37.8359,19.0313 Q39.1563,17.375 41.6563,17.375 Q42.3594,17.375 43.0078,17.5313 Q43.6563,17.6875 44.2188,17.9844 L44.2188,20.7031 Q43.5938,20.125 43,19.8516 Q42.4063,19.5781 41.7813,19.5781 Q40.4375,19.5781 39.75,20.6484 Q39.0625,21.7188 39.0625,23.8125 Q39.0625,25.9063 39.75,26.9766 Q40.4375,28.0469 41.7813,28.0469 Q42.4063,28.0469 43,27.7734 Q43.5938,27.5 44.2188,26.9219 L44.2188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"27\" x=\"59.75\" y=\"28.1543\">Dice</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"109\" y1=\"40\" y2=\"40\"/><rect fill=\"none\" height=\"6\" style=\"stroke: #C82930; stroke-width: 1.0;\" width=\"6\" x=\"14\" y=\"48.9023\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"78\" x=\"26\" y=\"54.2104\">number:int=0</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"109\" y1=\"60.8047\" y2=\"60.8047\"/><ellipse cx=\"17\" 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=\"53\" x=\"26\" y=\"75.0151\">roll():void</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Dice {\n",
    "    -number:int=0\n",
    "    +roll():void\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "UML로 그려진 주사위 클래스를 구현한다.\n",
    "아래는 코드 설명이다.\n",
    "roll() 함수는 '주사위 수'를 무작위로 얻어야 하므로, Math.random()함수를 사용한다.\n",
    "Math.random()은 0.0 and 0.999사이의 수를 '무작위'로 생성한다.\n",
    "Math클래스는 객체를 만들지 않고 바로 사용하고 있다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "2 | 주사위 숫자 number이다. 초기화를 0으로 해 놓는다.\n",
    "4 | Math.random()에서 생성된 수 x: 0.0 $\\le x \\lt$ 1.0는 소수이므로 6을 곱해서 정수, 0 ~ 5로 만든다. 그리고 더하기 1을 한다. x에서 소수점을 제거하고 1을 더해야 주사위 수를 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for(int i=0;i<10;i++) {\n",
    "    double random = Math.random();\n",
    "    System.out.println(random);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 1 ~ 10사이의 수를 '무작위'로 생성하려면 10을 곱해준다.\n",
    "    * 0.0~0.999에 10을 곱하면 0.0 ~ 9.99 사이의 수를 생성한다.\n",
    "    * 10을 포함하려면 1을 더해준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for(int i=0;i<10;i++) {\n",
    "    int random = (int )(Math.random() * 10 + 1);\n",
    "    System.out.println(random);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* java.util.Random 패키지의 nextInt()\n",
    "```java\n",
    "public int nextInt(int n)\n",
    "```\n",
    "    * uniform 분포를 사용하여, 0 (inclusive) ~ n (exclusive)의 값. 1을 더해준다.\n",
    "    * int를 반환하므로, 형변환을 하지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import java.util.Random;\n",
    "Random r = new Random();\n",
    "for(int i=0;i<10;i++) {\n",
    "    int random = r.nextInt(10+1);\n",
    "    System.out.println(random);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dice {\n",
    "    private int number = 0;\n",
    "    public void roll() {   \n",
    "        number = (int) (Math.random() * 6)+1;\n",
    "        System.out.println(\"turns on \" + number);\n",
    "    }   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Dice d=new Dice();\n",
    "for(int i=0; i<10;i++)\n",
    "    d.roll()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "앞서 number가 private으로 선언되었다.\n",
    "그렇다면 주사위를 굴리고 나서, 그 결과는 어떻게 알 수 있을까?\n",
    "\n",
    "roll() 함수를 변경하여 '주사위 수'를 돌려줄 수 있다.\n",
    "\n",
    "```java\n",
    "int roll()\n",
    "```\n",
    "\n",
    "또는 getNumber() 함수를 추가해서 '주사위 수'를 알 수 있다. \n",
    "\n",
    "```java\n",
    "int getNumber()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "다음 출력결과가 나오도록 프로그램을 완성하세요.\n",
    "아직 if문은 배우지 않았으므로 제외해도 됩니다.\n",
    "```python\n",
    "A:4\n",
    "B:3\n",
    "A wins\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/dice/DiceV0Main.java\n",
    "package com.sd.dice;\n",
    "public class DiceV0Main {\n",
    "    private int number = 0;\n",
    "    public void roll() {\n",
    "        number = (int) (Math.random() * 6)+1;\n",
    "        System.out.println(\"turns on \" + number);\n",
    "    }\n",
    "    public int getNumber() {\n",
    "        return number;\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        DiceV0Main d1=new DiceV0Main();\n",
    "        DiceV0Main d2=new DiceV0Main();\n",
    "        d1.roll();\n",
    "        d2.roll();\n",
    "        System.out.println(\"A:\"+d1.getNumber());\n",
    "        System.out.println(\"B:\"+d2.getNumber());\n",
    "        String message;\n",
    "        if (d1.getNumber() > d2.getNumber()) {\n",
    "           message=\"A wins\";\n",
    "        }\n",
    "        else if (d1.getNumber() < d2.getNumber()) {\n",
    "           message=\"B wins\";\n",
    "        }\n",
    "        else\n",
    "           message=\"tie\";\n",
    "        System.out.println(message);\n",
    "    }\n",
    "}"
   ]
  }
 ],
 "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
}