j_4_methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 4. Methods\n",
    "\n",
    "Last updated 20190416TUE1200 20180409MON1222 20180318SUN0708\n",
    "\n",
    "## 4.1 학습내용\n",
    "\n",
    "### 4.1.1 목표\n",
    "\n",
    "멤버함수를 다양하게 구현할 수 있다.\n",
    "반환 값이 있는 함수와 없는 함수를 구현할 수 있다.\n",
    "매개변수로 원시타잎, 객체를 넘겨서 함수를 다르게 구현할 수 있다. 함수를 오버로딩 할 수 있다.\n",
    "\n",
    "* 목차\n",
    "    * 함수구성\n",
    "    * 함수의 signature\n",
    "    * forward reference\n",
    "    * void 함수와 값을 돌려주는 함수\n",
    "    * pass-by-value, pass-by-reference\n",
    "    * 변수의 범위 - 지역 변수\n",
    "    * 오버로딩"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 4.1.2 문제\n",
    "\n",
    "* 문제 4-1: 큰 숫자를 출력하는 함수 시그니처에 맞게 클래스 컴파일\n",
    "```java\n",
    "int larger(int a, int b);\n",
    "```\n",
    "\n",
    "* 문제 4-2: 사용자에게 수를 받아서 별(`*`)을 그 수만큼 반복 출력하는 함수\n",
    "* 문제 4-3: 계산기 두 수를 받아서 더하기, 빼기, 곱하기, 나누기\n",
    "* 문제 4-4: 삼각형 클래스를 만들고, 면적을 계산하기\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4.2 함수 구성\n",
    "\n",
    "### 정의부분 과 구현부분\n",
    "\n",
    "어느 프로그래밍에서나 함수는 입력과 출력을 가진다. **입력에서 출력으로 변환하는 명령문을 묶어** 놓은 것이 함수라고 한다.\n",
    "함수는 **정의부분**과 **구현부분**으로 나뉜다.\n",
    "* 정의부분은 함수의 **헤더, header**라고 하고 **시그니처, Function Signiture**를 가진다.\n",
    "* 구현부분은 함수헤더에서 제공된 매개변수를 사용해서 구현한 부분, 이를 **body**라고 한다. 자바에서는 **괄호 {} 안**에 있는 부분을 말한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![alt text](figures/4_headerBody.png \"Function Header and Body\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 함수의 예 - 숫자 2개를 더하기\n",
    "\n",
    "* header는 `int addTwoNumbers(int a, int b)`\n",
    "* body는 `{ return a+b }`\n",
    "\n",
    "```java\n",
    "int addTwoNumbers(int a, int b) {\n",
    "    return a+b;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "###  함수는 왜 필요할까?\n",
    "\n",
    "함수를 만드는 이유는 재사용이다. \n",
    "필요할 때마다 **새로 작성, rewriting**하는 것이 아니라 **쓰고 또 쓸 수 있게, reuse**하는 것이다.\n",
    "\n",
    "또 **검증**이 함수를 만드는 이유이다. 처음 함수를 만들 때는 테스트하고 검증하는 시간과 노력이 많이 필요하다. 그러나 일단 만들어지고 나서는 튼튼한 함수가 되어 믿고 사용할 수 있게 된다.\n",
    "\n",
    "일련의 코드가 자꾸 반복된다. 같은 프로그램뿐만 아니라, 다른 프로그램에서도 이런 현상이 있다면, 함수를 만들자.\n",
    "함수를 만들고 나면, **코드 중복, Duplicate Code**이 줄어들고 이로 인해 프로그램이 수정노력이 훨씬 줄어들게 된다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 함수의 중복코드 예\n",
    "\n",
    "아직 배우지는 않았지만, 배열을 합계내는 경우를 생각해 보자.\n",
    "arr1, arr2는 데이터가 서로 다르다. **합계를 계산하는 코드가 중복**되어 있다.\n",
    "배열이 많아질수록 코드 중복은 늘어나게 되어있다.\n",
    "**배열의 크기를 구하는 요령, 'arr.lenght'**을 이용하면 함수로 만들어 코드 중복을 줄일 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " /set feedback off\r\n"
     ]
    }
   ],
   "source": [
    "/set feedback off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] arr1={1,2,3,4}\r\n",
      " int sum1=0;\r\n",
      " for(int i=0;i<4;i++)\r\n",
      "     sum1+=arr1[i]\r\n",
      " \r\n",
      " System.out.println(sum1);\r\n",
      "10\r\n"
     ]
    }
   ],
   "source": [
    "int[] arr1={1,2,3,4}\n",
    "int sum1=0;\n",
    "for(int i=0;i<4;i++)\n",
    "    sum1+=arr1[i]\n",
    "\n",
    "System.out.println(sum1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "비슷한 기능이 있는 경우, 상당히 많은 **중복**이 보인다.\n",
    "중복이 발생하는 패턴을 살펴보면:\n",
    "* 입력데이터를 정의하는 코드\n",
    "* 입력데이터를 합계를 계산하는 코드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] arr2={1,2,3,4,5,6}\r\n",
      " int sum2=0\r\n",
      " for(int i=0;i<6;i++)\r\n",
      "     sum2+=arr2[i]\r\n",
      " System.out.println(sum2);\r\n",
      "21\r\n"
     ]
    }
   ],
   "source": [
    "int[] arr2={1,2,3,4,5,6}\n",
    "int sum2=0\n",
    "for(int i=0;i<6;i++)\n",
    "    sum2+=arr2[i]\n",
    "System.out.println(sum2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "함수 sumOfArray()를 만들어 중복을 제거하였다.\n",
    "**합계를 계산하는 코드를 함수로** 만들어 보자.\n",
    "배열 데이터가 서로 다르고, 그 크기도 다른 경우 함수로 구현하려면 매개변수를 이용한다.\n",
    "배열의 크기를 **arr.length**로 알아내어 크기가 다른 경우에도 계산할 수 있게 하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int sumOfArray(int[] arr) {\r\n",
      "     int sum=0;\r\n",
      "     for(int i=0;i<arr.length;i++)\r\n",
      "         sum+=arr[i];\r\n",
      "     return sum;\r\n",
      " }\r\n"
     ]
    }
   ],
   "source": [
    "int sumOfArray(int[] arr) {\n",
    "    int sum=0;\n",
    "    for(int i=0;i<arr.length;i++)\n",
    "        sum+=arr[i];\n",
    "    return sum;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int[] arr1={1,2,3,4}\r\n",
      " int[] arr2={1,2,3,4,5,6}\r\n",
      " \r\n",
      " int fsum1=sumOfArray(arr1);\r\n",
      " int fsum2=sumOfArray(arr2);\r\n",
      " \r\n",
      " System.out.println(fsum1);\r\n",
      "10\r\n",
      " System.out.println(fsum2);\r\n",
      "21\r\n"
     ]
    }
   ],
   "source": [
    "int[] arr1={1,2,3,4}\n",
    "int[] arr2={1,2,3,4,5,6}\n",
    "\n",
    "int fsum1=sumOfArray(arr1);\n",
    "int fsum2=sumOfArray(arr2);\n",
    "\n",
    "System.out.println(fsum1);\n",
    "System.out.println(fsum2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.3 시그니처\n",
    "\n",
    "### 구성\n",
    "\n",
    "시그니처는 **함수명, 매개변수, 반환타잎**을 말한다. 함수 이름을 짓고, 필요한 변수를 정확하게 적어야 한다.\n",
    "\n",
    "```java\n",
    "수식어 반환타잎 함수명(매개변수, ...)\n",
    "```\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "함수명 | 목적을 포함하도록 의미있게, 동사+명사의 형식으로, camel case로 짓는다.\n",
    "반환타잎 | return명령어로 함수 밖으로 돌려주는 데이터타잎\n",
    "매개변수,... | 데이터타잎과 변수명과 함께 목록을 적는다.\n",
    "수식어 | 가시성, static, final 등을 사용할 수 있다.\n",
    "\n",
    "> 매개변수와 전달인자\n",
    ">\n",
    "> 한글로 인자는 모호하게 쓰이는 경우가 많다.\n",
    "> 영어로 **parameter는 매개변수**, **argument는 전달인자**를 의미하기로 한다.\n",
    "> 매개변수는 정의부분에 나열된 변수를 말한다. 데이터타잎과 함께 적는다.\n",
    "> 전달인자는 함수를 호출할 때의 실제 값을 말한다.\n",
    "> 두 수를 더하는 함수 addTwoNumbers(int a, int b)를 예로 설명하면, a, b는 매개변수\n",
    "> add(1,2)의 1,2는 전달인자이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 시그니처가 같아야 할까?\n",
    "\n",
    "시그니처가 서로 같지 않으면 다른 함수로 인식한다. 즉 함수를 호출할 때 동일한 시그니처를 가졌는지 보고 호출한다.\n",
    "그러나 객체지향에서는 함수명 또는 시그니처가 같아도 되는 경우가 있다. 뒤에 오버로딩, 오버라이딩에 대해 설명한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 시그니처 예\n",
    "\n",
    "위에서 예로 들었던 함수로 설명해보자. 매개변수가 원시타잎, 배열 등이 될 수 있다.\n",
    "\n",
    "함수명 | addTwoNumbers | sumOfArray\n",
    "-----|-----|-----\n",
    "매개변수 | int a, int b | int[]\n",
    "반환타잎 | int | int\n",
    "전달인자 | 1,2 | int[] a={1,2,3}과 같이 배열 값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int addTwoNumbers(int a, int b) {\r\n",
      "     return a+b;\r\n",
      " }\r\n",
      "|  Added method addTwoNumbers(int,int)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int addTwoNumbers(int a, int b) {\n",
    "    return a+b;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.println(addTwoNumbers(1,2));\r\n",
      "3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.println(addTwoNumbers(1,2));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "왜 변수를 함수의 argument로 넣을까?\n",
    "함수에 변수를 넘기지 않으면, 변수를 함수 내에 써야 하는데, 이를 **'하드 코딩' hard coding**이라고 한다.\n",
    "이런 경우 함수의 **재사용성**이 매우 제한된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "void myprint() {\n",
    "    System.out.println(1);\n",
    "}\n",
    "myprint();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "void myprint(int i) {\n",
    "    System.out.println(i);\n",
    "}\n",
    "myprint(1);\n",
    "myprint(2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### forward reference\n",
    "\n",
    "아직 정의되지 않은 함수를 호출하는 것을 forward reference라고 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void sayHello() {\r\n",
      "     String hello=\"Hello\";\r\n",
      "     System.out.println(hello);\r\n",
      " }\r\n",
      "|  Modified method sayHello()\r\n",
      "|    Update overwrote method sayHello()\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void sayHello() {\n",
    "    String hello=\"Hello\";\n",
    "    System.out.println(hello);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " sayHello()\r\n",
      "Hello\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "sayHello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void sayHelloA() {\r\n",
      "     String hello=\"Hello\";\r\n",
      "     System.out.println(hello);\r\n",
      "     printA();\r\n",
      " }\r\n",
      "|  Modified method sayHelloA()\r\n",
      "|    Update overwrote method sayHelloA()\r\n",
      "\r\n",
      " void printA() {\r\n",
      "     System.out.println(\"A\");\r\n",
      " }\r\n",
      "|  Modified method printA()\r\n",
      "|    Update overwrote method printA()\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void sayHelloA() {\n",
    "    String hello=\"Hello\";\n",
    "    System.out.println(hello);\n",
    "    printA();   //forward reference to printA()\n",
    "}\n",
    "void printA() {\n",
    "    System.out.println(\"A\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " sayHelloA();\r\n",
      "Hello\r\n",
      "A\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "sayHelloA();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4.4 값의 반환\n",
    "\n",
    "함수는 값을 돌려주는지에 따라 구분할 수 있다.\n",
    "앞서 roll() 함수를 두 버전을 모두 구현해 보자.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "void 함수 | 정상적으로 완료되고, 반환 값을 돌려주지 않는 함수\n",
    "값을 돌려 주는 함수 | 처리결과를 return으로 반환하는 함수\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "void 함수로 구현하고, 결과는 화면으로 출력하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void roll() {   \r\n",
      "     int number = (int) (Math.random() * 6)+1;\r\n",
      "     System.out.println(\"turns on \" + number);\r\n",
      " }\r\n",
      "|  Modified method roll()\r\n",
      "|    Update overwrote method roll()\r\n",
      "\r\n",
      " roll();\r\n",
      "turns on 3\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void roll() {   \n",
    "    int number = (int) (Math.random() * 6)+1;\n",
    "    System.out.println(\"turns on \" + number);\n",
    "}\n",
    "roll();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "반환 함수로 구현하고, 그 값을 함수가 완료된 후 받아서 출력하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " int roll() {   \r\n",
      "     int number = (int) (Math.random() * 6)+1;\r\n",
      "     return number;\r\n",
      " }\r\n",
      "|  Replaced method roll()\r\n",
      "|    Update overwrote method roll()\r\n",
      "\r\n",
      " int diceNum=roll();\r\n",
      "|  Added variable diceNum of type int with initial value 4\r\n",
      "\r\n",
      " System.out.println(\"turns on \" + diceNum);\r\n",
      "turns on 4\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "int roll() {   \n",
    "    int number = (int) (Math.random() * 6)+1;\n",
    "    return number;\n",
    "}\n",
    "int diceNum=roll();\n",
    "System.out.println(\"turns on \" + diceNum);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 문제 4-1: 큰 숫자를 출력하는 함수를 구현하기\n",
    "\n",
    "함수를 어떻게 만드는지 입출력을 설계하고 구현한다.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----|\n",
    "입력 | 소수 x, 소수 y\n",
    "출력 | 비교 결과\n",
    "\n",
    "* 비교결과에 대한 설계\n",
    "    * 비교 결과는 큰 수를 선택하거나\n",
    "    * 비교의 차이"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 버전 1: 반환이 없는 경우\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----|\n",
    "입력 | 소수 x, 소수 y\n",
    "출력 | 반환이 없고, 큰 수를 화면에 출력\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void larger(float x, float y) {\r\n",
      "     if(x>=y)\r\n",
      "         System.out.println(x);\r\n",
      "     else\r\n",
      "         System.out.println(y);\r\n",
      " }\r\n",
      "|  Added method larger(float,float)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void larger(float x, float y) {\n",
    "    if(x>=y)\n",
    "        System.out.println(x);\n",
    "    else\n",
    "        System.out.println(y);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "함수를 호출하면. 결과는 int가 아닌 float 4.0로 출력된다.\n",
    "함수 인자 3과 4는 int이다. 그러나 함수 인자의 형인 float로 자동 변환이 일어나고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " larger(3,4);\r\n",
      "4.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "larger(3,4);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 버전 2: 반환 값이 있는 경우\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----|\n",
    "입력 | 소수 x, 소수 y\n",
    "출력 | 큰 수를 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " float larger(float x, float y) {\r\n",
      "     if(x>=y)\r\n",
      "         return x;\r\n",
      "     else\r\n",
      "         return y;\r\n",
      " }\r\n",
      "|  Added method larger(float,float)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "float larger(float x, float y) {\n",
    "    if(x>=y)\n",
    "        return x;\n",
    "    else\n",
    "        return y;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " float result=larger(10,20);\r\n",
      "|  Added variable result of type float with initial value 20.0\r\n",
      "\r\n",
      " System.out.println(result);\r\n",
      "20.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "float result=larger(10,20);\n",
    "System.out.println(result);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 버전 3: 구조적 함수\n",
    "\n",
    "함수는 **single entry single exit**, 입력과 출력이 하나가 되도록 하는 것이 좋다.\n",
    "위 함수는 출력, 즉 return이 두 번 쓰여서 함수를 도중에 떠날 수 있게 되었다.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----|\n",
    "입력 | 소수 x, 소수 y\n",
    "출력 | 큰 수를 반환\n",
    "\n",
    "> 알아두기\n",
    "> **Spaghetti code**\n",
    "> \n",
    "> **GOTO문**을 많이 사용해서 소스코드가 마치 스파게티처럼 엉켜있는 모습을 빗대어 **이해하기 어려운 코드**를 의미하는 용어이다.\n",
    "> 함수를 완성하고 끝내는 출구를 하나만 가지도록 하면 Spagetti를 막아줄 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 구조적 함수\n",
    "    * 흐름을 중간에 끝내지 않는 것이 좋다. 반환은 한 번만 한다.\n",
    "    * break, continue, goto 이런 명령어는 명령문 실행순서를 뒤바꾸게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " float larger(float x, float y) {\r\n",
      "     float larger;\r\n",
      "     if(x>=y)\r\n",
      "         larger=x;\r\n",
      "     else\r\n",
      "         larger=y;\r\n",
      "     return larger;\r\n",
      " }\r\n",
      "|  Modified method larger(float,float)\r\n",
      "|    Update overwrote method larger(float,float)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "float larger(float x, float y) {\n",
    "    float larger;\n",
    "    if(x>=y)\n",
    "        larger=x;\n",
    "    else\n",
    "        larger=y;\n",
    "    return larger;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 버전 4 객체지향 방식\n",
    "\n",
    "비교할 경우 자바 API를 사용하자. compareTo() 함수를 사용한다.\n",
    "\n",
    "compareTo() 결과 | 설명\n",
    "-----|-----\n",
    "+1 | 큰 경우\n",
    "0 | 같은 경우\n",
    "-1 | 적은 경우\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " float x=4;\r\n",
      "|  Modified variable x of type float with initial value 4.0\r\n",
      "|    Update overwrote variable x\r\n",
      "\r\n",
      " float y=5;\r\n",
      "|  Modified variable y of type float with initial value 5.0\r\n",
      "|    Update overwrote variable y\r\n",
      "\r\n",
      " Float xobj=new Float(x);\r\n",
      "|  Modified variable xobj of type Float with initial value 4.0\r\n",
      "|    Update overwrote variable xobj\r\n",
      "\r\n",
      " Float yobj=new Float(y);\r\n",
      "|  Modified variable yobj of type Float with initial value 5.0\r\n",
      "|    Update overwrote variable yobj\r\n",
      "\r\n",
      " int cmp=xobj.compareTo(yobj);\r\n",
      "|  Modified variable cmp of type int with initial value -1\r\n",
      "|    Update overwrote variable cmp\r\n",
      "\r\n",
      " if(cmp > 0) {\r\n",
      "     System.out.printf(\"%f is greater than %f\",x,y);\r\n",
      " } else if(cmp < 0) {\r\n",
      "     System.out.printf(\"%f is less than %f\",x,y);\r\n",
      " } else {\r\n",
      "     System.out.printf(\"%f is eqaul to %f\",x,y);\r\n",
      " }\r\n",
      "4.000000 is less than 5.000000\r\n"
     ]
    }
   ],
   "source": [
    "float x=4;\n",
    "float y=5;\n",
    "Float xobj=new Float(x);\n",
    "Float yobj=new Float(y);\n",
    "int cmp=xobj.compareTo(yobj);\n",
    "if(cmp > 0) {\n",
    "    System.out.printf(\"%f is greater than %f\",x,y);\n",
    "} else if(cmp < 0) {\n",
    "    System.out.printf(\"%f is less than %f\",x,y);\n",
    "} else {\n",
    "    System.out.printf(\"%f is eqaul to %f\",x,y);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "참고로 문자열에 대해서도 compareTo()를 사용할 수 있다.\n",
    "* 문자열이 같으면 0\n",
    "* 순서가 빠르면 양수\n",
    "* 느리면 음수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \"a\".compareTo(\"a\");\r\n",
      "|  Expression value is: 0\r\n",
      "|    assigned to temporary variable $1 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "\"a\".compareTo(\"a\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \"abc\".compareTo(\"abb\");\r\n",
      "|  Expression value is: 1\r\n",
      "|    assigned to temporary variable $2 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "\"abc\".compareTo(\"abb\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \"abc\".compareTo(\"abd\");\r\n",
      "|  Expression value is: -1\r\n",
      "|    assigned to temporary variable $3 of type int\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "\"abc\".compareTo(\"abd\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "사용자에게 두 수를 입력받아서 큰 수를 출력하는 클래스로 만들어 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# %load src/j_4_1_FloatMain.java\n",
    "import java.util.Scanner;\n",
    "\n",
    "public class j_4_1_FloatMain {\n",
    "    static void larger(float x, float y) {\n",
    "        Float xobj=new Float(x);\n",
    "        Float yobj=new Float(y);\n",
    "        int cmp=xobj.compareTo(yobj);\n",
    "        if(cmp > 0) {\n",
    "            System.out.printf(\"%f is greater than %f\",x,y);\n",
    "        } else if(cmp < 0) {\n",
    "            System.out.printf(\"%f is less than %f\",x,y);\n",
    "        } else {\n",
    "            System.out.printf(\"%f is eqaul to %f\",x,y);\n",
    "        }\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        System.out.print(\"Enter two decimal numbers: \");\n",
    "        Scanner sc = new Scanner(System.in);\n",
    "        float f1=sc.nextFloat();\n",
    "        float f2=sc.nextFloat();\n",
    "        larger(f1,f2);\n",
    "    }\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 4-2: 사용자에게 수를 받아서 별(`*`)을 그 수만큼 반복 출력하는 함수\n",
    "\n",
    "사용자에게 **반복문자**와 **반복횟수**를 입력받아, **문자열을 생성**하는 문제이다.\n",
    "* **String은 문자배열**이므로 크기를 늘릴 수 없다. 따라서 **StringBuffer**를 사용한다.\n",
    "\n",
    "구분 | 변수\n",
    "-----|-----\n",
    "입력 | 반복문자, 반복횟수\n",
    "출력 | 반복문자열\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/j_4_2_StringRepeatMain.java\n",
    "import java.util.Scanner;\n",
    "\n",
    "public class j_4_2_StringRepeatMain {\n",
    "    static StringBuffer repeat(char ch, int times) {\n",
    "        StringBuffer s=new StringBuffer();\n",
    "        for(int i=0;i<times;i++)\n",
    "            s.append(ch);\n",
    "        return s;\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        System.out.print(\"Enter a number to print asterisks *: \");\n",
    "        Scanner sc = new Scanner(System.in);\n",
    "        int n=sc.nextInt();\n",
    "        System.out.printf(\"%s\\n\",repeat('*',n));\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 4-3: 계산기 두 수를 받아서 더하기, 빼기, 곱하기, 나누기\n",
    "\n",
    "**기본적인 계산기** 기능을 구현한다.\n",
    "사용자에게 **두 수와 연산자를 입력받아, 연산결과를 출력하는 문제이다.\n",
    "\n",
    "구분 | 변수\n",
    "-----|-----\n",
    "입력 | 소수 2, 연산자\n",
    "출력 | 연산결과\n",
    "\n",
    "간단한 연산이라서 함수를 구현할 필요가 적지만, 아래 문제에 **plus, minus, multiply, divide** 함수를 설계해서 넣어 본다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/calc/v0/CalculatorMainV0.java\n",
    "/*\n",
    " *\n",
    "import java.util.Scanner;\n",
    "canner sc=new Scanner(System.in)\n",
    "> sc.nextInt()\n",
    "[DrJava Input Box]\n",
    "10\n",
    "> sc.nextDouble()\n",
    "[DrJava Input Box]\n",
    "10.0\n",
    "> sc.next()\n",
    "[DrJava Input Box]\n",
    "\"10\"\n",
    " */\n",
    "package com.sd.calc.v0;\n",
    "\n",
    "import java.util.Scanner;\n",
    "\n",
    "public class CalculatorMainV0 {\n",
    "    public static void main(String[] args) {\n",
    "        double res=0.0;\n",
    "        try {\n",
    "            Scanner sc = new Scanner(System.in);\n",
    "            System.out.print(\"Enter a number: \");\n",
    "            double n1 = sc.nextDouble();\n",
    "            System.out.print(\"Enter an operation: \");\n",
    "            String operation = sc.next();\n",
    "            System.out.print(\"Enter another number: \");\n",
    "            double n2 = sc.nextDouble();\n",
    "            //String operation = (new BufferedReader(new InputStreamReader(System.in))).readLine();\n",
    "            System.out.printf(\"%.2f %s %.2f = \",n1,operation,n2);\n",
    "            if(operation.equals(\"+\"))\n",
    "                res=n1+n2;\n",
    "            else if(operation.equals(\"-\"))\n",
    "                res=n1-n2;\n",
    "            else if(operation.equals(\"*\"))\n",
    "                res=n1*n2;\n",
    "            else if(operation.equals(\"/\"))\n",
    "                res=n1/n2;\n",
    "            else\n",
    "                System.out.println(\"Operation not supported\");\n",
    "            System.out.printf(\"%.2f\\n\", res);\n",
    "        } catch (Exception e) {\n",
    "        }\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4.5  값과 객체를 함수에 넘겨주기\n",
    "\n",
    "함수는 괄호 () 안에 **매개변수**를 가진다.\n",
    "꼭 매개변수를 가지지 않아도 된다. 이런 경우 괄호를 비워 놓는다.\n",
    "매개변수는 몇 개를 가져도 좋다. 그러나 최소화하는 것이 좋다.\n",
    "매개변수는 원시타잎 또는 클래스를 가질 수 있다.\n",
    "\n",
    "* 문자를 넘겨 받아서 이름 출력하기\n",
    "* 객체를 넘겨 받아서 이름 출력하기\n",
    "\n",
    "> 결합성\n",
    ">\n",
    "> 함수의 매개변수가 많을수록 결합성이 증가한다.\n",
    "> 결합성은 최소화하는 것이 좋다\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**String 객체를 매개변수**로 넘겨받아서 출력하는 함수를 만들어 보자.\n",
    "원시타잎이 아니라 객체를 넘겨본다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void tellUsYourName(String name) {\r\n",
      "     System.out.println(\"Hi, my name is \" + name);\r\n",
      " }\r\n",
      "|  Added method tellUsYourName(String)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void tellUsYourName(String name) {\n",
    "    System.out.println(\"Hi, my name is \" + name);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " String myName=\"js\";\r\n",
      "|  Added variable myName of type String with initial value \"js\"\r\n",
      "\r\n",
      " tellUsYourName(myName);\r\n",
      "Hi, my name is js\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "String myName=\"js\";\n",
    "tellUsYourName(myName);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**우리가 만든 객체 Person**를 넘겨 받아서 이름 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Person {\r\n",
      "     private String name;\r\n",
      "     Person(String _name) {\r\n",
      "         this.name=_name;\r\n",
      "     }\r\n",
      "     String getName() {\r\n",
      "         return name;\r\n",
      "     }\r\n",
      "     void setName(String anotherName) {\r\n",
      "         name=anotherName;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Person\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Person {\n",
    "    private String name;\n",
    "    Person(String _name) {\n",
    "        this.name=_name;\n",
    "    }\n",
    "    String getName() {\n",
    "        return name;\n",
    "    }\n",
    "    void setName(String anotherName) {\n",
    "        name=anotherName;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void tellUsPersonName(Person p) {\r\n",
      "     System.out.println(\"Hi, my name is \" + p.getName());\r\n",
      " }\r\n",
      "|  Modified method tellUsPersonName(Person)\r\n",
      "|    Update overwrote method tellUsPersonName(Person)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void tellUsPersonName(Person p) {\n",
    "    System.out.println(\"Hi, my name is \" + p.getName());\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Person p=new Person(\"js\");\r\n",
      "|  Modified variable p of type Person with initial value Person@5649fd9b\r\n",
      "|    Update overwrote variable p\r\n",
      "\r\n",
      " tellUsPersonName(p);\r\n",
      "Hi, my name is js\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Person p=new Person(\"js\");\n",
    "tellUsPersonName(p);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### CALL BY VALUE\n",
    "\n",
    "함수에 변수를 값으로, by value, 전달할 때, **복사본이 전달**되어 함수에서 변수의 값을 변경한다 하더라도 그 범위는 함수 지역에 국한된다.\n",
    "**원래의 변수는 변경되지 않고 보존**된다.\n",
    "원시타잎은 값만 저장하므로, 그 값이 전달된다.\n",
    "단 클래스 또는 배열은 참조 타잎, reference type이라 **참조 값**, 영어로 표현하면 조금 더 명확할 수 있는데 **the value of the reference**이 전달된다. reference란 앞서 설명한 것처럼 실제 값이 저장되어 있는 메모리 영역을 가리키는 주소 값이다. 마찬가지로 복사본이 전달된다.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "원시타잎 | 실제 **값**이 전달된다.\n",
    "클래스 또는 배열 | **참조의 값, 즉 value of the reference to the object**이 전달된다. 자바에서 객체는 reference로 사용하지만, 함수에는 그 참조 값value of reference가 전달된다. 보통 다른 언어에서 구현하는 swap()은 가능하지 않다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 원시타잎 call by value\n",
    "\n",
    "원시타잎 int은 **실제 값**이 전달된다. a=1이 전달되어 함수 내에서 123으로 변경하지만, 그 **범위는 함수 지역에 국한**된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void changeVar(int a) {\r\n",
      "     a=123;\r\n",
      " }\r\n",
      "|  Modified method changeVar(int)\r\n",
      "|    Update overwrote method changeVar(int)\r\n",
      "\r\n",
      " int a=1;\r\n",
      "|  Modified variable a of type int with initial value 1\r\n",
      "|    Update overwrote variable a\r\n",
      "\r\n",
      " changeVar(a);\r\n",
      "\r\n",
      " System.out.printf(\"After calling changeVar: %d\",a);\r\n",
      "After calling changeVar: 1|  Expression value is: java.io.PrintStream@6e06451e\r\n",
      "|    assigned to temporary variable $11 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void changeVar(int a) {\n",
    "    a=123;\n",
    "}\n",
    "int a=1;\n",
    "changeVar(a);\n",
    "System.out.printf(\"After calling changeVar: %d\",a);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### 객체의 pass by value\n",
    "\n",
    "클래스 Integer a=1는 참조 값 (HashCode Before: 1501587365)\n",
    "함수내에서는 a=123을 하면 객체가 새로 생성되고, **새로운 참조 값 (HashCode After: 1596000437)이 할당**된다.\n",
    "따라서 **123으로 값을 변경해도 그 범위는 함수지역에 국한**된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "![alt text](figures/4_1_callByValue.png \"Call by value\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void changeVar(Integer a) {\r\n",
      "     System.out.println(\"*** HashCode Before: \"+System.identityHashCode(a));\r\n",
      "     a=123;\r\n",
      "     System.out.println(\"*** HashCode after: \"+System.identityHashCode(a));\r\n",
      " }\r\n",
      "|  Added method changeVar(Integer)\r\n",
      "\r\n",
      " Integer i=1;\r\n",
      "|  Added variable i of type Integer with initial value 1\r\n",
      "\r\n",
      " changeVar(i);\r\n",
      "*** HashCode Before: 1501587365\r\n",
      "*** HashCode after: 1596000437\r\n",
      "\r\n",
      " System.out.printf(\"After calling changeVar: %d\",i);\r\n",
      "After calling changeVar: 1|  Expression value is: java.io.PrintStream@5cb9f472\r\n",
      "|    assigned to temporary variable $4 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void changeVar(Integer a) {\n",
    "    System.out.println(\"*** HashCode Before: \"+System.identityHashCode(a));\n",
    "    a=123;\n",
    "    System.out.println(\"*** HashCode after: \"+System.identityHashCode(a));\n",
    "}\n",
    "Integer i=1;\n",
    "changeVar(i);\n",
    "System.out.printf(\"After calling changeVar: %d\",i);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**배열** 역시 복사본이 전달되고, 그 참조 값이 가리키는 실제 값을 함수에서 변경하게 되므로 그 효과가 함수 밖에서도 지속된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void changeArr(Integer[] n, int i) {\r\n",
      "     n[0]=i;                       //첫 요소를 입력 값으로 변경\r\n",
      " }\r\n",
      "|  Modified method changeArr(Integer[],int)\r\n",
      "|    Update overwrote method changeArr(Integer[],int)\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " Integer[] x={1,2,3,4,5};\r\n",
      "|  Modified variable x of type Integer[] with initial value [Ljava.lang.Integer;@6fd02e5\r\n",
      "|    Update overwrote variable x\r\n",
      "\r\n",
      " changeArr(x,1111);                //첫 요소를 1111로 변경\r\n",
      "\r\n",
      " for(Integer i:x)\r\n",
      "     System.out.printf(\"%d..\",i);  //함수 밖에서도 변경된 데이터 유지\r\n",
      "1111..2..3..4..5..\r\n"
     ]
    }
   ],
   "source": [
    "void changeArr(Integer[] n, int i) {\n",
    "    n[0]=i;                       //첫 요소를 입력 값으로 변경\n",
    "}\n",
    "\n",
    "Integer[] x={1,2,3,4,5};\n",
    "changeArr(x,1111);                //첫 요소를 1111로 변경\n",
    "for(Integer i:x)\n",
    "    System.out.printf(\"%d..\",i);  //함수 밖에서도 변경된 데이터 유지"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* swap은 안된다.\n",
    "\n",
    "swap()함수는 Point p1, p2의 서로 바꾸려고 한다.\n",
    "그러나 call by value이므로 값의 변경이 국지적이다.\n",
    "swap()함수의 효과가 함수 밖에서도 유지되려면 **원래 참조reference를 사용하여 변경**을 해야 한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " import java.awt.Point;\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " void swap(Point p1, Point p2) {\r\n",
      "     Point temp = p1;\r\n",
      "     p1 = p2;\r\n",
      "     p2 = temp;\r\n",
      "     System.out.printf(\"IN SWAP: p1 %s, p2 %s\", p1.toString(), p2.toString()); \r",
      "\r\n",
      " }\r\n",
      "|  Modified method swap(Point,Point)\r\n",
      "|    Update overwrote method swap(Point,Point)\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "import java.awt.Point;\n",
    "\n",
    "void swap(Point p1, Point p2) {\n",
    "    Point temp = p1;\n",
    "    p1 = p2;\n",
    "    p2 = temp;\n",
    "    System.out.printf(\"IN SWAP: p1 %s, p2 %s\", p1.toString(), p2.toString());\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Point p1=new Point(10,20);\r\n",
      "|  Modified variable p1 of type Point with initial value java.awt.Point[x=10,y=20]\r\n",
      "|    Update overwrote variable p1\r\n",
      "\r\n",
      " Point p2=new Point(30,40);\r\n",
      "|  Modified variable p2 of type Point with initial value java.awt.Point[x=30,y=40]\r\n",
      "|    Update overwrote variable p2\r\n",
      "\r\n",
      " System.out.printf(\"BEFORE swapping: p1:%s p2:%s\", p1.toString(), p2.toString( \r",
      "));\r\n",
      "BEFORE swapping: p1:java.awt.Point[x=10,y=20] p2:java.awt.Point[x=30,y=40]|  Expression value is: java.io.PrintStream@6e1567f1\r\n",
      "|    assigned to temporary variable $19 of type PrintStream\r\n",
      "\r\n",
      " swap(p1,p2);\r\n",
      "IN SWAP: p1 java.awt.Point[x=30,y=40], p2 java.awt.Point[x=10,y=20]\r\n",
      " System.out.printf(\"AFTER swapping: p1:%s p2:%s\", p1.toString(), p2.toString() \r",
      ");\r\n",
      "AFTER swapping: p1:java.awt.Point[x=10,y=20] p2:java.awt.Point[x=30,y=40]|  Expression value is: java.io.PrintStream@6e1567f1\r\n",
      "|    assigned to temporary variable $21 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Point p1=new Point(10,20);\n",
    "Point p2=new Point(30,40);\n",
    "System.out.printf(\"BEFORE swapping: p1:%s p2:%s\", p1.toString(), p2.toString());\n",
    "swap(p1,p2);\n",
    "System.out.printf(\"AFTER swapping: p1:%s p2:%s\", p1.toString(), p2.toString());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Person의 setName()함수를 사용하면 이름을 변경할 수 있다.\n",
    "p의 hashCode가 넘겨졌고, **동일한 객체의 setName()을 사용하였으므로 함수 밖에서도 그 값은 유효**하다.\n",
    "HashCode Before: 985397764와 HashCode after: 985397764가 동일하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void changeVar(Person p) {\r\n",
      "     System.out.println(\"*** HashCode Before: \"+System.identityHashCode(p));\r\n",
      "     p.setName(\"local js\");\r\n",
      "     System.out.println(\"*** HashCode after: \"+System.identityHashCode(p));\r\n",
      " }\r\n",
      "|  Added method changeVar(Person)\r\n",
      "\r\n",
      " Person p=new Person(\"js\");\r\n",
      "|  Added variable p of type Person with initial value Person@3abbfa04\r\n",
      "|    Update modified method changeVar(Person)\r\n",
      "\r\n",
      " changeVar(p);\r\n",
      "*** HashCode Before: 985397764\r\n",
      "*** HashCode after: 985397764\r\n",
      "\r\n",
      " System.out.printf(\"After calling changeVar: %s\",p.getName());\r\n",
      "After calling changeVar: local js|  Expression value is: java.io.PrintStream@56ef9176\r\n",
      "|    assigned to temporary variable $5 of type PrintStream\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void changeVar(Person p) {\n",
    "    System.out.println(\"*** HashCode Before: \"+System.identityHashCode(p));\n",
    "    p.setName(\"local js\");\n",
    "    System.out.println(\"*** HashCode after: \"+System.identityHashCode(p));\n",
    "}\n",
    "Person p=new Person(\"js\");\n",
    "changeVar(p);\n",
    "System.out.printf(\"After calling changeVar: %s\",p.getName());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4.6 변수의 범위\n",
    "\n",
    "* 함수 내에서의 변수는 존재할 수 있는 범위가 있다.\n",
    "* 함수를 사용하고 나서 함수 내에 선언된 지역변수를 사용하려고 하면 오류가 난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " void tellUsYourName() {\r\n",
      "     String name=\"js\";\r\n",
      "     System.out.println(\"Hi, my name is \" + name);\r\n",
      " }\r\n",
      "|  Added method tellUsYourName()\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "void tellUsYourName() {\n",
    "    String name=\"js\";\n",
    "    System.out.println(\"Hi, my name is \" + name);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " tellUsYourName();\r\n",
      "Hi, my name is js\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "tellUsYourName();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " System.out.println(\"Hi, my name is \" + name);\r\n",
      "|  Error:\r\n",
      "|  cannot find symbol\r\n",
      "|    symbol:   variable name\r\n",
      "|  System.out.println(\"Hi, my name is \" + name);\r\n",
      "|                                         ^--^\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Hi, my name is \" + name);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4.7 오버로딩과 오버라이딩\n",
    "\n",
    "앞서 생성자 오버로딩을 배웠다.\n",
    "오버로딩은 **동일한 클래스내에서 함수명은 같게, 매개변수는 다르게** 구현한다.\n",
    "오버라이딩 overriding은 상속에서 더 배우기로 한다.\n",
    "\n",
    "구분 | 설명 | 시그니처가 같은가? | 시점\n",
    "-----|-----|-----|-----\n",
    "오버라이딩 overriding | 상속관계에서 부모의 함수를 자식이 재정의 | Yes | 런타임\n",
    "오버로딩 overloading | 클래스 내에서 동일한 함수명을 다른 시그니처로 재정의 | No, 반환인자만을 다르게 정의할 수 없다 | 컴파일 타임"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "단 반환 타잎 return type만을 다르게 하는 것은 오버로딩이 아니다.\n",
    "add() 함수를 반환 타잎만 다르게 구현하면 오류가 발생한다. 중복함수로 간주한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Number {\r\n",
      "     int add(int a, int b) {\r\n",
      "         return a+b;\r\n",
      "     }\r\n",
      "     float add(int a, int b){\r\n",
      "         return (float)a+b;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Error:\r\n",
      "|  method add(int,int) is already defined in class Number\r\n",
      "|      float add(int a, int b){\r\n",
      "|      ^-----------------------...\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Number {\n",
    "    int add(int a, int b) {\n",
    "        return a+b;\n",
    "    }\n",
    "    float add(int a, int b){\n",
    "        return (float)a+b;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "add() 함수에 인자를 3개 넣으면 오버로딩이 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Number {\r\n",
      "     int add(int a, int b) {\r\n",
      "         return a+b;\r\n",
      "     }\r\n",
      "     float add(float a, float b){\r\n",
      "         return a+b;\r\n",
      "     }\r\n",
      "     int add(int a, int b, int c) {\r\n",
      "         return a+b+c;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Added class Number\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Number {\n",
    "    int add(int a, int b) {\n",
    "        return a+b;\n",
    "    }\n",
    "    float add(float a, float b){\n",
    "        return a+b;\n",
    "    }\n",
    "    int add(int a, int b, int c) {\n",
    "        return a+b+c;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 4-4: 삼각형 클래스를 만들고, 면적을 계산하기\n",
    "\n",
    "앞 장에서 사각형을 만들고 면적계산을 해보았다.\n",
    "\n",
    "```java\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",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 클래스 인식\n",
    "\n",
    "클래스를 인식해 보자. 문제가 요구사항이므로, 여기에서 **명사**를 골라내어 **클래스 후보**로 정한다.\n",
    "명사는 삼각형, 클래스, 면적이 있다. 클래스는 구현대상이므로 제외한다.\n",
    "\n",
    "클래스 | 후보\n",
    "-----|-----\n",
    "삼각형 | 적합\n",
    "면적 | 면적이라는 값만 가지고 있기 때문에 클래스가 될 수 없고, 속성 후보가 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 속성 인식\n",
    "\n",
    "삼각형의 면적을 계산하려면 필요한 데이터는 무엇일까? **너비**, **높이**가 필요하므로, 이를 속성으로 넣는다.\n",
    "그러나 **면적은 속성으로 포함하지 않는다**. 너비와 높이에서 계산해 낼 수 있기 때문이다.\n",
    "삼각형의 너비, 높이는 **언제 설정**하는가? 삼각형 고유의 특징이므로 **생성시점**에 넣는다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 함수 인식\n",
    "\n",
    "다음으로 면적을 계산하는 함수를 설계해 본다.\n",
    "* 면적을 계산하는 함수의 이름은? 'computeArea()' vs 'computeAreaOfTriangle()' 어느 **함수명**이 좋을까?\n",
    "    * 개체지향은 함수명에서 '...OfTriangle'을 생략할 수 있다.\n",
    "    * 예를 들어, 사각형의 면적을 계산할 경우:\n",
    "        * 객체지향은 사각형 객체의 동일한 이름을 가진 함수를 사용하게 된다.\n",
    "        * 함수방식은 'computeAreaOfRectangle'이라고 명명하게 된다.\n",
    "        * 이런 차이는 함수를 사용할 때 객체지향이 보다 편리하게 된다. 또한 **다형성**을 사용할 수 있게 된다.\n",
    "* 'computeArea()'함수의 **매개변수**는 어떻게 정할까?\n",
    "    * 너비와 높이는 삼각형 자신의 데이터이다. 따라서 이를 사용하여 면적을 계산하면 매개변수는 없어도 된다.\n",
    "* 면적을 계산한 후 결과 값을 반환하는가? 너비, 높이가 정수라 하더라도, 면적을 계산하기 위해 **나눗셈을 하면 소수**가 될 수 있다.\n",
    "* 면적을 계산하는 함수의 가시성은 속성은 private으로 하고, 함수는 public으로 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 함수 프로그램의 예 - 삼각형 면적 구하기\n",
    "\n",
    "삼각형 면적은 너비, 높이의 곱을 1/2로 나누어 구한다.\n",
    "너비, 높이, 면적이 정수가 아닐 경우 문제가 될 수 있다.\n",
    "함수는 이런 변경이 있는 경우 수정이 용이하다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " float computeAreaOfTriangle(int width, int height) {\r\n",
      "     return (float)(width*height)/2;\r\n",
      " }\r\n",
      "|  Added method computeAreaOfTriangle(int,int)\r\n",
      "\r\n",
      " \r\n",
      "\r\n",
      " float area=computeAreaOfTriangle(3,5);\r\n",
      "|  Modified variable area of type float with initial value 7.5\r\n",
      "|    Update overwrote variable area\r\n",
      "\r\n",
      " System.out.println(area);\r\n",
      "7.5\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "float computeAreaOfTriangle(int width, int height) {\n",
    "    return (float)(width*height)/2;\n",
    "}\n",
    "\n",
    "float area=computeAreaOfTriangle(3,5);\n",
    "System.out.println(area);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"103px\" style=\"width:115px;height:103px;\" version=\"1.1\" viewBox=\"0 0 115 103\" width=\"115px\" 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=\"100\" x=\"6\" y=\"8\"/><ellipse cx=\"23.25\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M26.2188,29.6406 Q25.6406,29.9375 25,30.0859 Q24.3594,30.2344 23.6563,30.2344 Q21.1563,30.2344 19.8359,28.5859 Q18.5156,26.9375 18.5156,23.8125 Q18.5156,20.6875 19.8359,19.0313 Q21.1563,17.375 23.6563,17.375 Q24.3594,17.375 25.0078,17.5313 Q25.6563,17.6875 26.2188,17.9844 L26.2188,20.7031 Q25.5938,20.125 25,19.8516 Q24.4063,19.5781 23.7813,19.5781 Q22.4375,19.5781 21.75,20.6484 Q21.0625,21.7188 21.0625,23.8125 Q21.0625,25.9063 21.75,26.9766 Q22.4375,28.0469 23.7813,28.0469 Q24.4063,28.0469 25,27.7734 Q25.5938,27.5 26.2188,26.9219 L26.2188,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"63\" x=\"37.75\" y=\"28.1543\">Rectangle</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"105\" 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=\"48\" x=\"26\" y=\"54.2104\">width:int</text><rect fill=\"none\" height=\"6\" style=\"stroke: #C82930; stroke-width: 1.0;\" width=\"6\" x=\"14\" y=\"61.707\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"53\" x=\"26\" y=\"67.0151\">height:int</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"105\" y1=\"73.6094\" y2=\"73.6094\"/><ellipse cx=\"17\" cy=\"85.5117\" fill=\"#84BE84\" rx=\"3\" ry=\"3\" style=\"stroke: #038048; stroke-width: 1.0;\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"74\" x=\"26\" y=\"87.8198\">calcArea():int</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class Triangle {\n",
    "    -width:int\n",
    "    -height:int\n",
    "    +Triangle(w:int, h:int)\n",
    "    +computeArea():float\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Triangle {\r\n",
      "     private int width;\r\n",
      "     private int height;\r\n",
      "     public Triangle(int w, int h) {\r\n",
      "         this.width=w;\r\n",
      "         this.height=h;\r\n",
      "     }\r\n",
      "     public int getWidth() {\r\n",
      "         return width;\r\n",
      "     }\r\n",
      "     public int getHeight() {\r\n",
      "         return height;\r\n",
      "     }\r\n",
      "     public float computeArea() {\r\n",
      "         return (float)(width*height)/2;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Triangle\r\n",
      "|    Update replaced variable t, reset to null\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "|    Update overwrote class Triangle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Triangle {\n",
    "    private int width;\n",
    "    private int height;\n",
    "    public Triangle(int w, int h) {\n",
    "        this.width=w;\n",
    "        this.height=h;\n",
    "    }\n",
    "    public int getWidth() {\n",
    "        return width;\n",
    "    }\n",
    "    public int getHeight() {\n",
    "        return height;\n",
    "    }\n",
    "    public float computeArea() {\n",
    "        return (float)(width*height)/2;\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Triangle t=new Triangle(3,4);\r\n",
      "|  Modified variable t of type Triangle with initial value Triangle@10bdf5e5\r\n",
      "|    Update overwrote variable t\r\n",
      "\r\n",
      " t.computeArea();\r\n",
      "|  Expression value is: 6.0\r\n",
      "|    assigned to temporary variable $23 of type float\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Triangle t=new Triangle(3,4);\n",
    "t.computeArea();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 삼각형의 너비, 높이를 변경하는 함수를 넣어 본다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " class Triangle {\r\n",
      "     private int width;\r\n",
      "     private int height;\r\n",
      "     public Triangle(int w, int h) {\r\n",
      "         this.width=w;\r\n",
      "         this.height=h;\r\n",
      "     }\r\n",
      "     public int getWidth() {\r\n",
      "         return width;\r\n",
      "     }\r\n",
      "     public int getHeight() {\r\n",
      "         return height;\r\n",
      "     }\r\n",
      "     public void setHeight(int h) {\r\n",
      "         height=h;\r\n",
      "     }\r\n",
      "     public void setWidth(int newWidth){\r\n",
      "         width = newWidth;\r\n",
      "     }\r\n",
      "     public void setSize(int w, int h){\r\n",
      "         setWidth(w);\r\n",
      "         setHeight(h);\r\n",
      "     }\r\n",
      "     public float computeArea() {\r\n",
      "         return (float)(width*height)/2;\r\n",
      "     }\r\n",
      " }\r\n",
      "|  Replaced class Triangle\r\n",
      "|    Update replaced variable r, reset to null\r\n",
      "|    Update overwrote class Triangle\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "class Triangle {\n",
    "    private int width;\n",
    "    private int height;\n",
    "    public Triangle(int w, int h) {\n",
    "        this.width=w;\n",
    "        this.height=h;\n",
    "    }\n",
    "    public int getWidth() {\n",
    "        return width;\n",
    "    }\n",
    "    public int getHeight() {\n",
    "        return height;\n",
    "    }\n",
    "    public void setHeight(int h) {\n",
    "        height=h;\n",
    "    }\n",
    "    public void setWidth(int newWidth){\n",
    "        width = newWidth;\n",
    "    }\n",
    "    public void setSize(int w, int h){\n",
    "        setWidth(w);\n",
    "        setHeight(h);\n",
    "    }\n",
    "    public float computeArea() {\n",
    "        return (float)(width*height)/2;\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Triangle t=new Triangle(3,4);\r\n",
      "|  Modified variable t of type Triangle with initial value Triangle@31a5c39e\r\n",
      "|    Update overwrote variable t\r\n",
      "\r\n",
      " t.computeArea();\r\n",
      "|  Expression value is: 6.0\r\n",
      "|    assigned to temporary variable $14 of type float\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Triangle t=new Triangle(3,4);\n",
    "t.computeArea();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Triangle t=new Triangle(3,4);\r\n",
      "|  Modified variable t of type Triangle with initial value Triangle@56ac3a89\r\n",
      "|    Update overwrote variable t\r\n",
      "\r\n",
      " System.out.println(\"면적: \"+t.computeArea());\r\n",
      "면적: 6.0\r\n",
      "\r\n",
      " t.setSize(4,5);\r\n",
      "\r\n",
      " System.out.println(\"면적: \"+t.computeArea());\r\n",
      "면적: 10.0\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "Triangle t=new Triangle(3,4);\n",
    "System.out.println(\"면적: \"+t.computeArea());\n",
    "t.setSize(4,5);\n",
    "System.out.println(\"면적: \"+t.computeArea());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "실제 삼각형을 그려 보자. 화면 좌표 3개를 잡아서 그린다.\n",
    "좌표 3개는 배열에 넣어 반복문으로 서로 연결한다.\n",
    "좌표로 이동하는 **moveTo()**를 사용할 경우:\n",
    "* **`java.awt.geom.Point2D.Double`**는 **(x,y)**로 묶어서 매개변수로 한다.\n",
    "* 반면에 **`java.awt.Point`**는 **x,y**를 따로 매개변수로 한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# %load src/com/sd/turtle/Triangle.java\n",
    "/*\n",
    " * @author jsl\n",
    " * @since 20180408\n",
    " *\n",
    " * javac -sourcepath src/ -d classes/ -cp lib/aplu5.jar\n",
    " *   src/com/sd/turtle/Triangle.java \n",
    " * java -cp ./classes/:./lib/aplu5.jar com.sd.turtle.Triangle\n",
    " */\n",
    "\n",
    "package com.sd.turtle;\n",
    "import ch.aplu.turtle.*;\n",
    "import java.awt.Color;\n",
    "//import java.awt.geom.Point2D.Double;\n",
    "import java.awt.Point;\n",
    "\n",
    "public class Triangle {\n",
    "    static Point[] pts=new Point[3];\n",
    "    //private Point p1;\n",
    "    //private Point p2;\n",
    "    //private Point p2;\n",
    "    static Turtle pen;\n",
    "    public Triangle(Point x, Point y, Point z) {\n",
    "        pts[0] = x;\n",
    "        pts[1] = y;\n",
    "        pts[2] = z;\n",
    "        pen = new Turtle();\n",
    "        pen.setColor(Color.red);\n",
    "        pen.setPenColor(Color.green);\n",
    "    }\n",
    "    public static void draw() {\n",
    "        pen.penUp();\n",
    "        pen.moveTo(pts[0].x, pts[0].y);\n",
    "        pen.penDown();\n",
    "        for (int i = 0; i < 3; i++)\n",
    "            pen.moveTo(pts[i].x, pts[i].y);\n",
    "        pen.moveTo(pts[0].x, pts[0].y);\n",
    "    }\n",
    "    public static void main(String[] args) {\n",
    "        Point x=new Point(0,0);\n",
    "        Point y=new Point(100,0);\n",
    "        Point z=new Point(50,50);\n",
    "        Triangle t = new Triangle(x, y, z);\n",
    "        t.draw();\n",
    "    }\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Java 9",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "file_extension": ".class",
   "mimetype": "application/java-vm",
   "name": "java"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}