Courses/Mathesis/Intro2ProgrammingWithJava/Week4/4.1-Inheritance/4.1-Inheritance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1868427e-c752-4580-9edd-0d1bd33d89f6",
   "metadata": {},
   "source": [
    "# 4.1 Κληρονομικότητα\n",
    "© Γιάννης Κωστάρας\n",
    "\n",
    "---\n",
    "\n",
    "[Δ](../../TOC.ipynb) | [>](../4.2-Polymorphism/4.2-Polymorphism.ipynb)\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a2b3e27-8cc7-469a-9d9a-d33f9af81fd4",
   "metadata": {},
   "source": [
    "### Μαθησιακοί στόχοι\n",
    "Σε αυτήν την ενότητα θα μάθουμε:\n",
    "\n",
    "* τι είναι η κληρονομικότητα (inheritance) στον αντικειμενοστραφή προγραμματισμό\n",
    "* για τις αφαιρετικές κλάσεις (abstract classes)\n",
    "* για τις σφραγισμένες κλάσεις (sealed classes)\n",
    "* για την κλάση ```Object```\n",
    "* για τις διεπαφές (interfaces)\n",
    "* για τις επισημειώσεις (annotations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06669db6-caa2-4009-af1a-1f1eb56160e5",
   "metadata": {},
   "source": [
    "## Κληρονομικότητα\n",
    "\n",
    "Άλλο ένα \"όπλο\" που έχουν οι προγραμματιστές αντικειμενοστραφών προγραμμάτων στο \"οπλοστάσιό\" τους για τη δημιουργία πιο κατανοητού και ευκολότερα συντηρήσιμου κώδικα είναι η κληρονομικότητα (inheritance). Επιτρέπει την επαναχρησιμοποίηση κώδικα (αρχή \"Μην επαναλαμβάνεσαι\" - \"Don't Repeat Yourself\" ή DRY principle)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57cb20f3-c531-41ce-b531-eec05562c800",
   "metadata": {},
   "source": [
    "Ας δούμε ένα παράδειγμα. Το παιχνίδι αγώνων αυτοκινήτου πήγε καλά οπότε ήρθε νέα απαίτηση να το επεκτείνουμε να υποστηρίζει και μοτοσυκλέτες.\n",
    "\n",
    "Θα δημιουργήσουμε μια νέα κλάση ```Motorcycle``` βασισμένη στην τελευταία έκδοση της κλάσης ```Car``` από τα μαθήματα της προηγούμενης εβδομάδας, την οποία ξαναδείχνουμε παρακάτω: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "098b9eb4-34ef-4cae-9a2e-bf1e45810708",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Car { // κλάση\n",
    "  // ιδιότητες/γνωρίσματα\n",
    "  private String model;\n",
    "  private int maxSpeed;\n",
    "  private int ccm;\n",
    "  private int speed = 0;\n",
    "  // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "  public Car(String m, int s, int c) {\n",
    "    model = m; maxSpeed = s; ccm = c;\n",
    "  }\n",
    "  // ενέργειες/μέθοδοι\n",
    "  public void accelerate() {\n",
    "     if (speed <= maxSpeed - 10)\n",
    "        speed+=10;\n",
    "  }\n",
    "  public void decelerate() {\n",
    "     if (speed >= 10)\n",
    "        speed-=10;\n",
    "  }  \n",
    "  public String getModel() {\n",
    "  \treturn model;\n",
    "  }\n",
    "  public void setModel(String m) {\n",
    "    this.model = m;\n",
    "  }\n",
    "  public int getMaxSpeed() {\n",
    "  \treturn maxSpeed;\n",
    "  }\n",
    "  public void setMaxSpeed(int ms) {\n",
    "    this.maxSpeed = ms;\n",
    "  }        \n",
    "  public int getCcm() {\n",
    "  \treturn ccm;\n",
    "  }\n",
    "  public void setCcm(int ccm) {\n",
    "    this.ccm = ccm;\n",
    "  }      \n",
    "  public int getSpeed() {\n",
    "  \treturn speed;\n",
    "  }\n",
    "  public String toString() {\n",
    "    return \"Car {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm=\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a2fc8e34-da65-4b47-8744-f3ef0da701c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Motorcycle { // κλάση\n",
    "  // ιδιότητες/γνωρίσματα\n",
    "  private String model;\n",
    "  private int maxSpeed;\n",
    "  private int ccm;\n",
    "  private int speed = 0;\n",
    "  // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "  public Motorcycle(String m, int s, int c) {\n",
    "    model = m; maxSpeed = s; ccm = c;\n",
    "  }\n",
    "  // ενέργειες/μέθοδοι\n",
    "  public void accelerate() {\n",
    "     if (speed <= maxSpeed - 20)\n",
    "        speed+=20;\n",
    "  }\n",
    "  public void decelerate() {\n",
    "     if (speed >= 20)\n",
    "        speed-=20;\n",
    "  }  \n",
    "  public String getModel() {\n",
    "  \treturn model;\n",
    "  }\n",
    "  public void setModel(String m) {\n",
    "    this.model = m;\n",
    "  }\n",
    "  public int getMaxSpeed() {\n",
    "  \treturn maxSpeed;\n",
    "  }\n",
    "  public void setMaxSpeed(int ms) {\n",
    "    this.maxSpeed = ms;\n",
    "  }        \n",
    "  public int getCcm() {\n",
    "  \treturn ccm;\n",
    "  }\n",
    "  public void setCcm(int ccm) {\n",
    "    this.ccm = ccm;\n",
    "  }      \n",
    "  public int getSpeed() {\n",
    "  \treturn speed;\n",
    "  }\n",
    "  public String toString() {\n",
    "    return \"Motorcycle {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm=\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f717026d-41c1-4b48-bbb9-b6572f0c8051",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Motorcycle {model=Honda CBR 650, maxSpeed=250, ccm=649, speed=0}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Motorcycle honda = new Motorcycle(\"Honda CBR 650\", 250, 649);\n",
    "honda"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d555d1a0-ebef-4a16-9dee-b843f404395e",
   "metadata": {},
   "source": [
    "Τι παρατηρείτε; Οι δυο κλάσεις περιέχουν πλέον πολύ διπλότυπο (επαναλαμβανόμενο) κώδικα. Αν θελήσουμε να κάνουμε μια αλλαγή ή διόρθωση στην κλάση ```Car``` θα πρέπει να επαναλάβουμε την αλλαγή/διόρθωση και στην κλάση ```Motorcycle```. Κι αν αργότερα μας ζητηθεί να επεκτείνουμε το πρόγραμμα ώστε να περιλαμβάνει και ταχύπλοα και αεροπλάνα, τότε θα πρέπει να κάνουμε την ίδια αλλαγή 4 φορές! Κάτι δεν πάει καλά λοιπόν. Η αντιγραφή/επικόλληση κώδικα δεν είναι καλή ιδέα και είναι ενάντια στο DRY principle. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14c3cc62-0817-470f-a2d0-ddb936e2ae70",
   "metadata": {},
   "source": [
    "Μια λύση στο πρόβλημα του επαναλαμβανόμενου κώδικα, αν και όχι πάντα η καλύτερη, είναι η κληρονομικότητα. Δημιουργούμε μια νέα κλάση ```Vehicle``` που περιέχει τα κοινά στοιχεία των ```Car, Motorcycle``` και κάνουμε τις ```Car, Motorcycle``` να κληρονομούν απ' αυτήν. Η ```Vehicle``` ονομάζεται υπερκλάση (superclass) ή γονική κλάση και οι ```Car, Motorcycle``` υποκλάσεις (subclass) ή κλάσεις παιδιά.\n",
    "\n",
    "Δοκιμάστε να κάνετε αυτά που περιγράφουμε παρακάτω στο BlueJ ή/και στο NetBeans."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "121011fe-dbcd-4115-94a1-664fcb7702c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Vehicle { // κλάση\n",
    "  // ιδιότητες/γνωρίσματα\n",
    "  protected String model;\n",
    "  protected int maxSpeed;\n",
    "  protected int ccm;\n",
    "  protected int speed = 0;\n",
    "  // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "  public Vehicle(String m, int s, int c) {\n",
    "    model = m; maxSpeed = s; ccm = c;\n",
    "  }\n",
    "  // ενέργειες/μέθοδοι\n",
    "  public String getModel() {\n",
    "  \treturn model;\n",
    "  }\n",
    "  public void setModel(String m) {\n",
    "    this.model = m;\n",
    "  }\n",
    "  public int getMaxSpeed() {\n",
    "  \treturn maxSpeed;\n",
    "  }\n",
    "  public void setMaxSpeed(int ms) {\n",
    "    this.maxSpeed = ms;\n",
    "  }        \n",
    "  public int getCcm() {\n",
    "  \treturn ccm;\n",
    "  }\n",
    "  public void setCcm(int ccm) {\n",
    "    this.ccm = ccm;\n",
    "  }      \n",
    "  public int getSpeed() {\n",
    "  \treturn speed;\n",
    "  }\n",
    "  public String toString() {\n",
    "    return \"Vehicle {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm=\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cee5008a-df9a-4ac2-9c18-1bd8de555f01",
   "metadata": {},
   "source": [
    "1. Δημουργήσαμε μια νέα κλάση ```Vehicle``` και αντιγράψαμε σ' αυτήν τα περιεχόμενα μιας από τις κλάσεις ```Car``` ή ```Motorcycle```.\n",
    "1. Μετονομάσαμε την κλάση σε ```Vehicle``` καθώς και τον constructor και το κείμενο στην ```toString()```. \n",
    "1. Αλλάξαμε την πρόσβαση στα γνωρίσματα από ```private``` σε ```protected``` ώστε να μπορούν να κληρονομηθούν από τις υποκλάσεις.\n",
    "1. Διαγράψαμε τις δυο μεθόδους ```accelerate(), decelerate()``` επειδή έχουν διαφορετική υλοποίηση στις υποκλάσεις."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c12a121-3e88-4222-9274-4280aa16df4a",
   "metadata": {},
   "source": [
    "Δηλώνουμε ότι οι κλάσεις ```Car, Motorcycle``` κληρονομούν από την ```Vehicle``` με τη δεσμευμένη λέξη ```extends``` στον ορισμό της υποκλάσης. Στο BlueJ μπορείτε να πατήσετε στο κουμπί με το βέλος της κληρονομικότητας (inheritance) και να επιλέξετε πρώτα την υποκλάση (π.χ. ```Car```) και στη συνέχεια την υπερκλάση (```Vehicle```).\n",
    "\n",
    "Θα πρέπει να δείτε το παρακάτω (με διαγραμμισμένες τις κλάσεις ```Car, Motorcycle``` επειδή υπάρχουν λάθη μεταγλώττισης).\n",
    "\n",
    "![](assets/Fig1.png)\n",
    "\n",
    "**Εικόνα 4.1.1** _Κληρονομικότητα κλάσεων στο BlueJ_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20bf3d4d-4080-4a78-aec1-a8588d27eb21",
   "metadata": {},
   "source": [
    "Θα πρέπει να κάνουμε κάποιες αλλαγές στις δυο κλάσεις για να διαγράψουμε τον κοινό κώδικα που έχουμε ορίσει στην ```Vehicle```. \n",
    "\n",
    "1. Διαγράψτε όλα τα πεδία από την κλάση ```Car```. Αυτά έχουν ήδη οριστεί στην ```Vehicle``` ως ```protected``` οπότε κληρονομούνται από τις υποκλάσεις.\n",
    "1. Υπάρχει λάθος μεταγλώττισης στον constructor. Για να δημιουργηθεί ένα αντικείμενο της υποκλάσης θα πρέπει πρώτα να κληθεί ο constructor της υπερκλάσης. Αυτό το πετυχαίνουμε αντικαθιστώντας το σώμα της μεθόδου κατασκευής της ```Car``` με:\n",
    "   ```java\n",
    "   super(m, s, c);\n",
    "   ```\n",
    "1. Διαγράψτε όλες τις άλλες μεθόδους εκτός από τις ```accelerate(), decelerate()``` και ```toString()```.\n",
    "1. Επαναλάβετε τα παραπάνω βήματα για την ```Motorcycle```.\n",
    "\n",
    "Το αποτέλεσμα φαίνεται παρακάτω:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c018b483-cc09-4690-b102-cf4c6263f71f",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Car extends Vehicle { // κλάση\n",
    "     // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "    public Car(String m, int s, int c) {\n",
    "        super(m, s, c);\n",
    "    }\n",
    "    // ενέργειες/μέθοδοι\n",
    "    public void accelerate() {\n",
    "        if (speed <= maxSpeed - 10)\n",
    "            speed+=10;\n",
    "    }\n",
    "\n",
    "    public void decelerate() {\n",
    "        if (speed >= 10)\n",
    "            speed-=10;\n",
    "    }  \n",
    "\n",
    "    public String toString() {\n",
    "        return \"Car {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7d15115d-dfc2-449d-a674-f3df81edc512",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Motorcycle extends Vehicle { // κλάση\n",
    "  // ιδιότητες/γνωρίσματα\n",
    "  // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "  public Motorcycle(String m, int s, int c) {\n",
    "    super(m, s, c);\n",
    "  }\n",
    "  // ενέργειες/μέθοδοι\n",
    "  public void accelerate() {\n",
    "     if (speed <= maxSpeed - 20)\n",
    "        speed+=20;\n",
    "  }\n",
    "  public void decelerate() {\n",
    "     if (speed >= 20)\n",
    "        speed-=20;\n",
    "  }  \n",
    "  public String toString() {\n",
    "    return \"Motorcycle {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm=\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e60d5b8e-e9a1-4e24-aa01-99249955916d",
   "metadata": {},
   "source": [
    "Τα κοινά στοιχεία δυο ή περισσοτέρων παρόμοιων κλάσεων μπορούν να οριστούν σε μια κοινή _υπερκλάση (superclass)_. Μία _υποκλάση (subclass)_ μπορεί να κληρονομήσει όλα τα \"επιτρεπτά\" γνωρίσματα και μεθόδους από τους \"προγόνους\" της (δηλ. όσα είναι δηλωμένα ως ```protected``` και ```public```) εκτός από τις μεθόδους κατασκευής. Αν οι κλάσεις βρίσκονται στο ίδιο package, τότε και μέλη με προσβασιμότητα πακέτου είναι διαθέσιμα στην κλάση παιδί. Η σχέση μεταξύ μιας υπερκλάσης και μιας υποκλάσης είναι σχέση τύπου \"ΕΊΝΑΙ (IS-A)\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c70cb177-a888-4186-864d-ce5c6723e00e",
   "metadata": {},
   "source": [
    "Μια υποκλάση μπορεί να ορίσει νέα γνωρίσματα και μεθόδους, μπορεί να υπερφορτώσει υφιστάμενες μεθόδους (overloading) ή ακόμα και να υπερσκελίσει (επανακαθορίσει, υπερκαλύψει) υφιστάμενες μεθόδους (overriding). Όλες οι κλάσεις στη Java κληρονομούν από την κλάση ```Object```."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12a9c4c4-c069-479d-8b9d-11adad18abd5",
   "metadata": {},
   "source": [
    "Η ```super()``` χρησιμοποιείται:\n",
    "\n",
    "* για να καλέσει τον constructor της υπερκλάσης καθώς αυτοί δεν κληρονομούνται. Στην περίπτωση αυτή πρέπει να είναι η πρώτη εντολή στον κώδικα της μεθόδου κατασκευής της υποκλάσης.\n",
    "* για να καλέσει μία μέθοδο της υπερκλάσης\n",
    "\n",
    "Η κλήση της μεθόδου κατασκευής μιας υποκλάσης καλεί τις μεθόδους κατασκευής όλων των υπερκλάσεων αυτής."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "905452b0-81b1-4394-98ab-68ec646e869a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person {\n",
    "   public Person() {\n",
    "      System.out.println(\"(1) Person's no-arg constructor\");\n",
    "   }\n",
    "}\n",
    "\n",
    "class Student extends Person {\n",
    "\tpublic Student() {\n",
    "\t\tSystem.out.println(\"(2) Student's no-arg constructor\");\n",
    "\t}\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8aa3ad71-ee09-492c-bf59-f1a5131ac96e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1) Person's no-arg constructor\n",
      "(2) Student's no-arg constructor\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "REPL.$JShell$18$Student@1a55b70d"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new Student();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b91204-71bd-4d2a-bab7-b1c3b555118d",
   "metadata": {},
   "source": [
    "Στο πιο πάνω παράδειγμα βλέπουμε ότι παρόλο που ο constructor της κλάσης ```Student``` δεν καλεί την ```super```, η εξ'ορισμού μέθοδος κατασκευής (default constructor) της υπερκλάσης καλείται ούτως ή άλλως. \n",
    "\n",
    "Όπως έχουμε ήδη πει, αν δεν ορίσουμε κάποιον constructor σε μια κλάση, τότε δημιουργείται αυτόματα ο no argument constructor, διαφορετικά αν ορίσουμε έναν constructor, δε δημιουργείται no argument constructor. Αυτό έχει ως συνέπεια κώδικας όπως ο παρακάτω να μην μεταγλωττίζεται καθώς ο εξ'ορισμού no argument constructor της ```Carnivor``` δεν βρίσκει να καλέσει no argument constructor στην υπερκλάση. Από τη στιγμή που ορίσαμε constructor στην ```Animal```, δεν δημιουργείται η εξ'ορισμού μέθοδος κατασκευής χωρίς παραμέτρους. Καθώς όμως δεν ορίσαμε constructor στην ```Carnivor```, δημιουργείται σ' αυτήν no argument constructor, ο οποίος θα προσπαθήσει να καλέσει τον no argument constructor της ```Animal```, δεν τον βρίσκει οπότε έχουμε το παρακάτω λάθος μεταγλώττισης."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c842ee21-239a-456a-95d3-549ca436e8d1",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[31mconstructor Animal in class Animal cannot be applied to given types;\u001b[0m",
      "\u001b[1m\u001b[31m  required: java.lang.String\u001b[0m",
      "\u001b[1m\u001b[31m  found:    no arguments\u001b[0m",
      "\u001b[1m\u001b[31m  reason: actual and formal argument lists differ in length\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "class Animal {\n",
    "   public Animal(String name) {\n",
    "      //...\n",
    "   }\n",
    "}\n",
    "\n",
    "public class Carnivor extends Animal {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56ac62c7-63ba-4770-929d-4c4bf6c7d472",
   "metadata": {},
   "source": [
    "### Επισημειώσεις (Annotations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c8bee10-0e50-40d7-ac3e-e8f492c81872",
   "metadata": {},
   "source": [
    "Το ```@Override``` είναι μια _επισημείωση (annotation)_ η οποία χρησιμοποιείται από τον μεταγλωττιστή για να επιβεβαιώσει ότι υπερκαλύπτουμε (override) τη σωστή μέθοδο, διαφορετικά ο μεταγλωττιστής εμφανίζει λάθος μεταγλώττισης (```method does not override or implement a method```). Η γλώσσα διαθέτει κι άλλες τέτοιες επισημειώσεις όπως:\n",
    "\n",
    "* ```@deprecated```: δηλώνει ότι η μέθοδος/κλάση/γνώρισμα κλπ. δεν εγκρίνεται προς χρήση πλέον (είτε γιατί υπάρχει μια καλύτερη υλοποίηση, είτε γιατί η υλοποίησή της ήταν λάθος, είτε γιατί μπορεί να διαγραφεί ή να είναι ασύμβατη σε μελλοντικές εκδόσεις). Ο μεταγλωττιστής παράγει προειδοποιήσεις (warnings) όταν χρησιμοποιείται. Π.χ. ```@deprecated(since=\"9\", forRemoval=true)``` δηλώνει ότι το στοιχείο αυτό (μέθοδος/κλάση/γνώρισμα κλπ.) έχει γίνει παρωχημένο από την έκδοση 9 της Java και ότι πρόκειται να διαγραφεί στο μέλλον\n",
    "* ```@SuppressWarnings```: προτρέπει τον μεταγλωττιστή να μην εμφανίζει προειδοποιήσεις (warnings) κατά τη μεταγλώττιση, π.χ. ```@SuppressWarnings(\"unchecked\")```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4671ecd9-8b9c-4cf4-8f88-f8fef818f887",
   "metadata": {},
   "source": [
    "### Αρχή της Υποκατάστασης (Substitution Principle)\n",
    "\n",
    "Η _Αρχή της Υποκατάστασης (Substitution Principle)_ μας λέει ότι όταν περιμένουμε ένα αντικείμενο μιας κλάσης, μπορούμε να παρέχουμε και μια οποιανδήποτε υπο-κλάσης αυτής της κλάσης:\n",
    "\n",
    "**Αρχή της Υποκατάστασης (Substitution Principle)**: _σε μια μεταβλητή μιας δοθείσας κλάσης μπορεί να αποθηκευθεί μια τιμή μιας οποιασδήποτε υπο-κλάσης αυτής της κλάσης, και μια μέθοδος με μια παράμετρο μιας δοθείσας κλάσης μπορεί να κληθεί με όρισμα μια οποιαδήποτε υποκλάση αυτής της κλάσης._\n",
    "\n",
    "Με βάση την αρχή αυτή μπορούμε να γράψουμε:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7a205b3f-a822-4399-bf38-2a19434c1d66",
   "metadata": {},
   "outputs": [],
   "source": [
    "Vehicle v = new Car(\"Subaru Impreza\", 180, 1600);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c6bdc95-06ef-4a97-adcb-ea2d70fcb468",
   "metadata": {},
   "source": [
    "Δεν μπορούμε όμως να γράψουμε το ανάποδο."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8032cba1-15e1-4384-88a4-824d0775887d",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mCar c = \u001b[0m\u001b[1m\u001b[30m\u001b[41mnew Vehicle(\"Subaru Impreza\", 180, 1600)\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mincompatible types: Vehicle cannot be converted to Car\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "Car c = new Vehicle(\"Subaru Impreza\", 180, 1600);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c27d89a-df9a-45ca-8486-e6a53d355b23",
   "metadata": {},
   "source": [
    "Αν δε θέλουμε να επιτρέψουμε να μπορούν να δημιουργηθούν υποκλάσεις μιας κλάσης (δηλ. δε θέλουμε να μπορεί να κληρονομηθεί) τότε τη δηλώνουμε ως ```final``` (π.χ. ```public final class Car```). \n",
    "\n",
    "Επίσης, αν δε θέλουμε να μπορούν να υπερκαλυφθούν (overriden) οι μέθοδοι μιας κλάσης, τότε τις δηλώνουμε ```final```, π.χ.:\n",
    "\n",
    "```java\n",
    "public final int getEdges() { // δεν μπορεί να υπερκαλυφθεί από τις υποκλάσεις\n",
    "   return this.points.length;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c5dbf01-b494-4e55-ad8d-6fffa257d048",
   "metadata": {},
   "source": [
    "Εξασκηθείτε στις παραπάνω κλάσεις εδώ <a href=\"sandbox/vehicle.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50653b32-7d78-499f-82d2-d2b31bb0651d",
   "metadata": {},
   "source": [
    "### Σειρά εκτέλεσης υπερσκελισμένης μεθόδου στον constructor\n",
    "Ένα συχνό λάθος είναι όταν καλούμε μια υπερκαλυμμένη (overridable) μέθοδο στο σώμα της μεθόδου κατασκευής (constructor). Ας δούμε ένα παράδειγμα:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "177a2f61-58c0-4527-ab99-50a3c5b094da",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.awt.Color;\n",
    "class Point {\n",
    "  protected final int x, y;\n",
    "\n",
    "  public Point(int x, int y) {  // 3\n",
    "\t  this.x = x;  \n",
    "\t  this.y = y;\n",
    "\t  print();  // 4\n",
    "  }\n",
    "\n",
    "  public int getX() {\n",
    "\t  return this.x;\n",
    "  }\n",
    "\n",
    "  public int getY() {\n",
    "\t  return this.y;\n",
    "  } \n",
    "\n",
    "  public void print() {\n",
    "  \tSystem.out.println(\"{x=\" + this.x + \", y=\" + this.y + \"}\");\n",
    "  }\n",
    "}\n",
    "\n",
    "class ColouredPoint extends Point {\n",
    "\tprivate Color color = null;\n",
    "\t\n",
    "\tpublic ColouredPoint(int x, int y, Color color) {  // 1\n",
    "\t\tsuper(x, y);  // 2\n",
    "\t\tthis.color = color;\n",
    "\t}\n",
    "\t\n",
    "\tpublic Color getColor() {\n",
    "\t\treturn color;\n",
    "\t}\n",
    "    \n",
    "    @Override\n",
    "  \tpublic void print() {  // 5\n",
    "  \t\tSystem.out.println(\"{x=\" + this.x + \", y=\" + this.y + \", color=\" + this.color + \"}\");\n",
    "  \t}\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "94f0ba3d-5f1f-4f5c-9c03-4303fe907a4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{x=1, y=1}\n"
     ]
    }
   ],
   "source": [
    "Point p = new Point(1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "dfaa3989-d854-4e1d-b04d-4aa3771fbe44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{x=1, y=2, color=null}\n"
     ]
    }
   ],
   "source": [
    "Point cp = new ColouredPoint(1,2,Color.BLACK)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8143e799-60bf-47b4-84d1-b76d4a51444a",
   "metadata": {},
   "source": [
    "1. Καλείται η μέθοδος κατασκευής της ColouredPoint\n",
    "2. Με τη σειρά της καλεί την μέθοδο κατασκευής της υπερκλάσης\n",
    "3. Καλείται ο constructor της ```Point``` \n",
    "4. Ο δε constructor της ```Point``` καλεί την μέθοδο ```print()``` της υποκλάσης \n",
    "5. Καλείται η ```print()``` της υποκλάσης η οποία με τη σειρά της τυπώνει την τιμή της ```color``` η οποία δεν έχει προλάβει ν' αρχικοποιηθεί ακόμα. (Το γιατί συμβαίνει αυτό θα το εξηγήσουμε στο επόμενο μάθημα).\n",
    "\n",
    "Το πρόβλημα διορθώνεται είτε αν αποφύγουμε να καλέσουμε την υπερκαλυμμένη μέθοδο ```print()``` στον constructor της ```Point``` είτε αν δηλώσουμε την ```print()``` ως ```final``` ώστε να μην μπορεί να υπερκαλυφθεί."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d3c936-35bb-4f10-af00-100afd120275",
   "metadata": {},
   "source": [
    "## Αφαιρετικές/Ιδεατές Κλάσεις (Abstract class)\n",
    "Η κλάση ```Vehicle``` είναι αφαιρετική κλάση, με την έννοια ότι δεν έχει νόημα να δημιουργήσουμε αντικείμενα απ' αυτήν, ενώ έχει νόημα να δημιουργήσουμε αντικείμενα των υποκλάσεών της ```Car``` και ```Motorcycle```. Μπορούμε λοιπόν να δηλώσουμε την κλάση ```Vehicle``` ως ```abstract``` και έτσι να εμποδίσουμε την απευθείας δημιουργία αντικειμένων τύπου ```Vehicle```. \n",
    "\n",
    "Μια αφαιρετική κλάση μπορεί να περιλαμβάνει αφαιρετικές μεθόδους, δηλ. μεθόδους που δεν έχουν σώμα υλοποίησης παρά μόνο ορισμό. Την υλοποίηση των αφαιρετικών μεθόδων την αναλαμβάνουν οι υποκλάσεις, οι οποίες υποχρεούνται να παρέχουν μια υλοποίηση για τις αφαιρετικές μεθόδους που κληρονομούν, διαφορετικά πρέπει να δηλωθούν κι αυτές ως ```abstract```."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f7541a-6388-4cc2-817c-57711c6e70c5",
   "metadata": {},
   "source": [
    "Συνοπτικά λοιπόν, μια κλάση η οποία περιλαμβάνει έστω και μια «αφαιρετική» μέθοδο, καθίσταται επίσης αφαιρετική και πρέπει να δηλωθεί ως αφαιρετική (abstract). Δε μπορούμε να δημιουργήσουμε αντικείμενα μιας αφαιρετικής κλάσης εκτός κι αν παρέχουμε μια υλοποίηση όλων των αφαιρετικών μεθόδων της. Μια κλάση που κληρονομεί από μια αφαιρετική κλάση θα πρέπει να υλοποιήσει όλες τις αφαιρετικές μεθόδους της υπερκλάσης, διαφορετικά ο μεταγλωτιστής επιβάλλει να οριστεί και η υποκλάση ως αφαιρετική."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "345d5863-32b0-46b1-8d85-0eabf2f532c9",
   "metadata": {},
   "source": [
    "Παρακάτω δηλώνουμε την κλάση ```Vehicle``` ως ```abstract``` καθώς και δυο ```abstract``` μεθόδους, τις ```accelerate(), decelerate()```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a69c44b4-dd8e-4aa3-8e3b-da396138c35e",
   "metadata": {},
   "outputs": [],
   "source": [
    "public abstract class Vehicle { // κλάση\n",
    "  // ιδιότητες/γνωρίσματα\n",
    "  protected String model;\n",
    "  protected int maxSpeed;\n",
    "  protected int ccm;\n",
    "  protected int speed = 0;\n",
    "  // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "  public Vehicle(String m, int s, int c) {\n",
    "    model = m; maxSpeed = s; ccm = c;\n",
    "  }\n",
    "  // ενέργειες/μέθοδοι\n",
    "  public String getModel() {\n",
    "  \treturn model;\n",
    "  }\n",
    "  public void setModel(String m) {\n",
    "    this.model = m;\n",
    "  }\n",
    "  public int getMaxSpeed() {\n",
    "  \treturn maxSpeed;\n",
    "  }\n",
    "  public void setMaxSpeed(int ms) {\n",
    "    this.maxSpeed = ms;\n",
    "  }        \n",
    "  public int getCcm() {\n",
    "  \treturn ccm;\n",
    "  }\n",
    "  public void setCcm(int ccm) {\n",
    "    this.ccm = ccm;\n",
    "  }      \n",
    "  public int getSpeed() {\n",
    "  \treturn speed;\n",
    "  }\n",
    "  public abstract void accelerate();\n",
    "  public abstract void decelerate();  \n",
    "    \n",
    "  public String toString() {\n",
    "    return \"Vehicle {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm=\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "68ebfdc3-f340-4ae4-90d5-372b4fd8c15e",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mVehicle v = \u001b[0m\u001b[1m\u001b[30m\u001b[41mnew Vehicle(\"Abstract Vehicle\", 100, 1000)\u001b[0m\u001b[1m\u001b[30m; \u001b[0m",
      "\u001b[1m\u001b[31mVehicle is abstract; cannot be instantiated\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "Vehicle v = new Vehicle(\"Abstract Vehicle\", 100, 1000); "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c017a10-96e2-4e39-87f8-5345ef6483b3",
   "metadata": {},
   "source": [
    "Παρατηρούμε ότι δεν μπορούμε ν' αρχικοποιήσουμε μια abstract κλάση.\n",
    "\n",
    "```Abstract``` κλάσεις και μέθοδοι αναπαρίστανται με πλάγια γραφή στη UML. Στο παρακάτω UML διάγραμμα κλάσεων, η ```Shape``` και οι μέθοδοι ```area()``` και ```perimeter()``` έχουν δηλωθεί ως abstract.\n",
    "\n",
    "![](assets/Fig2.png)\n",
    "\n",
    "**Εικόνα 4.1.2** _Παράδειγμα ιεραρχίας κλάσεων στη UML_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b73e0d5c-3e15-4a88-98c0-0065d521b7ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Point(int x, int y) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3afd0cb1-fe88-4203-bc23-68ae0930cc87",
   "metadata": {},
   "outputs": [],
   "source": [
    "public abstract class Shape {   \n",
    "  protected final Point[] points;\n",
    " \n",
    "  Shape(int edges) {\n",
    "     this.points = new Point[edges];\n",
    "  }  \n",
    "\n",
    "  Shape(Point... points) {\n",
    "     this.points = points;\n",
    "  }\n",
    "\n",
    "  public int getEdges() {\n",
    "     return this.points.length;\n",
    "  }\n",
    " \n",
    "  protected abstract double area();\n",
    "\n",
    "  protected abstract double perimeter();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6139cf19-0229-47b4-8148-028026dd72b5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "public class Circle extends Shape {  \n",
    "  private final int radius;\n",
    "\n",
    "  Circle() {\n",
    "    super(1);\n",
    "    this.radius = 1;\n",
    "  }  \n",
    "\n",
    "  Circle(Point center, int radius) {\n",
    "    super(center);\n",
    "    this.radius = radius;\n",
    "  }    \n",
    "  \n",
    "  public int getRadius() {\n",
    "    return radius;\n",
    "  }\n",
    "    \n",
    "  public Point getCenter() {\n",
    "    return points[0];   \n",
    "  }\n",
    "\n",
    "  @Override\n",
    "  public double area() {\n",
    "      return Math.PI * (radius * radius);\n",
    "  } \n",
    "\n",
    "  @Override\n",
    "  public double perimeter() {\n",
    "    return Math.PI * 2*radius;\n",
    "  } \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7062dcc3-f70a-4c4e-b482-8f2139d0c2bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Rectangle extends Shape {  \n",
    "  private int width, height; \n",
    "\n",
    "  Rectangle(int width, int height) {\n",
    "    super(1);\n",
    "    this.width = width;\n",
    "    this.height = height;\n",
    "  }  \n",
    "\n",
    "  Rectangle(Point upperLeft, int width, int height) {\n",
    "    super(upperLeft);\n",
    "    this.width = width;\n",
    "    this.height = height;\n",
    "  }\n",
    "  \n",
    "  public int getWidth() {\n",
    "    return width;\n",
    "  }\n",
    "  \n",
    "  public int getHeight() {\n",
    "    return height;\n",
    "  }\n",
    "\n",
    "  @Override\n",
    "  public double area() {\n",
    "      return width * height;\n",
    "  } \n",
    "  \n",
    "  @Override\n",
    "  public double perimeter() {\n",
    "    return 2*width + 2*height;\n",
    "  }  \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "278c321f-af31-4818-88e5-1d3a101a1be1",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Triangle extends Shape {\n",
    "\n",
    "    Triangle(Point... points) {\n",
    "        super(points);\n",
    "    }\n",
    "\n",
    "    public Point[] getPoints() {\n",
    "        return points;\n",
    "    }\n",
    "    \n",
    "    // see https://tinyurl.com/msfdtjme\n",
    "    private double length(Point p1, Point p2) {\n",
    "        return Math.sqrt((p2.x() - p1.x()) * (p2.x() - p1.x()) + (p2.y() - p1.y()) * (p2.y() - p1.y()));\n",
    "    }\n",
    "    \n",
    "    // see https://www.ypologismos.gr/emvadon-trigonou-xerontas-3-pleyres-typos-hrona/\n",
    "    @Override\n",
    "    public double area() {\n",
    "        double s = perimeter()/2;\n",
    "        double a = length(points[0], points[1]);\n",
    "        double b = length(points[1], points[2]);\n",
    "        double c = length(points[2], points[0]);\n",
    "        return Math.sqrt(s*(s-a)*(s-b)*(s-c));\n",
    "    }\n",
    "\n",
    "    // https://www.ypologismos.gr/emvadon-trigonou-xerontas-3-pleyres-typos-hrona/\n",
    "    @Override\n",
    "    public double perimeter() {\n",
    "        return length(points[0], points[1]) + length(points[1], points[2]) + length(points[2], points[0]);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8547eda-eb4e-4b9b-96f3-005d337ad1ee",
   "metadata": {},
   "source": [
    "Η σχέση μεταξύ των κλάσεων ```Shape```, ```Circle, Rectangle``` και ```Triangle```  ονομάζεται _γενίκευση (generalization)_ η οποία είναι μια σχέση τύπου _είναι (is a)_.\n",
    "\n",
    "Εξασκηθείτε στις παραπάνω κλάσεις εδώ <a href=\"sandbox/shape.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "657625db-4e84-4362-993b-21d85aecaeb7",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Σχέσεις μεταξύ κλάσεων\n",
    "\n",
    "Στο παραπάνω διάγραμμα βλέπουμε μια ακόμα σχέση μεταξύ κλάσεων, την _συσσωμάτωση (aggregation)_ η οποία είναι μια σχέση τύπου _ανήκει (owns)_. Η σχέση αυτή δηλώνει ότι η κλάση ```Shape``` περιλαμβάνει μια συλλογή από σημεία (```Points```) τα οποία τα αποθηκεύει στην ```protected``` μεταβλητή ```points```.\n",
    "\n",
    "Όπως μπορείτε να δείτε στην Εικόνα 3.3.5 του μαθήματος 3.3 της προηγούμενης εβδομάδας (το οποίο επαναλαμβάνεται παρακάτω)\n",
    "\n",
    "![](../../Week3/3.3-UML/assets/Fig5.png)\n",
    "\n",
    "**Εικόνα 3.3.5.** _Σχέσεις μεταξύ κλάσεων στα διαγράμματα κλάσεων UML_\n",
    "\n",
    "η UML υποστηρίζει διάφορους τύπους σχέσεων μεταξύ κλάσεων. Είδαμε τη _συσσωμάτωση (aggregation)_ αλλά υπάρχει και η _σύνθετη συσσωμάτωση (composite aggregation ή composition)_ (σχέση τύπου _περιέχει (is part of)_). Η διαφορά τους είναι ότι στη δεύτερη περίπτωση, αν καταστραφεί το αντικείμενο που περιέχει τη συλλογή των συσσωματωμένων αντικειμένων, τότε καταστρέφονται και τα συσσωματωμένα αντικείμενα, ενώ στην περίπτωση της απλής συσσωμάτωσης, τα συσσωματωμένα αντικείμενα παραμένουν και μετά την καταστροφή του αντικειμένου που τα περιέχει και μπορούν να επαναχρησιμοποιηθούν από άλλα αντικείμενα. Π.χ. αν καταστραφεί ένα αντικείμενο τύπου ```Rectangle``` το οποίο περιέχει ένα αντικείμενο τύπου ```Point``` για την πάνω αριστερά κορυφή του, τότε ανάλογα με το αν η εφαρμογή μας υποστηρίζει το ```Point``` ως σχήμα ή όχι, η σχέση θα μπορεί να είναι _aggregation_ (αν υποστηρίζει) ή _composite aggregation_ (αν δεν υποστηρίζει οπότε το σημείο θα πρέπει να καταστραφεί μαζί με το αντικείμενο). \n",
    "\n",
    "**Σημείωση** _Η σύνθετη συσσωμάτωση υλοποιείται ως εμφωλιασμένη κλάση (ώστε αντικείμενά της να καταστρέφονται όταν καταστρέφονται και τα αντικείμενα που τις περιέχουν) ενώ η συσσωμάτωση ως στατική εμφωλιασμένη κλάση ώστε να μπορεί να υπάρχει και όταν αντικείμενα της κλάσης που την περιέχουν παύσουν να υπάρχουν. Δεν θα μιλήσουμε για εμφωλιασμένες κλάσεις σε αυτό το μάθημα_."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58811cd3-f660-4c26-8613-91a069d3f6a7",
   "metadata": {},
   "source": [
    "Η σχέση _συσχέτιση (association)_ χρησιμοποιείται όταν μια κλάση σχετίζεται με μια άλλη, δηλ. την έχει ως γνώρισμά της (σχέση _has a_).\n",
    "\n",
    "Π.χ. η κλάση ```Fighter``` έχει ένα γνώρισμα τύπου ```Weapon``` το οποίο δηλώνεται με τη σχέση _συσχέτιση (association)_ στη UML (βλ. Εικόνα 4.1.3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6493d8a7-4cef-45d9-a9ea-3bb40acd511b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Weapon {\n",
    "}\n",
    "\n",
    "class Fighter {\n",
    "\tprivate Weapon weapon;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e20eaae3-d26c-48e0-9dbb-9b253378e00c",
   "metadata": {},
   "source": [
    "![](assets/Fig3.png)\n",
    "\n",
    "**Εικόνα 4.1.3** _Παράδειγμα association με ρόλο (role) στη UML_\n",
    "\n",
    "Τέλος, αν μέσα σε μια μέθοδο μιας κλάσης χρησιμοποιούμε ένα αντικείμενο μιας άλλης κλάσης αλλά χωρίς να την ορίζουμε ως γνώρισμα της κλάσης, τότε χρησιμοποιούμε τη σχέση _εξάρτηση (dependency)_.\n",
    "\n",
    "Παρατηρήστε ότι το BlueJ αναγνωρίζει μόνο τις σχέσεις κληρονομικότητα (inheritance) και εξάρτηση (dependency), μάλιστα τις σχέσεις συσχέτιση (association), συσσωμάτωση (aggregation) και σύνθετη συσσωμάτωση (composite aggregation ή composition) τις εμφανίζει ως εξαρτήσεις."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6e19858-7560-4549-9580-65b3a02a99a4",
   "metadata": {},
   "source": [
    "## Σφραγισμένες κλάσεις\n",
    "Στην έκδοση 15 της Java εμφανίστηκαν δυο νέες δεσμευμένες λέξεις, η ```sealed``` και η ```permits```. Ας δούμε τη χρήση τους μ' ένα παράδειγμα (στο JShell δεν δουλεύει πολύ καλά ακόμα κι αν ενεργοποιήσετε τα προαιρετικά χαρακτηριστικά δίνοντας την παράμετρο):\n",
    "```bash\n",
    "$ ./jshell --enable-preview\n",
    "```\n",
    "γι' αυτό προτιμήστε το NetBeans."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "98318b21-f1e9-4262-bc73-df63f815f9a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Point(int x, int y) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4287597b-739e-4c5b-baca-de1efbd6b134",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mpublic abstract sealed class Shape permits Circle, Rectangle {   \u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  protected final Point[] points;\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m \u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  Shape(int edges) {\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m     this.points = new Point[edges];\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  }  \u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  Shape(Point... points) {\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m     this.points = points;\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  }\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  public int getEdges() {\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m     return this.points.length;\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  }\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m \u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  protected abstract double area();\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  protected abstract double perimeter();\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m}\u001b[0m",
      "\u001b[1m\u001b[31mUnresolved dependencies:\u001b[0m",
      "\u001b[1m\u001b[31m   - class Circle\u001b[0m"
     ]
    }
   ],
   "source": [
    "public abstract sealed class Shape permits Circle, Rectangle {   \n",
    "  protected final Point[] points;\n",
    " \n",
    "  Shape(int edges) {\n",
    "     this.points = new Point[edges];\n",
    "  }  \n",
    "\n",
    "  Shape(Point... points) {\n",
    "     this.points = points;\n",
    "  }\n",
    "\n",
    "  public int getEdges() {\n",
    "     return this.points.length;\n",
    "  }\n",
    " \n",
    "  protected abstract double area();\n",
    "\n",
    "  protected abstract double perimeter();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1c1abc65-e4e7-43bd-8e53-85ec1603dbc0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mpublic final class Circle extends \u001b[0m\u001b[1m\u001b[30m\u001b[41mShape\u001b[0m\u001b[1m\u001b[30m {  \u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   class Shape\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m    return \u001b[0m\u001b[1m\u001b[30m\u001b[41mpoints\u001b[0m\u001b[1m\u001b[30m[0];   \u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable points\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  \u001b[0m\u001b[1m\u001b[30m\u001b[41m@Override\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mmethod does not override or implement a method from a supertype\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  \u001b[0m\u001b[1m\u001b[30m\u001b[41m@Override\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mmethod does not override or implement a method from a supertype\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "public final class Circle extends Shape {  \n",
    "  private final int radius;\n",
    "\n",
    "  Circle() {\n",
    "    super(1);\n",
    "    this.radius = 1;\n",
    "  }  \n",
    "\n",
    "  Circle(Point center, int radius) {\n",
    "    super(center);\n",
    "    this.radius = radius;\n",
    "  }    \n",
    "  \n",
    "  public int getRadius() {\n",
    "    return radius;\n",
    "  }\n",
    "    \n",
    "  public Point getCenter() {\n",
    "    return points[0];   \n",
    "  }\n",
    "\n",
    "  @Override\n",
    "  public double area() {\n",
    "      return Math.PI * (radius * radius);\n",
    "  } \n",
    "\n",
    "  @Override\n",
    "  public double perimeter() {\n",
    "    return Math.PI * 2*radius;\n",
    "  } \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d6639ca3-dadf-4973-9c44-c14bf847a4c4",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mpublic final class Rectangle extends \u001b[0m\u001b[1m\u001b[30m\u001b[41mShape\u001b[0m\u001b[1m\u001b[30m {  \u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   class Shape\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  \u001b[0m\u001b[1m\u001b[30m\u001b[41m@Override\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mmethod does not override or implement a method from a supertype\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  \u001b[0m\u001b[1m\u001b[30m\u001b[41m@Override\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mmethod does not override or implement a method from a supertype\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "public final class Rectangle extends Shape {  \n",
    "  private final int width, height; \n",
    "\n",
    "  Rectangle(int width, int height) {\n",
    "    super(1);\n",
    "    this.width = width;\n",
    "    this.height = height;\n",
    "  }  \n",
    "\n",
    "  Rectangle(Point upperLeft, int width, int height) {\n",
    "    super(upperLeft);\n",
    "    this.width = width;\n",
    "    this.height = height;\n",
    "  }\n",
    "  \n",
    "  public int getWidth() {\n",
    "    return width;\n",
    "  }\n",
    "  \n",
    "  public int getHeight() {\n",
    "    return height;\n",
    "  }\n",
    "\n",
    "  @Override\n",
    "  public double area() {\n",
    "      return width * height;\n",
    "  } \n",
    "  \n",
    "  @Override\n",
    "  public double perimeter() {\n",
    "    return 2*width + 2*height;\n",
    "  }  \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d439033c-9c24-4c85-8918-1917d2c6187d",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mpublic class Triangle extends \u001b[0m\u001b[1m\u001b[30m\u001b[41mShape\u001b[0m\u001b[1m\u001b[30m {  \u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   class Shape\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m    return \u001b[0m\u001b[1m\u001b[30m\u001b[41mpoints\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable points\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  \u001b[0m\u001b[1m\u001b[30m\u001b[41m@Override\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mmethod does not override or implement a method from a supertype\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m      return \u001b[0m\u001b[1m\u001b[30m\u001b[41mwidth\u001b[0m\u001b[1m\u001b[30m * height;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable width\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m      return width * \u001b[0m\u001b[1m\u001b[30m\u001b[41mheight\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable height\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m  \u001b[0m\u001b[1m\u001b[30m\u001b[41m@Override\u001b[0m\u001b[1m\u001b[30m\u001b[0m",
      "\u001b[1m\u001b[31mmethod does not override or implement a method from a supertype\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m    return 2*\u001b[0m\u001b[1m\u001b[30m\u001b[41mwidth\u001b[0m\u001b[1m\u001b[30m + 2*height;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable width\u001b[0m",
      "",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m    return 2*width + 2*\u001b[0m\u001b[1m\u001b[30m\u001b[41mheight\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable height\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "public class Triangle extends Shape {  \n",
    "\n",
    "  Triangle(Point... points) {\n",
    "    super(points);\n",
    "  }\n",
    "  \n",
    "  public Point[] getPoints() {\n",
    "    return points;\n",
    "  }\n",
    "\n",
    "  @Override\n",
    "  public double area() {\n",
    "      return width * height;\n",
    "  } \n",
    "  \n",
    "  @Override\n",
    "  public double perimeter() {\n",
    "    return 2*width + 2*height;\n",
    "  }  \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d954fdec-ae14-4d59-9dc1-84bd0b39d82c",
   "metadata": {},
   "source": [
    "Η ```sealed``` περιορίζει ποιες άλλες κλάσεις μπορούν να κληρονομήσουν την κλάση ```Shape```. Βλέπουμε ότι επιτρέπει μόνο τις ```Circle, Rectangle``` με αποτέλεσμα η κλάση ```Triangle``` να εμφανίζει λάθος μεταγλώττισης. \n",
    "\n",
    "```\n",
    "error: class is not allowed to extend sealed class: Shape (as it is not listed in its permits clause)\n",
    "```\n",
    "\n",
    "Από δω και πέρα, έχουμε διάφορες επιλογές για τις (επιτρεπόμενες) υποκλάσεις (```Circle, Rectangle```). Μπορούμε να τις ορίσουμε ως ```final``` (δεν επιτρέπεται να κληρονομηθούν), ή ως ```sealed``` (οπότε πρέπει να ορίσουμε με την ```permits``` ποιες άλλες κλάσεις επιτρέπεται να τις κληρονομήσουν), ή ακόμα μπορούμε να τις ορίσουμε ως ```non-sealed```.\n",
    "\n",
    "Στα μαθήματα της 1ης εβδομάδας μάθαμε για τη νέα σύνταξη της ```switch```. Οι ```sealed``` κλάσεις επιτρέπουν την απλοποίησή της, καθώς, όπως βλέπουμε στο παρακάτω παράδειγμα δεν απαιτείται ```default```:\n",
    "\n",
    "```java\n",
    "double area = switch (shape) {\n",
    "  case Circle c -> Math.pow(c.radius(), 2)*Math.PI\n",
    "  case Rectangle r -> r.a() * r.b()\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8d2c5b-3085-45d8-a16d-39be6603f86f",
   "metadata": {},
   "source": [
    "Εξασκηθείτε στις παραπάνω κλάσεις εδώ <a href=\"sandbox/sealed.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1fd52a0-1d24-4413-8ebe-7418ee275018",
   "metadata": {},
   "source": [
    "## Κλάση ```Object```\n",
    "Όλες οι κλάσεις στη Java κληρονομούν (νοητά) από την κλάση ```Object``` (δηλ. κάθε κλάση μπορεί να γραφτεί και ως ```class MyClass extends Object```). Η κλάση ```Object``` είναι η ριζική κλάση της ιεραρχίας, δηλ. η μόνη που δεν έχει γονέα. Οι πρωτογενείς τύποι ```int, char``` κλπ. δεν κληρονομούν από την ```Object``` αφού δεν είναι αντικείμενα, οι επικαλυπτόμενοι τύποι ```Integer, Character``` κλπ. όμως την κληρονομούν. \n",
    "\n",
    "Η κλάση ```Object``` δηλώνει έναν αριθμό από χρήσιμες μεθόδους:\n",
    "\n",
    "```java\n",
    "public class Object {\n",
    "\tboolean\tequals(Object obj); // Indicates whether some other object is \"equal to\" this one.\n",
    "\tint\thashCode();\t// Returns a hash code value for the object.\n",
    "\tString toString(); \t// Returns a string representation of the object.\n",
    "}\n",
    "```\n",
    "Είναι πολύ σημαντικό να υπερκαλύπτουμε (override) αυτές τις μεθόδους όταν ορίζουμε τις κλάσεις μας. \n",
    "\n",
    "Η ```equals()``` ελέγχει για ισότητα μεταξύ δυο αντικειμένων και είναι πολύ σημαντική όταν θέλουμε να συγκρίνουμε αντικείμενα. Επιστρέφει ```true``` αν ένα αντικείμενο της κλάσης είναι ίσο μ' ένα άλλο αντικείμενο της κλάσης ή μιας υποκλάσης της κλάσης. \n",
    "\n",
    "Η ```hashCode()``` επιστρέφει ένα μοναδικό αριθμό με βάση τις τιμές των γνωρισμάτων του αντικειμένου της κλάσης και χρησιμοποιείται όταν το αντικείμενο εισαχθεί σε μια συλλογή (για τις συλλογές θα μιλήσουμε σε επόμενο μάθημα). \n",
    "\n",
    "Τέλος η ```toString()``` επιστρέφει μια αναπαράσταση του αντικειμένου σε φιλική μορφή για τον προγραμματιστή. Μας βοηθάει ώστε να αναγνωρίζουμε εύκολα τι τιμές έχει το αντικείμενό μας. Η κλάση ```Object``` παρέχει μια όχι και τόσο χρήσιμη υλοποίηση της μεθόδου αυτής παρέχοντας το όνομα της κλάσης, το χαρακτήρα ```@``` ακολουθούμενο από τον κωδικό κατακερματισμού (hash) της κλάσης.\n",
    "\n",
    "Σε γενικές γραμμές, μια καλή υλοποίηση της μεθόδου ```equals()``` πρέπει ν' ακολουθεί τους εξής κανόνες:\n",
    "\n",
    "1. Έλεγχος αν ένα αντικείμενο είναι ίδιο με τον εαυτό του χρησιμοποιώντας τον τελεστή ```==```\n",
    "1. Έλεγχος αν το αντικείμενο που περνάμε είναι του ίδιου τύπου, με χρήση της ```instanceof``` (η οποία καλύπτει και την περίπτωση το αντικείμενο που περνάμε να είναι ```null```)\n",
    "1. Μετατροπή (cast) του αντικειμένου που περνάμε στον σωστό τύπο\n",
    "1. Έλεγχος για ισότητα όλων των γνωρισμάτων των δυο αντικειμένων\n",
    "1. Πάντα υπερσκελίστε την ```hashCode()``` όταν υπερσκελίζετε την ```equals()```. Δυο ίσα αντικείμενα (με βάση την ```equals()```) πρέπει να επιστρέφουν την ίδια τιμή ```hashCode()```\n",
    "\n",
    "Π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a7e49a25-e00a-4872-96a6-2e4474ace6b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Car extends Vehicle { // κλάση\n",
    "     // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "    public Car(String m, int s, int c) {\n",
    "        super(m, s, c);\n",
    "    }\n",
    "    // ενέργειες/μέθοδοι\n",
    "    public void accelerate() {\n",
    "        if (speed <= maxSpeed - 10)\n",
    "            speed+=10;\n",
    "    }\n",
    "\n",
    "    public void decelerate() {\n",
    "        if (speed >= 10)\n",
    "            speed-=10;\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public boolean equals(Object o) {\n",
    "      if (o == this)\n",
    "        return true;\n",
    "      if (!(o instanceof Car car))\n",
    "        return false;\n",
    "      return car.model.equals(this.model) && car.maxSpeed == this.maxSpeed && car.ccm == this.ccm;\n",
    "    }\n",
    "  \n",
    "    @Override \n",
    "    public int hashCode() {\n",
    "      int result = model.hashCode();\n",
    "      result = 31 * result + Integer.hashCode(maxSpeed);\n",
    "      result = 31 * result + Integer.hashCode(ccm);\n",
    "      return result;\n",
    "    // return Objects.hash(model, maxSpeed, ccm);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        return \"Car {model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm\" + ccm + \", speed=\" + speed  + \"}\";   \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72def1d5-b9ce-41c1-acb1-8f5afb27ec9b",
   "metadata": {},
   "source": [
    "Ο τελεστής ```instanceof``` ελέγχει από ποια κλάση δημιουργήθηκε αρχικά το αντικείμενο. Η παραπάνω σύνταξη είναι αυτή που εισήχθηκε στην έκδοση 14. Πριν από την έκδοση 14 κάποιος έπρεπε να γράψει:\n",
    "```java\n",
    "@Override\n",
    "public boolean equals(Object o) {\n",
    "  if (o == this)\n",
    "    return true;\n",
    "  if (!(o instanceof Car))\n",
    "    return false;\n",
    "  Car car = (Car)o;\n",
    "  return car.model.equals(this.model) && car.maxSpeed == this.maxSpeed && car.ccm == this.ccm;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8b9da72-7433-4eca-851d-2159f8dea2ce",
   "metadata": {},
   "source": [
    "ΟΠΕ όπως το NetBeans παρέχουν δυνατότητες ώστε να παράγετε εύκολα και γρήγορα αυτές τις μεθόδους. Απλά κάντε δεξί κλικ μέσα σε μια κλάση και επιλέξτε **Insert code --> Generate --> equals() and hashCode()** και αντίστοιχα **Insert code --> Generate --> toString()**. Θα εμφανιστεί ένα διαλογικό παράθυρο που θα σας ρωτήσει ποια γνωρίσματα θέλετε να χρησιμοποιήσετε. Επιλέξτε τα ίδια γνωρίσματα για τις ```equals()``` και ```hashCode()```. Όταν πατήσετε **ΟΚ** το NetBeans θα δημιουργήσει τις μεθόδους αυτές για εσάς. Επίσης, το σχόλιο μεταγλώττισης ```@AutoValue``` της [Google](https://github.com/google/auto/blob/master/value/userguide/index.md) κάνει την ίδια δουλειά. Για μια πιο λεπτομερή περιγραφή αυτών των μεθόδων και πώς θα πρέπει να τις υλοποιείτε, βλ. πηγή [1].\n",
    "\n",
    "Ο τελεστής ```==``` συγκρίνει αν δυο αντικείμενα έχουν την ίδια ταυτότητα (object ID) κι όχι αν έχουν την ίδια τιμή. Αν θέλουμε να συγκρίνουμε αν οι τιμές δυο αντικειμένων είναι ίσες τότε θα πρέπει να χρησιμοποιήσουμε την μέθοδο ```equals()```.\n",
    "\n",
    "**Σημαντική σημείωση** _Ενώ για τη σύγκριση πρωτογενών τύπων (raw types) χρησιμοποιούμε τον τελεστή ```==```, κάτι τέτοιο δε συνιστάται για τη σύγκριση αντικειμένων. Ο τελεστής ```==``` δηλώνει σύγκριση ταυτότητας των αντικειμένων αντί για ισότητα των τιμών τους. Συγκρίνει δηλ. αν η ταυτότητα του αντικειμένου ```objA``` είναι ίση με την ταυτότητα του αντικειμένου ```objB``` δηλ. για το αν πρόκειται για το ίδιο αντικείμενο στη μνήμη σωρού ή όχι. Για να συγκρίνουμε αν οι τιμές των δυο αντικειμένων είναι ίσες, θα πρέπει να χρησιμοποιήσουμε τη μέθοδο ```equals()```, δηλ. ```objA.equals(objB)```. Έτσι, π.χ._\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "10ee9773-797c-4fe2-ba23-8503fc1654b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int num1 = 5;\n",
    "int num2 = 5;\n",
    "num1 == num2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "be9c1cc7-9368-4fce-b938-bac2ac933906",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integer num1 = 5;\n",
    "Integer num2 = 5;\n",
    "num1 == num2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ec484288-a189-424c-a70d-8bcf388e8343",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1.equals(num2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "435fbc57-6cea-4214-8538-fef4fab850df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1 = 150;\n",
    "num2 = 150;\n",
    "num1 == num2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "202e85fa-a09c-4192-a2f4-c1700c3ada03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num1.equals(num2);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd8076bd-3e25-4f23-b425-08be55fe6865",
   "metadata": {},
   "source": [
    "_Η κλάση ```Integer``` θέλει μεγάλη προσοχή καθώς χρησιμοποιεί μια λανθάνουσα μνήμη (cache) για να αποθηκεύει τις τιμές -128 έως 127 όπως βλέπουμε στο παραπάνω δείγμα κώδικα. Επίσης το παραπάνω παράδειγμα μας δείχνει γιατί πρέπει ΠΑΝΤΑ να συγκρίνουμε αντικείμενα με τη μέθοδο ```equals()```._\n",
    "\n",
    "Η τεχνική αυτή λέγεται _απομνημόνευση (memoization)_ και ισχύουν αυτά που φαίνονται στον ακόλουθο πίνακα:\n",
    "\n",
    "**Πίνακας 4.1.1** _Τιμές απομνημόνευσης (memoization) κατά το (Un)Boxing_\n",
    "\n",
    "| _Αρχέγονος τύπος_ | _Συσκευασμένος (boxed) τύπος_ | _Τιμές απομνημόνευσης_ |\n",
    "|---|---|---|\n",
    "| ```boolean``` | ```Boolean``` | όλες\n",
    "| ```byte``` | ```Byte``` | όλες\n",
    "| ```char``` | ```Character``` | μόνο ```\\u0000 - \\u007f``` ή ```[0, 127]```\n",
    "| ```short``` | ```Short``` | μόνο ```[-128, 127]```\n",
    "| ```int``` | ```Integer``` | μόνο ```[-128, 127]```\n",
    "| ```long``` | ```Long``` | μόνο ```[-128, 127]```\n",
    "\n",
    "Η κλάση ```Byte``` αποθηκεύει στη λανθάνουσα μνήμη όλες τις τιμές του πρωτογενούς τύπου ```byte``` (οπότε μπορούμε να συγκρίνουμε δυο τύπους ```Byte``` και με τον τελεστή ```==```). Οι τελεστές σύγκρισης (<, >, <=, >=) παρόλ' αυτά, δουλεύουν σωστά και με τους συσκευασμένους (boxed) τύπους δεδομένων.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58b777fe-f03a-4029-b412-14a13407c8ed",
   "metadata": {},
   "source": [
    "## Διεπαφές (Interfaces)\n",
    "Η Java (αντίθετα με άλλες γλώσσες προγραμματισμού όπως η C++) δεν υποστηρίζει πολλαπλή κληρονομικότητα κλάσεων. Αντιθέτως, υποστηρίζει πολλαπλή κληρονομικότητα διεπαφών.\n",
    "\n",
    "Μία διεπαφή (interface) είναι μία δομή (παρόμοια με την κλάση) η οποία μπορεί να περιλαμβάνει:\n",
    "\n",
    "* Δηλώσεις μεθόδων (δηλ. αφαιρετικές - abstract) χωρίς τις υλοποιήσεις τους\n",
    "* Εξ'ορισμού (default) μεθόδους με τις υλοποιήσεις τους (από την έκδοση 8)\n",
    "* Σταθερές (constant)\n",
    "\n",
    "Με άλλα λόγια, αποτελεί ένα \"συμβόλαιο\" που θα πρέπει να υλοποιήσει μια κλάση. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "24b551f7-1e85-49ef-921c-f4751619d37f",
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface IShape {\n",
    "\tdouble PI = 3.1415;\n",
    "\tdouble area();\n",
    "\tdouble perimeter();\n",
    "} "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f502928-9596-459e-b831-e9bf5a4d7cfd",
   "metadata": {},
   "source": [
    "Οι μέθοδοι και οι σταθερές μιας διεπαφής είναι εξ' ορισμού ```public```. Από την έκδοση 9 υποστηρίζονται και ```private``` μέθοδοι.\n",
    "\n",
    "Μια κλάση μπορεί να υλοποιεί (```implements```) μια ή περισσότερες διεπαφές. Επίσης, μια διεπαφή μπορεί να κληρονομήσει άλλες διεπαφές (```extends```) αλλά όχι άλλες κλάσεις.\n",
    "\n",
    "Μία κλάση πρέπει να υλοποιεί _όλες_ τις μεθόδους μίας διεπαφής εκτός και αν είναι δηλωμένη ως ```abstract```. Π.χ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3be5a7eb-5dc7-4ab0-b8ba-ac0651606108",
   "metadata": {},
   "outputs": [],
   "source": [
    "public abstract Shape implements IShape {\n",
    "    protected final Point[] points;\n",
    "\n",
    "    Shape(int edges) {\n",
    "        this.points = new Point[edges];\n",
    "    }\n",
    "\n",
    "    Shape(Point... points) {\n",
    "        this.points = points;\n",
    "    }\n",
    "\n",
    "    public int getEdges() {\n",
    "        return this.points.length;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8701c94-4210-4845-8dbe-d6ad5a78f0e3",
   "metadata": {},
   "source": [
    "Η παραπάνω κλάση δηλώνεται ως αφαιρετική (abstract) καθώς δεν υλοποιεί τις μεθόδους της διεπαφής ```IShape```.\n",
    "\n",
    "Στη UML ένα interface αναπαρίσταται με δυο τρόπους όπως φαίνεται στην ακόλουθη Εικόνα 4.1.4 (βλ. και Εικόνα 3.3.4). Λέμε ότι η κλάση ```Shape``` _υλοποιεί (realizes)_ τη διεπαφή ```IShape```.\n",
    "\n",
    "![](assets/Fig4.png)\n",
    "\n",
    "**Εικόνα 4.1.4** _Αναπαράσταση διεπαφής (interface) στη UML_\n",
    "\n",
    "Χαρακτηριστικές διεπαφές της γλώσσας Java:\n",
    "\n",
    "* ```Serializable```: ονομάζεται και marker interface καθώς δεν περιέχει καμία μέθοδο προς υλοποίηση.\n",
    "* ```Comparable```: καθορίζει μία φυσική σειρά για τα αντικείμενα όπως ισχύει π.χ. για τους αριθμούς.\n",
    "```java\n",
    "interface Comparable {\n",
    "\tint compareTo(T o);\n",
    "}\n",
    "``` \n",
    "Π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a2dfcf8-7b23-47de-a4d3-be9af60d76d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "public final class Circle extends Shape implements Comparable {\n",
    "\n",
    "    private final int radius;\n",
    "\n",
    "    Circle() {\n",
    "        super(1);\n",
    "        this.radius = 1;\n",
    "    }\n",
    "\n",
    "    Circle(Point center, int radius) {\n",
    "        super(center);\n",
    "        this.radius = radius;\n",
    "    }\n",
    "\n",
    "    public int getRadius() {\n",
    "        return radius;\n",
    "    }\n",
    "\n",
    "    public Point getCenter() {\n",
    "        return points[0];\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public double area() {\n",
    "        return Math.PI * (radius * radius);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public double perimeter() {\n",
    "        return Math.PI * 2 * radius;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public int hashCode() {\n",
    "        int hash = super.hashCode();\n",
    "        hash = 53 * hash + this.radius;\n",
    "        return hash;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public boolean equals(Object obj) {\n",
    "        if (this == obj) {\n",
    "            return true;\n",
    "        }\n",
    "        if (obj == null) {\n",
    "            return false;\n",
    "        }\n",
    "        if (!super.equals(obj)) {\n",
    "            return false;\n",
    "        }\n",
    "        if (getClass() != obj.getClass()) {\n",
    "            return false;\n",
    "        }\n",
    "        final Circle other = (Circle) obj;\n",
    "        return this.radius == other.radius;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String toString() {\n",
    "        return \"Circle{\" + super.toString() + \"radius=\" + radius + '}';\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public int compareTo(Object o) {\n",
    "        if (!(o instanceof Circle c)) {\n",
    "            throw new ClassCastException(\"must be an instance of Circle\");\n",
    "        }\n",
    "        if (getRadius() > c.getRadius()) {\n",
    "            return 1;\n",
    "        } else if (getRadius() < c.getRadius()) {\n",
    "            return -1;\n",
    "        } else {\n",
    "            return 0;\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4d6d6e-c559-43a4-9ed1-6ac158004441",
   "metadata": {},
   "source": [
    "Επιστρέφει ```0``` αν τα δυο αντικείμενα είναι ίσα (έχουν ίσες ακτίνες), ```1``` αν το αντικείμενο ```this``` είναι μεγαλύτερο απ' αυτό που περνάμε για σύγκριση, ή ```-1``` στην αντίθετη περίπτωση.\n",
    "\n",
    "* ```Cloneable```: επιτρέπει τη δημιουργία κλώνων της κλάσης\n",
    "* ```Runnable```: υλοποιείται από κάθε κλάση που προορίζεται να εκτελείται ως νήμα (thread)\n",
    "```java\n",
    "interface Runnable {\n",
    "\tpublic void run();\n",
    "}\n",
    "```\n",
    "Π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca7d008f-adce-413c-bcc0-35f9fd5b6e32",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Job implements Runnable {\n",
    "    @Override\n",
    "\tpublic void run() {\n",
    "\t\tSystem.out.println(\"Runs in a new thread.\");\n",
    "\t}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c743aaab-4338-4f68-a356-3375441d3db4",
   "metadata": {},
   "source": [
    "Εξασκηθείτε στις παραπάνω κλάσεις εδώ <a href=\"sandbox/shape_interface.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bbd0396-6099-42b7-bab9-f450e372ef07",
   "metadata": {},
   "source": [
    "### Προσθήκες στις διεπαφές\n",
    "Η έκδοση 8 πρόσθεσε τις έννοιες των _στατικών (static)_ και _εξ' ορισμού (default)_ μεθόδων στις διεπαφές.\n",
    "\n",
    "Με την εισαγωγή των ροών (streams) στην έκδοση 8, υπήρξε το πρόβλημα επεκτασιμότητας των διεπαφών. Όπως μάθαμε, μια κλάση που υλοποιεί μια διεπαφή θα πρέπει να υλοποιήσει _όλες_ τις μεθόδους της διεπαφής. Αυτό δημιουργεί ζητήματα με κώδικα που χρησιμοποιεί παλαιότερες εκδόσεις της γλώσσας. Οι εξ' ορισμού (default) μέθοδοι επιτρέπουν τη μελλοντική επέκταση της γλώσσας.\n",
    "\n",
    "Ας δούμε τι εννοούμε με ένα παράδειγμα. Η διεπαφή ```Collection``` που θα δούμε σε επόμενο μάθημα, υπάρχει ήδη από την έκδοση 1.2 της γλώσσας. Στην έκδοση 8 έπρεπε να την αλλάξουν προσθέτοντας νέες μεθόδους (π.χ. ```stream()```). Κάτι τέτοιο όμως θα \"έσπαγε\" κώδικα που είχε γραφτεί πριν την έκδοση 8, καθώς ο παλιός κώδικας θα έπρεπε, όταν η εφαρμογή αναβαθμιζόταν ώστε να τρέχει με την έκδοση 8 της Java, να υλοποιήσει τις νέες μεθόδους, αλλοιώς δε θα μπορούσε να μεταγλωττιστεί. Με τη χρήση των εξ' ορισμού μεθόδων κάτι τέτοιο δεν είναι πλέον απαραίτητο. Οι εξ' ορισμού μέθοδοι παρέχουν μια εξ'ορισμού υλοποίηση κι έτσι δεν είναι απαραίτητο για τις κλάσεις που υλοποιούν (```implements```) αυτές τις διεπαφές να υλοποιήσουν τις εξ' ορισμού μεθόδους καθώς υπάρχει ήδη μια εξ' ορισμού υλοποίηση που μπορούν να χρησιμοποιήσουν. Με αυτόν τον τρόπο μπορούμε πλέον να επεκτείνουμε τις διεπαφές χωρίς να \"σπάμε\" την προς τα πίσω συμβατότητα.\n",
    "\n",
    "Οι εξ' ορισμού μέθοδοι είναι μέθοδοι με μια εξ'ορισμού υλοποίηση ώστε να λύνουν το πρόβλημα της προς τα πίσω συμβατότητας (backwards compatibility) αλλά που μπορούν να επεκταθούν από τις κλάσεις που τις υλοποιούν ώστε να αλλάξουν την εξ'ορισμού υλοποίηση αν το επιθυμούν.\n",
    "\n",
    "Μια εξ' ορισμού (default) μέθοδος σε μια διεπαφή ορίζεται με τη λέξη-κλειδί ```default```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "684976e5-a353-443d-90f6-cba6e0fb78a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface AInterface {\n",
    "    default String message() {\n",
    "        return \"Hallo A\";\n",
    "    }\n",
    "}\n",
    "\n",
    "public class A implements AInterface {\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d303fb75-fa12-4843-9d31-90c9772892d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "AInterface a = new A();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c38e8a2-2327-448a-b55c-64bc32cb099e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.message();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c237a47f-5565-4656-ba6b-5bdac7f9849c",
   "metadata": {},
   "source": [
    "Μια υπο-διεπαφή μπορεί να υπερκαλύψει (override) αυτή τη μέθοδο."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59035f63-2d4f-4814-bad3-853ecadfe222",
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface BInterface extends AInterface {\n",
    "    default String message() {\n",
    "        return \"Hallo B\";\n",
    "    }\n",
    "}\n",
    "\n",
    "public class B implements BInterface {\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ef167d9-062a-4e8d-9ca8-8462e9ad4d8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "AInterface b = new B();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acd6c968-749c-4021-830c-b4605e8035be",
   "metadata": {},
   "outputs": [],
   "source": [
    "b.message();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a383fc4d-687a-49ff-9dbe-0a9af5f7fcce",
   "metadata": {},
   "source": [
    "Στο ακόλουθο παράδειγμα βλέπουμε ότι η εξ'ορισμού μέθοδος μπορεί να υπερκαλυφθεί κι από μια κλάση (όχι μόνο από διεπαφή):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbddd553-53ff-4170-afeb-26cdabcac32d",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class C extends B {\n",
    "    public String message() {\n",
    "        return \"Hallo C\";\n",
    "    }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8c69821-e350-46c8-8758-d36a34e063d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "AInterface c = new C();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfc3d96e-a4cd-4712-a606-7f395880ee04",
   "metadata": {},
   "outputs": [],
   "source": [
    "c.message();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a42c051d-47c0-4c3c-a1e8-66e390b00f11",
   "metadata": {},
   "source": [
    "Έστω η ακόλουθη δήλωση:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8baf2d4d-05b9-4cb2-a5d1-4a9e6e441436",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class D extends C implements AInterface { }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e63f99a-12f4-419a-ac94-2399845651dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "AInterface d = new D();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a367b32-43b8-4dc2-baed-499b0d53ec54",
   "metadata": {},
   "outputs": [],
   "source": [
    "d.message();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73d8013d-1c40-491b-8f72-330ac8d530b5",
   "metadata": {},
   "source": [
    "Με άλλα λόγια, η κλάση νικά.\n",
    "\n",
    "Επιβεβαιώστε τα παραπάνω εδώ <a href=\"sandbox/interfaces.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c00232-a51b-43c0-acb1-d005f63f6933",
   "metadata": {},
   "source": [
    "Επειδή η πολλαπλή κληρονομικότητα ισχύει για τις διεπαφές, ενδέχεται μια διεπαφή να κληρονομήσει από δυο διεπαφές που παρέχουν την ίδια εξ'ορισμού μέθοδο."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "415e5d8a-24f4-4f01-a8e4-14440a7f3dbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface X {\n",
    "    default String message() {\n",
    "        return \"Hallo X\";\n",
    "    }\n",
    "}\n",
    "\n",
    "public interface Y {\n",
    "    default String message() {\n",
    "        return \"Hallo Y\";\n",
    "    }\n",
    "}\n",
    "\n",
    "public class XY implements X, Y {\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "380c9132-9be1-4aa9-a3f3-6b41b2de29f7",
   "metadata": {},
   "source": [
    "Σ' αυτήν την περίπτωση ο μεταγλωττιστής εμφανίζει λάθος μεταγλώττισης καθώς είναι αμφίβολο ποια εξ'ορισμού μέθοδο να κληρονομήσει. Μπορούμε φυσικά να υπερκαλύψουμε το λάθος υλοποιώντας τη δική μας εξ'ορισμού μέθοδο, π.χ.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c34a1ee-adb8-4b25-969e-f53de44d0750",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class XY implements X, Y {\n",
    "    public String message() {\n",
    "        return X.super.message();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e7f2a21-0e7c-47b4-b8db-f5cf4ae55680",
   "metadata": {},
   "source": [
    "Ισχύουν οι ακόλουθοι 2 κανόνες (σε περίπτωση που έχετε αμφιβολίες):\n",
    "\n",
    "* Η κλάση υπερισχύει οποιασδήποτε διεπαφής\n",
    "* Ο υπο-τύπος υπερισχύει του υπερ-τύπου (τύπος: κλάση ή διεπαφή)\n",
    "\n",
    "Όσων αφορά τις στατικές μεθόδους στις διεπαφές:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd01aba3-6e6c-49df-aff8-0261fcb8e430",
   "metadata": {},
   "outputs": [],
   "source": [
    "interface Z { static void print() { System.out.println(\"Hello Z\"); }}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc3d744b-c0b2-461c-8f5b-008d3d0c9c46",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ZZ implements Z {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e82e9ba-f4ce-4120-ad7d-39286d29d1fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "Z.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da34bea0-9587-478f-b86f-a0b6ae1d49c5",
   "metadata": {},
   "source": [
    "Παραδείγματα στατικών μεθόδων σε διεπαφές του Java API: ```Comparator.reverseOrder(), Collections.reverseOrder(), Collections.sort()``` κ.ά.\n",
    "\n",
    "Η Java 9 πρόσθεσε τη δυνατότητα ορισμού _ιδιωτικών μεθόδων (private methods)_ στις διεπαφές. Πριν από την έκδοση 9, όλες οι μέθοδοι στις διεπαφές έπρεπε να είναι ```public```. Με την εισαγωγή ιδιωτικών μεθόδων στις διεπαφές, μπορείτε να αναδιοργανώσετε (refactor) τον κώδικα default μεθόδων ώστε να εισάγετε ```private``` utility methods. Οι διεπαφές πλέον γίνονται όλο και περισσότερο όμοιες με τις abstract κλάσεις.\n",
    "\n",
    "Τα δικαιώματα πρόσβασης στις μεθόδους των διεπαφών είναι πλέον όπως περιγράφονται στον ακόλουθο πίνακα:\n",
    "\n",
    "**Πίνακας 4.1.2** _Τροποποιητές πρόσβασης στις δηλώσεις μεθόδων στις διεπαφές_\n",
    "\n",
    "| _Τροποποιητής Πρόσβασης_ | _Υποστηρίζεται_ | _Σχόλια_ |\n",
    "|---|---|---|\n",
    "| ```public abstract``` | Ναι | ≥ JDK 1\n",
    "| ```public static``` | Ναι | ≥ JDK 8\n",
    "| ```public default``` | Ναι | ≥ JDK 8\n",
    "| ```private static``` | Ναι | ≥ JDK 9, δεν μπορεί να επεκταθεί (override)\n",
    "| ```private``` | Ναι | ≥ JDK 9, δεν μπορεί να επεκταθεί (override)\n",
    "| ```private abstract``` | Όχι | από τη μία πρέπει να επεκταθεί (```abstract```) από την άλλη δεν μπορεί (```private```) \n",
    "| ```private default``` | Όχι | από τη μία θα πρέπει να μπορεί να επεκταθεί (```abstract```) από την άλλη δεν μπορεί (```private```)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05684d19-cc11-4c51-92be-ca9a54dd7c6b",
   "metadata": {},
   "source": [
    "Επιβεβαιώστε τα παραπάνω εδώ <a href=\"sandbox/interfaces2.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bfbd4b9-e76c-41cc-b6c6-723a589cdaec",
   "metadata": {},
   "source": [
    "## Περίληψη\n",
    "Ας δούμε περιληπτικά τι μάθαμε σε αυτό και τα προηγούμενα μαθήματα.\n",
    "\n",
    "* Η Java υποστηρίζει απλή κληρονομικότητα κλάσεων (με την ```extends```) και πολλαπλή κληρονομικότητα διεπαφών (με την ```implements```).\n",
    "* Μια υποκλάση κληρονομεί όλα τα ```public, protected``` μη στατικά γνωρίσματα και μη στατικές μεθόδους μιας υπερκλάσης. Οι constructors της υπερκλάσης δεν κληρονομούνται.\n",
    "* Η κλάση ```Object``` είναι η ριζική (root) κλάση από την οποία κληρονομούν (νοητά) όλες οι άλλες κλάσεις. Καλό είναι να υπερσκελίζουμε τις μεθόδους ```equals(), hashCode()``` και ```toString()``` της κλάσης ```Object```.\n",
    "\n",
    "Για τις μεθόδους κατασκευής μάθαμε ότι:\n",
    "* Μια κλάση μπορεί να περιέχει πολλούς υπερφορτωμένους (overloaded) constructors με διαφορετικές παραμέτρους\n",
    "* Ο μεταγλωττιστής εισάγει έναν εξ'ορισμού constructor χωρίς παραμέτρους αν δεν δηλώσουμε άλλες μεθόδους κατασκευής για την κλάση\n",
    "* Αν μια μέθοδος κατασκευής καλέσει την ```this()``` πρέπει να είναι η πρώτη εντολή της μεθόδου κατασκευής\n",
    "* Η Java δεν επιτρέπει να δημιουργήσουμε κύκλους όπου ένας constructor καλεί έναν άλλο ο οποίος με τη σειρά του καλεί τον αρχικό.\n",
    "* Η πρώτη γραμμή κάθε constructor είναι μια κλήση είτε στον γονικό constructor με τη ```super()``` είτε σε έναν υπερφορτωμένο constructor με την ```this()```.\n",
    "* Αν η μέθοδος κατασκευής δεν περιέχει μια εντολή ```this()``` ή ```super()``` τότε ο μεταγλωττιστής εισάγει αυτόματα μια εντολή ```super()``` χωρίς ορίσματα ως την πρώτη γραμμή της μεθόδου κατασκευής.\n",
    "* Αν ένανς constructor καλεί μια εντολή ```super()``` τότε αυτή πρέπει να είναι η πρώτη γραμμή του constructor.\n",
    "* Αν μια κλάση κληρονομεί μια άλλη κλάση που έχει δηλώσει constructor με παραμέτρους, η υποκλάση πρέπει κι αυτή να δηλώσει μέθοδο κατασκευής που να καλεί τον constructor της υπερκλάσης με την ```super()```.\n",
    "\n",
    "Ακόμα μάθαμε ότι:\n",
    "* Ενώ λόγω της αρχής της υποκατάστασης (substitution principle), αν ```class B extends A``` μπορούμε να γράψουμε ```A a = new B();``` δεν μπορούμε να γράψουμε ```B b = new A();```.\n",
    "* Υπάρχουν αφαιρετικές κλάσεις (abstract classes) που έχουν γνωρίσματα, abstract μεθόδους αλλά και κανονικές μεθόδους. Οι διεπαφές (interfaces) διαθέτουν μεθόδους που μπορούν να είναι abstract, default, static ή private. Δεν μπορούμε να δημιουργήσουμε αντικείμενα απευθείας ούτε από τις αφαιρετικές κλάσεις ούτε από τις διεπαφές.\n",
    "* Οι σφραγισμένες κλάσεις (sealed classes) δηλώνουν τις κλάσεις που μπορούν να κληρονομήσουν από αυτές."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98784999-b60e-4a1a-9b23-d92501acf90b",
   "metadata": {},
   "source": [
    "## Ασκήσεις\n",
    "1) Μετατρέψτε το ακόλουθο UML διάγραμμα σε <a href=\"sandbox/ex1.html\" target=\"_blank\">κώδικα Java</a>\n",
    "\n",
    "![](assets/Fig5.png)\n",
    "\n",
    "2) Σε συνέχεια της άσκησης 1. της προηγούμενης εβδομάδας, δημιουργήστε <a href=\"sandbox/ex2.html\" target=\"_blank\">μια κλάση ```Person```</a> με τα εξής γνωρίσματα:\n",
    "\n",
    "* όνομα (αλφαριθμητικό και δεν μπορεί να 'ναι κενό)\n",
    "* επώνυμο (αλφαριθμητικό και δεν μπορεί να 'ναι κενό)\n",
    "\n",
    "και μετατρέψτε την κλάση ```Student``` ώστε να κληρονομεί από αυτήν. Δημιουργήστε μια κλάση ```Teacher``` που να κληρονομεί από την ```Person``` και να έχει τα επιπλέον γνωρίσματα:\n",
    "\n",
    "* αριθμός δελτίου ταυτότητας (της μορφής ```ΑΒ123456```)\n",
    "* μαθήματα που διδάσκει (μέχρι 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e49e67f8-82b4-4294-929b-1db144f1a87d",
   "metadata": {},
   "source": [
    "## Πηγές\n",
    "1. Bloch J. (2018), _Effective Java_, 3rd Ed., Addison-Wesley. \n",
    "1. Evans B. (2019), [Inside the Language: Sealed Types](https://blogs.oracle.com/javamagazine/inside-the-language-sealed-types), Java Magazine.\n",
    "\n",
    "---\n",
    "\n",
    "[Δ](../../TOC.ipynb) | [>](../4.2-Polymorphism/4.2-Polymorphism.ipynb)\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "17+35-LTS-2724"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}