jupyter/chapter11-class_and_encapsulation.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# Class and encapsulation\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": null,
  "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": null,
  "metadata": {},
  "outputs": [],
  "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": null,
  "metadata": {},
  "outputs": [],
  "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": "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": null,
  "metadata": {},
  "outputs": [],
  "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": null,
  "metadata": {},
  "outputs": [],
  "source": ["books.remove(new Book(\"DaVinci Code\", \"Dan Brown\"));\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": null,
  "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 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": null,
  "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": null,
  "metadata": {},
  "outputs": [],
  "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": null,
  "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", "    books.add(book);\n", "  }\n", "  public List<Book> getBooks() {\n", "    return Collections.unmodifiableList(books);\n", "  }\n", "  public String toString() {\n", "    return \"ModifiableLibrary \" + books.toString();\n", "  }\n", "}\n", "var library = new ModifiableLibrary();\n", "var books = library.getBooks();\n", "books.add(new Book(\"DaVinci Code\", \"Dan Brown\"));\n"]
}
,
{
  "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": null,
  "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"]
}
],
  "metadata": {
    "kernelspec": {
      "display_name": "Java",
      "language": "java",
      "name": "java"
    },
    "language_info": {
      "codemirror_mode": "java",
      "file_extension": ".java",
      "mimetype": "text/x-java-source",
      "name": "Java",
      "pygments_lexer": "java",
      "version": "15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}