j11-class_and_encapsulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 클래스(class)와 캡슐화(encapsulation)\n",
    "\n",
    "클래스(레코드)를 설계할 때 되도록이면\n",
    "Encapsulation 원리/원칙, 요 성질이 잘 지켜져야 된다\n",
    "\n",
    "객체의 상태는 그 객체의 메소드를 통해서만 변경 가능해야 한다는 이 원칙을 완전히 지키려면\n",
    "- 객체 상태 공유를 아예 안하거나\n",
    "- 변경이 불가능한 것만 공유하거나\n",
    "- 직접 공유하지 않고 변경 불가능하게 포장해서 간접적으로 공유\n",
    "  - 간접적으로 공유해 주는 객체(즉, 변경 가능한 데이터의 주인)는 캡슐화 원리 지켜짐\n",
    "  - 공유를 받는 쪽에서 공유받은 참조를 객체 상태의 일부로 저장하는 경우에는, 공유받은 쪽은 캡슐화 원리가 깨짐"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say i want to create a library of books,\n",
    "so we need a record Book and a record Library that stores the books has a list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "record Book(String title, String author) { }\n",
    "record Library(List<Book> books) { }\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and use it that way\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Library[books=[Book[title=DaVinci Code, author=Dan Brown]]]\n"
     ]
    }
   ],
   "source": [
    "var book = new Book(\"DaVinci Code\", \"Dan Brown\");\n",
    "var books = new ArrayList<Book>();\n",
    "books.add(book);\n",
    "var library = new Library(books);\n",
    "System.out.println(library);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem with a Library declared like this in that the library is not really\n",
    "in control of the books inside itself, one can write\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Library[books=[Book[title=DaVinci Code, author=Dan Brown], Book[title=Effective Java, author=Joshua Bloch]]]\n"
     ]
    }
   ],
   "source": [
    "books.add(new Book(\"Effective Java\", \"Joshua Bloch\"));\n",
    "System.out.println(library);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is surprising, you can add books in the library without calling\n",
    "a method of the library which make the code hard to debug because changing\n",
    "an object has an effect to another object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// 맨 처음 초기화를 위해 사용한 books 변수가 아니라도\n",
    "// 또 다른 참조로 레코드 내부 정보를 추가 공유도 가능\n",
    "var books2 = library.books();\n",
    "books2.add(new Book(\"홍길동전\",\"허균\"));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Library[books=[Book[title=DaVinci Code, author=Dan Brown], Book[title=Effective Java, author=Joshua Bloch], Book[title=홍길동전, author=허균]]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encapsulation principle\n",
    "In a pure functional language, the language doesn't allow you to\n",
    "do side effect. In an OO language, if you want to survive, the idea is\n",
    "to limit the functions that can do side effects to the instance methods.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This idea is named the encapsulation principle and is sum up by this sentence\n",
    "> The only way to change the value of an object is to use one of the methods of this object.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Java, the way to ensure the encapsulation principle is to do information hiding,\n",
    "i.e. to separate the __public__ API part (what the user code can use) from the __private__\n",
    "implementation part (how the class is implemented).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This separation is done by using a special syntax named __class__ that allows\n",
    "to precisely control of the visibility of its members.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class\n",
    "A class defines\n",
    "- private fields that is like a record component but not visible by the user code\n",
    "- a public constructor (Library), that guarantee that any objects will be correctly initialized\n",
    "- public and private instance and static methods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unmodifiable class\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Library [Book[title=DaVinci Code, author=Dan Brown], Book[title=Effective Java, author=Joshua Bloch], Book[title=홍길동전, author=허균]]\n"
     ]
    }
   ],
   "source": [
    "class Library {\n",
    "  private final List<Book> books;\n",
    "  public Library(List<Book> books) {\n",
    "    this.books = List.copyOf(books);\n",
    "  }\n",
    "  public String toString() {\n",
    "    return \"Library \" + books.toString();\n",
    "  }\n",
    "}\n",
    "var library = new Library(books);\n",
    "System.out.println(library);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now changing the list of books has no effect on the library\n",
    "because the field `books` and the argument of the constructor `books` are different references\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Book[title=Effective Java, author=Joshua Bloch]]\n",
      "Library [Book[title=DaVinci Code, author=Dan Brown], Book[title=Effective Java, author=Joshua Bloch], Book[title=홍길동전, author=허균]]\n"
     ]
    }
   ],
   "source": [
    "books.remove(new Book(\"DaVinci Code\", \"Dan Brown\"));\n",
    "books.remove(new Book(\"홍길동전\", \"허균\"));\n",
    "System.out.println(books);\n",
    "System.out.println(library);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can notice that the constructor has no return type, it's because it's always void.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The field 'books' is declared final which means must be initialized\n",
    "in the constructor (and not changed afterward) so we are sure that in toString(),\n",
    "the field 'books' has been initialized.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike a record, the method equals()/hashCode() and toString() are not provided and has\n",
    "to be hand written. We will see how to implement them later.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifiable class\n",
    "The code above is an unmodifiable implementation of Library.\n",
    "We can also write a mutable version with the caveat that using it\n",
    "as element of a list or a map is not recommended.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModifiableLibrary [Book[title=DaVinci Code, author=Dan Brown]]\n",
      "ModifiableLibrary [Book[title=DaVinci Code, author=Dan Brown], Book[title=Effective Java, author=Joshua Bloch]]\n"
     ]
    }
   ],
   "source": [
    "class ModifiableLibrary {\n",
    "  private final ArrayList<Book> books;\n",
    "  public ModifiableLibrary() {\n",
    "    books = new ArrayList<>();\n",
    "  }\n",
    "  public void add(Book book) {\n",
    "    Objects.requireNonNull(book);\n",
    "    books.add(book);\n",
    "  }\n",
    "  public String toString() {\n",
    "    return \"ModifiableLibrary \" + books.toString();\n",
    "  }\n",
    "}\n",
    "var library = new ModifiableLibrary();\n",
    "library.add(new Book(\"DaVinci Code\", \"Dan Brown\"));\n",
    "System.out.println(library);\n",
    "library.add(new Book(\"Effective Java\", \"Joshua Bloch\"));\n",
    "System.out.println(library);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifiable class and accessors\n",
    "An error sometime seen is to add a method to get the content of the library\n",
    "and forget that it may expose the private list of books\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModifiableLibrary {\n",
    "  private final ArrayList<Book> books;\n",
    "  public ModifiableLibrary() {\n",
    "    books = new ArrayList<>();\n",
    "  }\n",
    "  public void add(Book book) {\n",
    "    Objects.requireNonNull(book);\n",
    "    books.add(book);\n",
    "  }\n",
    "  public List<Book> getBooks() {\n",
    "    return books;\n",
    "  }\n",
    "  public String toString() {\n",
    "    return \"ModifiableLibrary \" + books.toString();\n",
    "  }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code breaks the encapsulation because you can \n",
    "modify the library without calling a method of the Library\n",
    "(`add()` is called on the List<Book> not on the Library)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var library = new ModifiableLibrary();\n",
    "var books = library.getBooks();\n",
    "books.add(new Book(\"DaVinci Code\", \"Dan Brown\"));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One solution is to return a copy, or better a non modifiable view\n",
    "of the internal list of books\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModifiableLibrary {\n",
    "    private final ArrayList<Book> books;\n",
    "    public ModifiableLibrary() { books = new ArrayList<>(); }\n",
    "    public void add(Book book) { books.add(book); }\n",
    "    public List<Book> getBooks() {\n",
    "        // // 매번 복사본을 만드는 것도 가능하지만 다소 비효율적\n",
    "        // return List.copyOf(books); \n",
    "        \n",
    "        // set, add 등의 변경 연산을 시도하면 에러가 나도록 포장한 view를 리턴\n",
    "        return Collections.unmodifiableList(books); \n",
    "    }\n",
    "    public String toString() { return \"ModifiableLibrary \" + books.toString(); }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "var library = new ModifiableLibrary();\n",
    "var books = library.getBooks();\n",
    "System.out.println(books);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "EvalException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0m\u001b[1m\u001b[31mjava.lang.UnsupportedOperationException: null\n\u001b[0m",
      "\u001b[0m\u001b[1m\u001b[34m   at java.base/java.util.Collections$UnmodifiableCollection.add(Collections.java:1092)\u001b[0m",
      "\u001b[0m\u001b[1m\u001b[34m   at .(#26:1)\u001b[0m",
      "\u001b[0m\u001b[0m\u001b[1m|--> books.add(new Book(\"DaVinci Code\", \"Dan Brown\"));\u001b[0m"
     ]
    }
   ],
   "source": [
    "books.add(new Book(\"DaVinci Code\", \"Dan Brown\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best solution being to not have a method `getBook()` at all,\n",
    "the less code you write the less bug you have.\n",
    "So please don't write getters and setters unless you really need them.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Record constructor\n",
    "Records also provides ways to customize the code to respect the\n",
    "encapsulation principle\n",
    "Here, we only need to change the canonical constructor \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "record Library(List<Book> books) {\n",
    "  public Library(List<Book> books) {\n",
    "    this.books = List.copyOf(books);\n",
    "  }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To summarize, a class is a general mechanism to describe how things\n",
    "are implemented and make a separation between what is publicly visible\n",
    "and what is privately implemented to make the code working.\n",
    "A record is a special case when there is no separation, everything is public.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "용어 정리\n",
    "\n",
    "클래스(class) 안에 작성되는 내용들\n",
    " - **필드**(field): 멤버 변수(member variable)라고도 부름. 레코드에서는 구성요소(component)라고 부르기도\n",
    "   - 인스턴스 필드(instance field) = 인스턴스 변수(instance variable)\n",
    "   - 클래스 필드(class field) = 클래스 변수(class variable)\n",
    " - **메소드**/메서드(method): 최신 외래어 표기법에 따르면 \"메서드\"가 더 맞다고 함. 다른 객체지향 언어에서는 멤버 함수(member function)라는 용어를 쓰기도 함.\n",
    "   - 클래스 메소드(class method): 정적 메소드(static method)라고 부르기도 함\n",
    "   - 인스턴스 메소드(instance method)\n",
    " - **생성자**(constructor)\n",
    " - 기타 다른 내용들: nested class, enum, ...\n",
    "\n",
    "접근 제한자\n",
    "- `public` 클래스 외부에서도 접근 가능\n",
    "- `priviate` 클래스(와 상속받은 하위 클래스) 내부에서만 접근 가능\n",
    "- 접근 제한자를 생략하면 public 도 priavate도 아니고 대략 패키지 내부에서만 접근 가능\n",
    "- 자바에서 절대 사용하지 말라고 대부분의 사람들이 충고하는 `protected` (그냥 자바에 존재하지 않는다고 기억에서 없애는 것이 맘편함)\n",
    "  \n",
    "\n",
    "자바에서 값을 담는 변수(variable)의 종류\n",
    " - 클래스/레코드 안에서 선언하는 필드/구성요소\n",
    " - 메소드의 파라메터\n",
    " - 메소드 안에서 선언하는 지역 변수(local variable)\n",
    "\n",
    "`final` 키워드는\n",
    "- 변수 앞에 붙이면 재지정(대입) 불가. 처음 초기화된 값(객체)을 유지.\n",
    "- final 변수는 객체를 바꿔치기 못한다는 거지 변경 가능한 객체이면 내용은 변경 가능. 예를 들어 final 변수로 변경 가능한 ArrayList로 초기화하면 다른 ArrayList 로 갈아치우지 못할 뿐 기존의 ArrayList의 원소를 변경/삭제/추가는 얼마든지 가능\n",
    "- 메소드 앞에 붙이면 override 불가\n",
    "- 클래스 앞에 붙이면 상속 불가\n",
    "\n",
    "참고자료\n",
    "- https://docs.oracle.com/javase/tutorial/java/javaOO/variables.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java (rjk 2.1.0)",
   "language": "java",
   "name": "rapaio-jupyter-kernel"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "java",
   "nbconvert_exporter": "script",
   "pygments_lexer": "java",
   "version": "22.0.2+9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}