Chap02b.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cabf41b1-d71a-4249-8042-85f388e9e4bf",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 02. Intro. to OOP (Part B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e592c321-4c50-42b7-b690-5dc8d6c31c68",
   "metadata": {},
   "source": [
    "## Secondary constructor\n",
    "부생성자\n",
    "\n",
    "참고로 생성자는 리턴 타입에 대해 생각할 필요가 없다.\n",
    "\n",
    "객체가 만들어지며 속성 초기화 등 수행해야 할 일을 하는 특수한 함수다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "989340c5-d5b8-41e3-91f1-ee5032ca0707",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Person(name: String, age: Int) { // 주생성자에 이름과 나이만\n",
    "    var name: String\n",
    "    var age: Int\n",
    "    var height: Int\n",
    "    \n",
    "    init {\n",
    "        this.name = name\n",
    "        this.age = age\n",
    "        this.height = 0 // 주생성자에서는 키는 그냥 0으로 초기화\n",
    "    }\n",
    "    \n",
    "    // 부생성자에서는 키까지 설정\n",
    "    constructor(name: String, age: Int, height: Int): this(name, age) {\n",
    "        this.height = height\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8b946489-f74c-4437-bb14-1598382b1607",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "이름: 차범근, 나이: 70, 키: 0cm\n",
      "이름: 차범근, 나이: 70, 키: 179cm\n"
     ]
    }
   ],
   "source": [
    "val p4 = Person(\"차범근\", 70) // 주생성자\n",
    "val p5 = Person(\"차범근\", 70, 179) // 부생성자\n",
    "\n",
    "println(\"이름: ${p4.name}, 나이: ${p4.age}, 키: ${p4.height}cm\")\n",
    "println(\"이름: ${p5.name}, 나이: ${p5.age}, 키: ${p5.height}cm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf495920-535c-4233-9332-6117c8fdd162",
   "metadata": {},
   "source": [
    "## Constructor overloading\n",
    "앞에서도 살펴보았지만 `this`의 또 다른 용도는 생성자 호출\n",
    "\n",
    "오버로딩된 생성자에서 다른 생성자를 호출하는 경우에만 가능 (생성자가 아닌 다른 보통 함수에서는 이런 용도로 활용 불가)\n",
    "\n",
    "나머지 내용은 교재를 살펴보며 스스로 학습"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bad8348a-8d72-4b18-be3f-8d277515c4df",
   "metadata": {},
   "source": [
    "## Constructor with default parameters\n",
    "방금전의 주생성자 부생성자 예시 코드는\n",
    "그냥 기본값이 설정된 파라메터를 활용하는 주생성자 하나로도 간단히 작성 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ef918a75-6acf-4199-827b-fa492aa956e5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Person(name: String, age: Int, height: Int = 0) { \n",
    "    var name: String\n",
    "    var age: Int\n",
    "    var height: Int\n",
    "    \n",
    "    init {\n",
    "        this.name = name\n",
    "        this.age = age\n",
    "        this.height = height\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ee57ffe6-7581-43aa-916e-1ef3de85c627",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "// 위와 똑같은 코드를 더 간단히 작성하면\n",
    "class Person(var name: String, var age: Int, var height: Int = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0ee5585b-e065-48fc-90d5-ce0f485d2214",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "이름: 차범근, 나이: 70, 키: 0cm\n",
      "이름: 차범근, 나이: 70, 키: 179cm\n"
     ]
    }
   ],
   "source": [
    "val p4 = Person(\"차범근\", 70) // 주생성자 height 파라메터 기본값 활용\n",
    "val p5 = Person(\"차범근\", 70, 179) // 주생성자  \n",
    "\n",
    "println(\"이름: ${p4.name}, 나이: ${p4.age}, 키: ${p4.height}cm\")\n",
    "println(\"이름: ${p5.name}, 나이: ${p5.age}, 키: ${p5.height}cm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8473dfbf-9241-4bbe-9928-e056a405b23f",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Constructor with named parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "74d03ba7-e206-48dc-af8f-e254e3e578cb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "이름: 김연아, 나이: 33, 키: 164cm\n",
      "이름: 차범근, 나이: 33, 키: 164cm\n"
     ]
    }
   ],
   "source": [
    "val p6 = Person(name=\"김연아\", age=33, height=164)\n",
    "val p7 = Person(name=\"차범근\", height=164, age=33)\n",
    "println(\"이름: ${p6.name}, 나이: ${p6.age}, 키: ${p6.height}cm\")\n",
    "println(\"이름: ${p7.name}, 나이: ${p7.age}, 키: ${p7.height}cm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e02c3fc-fdf8-49ea-9181-36de774f8693",
   "metadata": {},
   "source": [
    "## What are data classes?\n",
    "데이터 클래스 `T`를 선언하면 다음 메소드가 자동으로 제공됨\n",
    "- `Any.toString(): String`를 자동으로 적절히 재정의(override)\n",
    "- `Any.equals(other: Any?): Boolean`를 자동으로 적절히 재정의(override)\n",
    "- `Any.hashCode(): Int`를 자동으로 적절히 재정의(override)\n",
    "- `T.copy(...): T`를 자동으로 적절히 정의"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4b25eaa4-a83f-4a10-b30d-02bf61a99e27",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun kotlin.Any.toString(): kotlin.String"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Any::toString"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f88f63c4-cb18-4088-9499-88dbfc949237",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun kotlin.Any.equals(kotlin.Any?): kotlin.Boolean"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Any::equals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f2e53634-cb5b-42b4-85a9-683578161ee4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun kotlin.Any.hashCode(): kotlin.Int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Any::hashCode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3ad48f93-3d76-4204-bdca-debdfd063f9f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "/* data */ class Person(var name: String, var age: Int, var height: Int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b75bbf2c-ccc9-4037-a6c1-3f751d4ac629",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun Line_9_jupyter.Person.toString(): kotlin.String"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Person::toString"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e9f00504-9118-407f-a38b-e42d59f8390f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun Line_9_jupyter.Person.equals(kotlin.Any?): kotlin.Boolean"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Person::equals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "643c7b22-96b9-4d7b-a686-5b5346997aa7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fun Line_9_jupyter.Person.hashCode(): kotlin.Int"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Person::hashCode "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ade0a610-8cbd-456c-bbdd-8dfe9e8f189d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Line_13.jupyter.kts (1:1 - 13) The expression is unused\n",
      "Line_13.jupyter.kts (1:9 - 13) Unresolved reference: copy"
     ]
    }
   ],
   "source": [
    "Person::copy\n",
    "// class Person(...)으로 선언된 상태에서는 오류가 날 것임\n",
    "// 위에서 class Person(...)을 data class Person(...)으로\n",
    "// 클래스 선언을 수정한 다음 다시 실행해 보라"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5319a26-61c6-42cb-b368-d7c5002e23cf",
   "metadata": {
    "tags": []
   },
   "source": [
    "## The `toString()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "81f6bd27-5c70-46ee-bdbf-5735ad79ef81",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line_14_jupyter$Person@1b454dc6\n",
      "Line_14_jupyter$Person@1b454dc6\n"
     ]
    }
   ],
   "source": [
    "/* data */ class Person(var name: String, var age: Int, var height: Int)\n",
    "\n",
    "val p8 = Person(\"홍길동\", 580, 173)\n",
    "\n",
    "println( p8.toString() )\n",
    "println( p8 )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e13166e9-fe9a-440f-bf10-43aca2a22503",
   "metadata": {},
   "source": [
    "## The `equals()` function\n",
    "`==` 연산자가 `equals()`를 호출해서 활용\n",
    "\n",
    "즉, `null`이 아닌 `obj1`에 대해 `obj1 == obj2`를 계산하는 것은 `obj1.equqls(obj2)`를 계산하는 것과 같다.\n",
    "\n",
    "코틀린에서는 `==`와 비슷하게 생겼지만 다른 연산자로는 `===`가 있으며, 공식 문서에서는\n",
    "- `==`는 structural equality (구성 요소가 같음)\n",
    "- `===`는 referrential equality (가리키는 대상이 같음)\n",
    "\n",
    "참고로, 위 연산자들의 결과값에 논리 부정을 결과로 하는 연산자는 `!=`와 `!==`이다.\n",
    "\n",
    "가리키는 대상 자체가 같으면 당연히 구성요소가 다를 수 없기 때문에\n",
    "`obj1 === obj2`인 경우에는 `obj1 == obj2`이어야만 한다. (그렇지 않게 `==` 즉 `equals` 함수를 정의했다면 잘못된 정의임)\n",
    "\n",
    "참고로, referrential equality와 같은 의미로 object equality라는 용어도 쓴다.\n",
    "\n",
    "Kotlin과 Java를 비교하자면\n",
    "- Kotlin의 `==` (즉, `equals` 함수)는 Java에서 `equals` 메소드에 해당 (Java에서 연산자로는 따로 없음)\n",
    "- Kotlin의 `===`는 Java에서 `==` 에 해당\n",
    "\n",
    "그러니까 Kotlin에서 `==`와 Java에서 `==`는 다른 의미/용도의 연산자라는 것에 주의!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "dbc3d986-43cf-4ee9-996e-796e1291e420",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n",
      "false\n",
      "===============\n",
      "true\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "/* data */ class Person(var name: String, var age: Int, var height: Int)\n",
    "\n",
    "// 우연찮게 동명이인인데 나이랑 키까지 같은 두 사람\n",
    "val p8 = Person(\"홍길동\", 580, 173)\n",
    "val p9 = Person(\"홍길동\", 580, 173)\n",
    "\n",
    "// data calss로 선언하면 어느 부분이 어떻게 달라지는지 확인해 보라\n",
    "println( p8 == p9 ) // structural equality   \n",
    "println( p8 === p9 ) // object equality\n",
    "println( \"===============\" )\n",
    "println( p8 == p8 ) // structural equality\n",
    "println( p8 === p8 ) // object equality"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80415baa-0e4e-43b9-a9e4-cf0153e59935",
   "metadata": {},
   "source": [
    "## The `hashCode()` function\n",
    "`obj1.hashCode() != obj2.hashCode()`이면 `obj1 != obj2`이어야만 한다.\n",
    "\n",
    "`obj1.hashCode() == obj2.hashCode()`인 경우 `obj1 == obj2`이라고 보장하지는 못하더라도, 높은 확률로 그렇도록 `hashCode` 함수를 정의하는 것이 바람직하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1eb78477-20df-460e-bec2-3e315608c25f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line_16_jupyter$Person@6d00896\n",
      "114296982\n",
      "6d00896\n",
      "===============\n",
      "Line_16_jupyter$Person@14e632f0\n",
      "350630640\n",
      "14e632f0\n",
      "===============\n",
      "false\n"
     ]
    }
   ],
   "source": [
    "/* data */ class Person(var name: String, var age: Int, var height: Int)\n",
    "\n",
    "// 우연찮게 동명이인인데 나이랑 키까지 같은 두 사람\n",
    "val p8 = Person(\"홍길동\", 580, 173)\n",
    "val p9 = Person(\"홍길동\", 580, 173)\n",
    "\n",
    "// data calss로 선언하면 어느 부분이 어떻게 달라지는지 확인해 보라\n",
    "println( p8 )\n",
    "println( p8.hashCode() )\n",
    "println( p8.hashCode().toString(16) ) // 16진수로 변환\n",
    "println( \"===============\" )\n",
    "println( p9 )\n",
    "println( p9.hashCode() )\n",
    "println( p9.hashCode().toString(16) ) // 16진수로 변환\n",
    "println( \"===============\" )\n",
    "println( p8.hashCode() == p9.hashCode() )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "597af0b0-8fa4-47a0-bbe8-d5e151947be1",
   "metadata": {},
   "source": [
    "## The `copy()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9b460e74-8fee-4911-bf3e-b4aaec3f39d5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "data class Person(var name: String, var age: Int, var height: Int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6d457cf8-79ac-4b35-ac41-c9f412408131",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "===============\n",
      "Person(name=홍길동, age=580, height=173)\n",
      "Person(name=홍길동, age=580, height=173)\n",
      "===============\n",
      "Person(name=홍길동, age=581, height=173)\n",
      "Person(name=홍길동, age=581, height=173)\n"
     ]
    }
   ],
   "source": [
    "val p8 = Person(\"홍길동\", 580, 173)\n",
    "val p9 = p8    // 이렇게 하면 p8 === p9\n",
    "\n",
    "println( p8 == p9 ) // structural equality   \n",
    "println( p8 === p9 ) // object equality\n",
    "println( \"===============\" )\n",
    "println(p8)\n",
    "println(p9)\n",
    "println( \"===============\" )\n",
    "p9.age++\n",
    "println(p8)\n",
    "println(p9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "cdbc5af7-3f72-4959-b708-17acaa7aa0a2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "false\n",
      "===============\n",
      "Person(name=홍길동, age=580, height=173)\n",
      "Person(name=홍길동, age=580, height=173)\n",
      "===============\n",
      "Person(name=홍길동, age=580, height=173)\n",
      "Person(name=홍길동, age=581, height=173)\n"
     ]
    }
   ],
   "source": [
    "val p8 = Person(\"홍길동\", 580, 173)\n",
    "val p9 = p8.copy()\n",
    "\n",
    "println( p8 == p9 ) // structural equality   \n",
    "println( p8 === p9 ) // object equality\n",
    "println( \"===============\" )\n",
    "println(p8)\n",
    "println(p9)\n",
    "println( \"===============\" )\n",
    "p9.age++\n",
    "println(p8)\n",
    "println(p9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a661ddf-21ec-4d63-bbaf-0295283dd013",
   "metadata": {},
   "source": [
    "## Object decomposition\n",
    "이거 앞에서 `Pair`와 `Triple`에 대해서 해봤던 내용인데\n",
    "(`Pair`와 `Triple`도 data class로 선언되어 있음)\n",
    "다시 다른 예제로 설명하는 것이니 스스로 학습\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b86f1f7b-0dcb-4def-a697-6748e7ef2bfe",
   "metadata": {},
   "source": [
    "## Classes and functions\n",
    "기본적으로 클래스 밖에서 함수를 정의하는 것과 마찬가지\n",
    "\n",
    "클래스 안에 선언된 함수는 속성(property)에 접근 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "43a998fb-1b87-42f2-8139-6431bfafdcc1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n",
      "===============\n",
      "이름: 홍길동, 나이: 580, 키: 173cm\n",
      "이름: 홍길동, 나이: 580, 키: 173cm\n",
      "===============\n",
      "이름: 홍길동, 나이: 580, 키: 173cm\n",
      "이름: 홍길동, 나이: 581, 키: 173cm\n"
     ]
    }
   ],
   "source": [
    "class Person(var name: String, var age: Int, var height: Int) {\n",
    "    // data class에서의 copy()와 같이 동작하는 함수\n",
    "    fun copy() = Person(this.name, this.age, this.height)\n",
    "}\n",
    "\n",
    "val p8 = Person(\"홍길동\", 580, 173)\n",
    "val p9 = p8.copy()\n",
    "\n",
    "println( p8 === p9 ) // object equality\n",
    "println( \"===============\" )\n",
    "println(\"이름: ${p8.name}, 나이: ${p8.age}, 키: ${p8.height}cm\")\n",
    "println(\"이름: ${p9.name}, 나이: ${p9.age}, 키: ${p9.height}cm\")\n",
    "println( \"===============\" )\n",
    "p9.age++\n",
    "println(\"이름: ${p8.name}, 나이: ${p8.age}, 키: ${p8.height}cm\")\n",
    "println(\"이름: ${p9.name}, 나이: ${p9.age}, 키: ${p9.height}cm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b1bad87-88ff-4bcf-b748-da0f3d54d286",
   "metadata": {},
   "source": [
    "## Function overloading\n",
    "스스로 학습"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1c9c91b-315f-43c2-ad38-cd8eb3256671",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Kotlin",
   "language": "kotlin",
   "name": "kotlin"
  },
  "language_info": {
   "codemirror_mode": "text/x-kotlin",
   "file_extension": ".kt",
   "mimetype": "text/x-kotlin",
   "name": "kotlin",
   "nbconvert_exporter": "",
   "pygments_lexer": "kotlin",
   "version": "1.8.20-Beta"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}