Courses/Mathesis/Intro2ProgrammingWithJava/Week3/3.1-OOP/3.1-OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "12670fec-996e-40ec-a4d0-e189c5b314bb",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 3.1 Εισαγωγή στον Αντικειμενοστραφή Προγραμματισμό\n",
    "© Γιάννης Κωστάρας\n",
    "\n",
    "---\n",
    "\n",
    "[Δ](../../TOC.ipynb) | [>](../3.2-IDEs/3.2-IDEs.ipynb)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b7d92c4-a317-463e-b95d-b2a00e4ed8d1",
   "metadata": {},
   "source": [
    "### Μαθησιακοί στόχοι\n",
    "Σε αυτήν την ενότητα θα μάθουμε:\n",
    "\n",
    "* τι είναι ο αντικειμενοστραφής προγραμματισμός (Object Oriented Programming)\n",
    "* για τις κλάσεις (classes) και τα αντικείμενα (objects) των κλάσεων\n",
    "* για τα χαρακτηριστικά των αντικειμένων\n",
    "* τις κατηγορίες κλάσεων: class, record, interface, enum\n",
    "* τα δυο είδη μνημών: τη μνήμη στοίβας (stack) και τη μνήμη σωρού (heap)\n",
    "* για το πέρασμα παραμέτρων με αναφορά (By Reference)\n",
    "* για τους τύπους επικάλυψης (Wrapper types)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa99275-e822-43bb-9d1e-f30f07c0e6b4",
   "metadata": {},
   "source": [
    "## Εισαγωγή\n",
    "Τα προγράμματα που γράψαμε τις προηγούμενες εβδομάδες ονομάζονται διαδικαστικά. Χάρις στο JShell μάθαμε τη σύνταξη και τις βασικές εντολές και τύπους δεδομένων της Java. Επικεντρωθήκαμε στο συντακτικό της γλώσσας και πώς να λύνουμε αλγορίθμους χωρίς να μπερδευόμαστε με άλλες λεπτομέρειες της γλώσσας. \n",
    "\n",
    "Ο διαδικαστικός (procedural) προγραμματισμός είναι καλός για μικρά προγράμματα και προβλήματα αλλά όχι τόσο για μεγάλα προγράμματα. Γι' αυτό το σκοπό έχει αναπτυχθεί ο αντικειμενοστραφής προγραμματισμός (Object Oriented Programming). Αν και το JShell είναι ένα θαυμάσιο εργαλείο για την εκμάθηση της γλώσσας, για να αναπτύξετε προγράμματα θα πρέπει να εντρυφήσετε στον αντικειμενοστραφή προγραμματισμό. \n",
    "\n",
    "Καθώς ο κόσμος μας αποτελείται από αντικείμενα, αναπαριστώντας τα με κάποιον τρόπο στους Η/Υ έφερε μια νέα επανάσταση στην ανάπτυξη εφαρμογών. Οι εφαρμογές που βασίζονται στα αντικείμενα είναι πιο εύκολες στην κατανόηση και στη συντήρηση.\n",
    "\n",
    "Η Java ήταν από την αρχή της δημιουργίας της μια αμιγώς αντικειμενοστραφής γλώσσα προγραμματισμού (από την έκδοση 8 και μετά έχει και στοιχεία συναρτησιακής, functional, γλώσσας αλλά αυτό δεν θα μας απασχολήσει σ' αυτά τα μαθήματα).\n",
    "\n",
    "Είδαμε ήδη στις τελευταίες ενότητες της προηγούμενης εβδομάδας την πρώτη μας κλάση (class), ότι οι κλάσεις αποτελούνται από μεθόδους (methods) και ότι η πιο σημαντική μέθοδος ενός προγράμματος είναι η ```main()```. Στα μαθήματα αυτής και της επόμενης εβδομάδας θα επικεντρωθούμε στα αντικειμενοστραφή χαρακτηριστικά της γλώσσας.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d8cfe8d-d3ec-4905-92e6-ae03cc996a1d",
   "metadata": {},
   "source": [
    "## Κλάσεις και Αντικείμενα\n",
    "Η Java διαθέτει δυο κατηγορίες τύπων δεδομένων:\n",
    "\n",
    "* Αρχέγονους ή πρωτογενείς (raw data types) (π.χ. ```int, char, float```)\n",
    "* Κλάσεις (π.χ. ```String, array```)\n",
    "\n",
    "Μια _κλάση_ (class) είναι όπως ένα αρχιτεκτονικό σχέδιο, ένα πρότυπο (καλούπι), μια αφαιρετική εικόνα της πραγματικότητας που περιγράφει τις _ιδιότητες (γνωρίσματα)_ ενός αντικειμένου καθώς και τις _ενέργειες_ που μπορούν να εκτελεστούν σ’ αυτές τις ιδιότητες. Κάθε κλάση περιγράφει μία μοναδική οντότητα με ξεχωριστές ιδιότητες (γνωρίσματα). Οι κλάσεις οργανώνονται σε δενδρικές δομές μοναδικού γονικού κόμβου (_κληρονομικότητα_).\n",
    "\n",
    "Π.χ. το _αυτοκίνητο_ αποτελεί μια κλάση, καθώς είναι μια αφαίρεση της πραγματικότητας. Κάθε αυτοκίνητο διαθέτει κάποια γνωρίσματα, π.χ. χρώμα, τελική ταχύτητα, κυβισμό, κ.ά. Επίσης, κάθε αυτοκίνητο μπορεί να κινείται, να επιταχύνει και να επιβραδύνει, να στρίβει κλπ. Αυτά αποτελούν τις _ενέργειες_ της κλάσης.\n",
    "\n",
    "Από μία κλάση μπορούν να δημιουργηθούν πολλά _στιγμιότυπα (αντικείμενα)_. Π.χ. μπορούμε από τη κλάση _Αυτοκίνητο_ να έχουμε απτά αντικείμενα, π.χ. ένα Fiat 500, ένα Peugeot 208, ένα Audi A3. Όλα τα αντικείμενα μιας κλάσης έχουν τα ίδια γνωρίσματα, αλλά οι τιμές των γνωρισμάτων διαφέρουν.\n",
    "\n",
    "Κάθε κλάση περιγράφει μία μοναδική οντότητα με ξεχωριστές ιδιότητες. Κάθε αντικείμενο μπορεί να: \n",
    "\n",
    "* παραλάβει μηνύματα από άλλα αντικείμενα\n",
    "* επεξεργαστεί δεδομένα \n",
    "* στείλει μηνύματα σε άλλα αντικείμενα\n",
    "\n",
    "Π.χ. αν θεωρήσουμε ένα αντικείμενο της κλάσης _Οδηγός_, αυτό μπορεί να επιταχύνει ή/και να επιβραδύνει το στιγμιότυπο αυτοκινήτου το οποίο οδηγεί.\n",
    "\n",
    "Άλλο παράδειγμα είναι η μοντελοποίηση μιας εταιρίας. Μια εταιρία αποτελείται από υπαλλήλους. Οπότε χρειαζόμαστε μια κλάση ```Employee``` η οποία να διαθέτει π.χ. τα εξής γνωρίσματα:\n",
    "\n",
    "* Όνομα\n",
    "* Επώνυμο\n",
    "* Κωδικός Υπαλλήλου\n",
    "* ΑΦΜ\n",
    "* Μισθός\n",
    "* ημέρες αδείας\n",
    "* τμήμα (στο οποίο δουλεύει)\n",
    "\n",
    "κλπ.\n",
    "\n",
    "και τις εξής μεθόδους:\n",
    "\n",
    "* εργάζεται (π.χ. μπορεί να είναι άρρωστος)\n",
    "* πληρώθηκε\n",
    "* ζητά άδεια\n",
    "\n",
    "κλπ."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7ab995a-e205-48b9-9db0-2494ef923be3",
   "metadata": {},
   "source": [
    "## Χαρακτηριστικά των αντικειμένων\n",
    "\n",
    "Ο αντικειμενοστραφής προγραμματισμός εισήχθηκε για να βοηθήσει τους προγραμματιστές να δημιουργούν κλάσεις και αντικείμενα ως μια αφαίρεση της πραγματικότητας και έτσι να μπορούν να σχεδιάζουν πιο εύκολα και κατανοητά τα προγράμματά τους. \n",
    "\n",
    "Η αφαιρετικότητα (abstraction) είναι επιλεκτική άγνοια! Είναι επιλογή του τι είναι σημαντικό και τι όχι. Δίνει έμφαση και εξάρτηση στα σημαντικά ενώ αγνοεί τα _ΜΗ_ σημαντικά. Επιτυγχάνεται με τη χρήση _ενθυλάκωσης (encapsulation)_ όπως θα δούμε παρακάτω. Σε μια καλή αντικειμενοστραφή σχεδίαση, κάθε αντικείμενο έχει συγκεκριμένο ρόλο και ευθύνες.\n",
    "\n",
    "Τα αντικείμενα στον αντικειμενοστραφή προγραμματισμό έχουν τρία βασικά χαρακτηριστικά:\n",
    "\n",
    "* _Ταυτότητα (identity)_: Το “κλειδί” μέσω του οποίου μπορούμε να αποκτήσουμε πρόσβαση στο αντικείμενο (ένα όνομα ή μια διεύθυνση μνήμης)\n",
    "* _Κατάσταση (state)_: Οι τιμές των ιδιοτήτων/γνωρισμάτων του αντικειμένου κάθε χρονική στιγμή\n",
    "* _Συμπεριφορά (behaviour)_: Το σύνολο των ενεργειών (μεθόδων) που μπορεί να διεκπεραιώσει το αντικείμενο\n",
    "\n",
    "Η Java διαθέτει τους εξής τύπους δεδομένων για την αναπαράσταση κλάσεων, τους οποίους και θα μελετήσουμε στη συνέχεια:\n",
    "\n",
    "* ```Record``` (εγγραφή), από την έκδοση 14 και μετά\n",
    "* ```Class``` (κλάση)\n",
    "* ```Interface``` (διεπαφή)\n",
    "* ```Enum``` (απαριθμημένος τύπος) από την έκδοση 5 και μετά"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "060a4a81-e71a-480c-a693-b521e9254a33",
   "metadata": {},
   "source": [
    "## Εγγραφές (records)\n",
    "Η πιο απλή μορφή αναπαράστασης κλάσεων είναι η _εγγραφή (record)_. Τα records εμφανίστηκαν σχετικά πρόσφατα στη γλώσσα, στην έκδοση 14. \n",
    "\n",
    "Ας υποθέσουμε ότι θέλουμε να φτιάξουμε ένα πρόγραμμα ζωγραφικής στο οποίο ο χρήστης θα μπορεί να σχεδιάζει πάνω σε έναν καμβά, κάτι π.χ. σαν το πρόγραμμα ζωγραφικής των Windows. Θέλουμε να μοντελοποιήσουμε το σημείο. Ένα σημείο ορίζεται στο δισδιάστατο επίπεδο με δυο συντεταγμένες ```x``` και ```y```. Ας δούμε πώς μπορούμε να γράψουμε τον τύπο δεδομένων _Σημείο_ στην Java."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c9c2e7d0-54e4-40cf-af4b-549e65d7a3f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Point(int x, int y) { }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8060e3cd-62ed-4bc4-9e0b-25001fec0f58",
   "metadata": {},
   "source": [
    "Το παραπάνω είναι το \"καλούπι\" ενός σημείου. Από αυτό μπορούμε να δημιουργήσουμε όσα σημεία, δηλ. αντικείμενα της ```Point```, θέλουμε, ως εξής:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "c88bce0c-e15f-4cf6-a746-3c3077d68a0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point p = new Point (0, 0);\n",
    "int x = p.x();\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "be2be437-dde9-4185-ba29-8fd166183bfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point[x=0, y=0]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fa6ae2d-74f6-4099-9fa8-be3567bebe5d",
   "metadata": {},
   "source": [
    "Για να δημιουργήσουμε ένα νέο σημείο χρησιμοποιούμε την γνώριμη από τις κλάσεις ```String``` και array δεσμευμένη λέξη ```new```. Μέσα στις παρενθέσεις περνάμε τις συντεταγμένες του σημείου. Αυτές αποθηκεύονται στις μεταβλητές ```x``` και ```y```. Οι μεταβλητές αυτές ονομάζονται _γνωρίσματα_ ή _ιδιότητες (attributes)_ της κλάσης. \n",
    "\n",
    "Για να προσπελάσουμε την τιμή ενός γνωρίσματος, χρησιμοποιούμε τη μέθοδο που ονομάζεται όπως το γνώρισμα και παρενθέσεις, π.χ. ```p.x()```. Αυτή επιστρέφει την τιμή του γνωρίσματος ```x```. Αντίστοιχα υπάρχει και η ```p.y()``` που επιστρέφει την τιμή του γνωρίσματος ```y```.\n",
    "\n",
    "Αλλά πώς δημιουργείται το αντικείμενο; Όταν καλούμε την ```new```, αυτή καλεί μια ειδική μέθοδο της κλάσης η οποία ονομάζεται _μέθοδος κατασκευής_ ή _constructor_. Στην περίπτωση της ```Point``` αυτή λαμβάνει δυο ορίσματα ```int x, int y```. Θα μιλήσουμε για μεθόδους κατασκευής όταν μιλήσουμε για τις κλάσεις.\n",
    "\n",
    "Πώς θα μπορούσαμε να ορίσουμε μια ευθεία γραμμή; Μια ευθεία γραμμή αποτελείται από δυο σημεία:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "20ba4907-a7e1-4093-8e5c-a9a7caa2eadd",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Line(Point p1, Point p2) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0e0bff19-9822-4938-a2b4-71cfbb0adfef",
   "metadata": {},
   "outputs": [],
   "source": [
    "Line line = new Line(p, new Point(10, 10));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b81443c1-1e5a-4258-b5b0-22f700e3d255",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point[x=10, y=10]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line.p2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9b11b9d9-3ee3-44b2-89cb-0eb6df2c4ff9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Line[p1=Point[x=0, y=0], p2=Point[x=10, y=10]]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4802d206-1e45-45f8-824a-e5027bcd3450",
   "metadata": {},
   "source": [
    "Δημιουργήσαμε μια νέα γραμμή (ένα αντικείμενο τύπου ```Line```) δίνοντάς της δυο σημεία, ένα το ```p``` που δημιουργήσαμε προηγουμένως, και ένα νέο σημείο καλώντας την μέθοδο κατασκευής της ```Point``` και περνώντας ως παραμέτρους ```x=10, y=10```.\n",
    "\n",
    "Παρόμοια μπορούμε να δημιουργήσουμε και τις εγγραφές ```Circle, Rectangle```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b136443d-ee2d-4827-9448-b64d80882284",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Circle(Point center, int radius) {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0161c665-6bf9-4fc4-8b99-24a39d6b0a6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Rectangle(Point upperLeft, Point lowerRight) {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27bba3eb-9d4a-4578-ad93-71a81a8d5591",
   "metadata": {},
   "source": [
    "Ένας κύκλος ορίζεται από το κέντρο και την ακτίνα του. Ένα ορθογώνιο ορίζεται από δυο σημεία, το πάνω αριστερό και το κάτω δεξί. \n",
    "\n",
    "Μέσα στα άγκιστρα μπορούμε να ορίσουμε και δικές μας μεθόδους, π.χ. παρακάτω ορίζουμε μια μέθοδο που μας επιστρέφει την περιφέρεια του κύκλου:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "25c637fc-cf94-4186-a658-f13679f95318",
   "metadata": {},
   "outputs": [],
   "source": [
    "record Circle(Point center, int radius) {\n",
    "    double circumference() {\n",
    "        return 2*Math.PI*radius;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "da8bee3e-3603-4a12-bae3-9cb9d3e6aedf",
   "metadata": {},
   "outputs": [],
   "source": [
    "Circle circle = new Circle(p, 5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c0341d56-b452-4a42-94e2-cd2906c4641a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31.41592653589793"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circle.circumference()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa28246f-a183-4edc-800a-5f5f17658ba8",
   "metadata": {},
   "source": [
    "Σαν άσκηση τροποποιήστε την εγγραφή ```Rectangle``` προσθέτοντάς της μια μέθοδο που να υπολογίζει το εμβαδό του ορθογώνιου παραλληλογράμμου.\n",
    "\n",
    "Έστω ότι θέλουμε να δημιουργήσουμε μια μέθοδο που να μπορεί να αλλάζει την τιμή της ακτίνας του κύκλου αφού ένα αντικείμενο κύκλου έχει δημιουργηθεί:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0a877978-d342-47d6-b0c6-49b799fa04c6",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m       \u001b[0m\u001b[1m\u001b[30m\u001b[41mradius\u001b[0m\u001b[1m\u001b[30m = r;\u001b[0m",
      "\u001b[1m\u001b[31mcannot assign a value to final variable radius\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "record Circle(Point center, int radius) {\n",
    "   double circumference() {\n",
    "       return 2*Math.PI*radius;\n",
    "   }\n",
    "   void setRadius(int r) {\n",
    "       radius = r;\n",
    "   }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0b95fe-89b5-46f0-bea2-16f34756879b",
   "metadata": {},
   "source": [
    "Προς έκπληξή μας δεν μας αφήνει (μας λέει ότι η ```radius``` είναι ```final```, δηλ. σταθερά). Η εγγραφή είναι μια _αμετάβλητη κλάση (immutable class)_, δηλ. δεν επιτρέπει ν' αλλάξουν οι τιμές των γνωρισμάτων της μετά τη δημιουργία των αντικειμένων της.\n",
    "\n",
    "Επίσης παρατηρήστε ότι δεν μπορούμε να προσπελάσουμε απευθείας τις τιμές των γνωρισμάτων, έξω από την εγγραφή, όπως π.χ. από το περιβάλλον JShell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b1424c72-11f2-4fe0-891c-e191f9877d24",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mcircle\u001b[0m\u001b[1m\u001b[30m.radius\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable circle\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "circle.radius"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f796ce05-7fbb-4497-8946-79073ce27593",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mcircle\u001b[0m\u001b[1m\u001b[30m.radius = 10;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable circle\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "circle.radius = 10;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07283fdc-ea8f-4e58-b8e0-c6fa0cbbb3d0",
   "metadata": {},
   "source": [
    "Η μέθοδος όμως ```circumference()``` μπορεί να προσπελάσει την ```radius```, όπως είδαμε πιο πάνω.\n",
    "\n",
    "Τα γνωρίσματα μιας εγγραφής είναι προσπελάσιμα από τις μεθόδους της εγγραφής, όχι όμως και εξωτερικά από την εγγραφή. Π.χ. πιο πάνω προσπαθήσαμε να προσπελάσουμε το γνώρισμα ```radius``` της ```Circle``` από το περιβάλλον του JShell, και η ```Point``` δεν μας το επέτρεψε. Ούτε μας άφησε να τροποποιήσουμε την τιμή του γνωρίσματος, αφού όπως είπαμε οι εγγραφές είναι αμετάβλητες. \n",
    "\n",
    "Αυτό το γνώρισμα του αντικειμενοστραφούς προγραμματισμού λέγεται _ενθυλάκωση (encapsulation)_, όπως θα δούμε σε επόμενο μάθημα, και διαφέρει σε σχέση με τον διαδικαστικό προγραμματισμό, όπου μεταβλητές και μέθοδοι είναι ανεξάρτητες. Στον αντικειμενοστραφή προγραμματισμό, οι μεταβλητές ανήκουν σε μια κλάση και μόνο αντικείμενα αυτής της κλάσης έχουν πρόσβαση στις μεταβλητές. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5afccf64-46ee-47ee-a01f-5c8371d40fa7",
   "metadata": {},
   "source": [
    "Μπορείτε να εξασκηθείτε μόνοι σας στα records εδώ <a href=\"sandbox/records.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c82a09a0-deac-4f47-8d95-e68dec28d818",
   "metadata": {},
   "source": [
    "## Κλάσεις (Class)\n",
    "Η εγγραφή (record) εισήχθηκε στην Java από την έκδοση 14 και μετά. Από την αρχή της δημιουργίας της, η γλώσσα υποστηρίζει τις κλάσεις. Τα πάντα είναι κλάσεις στη Java. Ας δούμε πώς θα γράφαμε την εγγραφή ```Point``` στις εκδόσεις της Java πριν την 14:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "565ba217-3209-4377-b938-f9e1ce339907",
   "metadata": {},
   "outputs": [],
   "source": [
    "final class Point {\n",
    "\tprivate final int x, y;\n",
    "\t\n",
    "\tpublic Point() {\n",
    "\t\tx=0;\n",
    "\t\ty=0;\n",
    "\t}\n",
    "\t\n",
    "\tpublic Point(int x, int y) {\n",
    "\t\tthis.x = x;\n",
    "\t\tthis.y = y;\n",
    "\t}\n",
    "\t\n",
    "\tpublic int getX() {\n",
    "\t\treturn x;\n",
    "\t}\n",
    "\t\n",
    "\tpublic int getY() {\n",
    "\t\treturn y;\n",
    "\t}\n",
    "    \n",
    "    public String toString() {\n",
    "        return \"Point[\" + \"x=\" + x + \", y=\" + y + \"]\";\n",
    "    }      \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cdbd886-f544-454b-a904-22ceaa6e643f",
   "metadata": {},
   "source": [
    "Όπως βλέπετε, η εγγραφή μας γλυτώνει από πολύ πληκτρολόγηση! Κατ' αρχήν βλέπουμε πώς ορίζονται τα γνωρίσματα μέσα σε μια κλάση. Τα γνωρίσματα ```x, y``` ορίζονται ως ```private final```. Όπως έχουμε μάθει, η δεσμευμένη λέξη ```final``` δηλώνει ότι πρόκειται για σταθερές, δηλ. ότι η τιμή τους δεν μπορεί ν' αλλάξει. Αλλά πώς είναι δυνατόν να ορίσουμε μια σταθερά χωρίς να της δώσουμε αρχική τιμή; Αυτό είναι κάτι που επιτρέπεται στις κλάσεις και θα δούμε στη συνέχεια γιατί. Τη δεσμευμένη λέξη ```private``` την βλέπουμε για πρώτη φορά και είναι η αντίθετη της ```public```. Όπως ίσως θυμάστε από προηγούμενο μάθημα, το ```public``` δηλώνει ότι το γνώρισμα είναι προσβάσιμο από οποιαδήποτε άλλη κλάση και από την ΕΜ (JVM). Το ```private``` δηλώνει ότι είναι προσβάσιμο μόνο από αντικείμενα της ίδιας κλάσης.\n",
    "\n",
    "Οι μέθοδοι ```getX()``` και ```getY()``` είναι ίδιες με τις ```x()``` και ```y()``` της εγγραφής. Απλά παλαιότερα, η σύμβαση ήταν ότι μέθοδοι προσπέλασης των γνωρισμάτων θα πρέπει να ονομάζονται ως ```getXXX()``` όπου ```xxx``` το γνώρισμα που προσπελάζουν. Παρατηρούμε ότι αυτές οι μέθοδοι είναι ```public```.\n",
    "\n",
    "Αλλά τι είναι οι ```Point()``` και ```Point(int x, int y)```; Καλά το μαντέψατε! Είναι οι μέθοδοι κατασκευής (constructors). Καλούνται όταν καλείται η ```new```. Παρατηρήστε πώς διαφέρουν από τις κανονικές μεθόδους επειδή έχουν το ίδιο όνομα με το όνομα της κλάσης και _δεν_ έχουν τύπο επιστροφής. Η πρώτη μέθοδος κατασκευής καλείται όταν δημιουργείτε ένα _στιγμιότυπο (instance)_ ή _αντικείμενο (object)_ της κλάσης ```Point``` χωρίς να περάσετε ορίσματα:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "879c2587-28ac-4678-8ff7-7bc8bfc82ce4",
   "metadata": {},
   "outputs": [],
   "source": [
    "Point p = new Point()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e03f9aa2-9eff-418c-b0f1-c7c9edbc940a",
   "metadata": {},
   "source": [
    "ενώ η δεύτερη όταν περάσετε:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1b8c7fe1-3ac7-476e-97fd-e508f4bd5b57",
   "metadata": {},
   "outputs": [],
   "source": [
    "Point p = new Point(10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dedab7e-4911-4979-a445-b09fa4476c4c",
   "metadata": {},
   "source": [
    "_**Σημείωση!** Μην μπερδευτείτε, οι μέθοδοι κατασκευής δεν έχουν καμία σχέση με τις αναδρομικές μεθόδους (recursive methods)._\n",
    "\n",
    "Γι' αυτό επιτρέπεται οι σταθερές ```x, y``` να μην αρχικοποιούνται κατά τη δήλωσή τους, επειδή αρχικοποιούνται μέσα στις μεθόδους κατασκευής, χωρίς αυτό να σημαίνει ότι δεν μπορείτε να τις αρχικοποιήσετε κατά τη δήλωσή τους αντί για μέσα στην μέθοδο κατασκευής.\n",
    "\n",
    "Αλλά τι είναι αυτό το ```this```; Το ```this``` αναφέρεται στο αντικείμενο που δημιουργείται από την κλάση. Επειδή δεν γνωρίζουμε πώς θα το ονομάσει ο προγραμματιστής, μέσα στην κλάση αναφερόμαστε σ' αυτό με τη δεσμευμένη λέξη ```this```. Π.χ. για το παράδειγμα της ```Point``` το ```this``` μπορεί να αναφέρεται στο ```p``` ή στο ```p1```, δηλ. σε οποιοδήποτε αντικείμενο της κλάσης. Οπότε ```this.x``` σημαίνει το γνώρισμα ```x``` του αντικειμένου. Αλλά γιατί δεν αναφερόμαστε στο γνώρισμα απλά και μόνο με το όνομά του;\n",
    "\n",
    "Ας δούμε λίγο καλύτερα το σώμα του δεύτερου κατασκευαστή:\n",
    "\n",
    "```java\n",
    "\tpublic Point(int x, int y) {\n",
    "\t\tthis.x = x;\n",
    "\t\tthis.y = y;\n",
    "\t}\n",
    "```\n",
    "Αν γράφαμε:\n",
    "```java\n",
    "\tpublic Point(int x, int y) {\n",
    "\t\tx = x;\n",
    "\t\ty = y;\n",
    "\t}\n",
    "```\n",
    "τότε ο μεταγλωττιστής δεν μπορεί να καταλάβει αν αναφερόμαστε στο γνώρισμα ```x``` ή στην παράμετρο ```x```. Μάλιστα αυτό είναι ένα πολύ κοινό λάθος που γίνεται από τους προγραμματιστές κι ενώ νομίζουν ότι έχουν αλλάξει την τιμή του γνωρίσματος στην ουσία εκχωρούν στην παράμετρο ```x``` την τιμή της παραμέτρου ```x```.\n",
    "\n",
    "Ας το δούμε στην πράξη."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c39fa58a-5188-4371-9efa-7084e241782e",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\tpublic Point(int x, int y) \u001b[0m\u001b[1m\u001b[30m\u001b[41m{\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[41m\t\tx = x;\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[41m\t\ty = y;\u001b[0m",
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[41m\t}\u001b[0m",
      "\u001b[1m\u001b[31mvariable x might not have been initialized\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "final class Point {\n",
    "\tprivate final int x, y;\n",
    "\t\n",
    "\tpublic Point() {\n",
    "\t\tx=0;\n",
    "\t\ty=0;\n",
    "\t}\n",
    "\t\n",
    "\tpublic Point(int x, int y) {\n",
    "\t\tx = x;\n",
    "\t\ty = y;\n",
    "\t}\n",
    "\t\n",
    "\tpublic int getX() {\n",
    "\t\treturn x;\n",
    "\t}\n",
    "\t\n",
    "\tpublic int getY() {\n",
    "\t\treturn y;\n",
    "\t}\n",
    "    \n",
    "    public String toString() {\n",
    "        return \"Point[\" + \"x=\" + x + \", y=\" + y + \"]\";\n",
    "    }      \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb01bdf9-f976-48a1-bd74-c0bedcf57a5d",
   "metadata": {},
   "source": [
    "Στο συγκεκριμένο παράδειγμα ο μεταγλωττιστής μας προειδοποιεί ότι τα γνωρίσματα ```x``` και ```y``` δεν έχουν αρχικοποιηθεί επειδή είναι ```final``` και θα 'πρεπε να αρχικοποιηθούν στον κατασκευαστή. Αλλά ας πάμε ένα βήμα πιο πέρα. Ας μην τις ορίσουμε ```final```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ffe03ed9-c681-4338-8ff1-554e0413a8fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "final class Point {\n",
    "\tprivate int x, y;\n",
    "\t\n",
    "\tpublic Point() {\n",
    "\t\tx=0;\n",
    "\t\ty=0;\n",
    "\t}\n",
    "\t\n",
    "\tpublic Point(int x, int y) {\n",
    "\t\tx = x;\n",
    "\t\ty = y;\n",
    "\t}\n",
    "\t\n",
    "\tpublic int getX() {\n",
    "\t\treturn x;\n",
    "\t}\n",
    "\t\n",
    "\tpublic int getY() {\n",
    "\t\treturn y;\n",
    "\t}\n",
    "    \n",
    "    public String toString() {\n",
    "        return \"Point[\" + \"x=\" + x + \", y=\" + y + \"]\";\n",
    "    }      \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0f2fbc48-7120-4f37-af5e-bcac4f9fc7ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point[x=0, y=0]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point p = new Point(10,20);\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e40b80f7-bc84-423d-919a-facf92f68832",
   "metadata": {},
   "source": [
    "Όπως βλέπετε τα γνωρίσματα ```x, y``` δεν αρχικοποιήθηκαν από τις τιμές των ορισμάτων που περάσαμε στον κατασκευαστή. Πολύ προσοχή λοιπόν και καλό είναι να μην ονομάζουμε τις παραμέτρους όπως και τα γνωρίσματα."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07d93b58-a9b7-4af1-aed0-f0f76ca264b0",
   "metadata": {},
   "source": [
    "Η μέθοδος ```toString()``` επιστρέφει μια φιλική προς τον χρήστη αναπαράσταση του αντικειμένου. Αν την είχαμε αφαιρέσει τότε:\n",
    "\n",
    "```java\n",
    "Point p = new Point()\n",
    "p ==> Point@497470ed\n",
    "```\n",
    "Αυτό που συμβαίνει στο παρασκήνιο είναι ότι η ΕΜ της Java διαθέτει την ανάλογη μνήμη που χρειάζεται για τη δημιουργία του αντικειμένου, αναθέτει μια μοναδική ταυτότητα στο αντικείμενό μας (```Point@497470ed```) και εκτελεί τον κώδικα της μεθόδου κατασκευής (constructor). \n",
    "\n",
    "Τέλος, θα μιλήσουμε για την ```final``` στον ορισμό της κλάσης σε επόμενα μαθήματα.\n",
    "\n",
    "Σαν άσκηση γράψτε την εγγραφή ```Circle``` που ορίσαμε πιο πάνω σαν κλάση.\n",
    "\n",
    "Μπορούν να υπάρχουν πολλοί κατασκευαστές με το ίδιο όνομα (overloading) αλλά όχι με την ίδια υπογραφή, δηλ. θα πρέπει να περιέχουν διαφορετικό αριθμό ή/και τύπο παραμέτρων. Ένας κατασκευαστής χωρίς παραμέτρους ονομάζεται _εξ' ορισμού κατασκευαστής (default constructor)_. Σε περίπτωση που δεν δηλωθεί κατασκευαστής, δημιουργείται αυτόματα ο default (no-args) constructor.\n",
    "\n",
    "_**Σημαντική σημείωση**: Αν δηλώσουμε έστω μια μέθοδο κατασκευής σε μια κλάση, τότε **δεν** δημιουργείται αυτόματα default constructor_.\n",
    "\n",
    "Έτσι π.χ. αν ορίσουμε την κλάση Point χωρίς μεθόδους κατασκευαστή (απαιτείται τώρα ν' αρχικοποιήσουμε τα γνωρίσματά της):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0d0d8c4c-349a-4d86-be04-412258a39a09",
   "metadata": {},
   "outputs": [],
   "source": [
    "final class Point {\n",
    "    private final int x = 0, y = 0;\n",
    "    \n",
    "    public int getX() {\n",
    "        return x;\n",
    "    }\n",
    "    \n",
    "    public int getY() {\n",
    "        return y;\n",
    "    }\n",
    "    \n",
    "    public String toString() {\n",
    "        return \"Point[\" + \"x=\" + x + \", y=\" + y + \"]\";\n",
    "    }      \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e4798118-6be5-461a-b3ed-5f5018dde79e",
   "metadata": {},
   "outputs": [],
   "source": [
    "Point p = new Point()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b3c79112-6691-4ce9-a26c-d297e2acef63",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mPoint p = \u001b[0m\u001b[1m\u001b[30m\u001b[41mnew Point(10, 10)\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mconstructor Point in class Point cannot be applied to given types;\u001b[0m",
      "\u001b[1m\u001b[31m  required: no arguments\u001b[0m",
      "\u001b[1m\u001b[31m  found:    int,int\u001b[0m",
      "\u001b[1m\u001b[31m  reason: actual and formal argument lists differ in length\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "Point p = new Point(10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5018187-bb54-418a-a6f4-224d190d6be0",
   "metadata": {},
   "source": [
    "Βλέπουμε ότι η Java έχει εισάγει κρυφά έναν default constructor χωρίς παραμέτρους. Αυτό επειδή δεν έχουμε δηλώσει άλλους κατασκευαστές. Αν όμως δηλώσουμε τουλάχιστο μια μέθοδο κατασκευής: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "34a798bf-8319-4a49-8428-8db0bfbde05e",
   "metadata": {},
   "outputs": [],
   "source": [
    "final class Point {\n",
    "    private final int x, y;\n",
    "    \n",
    "    public Point(int x, int y) {\n",
    "        this.x = x;\n",
    "        this.y = y;\n",
    "    }\n",
    "    \n",
    "    public int getX() {\n",
    "        return x;\n",
    "    }\n",
    "    \n",
    "    public int getY() {\n",
    "        return y;\n",
    "    }\n",
    "    \n",
    "    public String toString() {\n",
    "        return \"Point[\" + \"x=\" + x + \", y=\" + y + \"]\";\n",
    "    }      \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "aacdb309-6d72-4515-9044-e3d67745d77b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Point p = new Point(10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ae68d23f-05c0-4744-87ed-f0e539dff92c",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mPoint p = \u001b[0m\u001b[1m\u001b[30m\u001b[41mnew Point()\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mconstructor Point in class Point cannot be applied to given types;\u001b[0m",
      "\u001b[1m\u001b[31m  required: int,int\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": [
    "Point p = new Point()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab2f610-8ab9-48ce-a5c9-bd8dd6d5e3f2",
   "metadata": {},
   "source": [
    "τότε δεν δημιουργείται κρυφά ένας no argument default constructor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b08e193e-d3f3-49fb-950e-95cb6e7ddeb8",
   "metadata": {},
   "source": [
    "Ένας έξυπνος τρόπος να μειώσουμε τις πιθανές αλλαγές, κι άρα και τις πιθανότητες λάθους στον κώδικά μας, είναι η χρήση της ```this()``` (μην την μπερδέψετε με το ```this``` που είδαμε πιο πάνω) όπως φαίνεται στο παρακάτω παράδειγμα:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "64c44d05-1d22-4274-b628-c64f48377209",
   "metadata": {},
   "outputs": [],
   "source": [
    "final class Point {\n",
    "    private final int x, y;\n",
    "\n",
    "    public Point() {\n",
    "        this(0, 0);\n",
    "    }\n",
    "\n",
    "    public Point(int x, int y) {\n",
    "        this.x = x;\n",
    "        this.y = y;\n",
    "    }\n",
    "\n",
    "    public int getX() {\n",
    "        return x;\n",
    "    }\n",
    "    \n",
    "    public int getY() {\n",
    "    return y;\n",
    "    }\n",
    "    \n",
    "    public String toString() {\n",
    "        return \"Point[\" + \"x=\" + x + \", y=\" + y + \"]\";\n",
    "    }      \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ad8eeae-cc37-4127-8b6e-f64a77ba7d3f",
   "metadata": {},
   "source": [
    "Η σύνταξη ```this(0,0)``` στο σώμα του κατασκευαστή χωρίς παραμέτρους σημαίνει ότι καλεί τον άλλον κατασκευαστή περνώντας του ως ορίσματα τα ```0, 0```. Με αυτόν τον τρόπο μπορούμε να μειώσουμε κατά πολύ κώδικα που επαναλαμβάνεται στους διάφορους κατασκευαστές μιας κλάσης. Η τεχνική που ακολουθούμε είναι να καλούμε με την ```this()``` τον constructor με τις περισσότερες παραμέτρους που θα είναι κι αυτός που θα περιέχει την υλοποίηση. Είναι σημαντικό να σημειώσουμε εδώ ότι η ```this()``` πρέπει να είναι η πρώτη γραμμή σε μια μέθοδο κατασκευής, αλλιώς ο μεταγλωττιστής θα παραπονεθεί. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78888341-5932-434f-9d6c-24614464f0ac",
   "metadata": {},
   "source": [
    "Στο σημείο αυτό θα πρέπει να προσθέσουμε ότι όπως μπορείτε να ορίσετε και τις δικές σας μεθόδους σε μια εγγραφή, μπορείτε να ορίσετε και compact constructors, όπως:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d674cb36-e404-49f8-8421-a1df35b755e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "public record Point(int x, int y) { \n",
    "\tpublic Point {\n",
    "\t\tif (x < 0 || y < 0) \n",
    "\t\t\tthrow new IllegalArgumentException(\n",
    "\t\t\t      \"x and y must be positive\");\n",
    "\t}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "689230ea-5a94-4fba-9174-be1b1615bb83",
   "metadata": {},
   "source": [
    "(θα μιλήσουμε για εξαιρέσεις (Exceptions) σε επόμενο μάθημα) ή ακόμα και εναλλακτικές μεθόδους κατασκευής (alternative constructors), π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2e6e1c09-bca6-43e2-b95d-9b5d23db6d19",
   "metadata": {},
   "outputs": [],
   "source": [
    "public record Point(int x, int y) { \n",
    "\tpublic static Point of(int x, int y) {\n",
    "\t\treturn new Point(x, y);\n",
    "\t}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "622212e6-4587-44a5-ab08-944a91c59356",
   "metadata": {},
   "source": [
    "(Θα μιλήσουμε για την δεσμευμένη λέξη ```static``` σε επόμενο μάθημα). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f1d6b6e0-3737-40be-80ca-d5c7540b25eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point[x=-1, y=-2]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point p2 = Point.of(-1, -2);\n",
    "p2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1c19667-de24-4b1c-bf57-63f82b1b16fe",
   "metadata": {},
   "source": [
    "Μπορείτε να εξασκηθείτε μόνοι σας στην κλάση ```Point``` εδώ <a href=\"sandbox/point.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4afc7f2b-2d10-4ba0-9012-5c8712ae925a",
   "metadata": {},
   "source": [
    "Ας δούμε ακόμα ένα παράδειγμα. Ας υποθέσουμε ότι θέλουμε να γράψουμε ένα παιχνίδι αγώνων αυτοκινήτων σε Java. Χρειαζόμαστε λοιπόν, μιαν αφαιρετική αναπαράσταση ενός αυτοκινήτου, δηλ. μια κλάση ```Car```. Τι γνωρίσματα θέλουμε να έχουμε για την κλάση αυτή (η κατάστασή του); Μας ενδιαφέρει να γνωρίζουμε το μοντέλο του (π.χ. _Tesla Model S_), την μέγιστη ταχύτητά του, τον κυβισμό του κλπ. καθώς επίσης και την ταχύτητά του κάθε στιγμή (καθώς θα τρέχει σε αγώνες).\n",
    "\n",
    "Τι συμπεριφορά θα θέλαμε να έχει το αυτοκίνητο; Θα θέλαμε να μπορούμε να επιταχύνουμε όταν πατάμε το γκάζι και να επιβραδύνουμε όταν πατάμε το φρένο. Επίσης, να στρίβουμε.\n",
    "\n",
    "Τα παραπάνω τα συνοψίζουμε στην ακόλουθη κλάση ```Car```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "2b7b1249-6160-4bb9-a1a6-7bdc384868dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car { // κλάση\n",
    "  // ιδιότητες/γνωρίσματα\n",
    "  String model;\n",
    "  int maxSpeed;\n",
    "  int ccm;\n",
    "  int speed = 0;\n",
    "  // μέθοδος δημιουργίας αντικειμένων - κατασκευαστής\n",
    "  Car(String m, int s, int c) {\n",
    "    model = m; maxSpeed = s; ccm = c;\n",
    "  }\n",
    "  // ενέργειες/μέθοδοι\n",
    "  void accelerate() {\n",
    "     if (speed <= maxSpeed - 10)\n",
    "        speed+=10;\n",
    "  }\n",
    "  void decelerate() {\n",
    "     if (speed >= 10)\n",
    "        speed-=10;\n",
    "  }\n",
    "  public String toString() {\n",
    "     return \"Car[\" + \"model=\" + model + \", maxSpeed=\" + maxSpeed + \", ccm=\" + ccm + \", speed=\" + speed + \"]\"; \n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bec4db2-3c9b-4229-beb9-4725a701b4d0",
   "metadata": {},
   "source": [
    "Η κλάση ```Car``` περιέχει 4 γνωρίσματα (```model, maxSpeed, ccm, speed```), τρεις μεθόδους (```accelerate(), decelerate(), toString()```) και μια μέθοδο κατασκευής."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "ac1a0b75-2b52-42d0-9bc3-0811f4c47c51",
   "metadata": {},
   "outputs": [],
   "source": [
    "Car audiA3 = new Car(\"Audi A3\", 210, 1595);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "9a2712af-b340-4809-9d4e-540c0e43ae18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "audiA3.speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "00f3d928-fbfc-4fe5-b18e-9734b55d3ddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "audiA3.accelerate();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "af6430f5-65f2-4d79-baf8-fe25b3a5a120",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "audiA3.speed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd3c025-999c-4e22-a9ab-ecc795504165",
   "metadata": {},
   "source": [
    "Στο παραπάνω τμήμα κώδικα δημιουργήσαμε ένα νέο αντικείμενο ```audiA3``` χρησιμοποιώντας τη δεσμευμένη λέξη ```new``` και καλώντας τον κατασκευαστή της κλάσης. Στη συνέχεια ζητάμε να δούμε την τρέχουσα ταχύτητά του καλώντας το γνώρισμα χωριζόμενο από το όνομα του αντικειμένου με την ```.```. Γενικά, όπως είδαμε, δεν είναι καλή τακτική να καλούμε απευθείας τα γνωρίσματα ενός αντικειμένου. Στη συνέχεια, καλούμε τη μέθοδο ```accelerate()``` με το ίδιο τρόπο, η οποία έχει ως αποτέλεσμα ν' αυξήσει την ταχύτητα του αυτ/του κατά 10 χλμ/ώ. Καλώντας πάλι το γνώρισμα ```speed``` βλέπουμε ότι τώρα πλέον το αυτοκίνητό μας κινείται με ταχύτητα 10 χλμ/ώ.\n",
    "\n",
    "Με τον ίδιο τρόπο μπορούμε να δημιουργήσουμε όσα στιγμιότυπα (αντικείμενα) της κλάσης ```Car``` θέλουμε παρέχοντας απλώς τις κατάλληλες τιμές (δηλ. μοντέλο, τελική ταχύτητα και κυβισμό) στη μέθοδο κατασκευαστή της κλάσης ```Car```. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ff77d5e-9e55-4bae-bbee-9acbe4d164ec",
   "metadata": {},
   "source": [
    "Αλλά τι συμβαίνει όταν δημιουργούμε ένα αντικείμενο με την ```new``` (όταν δηλ. καλούμε τον constructor); Η JVM καλεί το Λ.Σ. να δεσμεύσει ένα χώρο μνήμης τόσο ώστε να χωρέσει το αντικείμενό μας. Όπως θα δούμε λίγο πιο κάτω, η μνήμη χωρίζεται σε δυο μεγάλες περιοχές, την _στοίβα (stack)_ και τον _σωρό (heap)_. Η ΕΜ της Java αποθηκεύει μεταβλητές πρωτογενών τύπων στη στοίβα γιατί γνωρίζει εξ' αρχής πόσο χώρο μνήμης απαιτούν (βλ. Εικόνα 3.1.1). Στην περίπτωση των αντικειμένων όμως, ο χώρος μνήμης που θα χρειαστούν δεν είναι πάντοντε γνωστός εκ των προτέρων. Στην περίπτωση αυτή, η ΕΜ δεσμεύει έναν χώρο στην στοίβα για ν' αποθηκεύσει την _διεύθυνση μνήμης_ στο σωρό όπου θα αποθηκευθούν τα δεδομένα του αντικείμενου (βλ. Εικόνα 3.1.2). Αυτό που κάνει η ```new``` επομένως είναι να δεσμεύει ένα χώρο στη μνήμη σωρού και να επιστρέφει στην μεταβλητή αντικειμένου τη διεύθυνση αυτού του χώρου. Γι' αυτό το λόγο, π.χ. η ```p``` ή η ```audiA3``` δεν περιέχει το αντικείμενο που δημιουργήθηκε, αλλά έναν δείκτη (pointer) ή μια αναφορά (reference) στη διεύθυνση μνήμης που δημιουργήθηκε το αντικείμενο. Και φυσικά μπορούμε να έχουμε περισσότερους του ενός δείκτες (δηλ. μεταβλητές) που να δείχνουν στην ίδια διεύθυνση μνήμης (στο ίδιο αντικείμενο στη μνήμη σωρού).\n",
    "\n",
    "Πώς μπορούμε να δηλώσουμε ένα στιγμιότυπο μιας κλάσης αλλά να το αρχικοποιήσουμε αργότερα;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "5904cd54-e5a6-4421-a01b-e32b00ac5075",
   "metadata": {},
   "outputs": [],
   "source": [
    "Car teslaS = null;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb93801-3a0a-41dc-8563-9e3b66e9fd22",
   "metadata": {},
   "source": [
    "Η δεσμευμένη λέξη ```null``` δηλώνει το _τίποτα_. Στις γλώσσες προγραμματισμού σημαίνει ότι ο μεταγλωττιστής δεν δεσμεύει ακόμα μνήμη για το αντικείμενό μας. Ο δείκτης στη στοίβα για το αντικείμενό μας δεν δείχνει ακόμα σε κάποια δ/νση μνήμης σωρού.\n",
    "\n",
    "Αν προσπαθήσουμε να καλέσουμε μια μέθοδο ενός αντικειμένου που δεν έχει αρχικοποιηθεί ακόμα τότε:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c71d2d0f-e4d9-46f8-980a-3b1608449c08",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mteslaS\u001b[0m\u001b[1m\u001b[30m.toString()\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable teslaS\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "teslaS.toString()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39aa4c26-e2b7-4fad-abc8-5e99babce14f",
   "metadata": {},
   "source": [
    "λαμβάνουμε την διάσημη εξαίρεση (exception) ```NullPointerException```, τον τρόμο και των φόβο των προγραμματιστών. Πολύ μεγάλη προσοχή λοιπόν, πάντα να αρχικοποιείτε τα αντικείμενά σας προτού τα χρησιμοποιήσετε."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc1f029e-a507-4346-8e62-f859838de8f6",
   "metadata": {},
   "source": [
    "Μπορείτε να εξασκηθείτε μόνοι σας στην κλάση ```Car``` εδώ <a href=\"sandbox/car.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd2006c4-186a-4d1b-a0dc-d3b0a0ba7fe2",
   "metadata": {},
   "source": [
    "## Διεπαφές (Interface)\n",
    "Η _διεπαφή (interface)_ είναι ένα είδος κλάσης που περιέχει όμως μόνο σκελετούς μεθόδων (δηλ. χωρίς υλοποίηση) ή/και σταθερές. Π.χ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "ceee6157-7b69-4b87-843a-0f3184de01f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "public interface CarInterface {\n",
    "  int defaultAcceleration = 10;\n",
    "  void accelerate(int by);  \n",
    "  void decelerate(int by);\n",
    "  void turn(int byDegrees);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf8cfb46-faba-4115-b481-f28a47a7a795",
   "metadata": {},
   "source": [
    "Δεν μπορούμε να δημιουργήσουμε απευθείας αντικείμενα μιας διεπαφής (εκτός κι αν παρέχουμε υλοποιήσεις όλων των μεθόδων της). Θα μιλήσουμε αναλυτικά για διεπαφές σε επόμενο μάθημα."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b75f96a3-399c-470c-833a-5b46054e59ff",
   "metadata": {},
   "source": [
    "## Απαριθμημένοι Τύποι (Enum)\n",
    "Είδαμε για πρώτη φορά τους απαριθμημένους τύπους όταν μιλήσαμε για τις εντολές ελέγχου."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "900fad41-47b4-4799-852c-03ad3c918c0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "enum Choice {\n",
    "  RED_PILL, BLUE_PILL\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3020a3f9-4aea-4fd6-a75c-a0b8f47034fa",
   "metadata": {},
   "source": [
    "Ο ```enum``` στην Java είναι ένα είδος κλάσης. Θα μιλήσουμε αναλυτικά για απαριθμημένους τύπους σε επόμενο μάθημα.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "525cb37d-9c2b-46e6-97b2-418a0f5f5fe9",
   "metadata": {},
   "source": [
    "## Αποθήκευση μεταβλητών στην μνήμη. Στοίβα (Stack) και Σωρός (Heap)\n",
    "Οι περισσότερες γλώσσες προγραμματισμού χρησιμοποιούν δυο είδη μνήμης για να αποθηκεύσουν τα δεδομένα των προγραμμάτων τους. Τα δυο αυτά είδη μνήμης είναι:\n",
    "\n",
    "### Στοίβα (Stack) \n",
    "Η στοίβα δουλεύει το ίδιο με μια στοίβα από πιάτα. Το πρώτο πιάτο που θα τοποθετήσουμε στη στοίβα θα είναι και το τελευταίο που θα πάρουμε πίσω καθώς πρώτα θα πρέπει να πάρουμε πρώτα όλα τα πιάτα που έχουμε τοποθετήσει πάνω του. Ονομάζεται και LIFO (Last In First Out). Είναι περιορισμένη σε μέγεθος. Σ' αυτήν αποθηκεύονται μεταβλητές πρωτογενών τύπων δεδομένων. \n",
    "\n",
    "Ας δούμε ένα παράδειγμα. Η παρακάνω εικόνα μας παρουσιάζει πώς η Java εκτελεί την πρόσθεση δυο ακεραίων αριθμών στη στοίβα.\n",
    "\n",
    "Πρώτα αποθηκεύεται στη στοίβα η τιμή της μεταβλητής ```a``` και στη συνέχεια η τιμή της μεταβλητής ```b```. Στην συνέχεια το πρόγραμμα ζητάει την πρόσθεση αυτών των δυο αριθμών. Μπορείτε να θεωρήσετε ότι ο τελεστής ```+``` είναι η συντομογραφία της μεθόδου ```int add(int a, int b);```.\n",
    "Ακολούθως, ανακτούνται από τη στοίβα με την αντίστροφη σειρά από την οποία εισήχθηκαν στη στοίβα, δηλ. πρώτα η μέθοδος ```+```, στη συνέχεια η τιμή της μεταβλητής ```b``` και τέλος η τιμή της μεταβλητής ```a```, εκτελείται η πράξη και το αποτέλεσμα αποθηκεύεται πάλι στη στοίβα.\n",
    "\n",
    "![](assets/Fig1.png)\n",
    "\n",
    "**Εικόνα 3.1.1** _Στοίβα (Stack)_\n",
    "\n",
    "### Σωρός (Heap)\n",
    "Ο σωρός δεν έχει κάποιον περιορισμό, θεωρητικά μπορεί να είναι όσο και η μνήμη RAM του Η/Υ σας. Η πρόσβαση σ' αυτόν είναι όμως πιο αργή σε σχέση με την στοίβα. Στην μνήμη σωρού αποθηκεύονται τα αντικείμενα. Όταν δημιουργούμε ένα αντικείμενο με τον τελεστή ```new``` αυτό που συμβαίνει είναι να αποθηκευθεί στη στοίβα ένας δείκτης ο οποίος δείχνει σε μια θέση μνήμης στη μνήμη σωρού, όπως φαίνεται στην παρακάτω εικόνα. Το ίδιο ισχύει για τα αντικείμενα συστοιχιών (arrays) και τύπου ```String```.\n",
    " \n",
    "![](assets/Fig2.png)\n",
    "\n",
    "**Εικόνα 3.1.2** _Σωρός (Heap)_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "625f5b5a-9248-4cd2-94ec-1be9cacc8cdd",
   "metadata": {},
   "source": [
    "## Πέρασμα παραμέτρων με αναφορά (By Reference)\n",
    "Στο μάθημα που μιλήσαμε για τις μεθόδους μάθαμε ότι αν περάσουμε έναν πρωτογενή τύπο σαν όρισμα σε μια μέθοδο, τότε δημιουργείται ένα αντίγραφο αυτού στο σώμα της μεθόδου (pass by value). Αντιθέτως, αν περάσουμε ένα αντικείμενο σαν όρισμα σε μια μέθοδο, τότε περνάμε ένα αντίγραφο της αναφοράς μνήμης αυτού του αντικειμένου (by reference), κι ό,τι αλλαγές επικαλείται η μέθοδος σ' αυτό το αντικείμενο, εφαρμόζονται στο ίδιο το αντικείμενο (δεν δημιουργείται κάποιο αντίγραφο του αντικειμένου, μόνο του δείκτη που δείχνει σε αυτό):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "30918d32-6ab7-4cb0-b533-2b35e4a155dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "void setSpeed(Car car) {\n",
    "   car.speed = 50;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "cc6f38d0-40ae-4138-9018-5f9936a04923",
   "metadata": {},
   "outputs": [],
   "source": [
    "setSpeed(audiA3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "25d8d152-be61-40dc-b7d4-e3e1ec4a2de7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "audiA3.speed"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "735b7eb6-1ea0-47ef-99af-42b0460e602a",
   "metadata": {},
   "source": [
    "Εδώ βλέπουμε ότι περνώντας το αντικείμενο ```audiA3``` που δημιουργήσαμε πιο πάνω στη μέθοδο ```setSpeed```, όντως αλλάζει την ταχύτητα του αντικειμένου.\n",
    "\n",
    "![](assets/Fig3.png)\n",
    "\n",
    "**Εικόνα 3.1.3** _Κλήση by sharing στη Java, µέθοδος setSpeed()_\n",
    " \n",
    "Στη Java δε γίνεται μια μέθοδος να δημιουργήσει ένα αντικείμενο και να το επιστρέψει ως μια τιμή μιας παραμέτρου της."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "5173816b-87d5-462a-8b05-81dc86230213",
   "metadata": {},
   "outputs": [],
   "source": [
    "void createCar(Car car) {\n",
    "   car = new Car(\"BMW X1\", 200, 1996);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "3e771985-5b0b-4299-970d-f211162f446b",
   "metadata": {},
   "outputs": [],
   "source": [
    "createCar(audiA3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ecd82473-8041-44fa-b309-889b91597735",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Audi A3"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "audiA3.model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53e6bfb0-ee26-4daa-aec5-adf066a716c6",
   "metadata": {},
   "source": [
    "Τι συνέβει; Όταν καλέσαμε τη μέθοδο ```createCar(audiA3)``` της περάσαμε ένα αντίγραφο της διεύθυνσης μνήμης του αντικειμένου ```audiA3```. Η μέθοδος όμως δημιούργησε ένα νέο αντικείμενο (σε μια νέα διεύθυνση μνήμης) και έχασε τη διεύθυνση μνήμης του αντικειμένου ```audiA3```. Το νέο αντικείμενο ```car``` που δημιούργησε χρησιμοποιείται μόνο μέσα στη μέθοδο ```createCar``` και δεν έχει αναφορά σ' αυτό καμιά άλλη μέθοδος ούτε το κυρίως πρόγραμμα. Το αντικείμενο καταστρέφεται με το τέλος του σώματος της μεθόδου (δηλ. στο '}').\n",
    "\n",
    "**Σημείωση!** _Ο όρος \"call by reference\" που χρησιμοποιείται στη Java δεν είναι 100% σωστός, όπως περιγράφεται σ' αυτό το [άρθρο](https://en.wikipedia.org/wiki/Evaluation_strategy). Πιο σωστός είναι ο όρος \"call by sharing\" για το λόγο που είδαμε στο προηγούμενο παράδειγμα, δηλ. δε μπορούμε να αλλάξουμε την αναφορά μνήμης που περνιέται ως παράμετρος. Στην ουσία δημιουργείται ένα αντίγραφο της διεύθυνσης μνήμης που δείχνει η παράμετρος με το οποίο αντίγραφο μπορεί η μέθοδος ν' αλλάξει τα γνωρίσματα του αντικειμένου που δείχνει αυτή η διεύθυνση μνήμης (αν το αντικείμενο είναι μεταβλητό -- mutable). Ή πιο απλά, όλες οι κλήσεις μεθόδων στη Java είναι στην ουσία \"by value\" καθώς δημιουργείται ένα αντίγραφο του ορίσματος που περνάμε (είτε αυτό είναι πρωτογενής τύπος είτε δείκτης σε αντικείμενο)._\n",
    "\n",
    "![](assets/Fig4.png)\n",
    "\n",
    "**Εικόνα 3.1.4** _Κλήση by sharing στη Java, μέθοδος createCar()_\n",
    " \n",
    "Αν θέλουμε όντως η μέθοδος να δημιουργήσει ένα νέο αντικείμενο, θα πρέπει η μέθοδος να επιστρέψει το νέο αντικείμενο όπως στην παρακάτω _μέθοδο κατασκευής (factory method)_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "945d35c0-5627-486f-a789-a0f8fcd72e7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "Car createCar(String model, int maxSpeed, int ccm) {\n",
    "   return new Car(model, maxSpeed, ccm);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f447d67-1f8e-48a6-9c68-3a024812d46d",
   "metadata": {},
   "source": [
    "## Τύποι Επικάλυψης (Wrapper types)\n",
    "Στα μαθήματα της πρώτης εβδομάδας μάθαμε για τους πρωτογενείς τύπους δεδομένων (raw data types) και την κλάση ```String```. Η Java διαθέτει αντίστοιχες κλάσεις επικάλυψης για τους πρωτογενείς τύπους δεδομένων:\n",
    "\n",
    "| _Πρωτογενής τύπος_ | _Τύπος αναφοράς_ |\n",
    "|---|---|\n",
    "| ```byte``` | ```Byte``` |\n",
    "| ```short``` | ```Short``` |\n",
    "| ```int``` | ```Integer``` |\n",
    "| ```long``` | ```Long``` |\n",
    "| ```float``` | ```Float``` |\n",
    "| ```double``` | ```Double``` |\n",
    "| ```boolean``` | ```Boolean``` | \n",
    "| ```char``` | ```Character``` |\n",
    "\n",
    "Η μετατροπή ενός πρωτογενούς τύπου στην αντίστοιχη κλάση του ονομάζεται _εγκλεισμός (boxing)_ ενώ η αντίστροφη μετατροπή _απεγκλεισμός (unboxing)_. Η γλώσσα κάνει αυτές τις μετατροπές αυτόματα τις περισσότερες φορές. Π.χ. η έκφραση:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "14b82a07-a2e8-422c-9532-88bfb6e08ab3",
   "metadata": {},
   "outputs": [],
   "source": [
    "Integer val = 10; // autoboxing int --> Integer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "4aec59c0-5423-4f56-bbd8-cd6925ddaf61",
   "metadata": {},
   "outputs": [],
   "source": [
    "int ival = val; // auto-unboxing Integer --> int"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af719173-c486-4990-af52-dd6050155172",
   "metadata": {},
   "source": [
    "χωρίς autoboxing θα 'πρεπε να γραφτεί (όπως και συνέβαινε σε παλαιότερες εκδόσεις της γλώσσας):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "37483905-d8c1-46e2-b534-3d0ae278738d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Integer val = new Integer(10); // Boxing: int --> Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "e714f079-5c20-414e-a6dd-d39dd1a53707",
   "metadata": {},
   "outputs": [],
   "source": [
    "int ival = val.intValue(); // Unboxing: Integer --> int"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "324a51e3-01b3-4ee6-876b-aeb733d035e0",
   "metadata": {},
   "source": [
    "**Προσοχή!** \n",
    "Στην ενότητα 1.6 μάθαμε για τη μετατροπή μεταξύ πρωτογενών τύπων δεδομένων (casting), η οποία συνοψίζεται στο παρακάτω διάγραμμα.\n",
    "\n",
    "![](../../Week1/1.6-PrimitiveDataTypes/assets/Fig2.png)\n",
    "\n",
    "**Εικόνα 1.6.2** _Διάγραμμα μετατροπής τύπων δεδομένων_\n",
    "\n",
    "Το παραπάνω _δεν_ ισχύει για τους τύπους επικάλυψης (wrapper classes). Π.χ. ενώ μπορούμε να αναθέσουμε απευθείας μια τιμή ```int``` σε μια μεταβλητή τύπου ```long``` χωρίς να παραπονεθεί ο μεταγλωττιστής, δεν μπορούμε να αναθέσουμε απευθείας μια τιμή ```Integer``` σε μια μεταβλητή τύπου ```Long``` (not assignable compatible):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "793e77b9-b2a1-49e4-9abc-4543e578f03d",
   "metadata": {},
   "outputs": [],
   "source": [
    "int i = 10;\n",
    "long l = i;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "ca09e19c-7455-424a-9367-fa3e1eb8a9e1",
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mLong ll = \u001b[0m\u001b[1m\u001b[30m\u001b[41mii\u001b[0m\u001b[1m\u001b[30m;\u001b[0m",
      "\u001b[1m\u001b[31mincompatible types: java.lang.Integer cannot be converted to java.lang.Long\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "Integer ii = 10;\n",
    "Long ll = ii;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decd823d-bd6d-49d6-8080-200ab02f3cb5",
   "metadata": {},
   "source": [
    "## Ονοματολογία"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca45e3aa-0f39-487b-8129-ec29c040e845",
   "metadata": {},
   "source": [
    "Κάθε γλώσσα προγραμματισμού ορίζει κάποιες συμβάσεις ονοματολογίας για τα διάφορα στοιχεία της γλώσσας οι οποίες όταν ακολουθούνται καθιστούν τα προγράμματα πιο ευανάγνωστα (βλ. πηγές [8,13]). Αυτές περιγράφονται συνοπτικά παρακάτω:\n",
    "\n",
    "Ως γενικός κανόνας, για την ονομασία των ονομάτων που ορίζουμε εμείς στο πρόγραμμα, ακολουθείται, εκ συμβάσεως, ο _\"τρόπος καμήλας\" (Camel case)_, δηλ. όταν ξεκινά μια νέα λέξη αυτή ξεκινά με κεφαλαίο γράμμα. Από κει και πέρα:\n",
    "\n",
    "* οι μεταβλητές, τα πεδία και οι μέθοδοι ξεκινούν με πεζό γράμμα\n",
    "* οι κλάσεις ξεκινούν με κεφαλαίο γράμμα\n",
    "* οι σταθερές γράφονται με κεφαλαία γράμματα και αντί για camel case χρησιμοποιούμε κάτω παύλα (underscore δηλ. \\_)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ccb2908-ee7b-46d8-b1f6-10c3616a3cc4",
   "metadata": {},
   "source": [
    "## Περίληψη\n",
    "\n",
    "Σε αυτήν την ενότητα εξερευνήσαμε  τα βασικά στοιχεία των _κλάσεων (classes)_ και των _αντικειμένων (objects)_. Μάθαμε ότι τα αντικείμενα καθορίζονται από κλάσεις. Οι κλάσεις αντιπροσωπεύουν τη γενική έννοια των πραγμάτων, ενώ τα αντικείμενα αντιπροσωπεύουν συγκεκριμένες περιπτώσεις μιας κλάσης. Μπορούμε να έχουμε πολλά αντικείμενα μιας κλάσης.\n",
    "\n",
    "Τα αντικείμενα έχουν _μεθόδους (methods)_ που χρησιμοποιούμε για να επικοινωνήσουμε μαζί τους. Μπορούμε να χρησιμοποιήσουμε μια μέθοδο για να κάνουμε μια αλλαγή στο αντικείμενο ή για λήψη πληροφοριών από το αντικείμενο. Οι μέθοδοι μπορεί να έχουν παραμέτρους και\n",
    "οι παράμετροι έχουν τύπους. Οι μέθοδοι έχουν τύπους επιστροφής, οι οποίοι καθορίζουν τον τύπο δεδομένων που επιστρέφουν. Εάν ο τύπος επιστροφής είναι ```void```, δεν επιστρέφουν τίποτα.\n",
    "\n",
    "Τα αντικείμενα αποθηκεύουν δεδομένα σε _πεδία (fields)_ (τα οποία έχουν και τύπους). Όλες οι τιμές δεδομένων ενός αντικειμένου μαζί αναφέρεται ως η _κατάσταση (state)_ του αντικειμένου.\n",
    "\n",
    "Τα αντικείμενα δημιουργούνται από ορισμούς κλάσεων που έχουν γραφτεί σε μια συγκεκριμένη γλώσσα προγραμματισμού. Μεγάλο μέρος του προγραμματισμού στη Java αφορά την εκμάθηση της σύνταξης ορισμών κλάσεων. Ένα μεγάλο πρόγραμμα Java θα έχει πολλές κλάσεις, η καθεμία με πολλές μεθόδους που καλούν η μία την άλλη με πολλούς διαφορετικούς τρόπους.\n",
    "\n",
    "Για να μάθουμε να αναπτύσσουμε προγράμματα Java, πρέπει να μάθουμε πώς να γράφουμε ορισμούς κλάσεων, συμπεριλαμβανομένων των πεδίων και μεθόδων, και πώς να συνδυάσουμε αυτές τις κλάσεις. Οι υπόλοιπες ενότητες αυτού του μαθήματος πραγματεύονται αυτά τα ζητήματα."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aac355e-da99-4af9-9233-46293501b938",
   "metadata": {},
   "source": [
    "# Ασκήσεις\n",
    "1) Να δημιουργήσετε μια κλάση ```Student``` για μαθητές λυκείου με τα εξής γνωρίσματα:\n",
    "\n",
    "* αριθμός μητρώου (θετικός ακέραιος)\n",
    "* όνομα (αλφαριθμητικό και δεν μπορεί να 'ναι κενό)\n",
    "* επώνυμο (αλφαριθμητικό και δεν μπορεί να 'ναι κενό)\n",
    "* ηλικία (ακέραιος μεταξύ 15-18 και πρέπει να 'χει τιμή)\n",
    "* τάξη (αλφαριθμητικό μπορεί να είναι κενό, π.χ. στην αρχή της χρονιάς)\n",
    "\n",
    "   και τις αντίστοιχες μεθόδους πρόσβασης. Ο Α.Μ. θα πρέπει να αυξάνεται αυτόματα κατά την κατασκευή του αντικειμένου της κλάσης (υλοποιήστε το αφού κάνετε το μάθημα 3.4) και δε θα μπορεί να μεταβάλλεται μετά την εκχώρησή του. Θα πρέπει να μπορείτε να δημιουργήσετε αντικείμενα της κλάσης ```Student``` ως εξής:\n",
    "\n",
    "```java\n",
    "jshell> Student ioannis = new Student(\"Γιάννης\", \"Αντεκοτούμπο\", 16);\n",
    "Student{am=1, firstName=Γιάννης, lastName=Αντεκοτούμπο, age=16, classRoom=null}\n",
    "\n",
    "jshell> System.out.println(\"AM: \" + ioannis.getAm());   // 1\n",
    "AM: 1\n",
    "\n",
    "jshell> ioannis.setClassRoom(\"Β1\");\n",
    "\n",
    "jshell> System.out.println(ioannis.getClassRoom());     // Β1\n",
    "B1\n",
    "```\n",
    "   κλπ. Οι μέθοδοι θα πρέπει να ελέγχουν την εγκυρότητα των ορισμάτων τους.\n",
    "\n",
    "2) Να δημιουργήσετε μια κλάση ```ClassRoom``` η οποία θα μπορεί να δέχεται μέχρι 30 μαθητές τύπου ```Student```. Η τάξη θα διαθέτει επίσης ένα αναγνωριστικό το οποίο θα είναι ίδιο με το γνώρισμα _τάξη_ που ορίσατε για τον μαθητή στην προηγούμενη άσκηση. Ο χρήστης της κλάσης θα μπορεί να προσθέτει και να αφαιρεί μαθητές σ' αυτή. Τροποποιήστε το αντίστοιχο γνώρισμα τάξη του αντικειμένου ```Student``` να είναι τύπου ```ClassRoom```.\n",
    "\n",
    "```java\n",
    "jshell> ClassRoom b1 = new ClassRoom(\"B1\", 30);\n",
    "b1 ==> ClassRoom{name=Β1, size=30, numOfStudents=0}\n",
    "\n",
    "jshell> b1.addStudent(ioannis);\n",
    "\n",
    "jshell> ioannis.getClassRoom(); \n",
    "$1 ==> \"B1\"\n",
    "    \n",
    "jshell> b1\n",
    "b1 ==> ClassRoom{name=Β1, size=30, numOfStudents=1}\n",
    "\n",
    "jshell> b1.removeStudent(ioannis);\n",
    "\n",
    "jshell> ioannis.getClassRoom();\n",
    "$2 ==> null\n",
    "    \n",
    "jshell> b1\n",
    "b1 ==> ClassRoom{name=Β1, size=30, numOfStudents=0}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a554c036-9803-42e8-be6a-7b1ffac3d6f2",
   "metadata": {},
   "source": [
    "Εξασκηθείτε εδώ <a href=\"sandbox/classroom.html\" target=\"_blank\"><img src=\"../../../assets/javaalmanac.svg\" alt=\"javaalmanac.io\" style=\"width:5%; height:5%;\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2905c90b-5cca-40ab-88ad-ef612d09dfe6",
   "metadata": {},
   "source": [
    "## Περαιτέρω μελέτη\n",
    "Υπάρχουν δυο πολύ ενδιαφέροντες ιστοτόποι εκμάθησης της γλώσσας Java (στα Αγγλικά) τους οποίους συνιστούμε ανεπιφύλακτα για να μελετάτε τα μαθήματά τους παράλληλα με αυτό το μάθημα. Αν επιθυμείτε να παρακολουθήσετε παράλληλα και αυτά τα μαθήματα, καλό είναι να εγγραφείτε (register). \n",
    "1. [CodeGym](https://codegym.cc/quests/tutorial)\n",
    "1. [CodecAdemy](https://www.codecademy.com/learn/learn-java)\n",
    "\n",
    "Αφού εγγραφείτε, στο CodecAdemy απλά πατήστε το **Start** για να ξεκινήσετε το πρώτο σας μάθημα.\n",
    "\n",
    "Στο CodeGym, ακολουθήστε τον υπερσύνδεσμο **Courses** από το μενού στα αριστερά και στη συνέχεια **JAVA DEVELOPER** και μετά **READING (A STORY LINE)**. Θα πρέπει να καταλήξετε στη σελίδα όπου εμφανίζεται το **Java For Beginners**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84c7eacd-47a9-492b-b698-19f5cacfd0fd",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Πηγές\n",
    "1. [\"The Java Tutorial\"](https://docs.oracle.com/javase/tutorial/)\n",
    "1. Darwin I. F. (2014), _Java Cookbook_, 3rd Ed., O’ Reilly.\n",
    "1. Deitel P., Deitel H. (2018), _Java How to Program_, 11th Ed., Safari.\n",
    "1. Downey A. B., Mayfield C. (2016), _Think Java_, O' Reilly. \n",
    "1. Eckel B. (2006), _Thinking in Java_, 4th Ed., Prentice-Hall.\n",
    "1. Evans B. (2020), [Records Come to Java](https://blogs.oracle.com/javamagazine/records-come-to-java), Java Magazine.\n",
    "1. Evans B. J., Flanagan D. (2019), _Java in a Nutshell_, 7th Ed., O’ Reilly.\n",
    "1. [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html)\n",
    "1. Horstmann C. S. (2016), _Core Java, Volume 1 Fundamentals_, 10th Ed., Prentice-Hall.\n",
    "1. Horstmann C. S. (2018), _Core Java SE 9 for the impatient_, 2nd Ed., Addison-Wesley. \n",
    "1. Horstmann C., [Big Java 5 - Chapter 2 - Using Objects](https://www.cs.ryerson.ca/~aferworn/courses/CPS109/CLASSES/week02/ch02/index.html)\n",
    "1. [Java Notes for Professionals](https://books.goalkicker.com/JavaBook/JavaNotesForProfessionals.pdf)\n",
    "1. [Java Style Guide](https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/styleguide.md)\n",
    "1. Juneau J. (2017), _Java 9 Recipes_, 3rd Ed., APress.\n",
    "1. Liguori R. & Liguori P. (2014), _Java 8 Pocket Guide_, O'Reilly.\n",
    "1. Μαργαρίτης Κ. (2004), [Εισαγωγή στη Java](https://www.ebooks4greeks.gr/wp-content/uploads/2013/03/Java-free-book.pdf)\n",
    "1. Sierra K. & Bates B. (2022), _Head First Java_, 3rd Ed. Covers Java 8-17, O’Reilly.\n",
    "1. Τζίτζικας Γ. (2016), [Μια Γεύση από Java](https://leanpub.com/JavaTaste), LeanPub."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b96c6b68-fae6-4604-b96e-06b40d50c07b",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "[Δ](../../TOC.ipynb) | [>](../3.2-IDEs/3.2-IDEs.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
}