Differences

This shows you the differences between two versions of the page.

--- java:inner_classes [2016/02/11 21:30]
gthanos [Κρύβοντας τα πεδία της εξωτερικής κλάσης στην εσωτερική κλάση]
+++ java:inner_classes [2019/04/02 20:20]
gthanos
@@ Line 1: / Line 1: @@
 ====== Μη στατικές εμφωλευμένες κλάσεις ======
-Οι μη στατικές εμφωλευμένες κλάσεις ή εσωτερικές κλάσεις (inner classes) αποτελούν την γενικότερη περίπτωση εμφώλευσης μίας κλάσης μέσα σε μία άλλη κλάση. Δείτε το παρακάτω παράδειγμα απεικόνισης των ζυγών στοιχείων ενός πίνακα 15 στοιχείων με χρήση μίας εσωτερικής κλάσης η οποία υλοποιεί το interface [[https://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html|Iterator]]:
+Οι μη στατικές εμφωλευμένες κλάσεις ή εσωτερικές κλάσεις (inner classes) αποτελούν την γενικότερη περίπτωση εμφώλευσης μίας κλάσης μέσα σε μία άλλη κλάση. Ας υποθέσουμε ότι θέλουμε να κατασκευάσουμε μία διπλά συνδεδεμένη λίστα η οποία μπορεί να αποθηκεύσει οποιονδήποτε τύπο όμοιων αντικειμένων.
+Η λίστα θα χρειαστεί να έχει δύο βοηθητικές κλάσεις
+  - την κλάση που περιγράφει τον κόμβο της λίστας και
+  - μία κλάση τύπου //iterator// για την διάτρεξη της λίστας
+Οι δύο παραπάνω κλάσεις εξυπηρετεί να δηλωθούν ως εσωτερικές κλάσεις αποκρύπτοντας την υλοποίηση των κλάσεων αυτών. Το παραπάνω επιτρέπει η λίστα να είναι συμβατή με τα interfaces [[http://docs.oracle.com/javase/8/docs/api/java/util/List.html|java.util.List]] και [[http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html|java.util.Iterator]]. Δείτε τον παρακάτω κώδικα που την υλοποιεί.
-<code java DataStructure.java>
+<code java LinkedList.java>
-public class DataStructure {
+public class LinkedList<E> {
+  private Node<E> head, tail;
-  // Create an array
+  public LinkedList() {
-  private final static int SIZE = 15;
+    head = new Node<>(null, null, null);
-  private int[] arrayOfInts = new int[SIZE];
+    tail = new Node<>(null, head, null);
+    head.setNext(tail);
-  public DataStructure() {
-    // fill the array with ascending integer values
-    for (int i = 0; i < SIZE; i++) {
-      arrayOfInts[i] = i;
-    }
   }
-  public void printEven() {
+  private class Node<E> {
+    private Node<E> next, prev;
-    // Print out values of even indices of the array
+    private E e;
-    DataStructureIterator iterator = this.new EvenIterator();
-    while (iterator.hasNext()) {
-      System.out.print(iterator.next() + " ");
-    }
-    System.out.println();
-  }
-  interface DataStructureIterator extends java.util.Iterator<Integer> { }
+    public Node(Node<E> nxt, Node<E> prv, E elem) {
+      next = nxt;
-  // Inner class implements the DataStructureIterator interface,
+      prev = prv;
-  // which extends the Iterator<Integer> interface
+      e = elem;
-  private class EvenIterator implements DataStructureIterator {
-    // Start stepping through the array from the beginning
-    private int nextIndex = 0;
-    public boolean hasNext() {
-      // Check if the current element is the last in the array
-      return (nextIndex <= SIZE - 1);
-    }
-    public Integer next() {
-      // Record a value of an even index of the array
-      Integer retValue = Integer.valueOf(arrayOfInts[nextIndex]);
-      // Get the next even element
-      nextIndex += 2;
-      return retValue;
     }
-    public void remove() { }
+    public Node<E> getNext() {return next;}
+    public void setNext(Node<E> nxt) { next = nxt; }
+    public Node<E> getPrev() {return prev;}
+    public void setPrev(Node<E> prv) { prev = prv; }
+    public E getElement() { return e; }
+    public void setElement(E elem) { e = elem; }
   }
-  public static void main(String s[]) {
+  private class Iterator<E> implements java.util.Iterator<E> {
+    Node<E> curr;
-    // Fill the array with integer values and print out only
+    public Iterator(Node<E> c) {
-    // values of even indices
+      curr = c;
-    DataStructure ds = new DataStructure();
-    ds.printEven();
-  }
-}
-</code>
-<WRAP todo center 80% round> Σε αναλογία, δημιουργήστε την εσωτερική κλάση **OddIterator** και τη μέθοδο **printOdd()** για την εκτύπωση των μονών αριθμών του πίνακα.
-</WRAP>
-===== Δημιουργία αντικειμένων της εσωτερικής κλάσης =====
-==== Δημιουργία αντικειμένων της εσωτερικής κλάσης στην εξωτερική κλάση ====
-Απαραίτητη προϋπόθεση για να δημιουργηθεί ένα αντικείμενο της εσωτερικής κλάσης είναι να υπάρχει ένα αντικείμενο της εξωτερικής κλάσης. Δεν μπορείτε να έχετε δηλαδή οποιαδήποτε αντικείμενο της εσωτερικής κλάσης χωρίς αυτό να συνδυαστεί με ένα αντικείμενο της εξωτερικής κλάσης.
-Δείτε το παρακάτω παράδειγμα δημιουργίας ενός αντικειμένου της εσωτερικής κλάσης μέσα στον κατασκευαστή της εξωτερικής κλάσης
-<code java OuterClass.java>
-public class OuterClass {
-  int outerClassField;
-  InnerClass ic;
-  public OuterClass(int field) {
-    outerClassField = field;
-    ic = new InnerClass(field*2);
-  }
-  class InnerClass {
-    int innerClassField;
-    public InnerClass(int field) {
-      innerClassField = field;
     }
-  }
+    public boolean hasNext() {
+      if(curr.getNext() != tail)
-  public String toString() {
+        return true;
-    return "outerClassField: "+outerClassField+", innerClassField: "+ic.innerClassField;
+      return false;
-  }
-  public static void main(String []args) {
-    OuterClass outer = new OuterClass(10);
-    System.out.println(outer);
-  }
-}
-</code>
-==== Δημιουργία αντικειμένων της εσωτερικής κλάσης από άλλες κλάσεις ή στατικές μεθόδους ====
-Προηγούμενα αναφέρθηκε ότι για να δημιουργηθεί ένα αντικείμενο της εσωτερικής κλάσης θα πρέπει να υπάρχει ένα αντικείμενο της εξωτερικής κλάσης. Δείτε πως μπορείτε να δημιουργήσετε σε μία στατική μέθοδο (//όπως είναι η μέθοδος **main**//) ένα αντικείμενο της εσωτερικής κλάσης με βάση την εξωτερική κλάση.
-<code java OuterClass.java>
-public class OuterClass {
-  int outerClassField;
-  InnerClass ic;
-  public OuterClass(int field) {
-    outerClassField = field;
-    ic = new InnerClass(field*2);
-  }
-  class InnerClass {
-    int innerClassField;
-    public InnerClass(int field) {
-      innerClassField = field;
     }
+    public E next() {
-    public String toString() {
+      curr = curr.getNext();
-      return "[innerClassField: "+innerClassField+"]";
+      return curr.getElement();
+    }
+    public void remove() {
+      curr.getPrev().setNext(curr.getNext());
+      curr.getNext().setPrev(curr.getPrev());
+      curr = null;
     }
   }
-  public String toString() {
+  Iterator<E> iterator() {
-    return "outerClassField: "+outerClassField+" "+ic.toString();
+    return new Iterator<E>(head);
   }
-  public static void main(String []args) {
+  // append in the end
-    OuterClass outer = new OuterClass(10);
+  public void add(E elem) {
-    System.out.println(outer);
+    Node<E> plus = new Node<E>(tail, tail.getPrev(), elem);
-    OuterClass.InnerClass inner = outer.new InnerClass(4); //line 4
+    tail.getPrev().setNext(plus);
-    System.out.println(inner.toString());
+    tail.setPrev(plus);
-  }
-}
-</code>
-Η διαδικασία δημιουργίας ενός αντικειμένου της εσωτερικής κλάσης θα μπορούσε να δημιουργηθεί σε μία στατική ή μη στατική μέθοδο άλλης κλάσης. Δείτε το παρακάτω παράδειγμα.
-<code java TestOuterClass.java>
-public class TestOuterClass {
-  public static void main(String []args) {
-    OuterClass outer = new OuterClass(10);
-    System.out.println(outer);
-    OuterClass.InnerClass inner = outer.new InnerClass(4); //line 4
-    System.out.println(inner.toString());
   }
-}
-</code>
-Αρχικά, στην γραμμή 3 δημιουργούμε ένα αντικείμενο της κλάσης **OuterClass**. Στη συνέχεια με δεδομένο ότι έχουμε δημιουργήσει το αντικείμενο τύπου **OuterClass** στο οποίο δείχνει η μεταβλητή outer δημιουργούμε ένα νέο αντικείμενο της εσωτερικής κλάσης, όπως παρακάτω. Παρατηρήστε την ιδιαίτερη σύνταξη δημιουργίας αντικειμένων της εσωτερικής κλάσης.
-<code java>
-  OuterClass.InnerOuterClass inner = outer.new InnerOuterClass(4);
-</code>
-<WRAP todo 80% round center>
-Είναι προφανές ότι μπορούμε να φτιάξουμε πολλαπλά αντικείμενα της εσωτερικής κλάσης, με την προϋπόθεση ότι έχουμε τουλάχιστον ένα αντικείμενο της εξωτερικής κλάσης. Τι γίνεται όμως αν παραλείψετε να αρχικοποιήσετε την μεταβλητή της γονικής κλάσης, όπως παρακάτω:
-<code java TestOuterClass.java>
-public class TestOuterClass {
-  public static void mian(String args[]) {
-    OuterClass outer;                                                //line 3
-    OuterClass.InnerOuterClass inner = outer.new InnerOuterClass(4); //line 4
-  }
-}
-</code>
-Σε αυτή την περίπτωση λαμβάνετε από τον μεταγλωττιστή ένα λάθος της μορφής
-<code>
-OuterClass.java:29: error: variable outer might not have been initialized
-    OuterClass.InnerClass inner = outer.new InnerClass(4); //line 4
-                                  ^
-error
-</code>
-Δοκιμάστε το.
-</WRAP>
-Οι εσωτερικές κλάσεις μπορούν να έχουν προσδιοριστές πρόσβασης (//public, protected, package-private, private//) όπως και τα πεδία της κλάσης. Θα εξηγήσουμε αναλυτικά στη συνέχεια τη σημασία των προσδιοριστών πρόσβασης για τις εσωτερικές κλάσεις.
-===== Πρόσβαση στα πεδία της εξωτερικής κλάσης (από την εσωτερική κλάση) =====
-Κάθε εσωτερική κλάση έχει πρόσβαση στα πεδία και τις μεθόδους της εξωτερικής κλάσης, **ανεξάρτητα από τους προσδιοριστές πρόσβασης που έχουν αυτά**. Διαφορετικά, κάθε μέθοδος της εσωτερικής κλάσης μπορεί να έχει πρόσβαση σε μεταβλητές ή μεθόδους της εξωτερικής της κλάσης, ακόμη και εάν αυτές είναι δηλωμένες ως **private**.
-<WRAP tip 80% round center>
-Εάν μία μέθοδος της εσωτερικής κλάσης καλεί μία άλλη μέθοδο η οποία δεν ανήκει στην εσωτερική κλάση, τότε ο compiler αναζητά την μέθοδο στην εξωτερική κλάση. Αν δεν την βρει και στην εξωτερική κλάση τότε εμφανίζει μήνυμα λάθους.
-Αντίστοιχα, εάν μία μέθοδος της εσωτερικής κλάσης χρησιμοποιήσει ένα πεδίο που δεν υπάρχει στην εσωτερική κλάση, ο compiler θα το αναζητήσει στην εξωτερική κλάση και μόνο αν δεν το βρει ούτε εκεί θα εκτυπώσει ένα μήνυμα λάθους.
-</WRAP>
-Δείτε το παρακάτω παράδειγμα προσβασιμότητας των πεδίων της εξωτερικής κλάσης από την εσωτερική κλάση:
-<code java OuterClassAccess.java>
-public class OuterClassAccess {
-  private int outerPriv;
-  int outerPckgPriv;
-  protected int outerProt;
-  public int outerPub;
-  InnerClass ic;
-  private void setOuterPriv(int v) { outerPriv = v; }
+  public boolean contains(E elem) {
-  private int getOuterPriv() { return outerPriv; }
+    Iterator<E> it = iterator();
+    while(it.hasNext()) {
-  void setOuterPckgPriv(int v) { outerPckgPriv = v; }
+      E e = it.next();
-  int getPckgOuterPriv() { return outerPckgPriv; }
+      if( e.equals(elem) )
+        return true;
-  protected void setOuterProt(int v) { outerProt = v; }
+    }
-  protected int getOuterProt() { return outerProt; }
+    return false;
-  public void setOuterPub(int v) { outerPub = v; }
-  public int getOuterPub() { return outerPub; }
-  public OuterClassAccess() {
-     ic = new InnerClass(1,2,3,4);
-     ic.setOuterClassFields(5,6,7,8);
   }
-  public String toString() {
+  public int indexOf(E elem) {
-    return "outerPriv: "+outerPriv+", outerPckgPriv: "+outerPckgPriv+
+    Iterator<E> it = iterator();
-           ", outerProt: "+outerProt+", outerPub: "+outerPub;
+    int index = -1;
-  }
+    while(it.hasNext()) {
+      E e = it.next();
-  private class InnerClass {
+      index++;
+      if( e.equals(elem) )
-    public InnerClass(int p, int pp, int pr, int pu) {
+        return index;
-      outerPriv = p;
-      outerPckgPriv = pp;
-      outerProt = pr;
-      outerPub = pu;
     }
+    return -1;
-    public void setOuterClassFields(int p, int pp, int pr, int pu) {
-      setOuterPriv(p);
-      setOuterPckgPriv(pp);
-      setOuterProt(pr);
-      setOuterPub(pu);
-    }
-  }
-  public static void main(String args[]) {
-    OuterClassAccess oc = new OuterClassAccess();
-    System.out.println(oc);
   }
 }
 </code>
-<WRAP important 80% center round>
+Το παρακάτω πρόγραμμα επιχειρεί να δημιουργήσει μία λίστα με 20 τυχαίους αριθμούς και στη συνέχεια να τους εκτυπώσει χρησιμοποιώντας τον Iterator της λίστας. Παρατηρήστε ότι σε κανένα σημείου του προγράμματος δεν αποκαλύπτεται η ύπαρξη των εσωτερικών κλάσεων //Node// και //Iterator//. Η μεταβλητή //it// παραπέμπει στο interface [[http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html|java.util.Iterator]].
-Από το παραπάνω παράδειγμα, παρατηρούμε ότι η εσωτερική κλάση έχει πρόσβαση σε όλα τα πεδία και τις μεθόδους της εξωτερικής κλάσης, ανεξάρτητα από τον προσδιοριστή πρόσβασης που έχουν αυτά.
-</WRAP>
-===== Πρόσβαση από την εξωτερική κλάση σε πεδία της εσωτερικής κλάσης =====
+<code java LinkedListUsage.java>
+import java.util.*;
-Το παρακάτω παράδειγμα εξηγεί την προσβασιμότητα της εξωτερικής κλάσης σε πεδία και μεθόδους της εσωτερικής κλάσης.
+public class LinkedListUsage {
+  public static final int SIZE = 20;
-<code java OuterClass.java>
-public class OuterClass {
-  int outer;
-  InnerOuterClass innerObj;
-  public OuterClass(int o) {
-    outer = o;
-    innerObj = new InnerOuterClass();
-    innerObj.innerPriv = 10;
-    innerObj.innerProt = 20;
-    innerObj.innerPub = 30;
-    System.out.println(innerObj);
-  }
-  class InnerOuterClass {
-    private int innerPriv;
-    protected int innerProt;
-    public int innerPub;
-    private void setInnerPriv(int priv) { innerPriv = priv; }
-    protected void setInnerProt(int prot) { innerProt = prot; }
-    public void setInnerPub(int pub) { innerPub = pub; }
-    public String toString() {
-      return "innerPriv: "+innerPriv+", innerProt: "+innerProt+
-             ", innerPub: "+innerPub;
-    }
-  }
   public static void main(String[] args) {
-    OuterClass outer = new OuterClass(5);
+    Random rand = new Random( new Date().getTime());
-  }
+    LinkedList<Integer> list = new LinkedList<>();
-}
+    for(int i=0; i<SIZE; i++) {
-</code>
+      list.add(rand.nextInt(8*SIZE));
+    }
-Όπως θα παρατηρήσετε αν μεταγλωττίσετε και εκτελέσετε το πρόγραμμα η εξωτερική κλάση έχει απόλυτη πρόσβαση στα πεδία και τις μεθόδους της εσωτερικής κλάσης ανεξάρτητα από τον προσδιοριστή πρόσβασης που έχουν αυτά. Η διαφορά ανάμεσα στην πρόσβαση της εξωτερικής κλάσης στα πεδία της εσωτερικής γίνεται μέσω ενός αντικειμένου της εξωτερικής κλάσης.
+    Iterator<Integer> it = list.iterator();
+    while(it.hasNext()) {
-<WRAP important 80% center round>
+      System.out.print(it.next()+"  ");
-  * H εσωτερική κλάση έχει πρόσβαση σε όλα τα πεδία της εξωτερικής κλάσης.
+    }
-  * Η εξωτερική κλάση έχει πρόσβαση σε όλα τα πεδία της εσωτερικής κλάσης. Η πρόσβαση στα πεδία αυτά γίνεται μέσω ενός αντικειμένου της εξωτερικής κλάσης.
+    System.out.println();
-Οι προσδιοριστές πρόσβασης **δεν εισάγουν κανένα περιορισμό** στον προσδιορισμό της προσβασιμότητας των πεδίων και των μεθόδων της εσωτερικής κλάσης από την εξωτερική κλάση και αντίστροφα.
-</WRAP>
-===== Πρόσβαση από άλλες κλάσεις σε πεδία της εσωτερικής κλάσης =====
-Ο παρακάτω κώδικας επιχειρεί να δημιουργήσει ένα αντικείμενο μίας κλάσης εσωτερικής κλάσης από μία άλλη κλάση. Σε αυτή την περίπτωση και __με την προϋπόθεση ότι η εσωτερική κλάση είναι συνολικά προσβάσιμη__ από την κλάση που επιχειρεί να δημιουργήσει το αντικείμενο, η προσβασιμότητα των πεδίων και των μεθόδων της εσωτερικής κλάσης εξαρτάται από τους προσδιοριστές πρόσβασης που έχουν αυτά. Δείτε το παρακάτω παράδειγμα.
-<code java OuterClass.java>
-public class OuterClass {
-  int outer;
-  InnerClass innerObj;
-  public OuterClass(int o) {
-    outer = o;
-    innerObj = new InnerClass();
-    innerObj.innerPriv = 10;
-    innerObj.innerProt = 20;
-    innerObj.innerPub = 30;
-    System.out.println(innerObj);
   }
-  class InnerClass {
-    private int innerPriv;
-    protected int innerProt;
-    public int innerPub;
-    private void setInnerPriv(int priv) { innerPriv = priv; }
-    protected void setInnerProt(int prot) { innerProt = prot; }
-    public void setInnerPub(int pub) { innerPub = pub; }
-    public String toString() {
-      return "innerPriv: "+innerPriv+", innerProt: "+innerProt+
-             ", innerPub: "+innerPub;
-    }
-  }
 }
 </code>
-<code java TestOuterClass.java>
+<WRAP todo center 80% round> **Εργασία για το σπίτι:** Επιχειρήσετε να συμπληρώσετε την κλάση LinkedList ώστε να ικανοποιεί το interface [[http://docs.oracle.com/javase/8/docs/api/java/util/List.html|java.util.List]].
-public class TestOuterClass {
-  public static void main(String args[]) {
-    OuterClass outer = new OuterClass(5);
-    OuterClass.InnerClass inner = outer.new InnerClass();
-    inner.setInnerPriv(4);
-    inner.setInnerProt(5);
-    inner.setInnerPub(6);
-    System.out.println(inner);
-  }
-}
-</code>
-Κατά συνέπεια, για την προσβασιμότητα των πεδίων και των μεθόδων της εσωτερικής κλάσης από μία άλλη κλάση ισχύουν τα εξής:
-  - Η εσωτερική κλάση θα πρέπει να είναι συνολικά προσβάσιμη.
-  - Με την προϋπόθεση ότι ισχύει το **1.**, ισχύουν οι [[java:access_modifiers|κανόνες προσβασιμότητας]] που ορίζονται από προσδιοριστές πρόσβασης.
-==== Χρήση προσδιοριστών πρόσβασης στην εσωτερική κλάση ====
-Στο προηγούμενο παράδειγμα δοκιμάστε να αλλάξετε τον προσδιοριστή πρόσβασης της κλάσης **InnerClass** από package private σε private. Σε αυτή την περίπτωση θα παρατηρήσετε ότι η κλάση **TestOuterClass** δεν μεταγλωττίζεται. Συγκεκριμένα, o compiler εμφανίζει το παρακάτω μήνυμα λάθους, σημειώνοντας ότι ο προσδιοριστής πρόσβασης **private** δεν επιτρέπει τη πρόσβαση από μία άλλη κλάση στο συγκεκριμένο περιεχόμενο της **OuterClass**. Γενικότερα, ισχύουν οι κανόνες για τους προσδιοριστές πρόσβασης όπως αυτοί αναφέρονται [[java:access_modifiers|εδώ]].
-<code>
-TestOuterClass.java:6: error: OuterClass.InnerOuterClass has private access in OuterClass
-    OuterClass.InnerOuterClass inner = outer.new InnerOuterClass(4);
-              ^
-TestOuterClass.java:6: error: OuterClass.InnerOuterClass has private access in OuterClass
-    OuterClass.InnerOuterClass inner = outer.new InnerOuterClass(4);
-</code>
-<WRAP tip 80% center round>
-Το παραπάνω εξηγεί ικανοποιητικά τον τρόπο με τον οποίο μπορείτε να αποκλείσετε την πρόσβαση στην εσωτερική κλάση από άλλες κλάσεις πέραν της εξωτερικής. Ορίζοντας την εσωτερική κλάση ως **private** αυτή είναι προσβάσιμη μόνο από την εξωτερική της κλάση.
 </WRAP>
-==== Επαναορίζοντας (ή κρύβοντας..) τα πεδία της εξωτερικής κλάσης στην εσωτερική κλάση ====
-Στο προηγούμενο παράδειγμα είδαμε την προσβασιμότητα στα πεδία και τις μεθόδους της εξωτερικής κλάσης. Τι γίνεται όμως όταν υπάρχει μία μέθοδος που καλεί μία άλλη μέθοδο η οποία υπάρχει τόσο στη εσωτερική όσο και στην εξωτερική κλάση. Σε αναλογία τι γίνεται όταν μία μέθοδος καλεί ένα πεδίο το οποίο υπάρχει στην εσωτερική και την εξωτερική κλάση; Το παρακάτω παράδειγμα απαντά στις παραπάνω απορίες.
-<code java ShadowTest.java>
-public class ShadowTest {
-  public int x = 100;
-  class FirstLevel {
-    public int x = 200;
-    void methodInFirstLevel(int x) {
-      System.out.println("x = " + x);
-      System.out.println("this.x = " + this.x);
-      System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
-    }
-    String printX() { return "X in FirstLevel is "+x+" and "+ShadowTest.this.printX(); }
-  }
-  String printX() { return "X in ShadowTest is "+x; }
-  public static void main(String args[]) {
-    ShadowTest st = new ShadowTest();
-    ShadowTest.FirstLevel fl = st.new FirstLevel();
-    fl.methodInFirstLevel(23);
-    System.out.println(st.printX());
-    System.out.println(fl.printX());
-  }
-}
-</code>
+|Προηγούμενο: [[ :java:nested_classes| Εμφωλευμένες κλάσεις  ]] |  [[:toc|Περιεχόμενα]]  |Επόμενο: [[ :java:inner_class_objects | Δημιουργία αντικειμένων της εσωτερικής κλάσης ]]|

Αντικειμενοστραφής Προγραμματισμός

User Tools

Site Tools

Differences

Page Tools