Κυριακή, 13 Νοεμβρίου 2011

Εισαγωγή στον αντικειμενοστραφή προγραμματισμό

[πηγή]


Εισαγωγή
Αν ρωτήσουμε δέκα προγραμματιστές για το τι είναι αντικειμενοστραφής προγραμματισμός (object oriented programming) θα λάβουμε δέκα διαφορετικές απαντήσεις. Ουσιαστικώς πάντως, αντικειμενοστραφής προγραμματισμός είναι η μεθοδολογία που χρησιμοποιείται για να γράψουμε προγράμματα βασιζόμενοι σε αντικείμενα. Αυτά τα αντικείμενα είναι στην ουσία λογισμικά προπλάσματα (software models) που αναπαριστάνουνε και περιγράφουνε πράγματα και αντικείμενα στην καθημερινή μας ζωή (όπως ένα αυτοκίνητο για παράδειγμα ή ένα λογαριασμό τραπέζης). Τα προπλάσματα αυτά είναι επαναχρησιμοποιήσιμα (reusable) και διέπονται από κατάσταση (state) και συμπεριφορά (behaviour). Παραδείγματος χάρη η κατάσταση ενός αυτοκινήτου μπορεί να περιλαμβάνει το χρώμα, τον τύπο του αυτοκινήτου, αν είναι έτοιμο για ταξίδι κλπ, ενώ η συμπεριφορά του αυτοκινήτου μπορεί να περιλαμβάνει την επιτάχυνση, το φρενάρισμα, την αλλαγή των ταχυτήτων κλπ.
Στον κόσμο της πληροφορικής ένα αντικείμενο διατηρεί την κατάστασή του μέσω των μεταβλητών του (variables) και εφαρμόζει τη συμπεριφορά του μέσω των μεθόδων του (methods). Ο,τιδήποτε το αντικείμενο γνωρίζει (κατάσταση) και μπορεί να κάνει (συμπεριφορά) γίνεται μόνο μέσω αυτών των μεταβλητών και των μεθόδων του. Ο πυρήνας ενός αντικειμένου είναι φυσικά οι μεταβλητές του, χωρίς αυτές καμία μέθοδος δεν μπορεί να λειτουργήσει. Οι μέθοδοι μπορούνε να κρύψουνε τις μεταβλητές του αντικειμένου από τα άλλα αντικείμενα και να παρέχουνε ένα προστατευτικό περίβλημα, μία κάψουλα (encapsulation). Αυτό βοηθάει το αντικείμενο να διατηρεί προσωπικές πληροφορίες και δεδομένα χωρίς να επηρεάζει τα άλλα αντικείμενα που βασίζονται σε αυτό. Για παράδειγμα δε χρειάζεται να ξέρουμε πως ένας φούρνος μικροκυμάτων ζεσταίνει το φαγητό για να τον χρησιμοποιήσουμε.
Ο προγραμματιστής είναι αυτός που καθορίζει το επίπεδο πρόσβασης των μεταβλητών με το να τις δηλώνει προσωπικές (private), δημόσιες (public) ή προστατευμένες (protected). Όλα τα αντικείμενα ορίζονται σε σχέση με τις κλάσεις. Μπορούμε να ξέρουμε πολλά για ένα αντικείμενο αν ξέρουμε την κλάση του. Για παράδειγμα αν κάποιος μας πει ότι αγόρασε αυτοκίνητο τότε ξέρουμε ότι έχει τροχούς, τιμόνι, πόρτες κλπ. Η κάθε κλάση μπορεί να έχει υποκλάσεις (subclasses) και υπερκλάσεις (superclasses). Στη Java κάθε αντικείμενο έχει μία και μόνο μία υπερκλάση. Το γιατί θα το δούμε αργότερα. Ένα αυτοκίνητο (οχημα) μπορεί να είναι αγωνιστικό, ταξί, λεωφορείο, φορτηγό κλπ. Όλα αυτά είναι υποκλάσεις του αυτοκινήτου. μοιράζονται κοινά χαρακτηριστικά (π.χ. τροχούς, τιμόνι, πόρτες) αλλά το καθένα μπορεί να αναπτύξει τα δικά του προσωπικά χαρακτηριστικά (π.χ. το λεωφορείο έχει χώρο από κάτω για να βάζουμε τα πράγματα, δεν παύει όμως να είναι αυτοκίνητο). Με τη σειρά του το αυτοκίνητο είναι η υπερκλάση των αγωνιστικών αυτοκινήτων, των φορτηγών, των ταξί κλπ.
Ο σκοπός κάθε υποκλάσης είναι να προσφέρει πιο συγκεκριμένη συμπεριφορά για κάθε πρόβλημα. Κάθε υποκλάση κληρονομεί χαρακτηριστικά και συμπεριφορά από την υπερκλάση. Ένα λεωφορείο κληρονομεί τους τροχούς, το τιμόνι, τα καθίσματα, την αλλαγή των ταχυτήτων κλπ από το αυτοκίνητο. Εκτός αυτού όμως κάθε υποκλάση μπορεί να αψηφήσει τα κληρονομούμενα χαρακτηριστικά και συμπεριφορά της υπερκλάσης και να προέχει (override) τα δικά της. Το λεωφορείο έχει πολλά περισσότερα καθίσματα από ένα αυτοκίνητο ιδιωτικής χρήσεως ενώ ένα αγωνιστικό αυτοκίνητο της formula 1 έχει διαφορετικό τρόπο αλλαγής ταχυτήτων.
Αφηρημένες κλασεις και διεπαφες (abstract classses / Intefaces)
Στην πληροφορική επίσης υπάρχει η έννοια της αφηρημένης κλάσης (abstract class) και των διεπαφών (interfaces).Οι αφηρημένες κλάσεις αντιπροσωπεύουνε αφηρημένες έννοιες  και δεν μπορούμε να τις χρησιμοποιήσουμε για να δημιουργήσουμε οντότητες τους (instances). Για παράδειγμα το όχημα είναι μία αφηρημένη έννοια. Δεν υπάρχουνε οντότητες του οχήματος παρά μόνο οντότητες του αυτοκινήτου, του ποδηλάτου, του άρματος μάχης, της μοτοσικλέτας, του ταχύπλοου σκάφους, του πλοίου κλπ που χρησιμοποιούμε.
Οι διεπαφές (interfaces) ορίζουνε ένα πρωτόκολλο συμπεριφοράς και κανόνων μεταξύ οντοτήτων για να επικοινωνούνε και να αλληλεπιδρούνε. Για παράδειγμα η Ελληνική γλώσσα είναι μία διεπαφή μεταξύ των Ελλήνων. Αν κάποιος θέλει να μιλήσει Ελληνικά τότε πρέπει να υπακούει και να τηρεί τους κανόνες της Ελληνικής γλώσσας. Στον προγραμματισμό μπορούμε να σκεφτούμε τις διεπαφές σαν ένα «συμβόλαιο» μεταξύ των κλάσεων και των λειτουργιών τους.. Οι κλάσεις πρέπει να τηρούνε τους κανόνες που θέτονται από τις διεπαφές. Αν μία κλάση θέλει να εφαρμόσει μία διεπαφή τότε αυτή η κλάση πρέπει να συμμορφώνεται στα πρότυπα της διεπαφής.
Και οι αφηρημένες κλάσεις και οι διεπαφές παρέχουνε γενική συμπεριφορά για τις διάφορες υποκλάσεις τους. Η κύρια διαφορά μεταξύ των διεπαφών και των αφηρημένων κλάσεων είναι ότι οι αφηρημένες κλάσεις μπορούνε να παρέχουνε και εφαρμογή (υλοποίηση) των μεθόδων τους, ενώ οι διεπαφές όχι. Για παράδειγμα αν ένας λογαριασμός τραπέζης εφαρμοστεί ως αφηρημένη κλάση τότε μπορεί να παρέχει μία συγκεκριμένη συμπεριφορά για το πως ανοίγουμε ένα λογαριασμό. Αν η συμπεριφορά αυτή λέει ότι ο λογαριασμός μπορεί να ανοιχτεί εάν και μόνο εάν ο πελάτης βρίσκεται αυτοπροσώπως στην τράπεζα τότε όλες οι υποκλάσεις πρέπει να παρέχουνε ακριβώς την ίδια συμπεριφορά, δηλαδή ο πελάτης πρέπει να βρίσκεται αυτοπροσώπως στην τράπεζα για να ανοιχτεί ο λογαριασμός. Αν όμως ένας λογαριασμός τραπέζης εφαρμοστεί ως διεπαφή  τότε το πως ανοίγεται ο λογαριασμός μπορεί να αφεθεί κενό. Η κάθε υποκλάση μπορεί να εφαρμόσει το δικό της τρόπο για να ανοιχτεί ο λογαριασμός, π.χ. μέσω τηλεφώνου, μέσω ταχυδρομείου, αυτοπροσώπως κλπ. Το μόνο που παρέχεται είναι το δεδομένο ότι πρέπει να ανοιχτεί ο λογαριασμός και όχι ο τρόπος με τον οποίο θα ανοιχτεί. 

Εξετάζοντας την δομή μιας Java κλάσης
Ήρθε η στιγμή να δούμε σε μικρό η μεγάλο βαθμό τα χαρακτηριστικά που περιγράψαμε παραπάνω μέσα από μια πρώτη περιήγηση στον κώδικα μια απλής κλάσης. Χρησιμοποιώντας ένα παράδειγμα από το παραπάνω κείμενο θα αναλύσουμε διεξοδικά μια κλάση η οποία προσπαθεί να περιγράψει ένα αυτοκίνητο. Μπορεί να σας φανούν μερικά χαρακτηριστικά και σχόλια ως αφελή η γενικά σε κάποιο βαθμό αλλά όπως αναφέρθηκε παραπάνω με την παρακάτω κλάση κάνουμε μια προσπάθεια να περιγράψουμε το αντικείμενο 'αυτοκίνητο' και όχι να παρουσιάσουμε έναν απόλυτο τρόπο.
Κλάση Car ( Car.java)
**
 * <p>Title:Car </p>
 * <p>Description:A class that demonstares basic O.O features </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaHellug</p>
 * @author JavaHellug
  * @version 1.0
 */
 
public class Car {
 
  // Variable (or attribute) declaration
  private int iSpeed=0;
  private String sColor;
  private String sManufacturer;
  public static String sMessage = "I am a Car";
 
  //--------Class Constructors --------------------------------
 
  //default constructor
  public Car() {
  }
 
  //secondary constructor, instantiating user specific cars
  /**
   *
   * @param aNumOfWheels Specify your car how many wheels has
   * @param aNumOfDoors Specify your car how many Doors has
   * @param aColor Specify a custom color that your car wants to have
   * @param aManufacturer Specify the Manufacturer of your car
   */
  public Car(int aNumOfWheels,int aNumOfDoors,String aColor,String aManufacturer){
    this.sColor=aColor;
    this.sManufacturer=aManufacturer;
  }
  //----Methods--------------------------------------------
 
  /**
   * Sets a new color to the car ,in way it repaints your car
   * @param aColor The new color of your car
   */
  public void setColor(String aColor){
    this.sColor=aColor;
  }
 
  /**
   * This method returns the current color of your car
   * @return
   */
  public String getColor(){
    return this.sColor;
  }
  /**
   * Increases the speed of your car
   * @param aSpeed The new speed of your car
   */
  public void increaseSpeed(int aSpeed){
    this.iSpeed=aSpeed;
  }
 
  /**
   * Decreases the speed of your car
   * @param aDecrSpeed
   */
  public void decreaseSpeed(int aDecrSpeed){
    this.iSpeed=aDecrSpeed;
  }
}//end of class
Η βασική δομή μια κλάσης αποτελείται από το declaration (διακήρυξη) της και το body (βασικό σώμα). Η διακήρυξη είναι η πρώτη γραμμή κώδικα που βλέπουμε και δηλώνει την δημοσιότητα, το όνομα και αλλά πιο σύνθετα χαρακτηριστικά.Στη δική μας περίπτωση δεν έχουμε ορίσει κάποιο τέτοιο σύνθετο χαρακτηριστικό. Το βασικό σώμα ή body είναι όλο το υπόλοιπο μέρος του κώδικα που βρίσκεται μέσα στις αγκύλες { }.
Κάνοντας μια μικρή αναδρομή σε προηγούμενα κείμενα μπορούμε να δούμε αναλυτικά περιγραφή όλων των χαρακτηριστικών που μπορούμε να δηλώσουμε στην διακήρυξη μιας κλάσης.. Γι' αυτό θα επικεντρωθούμε στην δομή και τα χαρακτηριστικά του βασικού σώματος .
Βασικό σώμα (body) μιας κλάσης
Τρία είναι τα κύρια κομμάτια που αποτελούν το σώμα της κλάσης μας. Θα αναφερθούν με την σειρά που αναγράφονται στον κώδικα που παράλληλα είναι ο σωστός και προτεινόμενος τρόπος από τους δημιουργούς της Java. Θα διακρίνετε τα μέρη αυτά από τα σχόλια (//-----) που υπάρχουν.
·         Η διακήρυξη των μεταβλητών (variables ή attributes) της κλάσης .
·         Η διακήρυξη και το σώμα του ή των κατασκευαστών της κλάσης (class constructors).
·         H διακήρυξη και το σώμα των μεθόδων της κλάσης (methods ή functions).
Οι πρώτες 3 διακηρύξεις μεταβλητών έχουν ένα κοινό και αυτό είναι η λέξη private. Τι σημαίνει η λέξη private για τις μεταβλητές αυτές; Σημαίνει ότι οι συγκεκριμένες μεταβλητές είναι διαθέσιμες για χρήση ΜΟΝΟ στις μεθόδους της κλάσης μας. Καμία άλλη μεθόδους αλλού αντικειμένου δεν μπορεί να 'δει' αλλά και να χρησιμοποιήσει τις συγκεκριμένες μεταβλητές παρά μόνο οι παρακάτω μέθοδοι. Στην ερώτηση, πως θα μπορέσουμε εμείς να δείξουμε στον έξω κόσμο όλα αυτά τα χαρακτηριστικά που είναι ιδιωτικές για την κλάση μας, η απάντηση είναι... μέσω των απαραίτητων μεθόδων.
Ας αφήσουμε την λέξη private και ας συνεχίσουμε στο υπόλοιπο μέρος της διακήρυξης μεταβλητών μας. Να σημειώσουμε εδώ ότι δεν έχουμε αναφέρει μέχρι τώρα τον τύπο String (λέξη). Περιληπτικά να πούμε ότι δεν ανήκει στην ομάδα βασικών τύπων δεδομένων που έχουμε δει μέχρι τώρα αλλά σε μια άλλη μεγάλη οικογένεια τύπων που ουσιαστικά είναι αντικείμενα κλάσεων. Αργότερα θα γίνει περισσότερο αντιληπτό γι' αυτό υπομονή.
Τελευταίο τμήμα της διακήρυξης το όνομα που και εδώ πρέπει να ακολουθούμε κάποιους μικρούς κανόνες όπως ότι το όνομα της μεταβλητής πρέπει να αρχίζει με μικρό γράμμα και κάθε αλλά λέξη που περιέχεται στο όνομα μέσα να αρχίζει με κεφαλαίο π.χ.  (int iTheVariable). Συνηθίζεται το πρώτο μικρό γράμμα να είναι μια μικρή ένδειξη για τον τύπο της μεταβλητής π.χ. (int iTheVariable) το  (i) δηλώνει τον τύπο (int).
Επειδή όμως μέχρι τώρα μιλήσαμε για τον ορισμό των μεταβλητών μέσα στην κλάση μας ας περάσουμε λίγο στην επεξήγηση των μεταβλητών ως χαρακτηριστικά στην κλάση μας. Ο σχεδιαστής της κλάσης λοιπόν σκέφτηκε ότι για να δώσω μια περιγραφή του αυτοκίνητου πρέπει να ορίσω μερικά χαρακτηριστικά του που το κάνουν μοναδικό και ιδιαίτερο. Πράγματι λοιπόν στους πρώτους  ορισμούς μεταβλητών βλέπουμε να ορίζονται οι έννοιες της ταχύτητας, του χρώματος, του κατασκευαστή και ενός μηνύματος. Είναι μια μικρή και γενική θεώρηση αλλά δεν παύει να αντικατοπτρίζει την πραγματικότητα, ένα αυτοκίνητο ανάλογα με τον τύπο του έχει ιδιαίτερο, έχει ιδιαίτερο χρώμα και κατασκευαστή αλλά και για συγκεκριμένες στιγμές έχει ταχύτητα και κατάσταση .
Στην μεταβλητή με το όνομα (sMessage)διακρίνουμε την λέξη static η οποία δηλώνει ότι όλα τα αντικείμενα της κλάσης Car που θα δημιουργήσουμε θα έχουν ένα κοινό χαρακτηριστικό που θα είναι η μεταβλητή sMessage,να τονίσουμε ότι η μεταβλητή αυτή δεν θα υπάρχει σε κάθε αντικείμενο όπως οι άλλες μεταβλητές αλλά θα είναι μοναδική και όλα τα αντικείμενα της λέξης Car θα την μοιράζονται. Μια τέτοια μεταβλητή ονομάζεται class variable (μεταβλητές επιπέδου κλάσης) ενώ όλες οι άλλες μεταβλητές ονομάζονται instance variables (μεταβλητές επιπέδου αντικειμένου). Εννοιολογικά να προσθέσουμε ότι η iEngine δηλώνει ότι κάθε αυτοκίνητο έχει μία μόνο μηχανή και αυτό δεν μπορεί να αλλάξει ποτέ. Μέχρι τώρα έχουμε αναφέρει τις λέξεις αντικείμενα, έχουμε αναφέρει ότι οι μεταβλητές της κλάσης θα πάρουνε αρχικές τιμές. Αλήθεια ποιος είναι υπεύθυνος να τα κάνει όλα αυτά και να δώσει ζωή στην κλάση μας; Η απάντηση έρχεται στην επόμενη παράγραφο.
Οι κατασκευαστές της κλάσης ( class constructors )
Οι κατασκευαστές της κλάσης αποτελούν το δεύτερο τμήμα του βασικού σώματος (body) μιας κλάσης και είναι αυτοί που ευθύνονται για την δημιουργία αντικειμένων. Με τον ορισμό της κλάσης απλώς περιγράφουμε ένα αντικείμενο (χαρακτηριστικά, συμπεριφορές) αλλά δε δημιουργούμε κάποιο αντικείμενο. Για να δημιουργήσουμε αντικείμενα της κλάσης αυτής πρέπει να χρησιμοποιήσουμε τους κατασκευαστές της οι οποίοι θα δημιουργήσουν για εμάς οντότητες (αντικείμενα ) της κλάσης. Είναι λογικό ότι και οι κατασκευαστές είναι αναπόσπαστο κομμάτι μιας κλάσης και κάθε κλάση πρέπει να παρέχει τουλάχιστον έναν από αυτούς! Ας δούμε στην περίπτωση μας ποιοι είναι οι κατασκευαστές της κλάσης μας.
Παρατηρούμε λοιπόν ότι η κλάση Car παρέχει 2 κατασκευαστές (constructors), δηλαδή παρέχει 2 τρόπους που μπορούμε να δημιουργήσουμε εμείς αντικείμενα της κλάσης. Η γραφή των κατασκευαστών μοιάζει παρά πολύ με την γραφή απλών μεθόδων, αλλά έχουν ορισμένες διάφορες και χαρακτηριστικά.
·         Οι κατασκευαστές έχουν πάντα το όνομα της κλάσης στην συγκεκριμένη περίπτωση και οι 2 έχουν τον όνομα Car, ΔΕΝ επιτρέπεται να ορίσουμε διαφορετικό όνομα στους κατασκευαστές μια κλάσης.
·         Οι κατασκευαστές δεν έχουν τύπο επιστροφής, παρόλο που μοιάζουν με κανονικές μεθόδους δεν μπορούμε να γράψουμε ότι επιστρέφουν κάποιο ιδιαίτερο τύπο δεδομένων. Π.χ. η παρακάτω γραμμή κώδικα δημιουργεί τρομερό λάθος στον Java compiler.
public Car()
{
       return new Car();
}
·         Πρέπει κάθε κλάση μας να παρέχει τουλάχιστον έναν κατασκευαστή, σε περίπτωση που εμείς ξεχάσουμε να γράψουμε έναν στην κλάση μας τότε αυτόματα ο compiler θα δημιουργήσει έναν τον οποίο τον αποκαλούμε default constructor (προεπιλεγμένος κατασκευαστής). Στην περίπτωση μας έχουμε ορίσει εμείς τον προεπιλεγμένο κατασκευαστή ο οποίος είναι ο παρακάτω:
public Car()
{

}
Θα πρέπει να ΤΟΝΙΣΟΥΜΕ ότι όταν δημιουργούμε αντικείμενα με τον προεπιλεγμένο κατασκευαστή τότε όλες οι μεταβλητές της κλάσης μας οι οποίες στην διακήρυξη τους δεν έχουν αρχικές τιμές παίρνουν αρχικές τιμές. Για τις μεταβλητές που ανήκουν στους βασικούς τύπους παίρνουν την τιμή '0' ενώ για τις μεταβλητές που είναι και αυτές αντικείμενα κλάσεων (όπως τα String, ουσιαστικά προέρχονται από την κλάση String) παίρνουν την τιμή 'null'. Την έννοια του null θα την εξηγήσουμε λίγο παρακάτω προς το παρόν ας θυμόμαστε την παρατήρηση παραπάνω για τις αρχικές τιμές που δίνει ο προεπιλεγμένος κατασκευαστής.
·         Εκτός από τον προεπιλεγμένο κατασκευαστή μπορούμε να ορίσουμε εμείς όσους άλλους κατασκευαστές θέλουμε, π.χ. αν θέλουμε να κατασκευάσουμε αντικείμενα της κλάσης που να έχει σαν μεταβλητές (χαρακτηριστικά) τα οποία θέλουμε να τα ορίσουμε εμείς και όχι αυτά να πάρουν τις προεπιλεγμένες τιμές που αναλύσαμε παραπάνω.
Μια μικρή παρατήρηση περί της παράξενης λέξης ( this) που εμφανίζεται στο σώμα του κατασκευαστή. Αν και ίνα λίγο πρώιμη η πλήρης επεξήγηση της λέξης μπορούμε να αναφέρουμε ότι χρησιμοποίηση της είναι καλή προγραμματιστική τακτική και την χρησιμοποιούμε όταν μέσα σε μια κλάση θέλουμε να αναφερθούμε σε μεταβλητές η μεθόδους της ίδιας την κλάσης. Δηλαδή στο συγκεκριμένο παράδειγμα ήθελα να θέσω τις τιμές των παραμέτρων του κατασκευαστή με τις μεταβλητέ της κλάσης, άρα ήθελα να αναφερθώ σε κομμάτι της ίδιας την κλάσης για κάποιο εσωτερικό χαρακτηριστικό της. Αυτό το επιτυγχάνουμε με την λέξη (this).


Οι μέθοδοι μιας κλάσης

Το τρίτο και τελευταίο κομμάτι του κυρίως σώματος μίας κλάσης είναι η γραφή των μεθόδων της. Έχουμε αναφερθεί εκτενέστατα σε προηγούμενα κείμενα για τον σωστό τρόπο γραφής των μεθόδων. Σήμερα θα επικεντρωθούμε λίγο σε συγκεκριμένες συμπεριφορές αλλά και λειτουργικότητα που παρουσιάζουν μερικές από τις μεθόδους που βλέπουμε στην κλάση Car.
Ανατρέχοντας πιο πάνω στο κείμενο αναφέραμε ότι έχουμε ορίσει 3 από τις μεταβλητές της κλάσεις με δημοσιότητα ιδιωτική (private) που αυτό σημαίνει ότι τις συγκεκριμένες μεταβλητές μπορούμε να τις επεξεργαστούμε, να αλλάξουμε η να ελέγξουμε την τιμή τους ΜΟΝΟ μέσα από της μεθόδους της κλάσης. Συγκεκριμένα παραδείγματα μεθόδων οι οποίες υπηρετούν τον συγκεκριμένο σκοπό αυτό είναι οι  (setColor , getColor) οι οποίες μας δίνουν την δυνατότητα να μεταβάλλουμε αλλά και να χρησιμοποιήσουμε την ιδιωτική μεταβλητή (iColor). Τέτοιου είδους μέθοδοι αποκαλούνται στην προγραμματιστική αργκό ως (getter and setters). 
Συνεχίζοντας να πούμε ότι οι πιο πολλές μέθοδοι που είναι γραμμένοι στην κλάση Car έχουν αυτή ακριβώς την συμπεριφορά. Είναι ενδεικτική και πάλι η παρουσία της λέξης (this) σε πολλές από τις μεθόδους. Όμως περισσότερα για της μεθόδους μπορούμε να δούμε και να ανακαλύψουμε από την χρήση τους πάνω σε αντικείμενα (οντότητες, instances) της κλάσης Car.
Δημιουργία και επεξεργασία αντικειμένων της κλάσης Car
Έχοντας είδη γράψει μια κλάση η οποία αναπαριστά ένα αντικείμενο συγκεκριμένα ένα αυτοκίνητο θα γράψουμε άλλη μια η οποία θα αποτελέσει τον πυρήνα ενός μικρού Java προγράμματος στο οποίο θα δημιουργήσουμε μερικά αντικείμενα της κλάσης Car όπου και θα δούμε το πως αντιδρούν στις διάφορες μεθόδους που εμείς καλούμε αλλά και τη επιπτώσεις έχει στην κατάσταση τους!
/**
 * <p>Title:SimpleApp </p>
 * <p>Description:Class to illustrate a simple App</p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaHellug</p>
 * @author JavaInsomniac
 * @version 1.0
 */
 
public class SimpleApp {
 
  public SimpleApp() {
  }
 
  //the Main function of our application
  public static void main(String[] args) {
 
  //create instances of Car class
  Car aCar1 = new Car();
  Car aCar2 = new Car("Black","Mercedes");
  Car aCar3 = new Car("Red","Ferrari");
 
  //-------------examine some attributes of each instance--------------------
  //examine color
  System.out.println("The car1 color is: "+aCar1.getColor());
  System.out.println("The car2 color is: "+aCar2.getColor());
  System.out.println("The car3 color is: "+aCar3.getColor());
 
  //increase speed of our cars
  aCar1.increaseSpeed(10);
  aCar2.increaseSpeed(100);
  aCar3.increaseSpeed(150);
 
  //reduce speed of our cars
  aCar1.decreaseSpeed(0);
  aCar2.decreaseSpeed(50);
  aCar3.decreaseSpeed(100);
 
  //Lets change some of the characteristics of our cars
  aCar1.setColor("White");
  aCar3.increaseSpeed(100);
 
  //Whats the status now?
  System.out.println("The car1 color is: "+aCar1.getColor());
 
  }
}\\end of class
Στην μέθοδο (main) λοιπόν της κλάσης SimpleApp μπορούμε να διακρίνουμε τις 3 πρώτες γραμμές κώδικα οι οποίες αποτελούν κάτι το οποίο αναλύσαμε παραπάνω, οι κατασκευαστές. Συγκεκριμένα δημιουργούμε 3 αντικείμενα της κλάσης Car, τους  δίνουμε ονόματα και στην συνεχεία καλούμε τον κατασκευαστή της κλάσης για να δημιουργήσει  και να καταχωρήσει στη μνήμη  τα αντικείμενα αυτά. Η γραφή ακολουθεί την εξής σύνταξη
(Όνομα κλάσης ) (Όνομα Αντικειμένου) = new (Όνομα κλάσης) ( παράμετροι)
Car car1 = new Car() //χρησιμοποίηση του προεπιλεγμένου κατασκευαστή
Car ca2 = new Car ("red", "Ferrari") //χρησιμοποίηση δευτερεύοντος κατασκευαστή
Παρατηρούμε λοιπόν ότι η δημιουργία ενός αντικειμένου στην Java μοιάζει πολύ με την διακήρυξη μιας μεταβλητής. Ορίζουμε τον τύπο του αντικειμένου, όπως και στην μεταβλητή, δίνουμε ένα όνομα στο αντικείμενο όπως και στην μεταβλητή, μπορούμε να δώσουμε μια αρχική τιμή στη μεταβλητή το ίδιο μπορούμε να κάνουμε και σε ένα αντικείμενο με το να χρησιμοποιούμε τον κατασκευαστή της κλάσης.
Εδώ βέβαια πρέπει να σταθούμε λίγο και να εξηγήσουμε την φύση των αντικειμένων στην Java. Ας πάρουμε για παράδειγμα τη διακήρυξη παραπάνω του αντικειμένου (car1), στην Java το car1 δεν είναι ουσιαστικά το ίδιο το αντικείμενο με τις τιμές του, αλλά μια αναφορά ένας δείκτης σε συγκεκριμένο σημείο της μνήμης του υπολογιστή μας όπου η εικονική μηχανή έχει δεσμεύσει χώρο για να αποθηκεύσει τις μεταβλητές και ιδιότητες ενός αντικειμένου. Το όνομα λοιπόν του αντικειμένου που δίνουμε κατά την δημιουργία του είναι απλώς μια αναφορά σε εκείνο το σημείο της μνήμης. Έτσι λοιπόν στην Java έχουμε την έννοια του reference (αναφοράς) που είναι κοντινή με την έννοια του δείκτη (pointer) που συναντούμε σε άλλες γλώσσες όπως η C++ . Με την ίδια λογική λειτουργούν όλα στην Java όλα είναι αναφορές (references) σε κάποιο χώρο στην μνήμη. Η μόνη εξαίρεση είναι οι μεταβλητές βασικού τύπου (int , byte κτλ)που μας είχαν απασχολήσει σε παλιότερο κείμενο.
Μετά την δημιουργία των αντικειμένων παρατηρούμε το πώς καλούμε διάφορες μεθόδους του αντικειμένου. Η γραφή είναι πολύ εύκολη γράφουμε το όνομα του αντικειμένου και στην συνεχεία την ('.' τελεία) με το όνομα της μεθόδου. Ανάλογα με το είδος της μεθόδου θα πρέπει να ορίσουμε και τον δεκτή της τιμής επιστροφής. Στην κλάση μας παρατηρούμε ότι καλούνται διαδοχικά και για 3 αντικείμενα μας μέθοδοι οι οποίες μας επιστρέφουν το χρώμα του αυτοκίνητου (επιστρέφουν μια λέξη (String) ενώ οι υπόλοιπες μέθοδοι που καλούνται δεν επιστρέφουν κάτι απλώς αλλάζουν κάποιες ιδιωτικές μεταβλητές των αντικειμένων όπως είναι η ταχύτητα (speed).
Δημιουργώντας υποκλάσεις, μια πρώτη μάτια στην κληρονομικότητα
Με την κλάση Car δημιουργήσαμε ένα προγραμματιστικό μοντέλο για να παρουσιάσουμε την έννοια και την λειτουργία ενός αυτοκίνητου, έστω απλοϊκά. Επειδή όμως ένα αυτοκίνητο σαν έννοια έχει πολλές προεκτάσεις και υποκατηγορίες μας δημιουργείται η ανάγκη να αναπαραστήσουμε προγραμματιστικά κάτι πιο εξειδικευμένο από ένα απλό Car αυτοκίνητο. Η ανάγκη αυτή είναι η δημιουργία ενός αγωνιστικού αυτοκίνητου  Αν συγκρίνουμε (απλοϊκά) ένα απλό αυτοκίνητο με ένα αγωνιστικό θα δούμε ότι έχουν πολλές ομοιότητες σε κύρια σημεία., και άλλες τόσες διάφορες σε αλλά σημεία. Θα ήταν λοιπόν πολύ βολικό για εμάς αν μπορούσαμε να χρησιμοποιήσουμε όλα αυτά τα κοινά σημεία ενός απλού αυτοκίνητου που έχουμε είδη ορίσει στην κλάση Car , και να ορίσουμε κάποια αλλά πρόσθετα πιο εξειδικευμένα. Όπως γίνεται δηλαδή και στην πραγματικό κόσμο.
Οι εταιρίες παραγωγής που λαμβάνουν μέρος σε αγώνες, διαλέγουν έναν από τους τύπου αυτοκίνητων που πουλάνε στο ευρύ κοινό, κρατάνε τα βασικά συστατικά του όπως π.χ. τη σχεδίαση του αμαξώματος και στην συνεχεία χτίζουν πάνω στον απλό αυτό αμάξι όλα εκείνα τα χαρακτηριστικά που χρειάζονται για να φτιάξουν ένα πετυχημένο αμάξι. Δεν μπαίνουν όμως στην διαδικασία να σχεδιάσουν από την αρχή όλο το αυτοκίνητο. Αυτό θα κάνουμε και εμείς για να αντικατοπτρίσουμε προγραμματιστικά ένα αγωνιστικό αμάξι. Θα χρησιμοποιήσουμε το χαρακτηριστικό του αντικειμενοστραφούς προγραμματισμού που ονομάζεται κληρονομικότητα (inheritance) και θα δημιουργήσουμε μια υποκλάση (subclass) της κλάσης Car την οποία θα ονομάσουμε RacingCar.
Η κλάση RacingCar θα κληρονομήσει όλα εκείνα τα χαρακτηριστικά της απλής κλάσης Car, όλες τις ιδιωτικές μεταβλητές αλλά και όλες τις μεθόδους συν θα προσθέσει κάποια προσθετά στοιχεία που θα την κάνουν να ξεχωρίζει.
·         Η RacingCar κλάση ορίζεται ως υποκλάση της Car, (subclass) η αλλιώς μπορούμε να αναφέρουμε ότι κληρονομεί από την κλάση Car. Eνώ η κλάση Car ορίζεται ως υπερκλάση (super class).
·         ¨Ένα αντικείμενο της κλάσης RacingCar μπορεί να καλέσει εξαιτίας της κληρονομικότητας όλες τις μεθόδους που έχουν οριστεί στην κλάση Car συν αυτές που έχει διακηρύξει προσθετά  η κλάση του. Ένα αντικείμενο της Car μπορεί να καλέσει μόνο της μεθόδους που έχουν διακηρυχτεί στην ομώνυμοι κλάση και ΟXI τις προσθετές κλάσεις που έχουν διακηρυχτεί στην υποκλάση της RacingCar
·         Ένα RacingCar αντικείμενο  μπορεί να συμπεριφερθεί σαν ένα απλό αντικείμενο Car ενώ ένα αντικείμενο Car δεν μπορεί να συμπεριφερθεί σαν ένα RacingCar
Παρακάτω είναι ο κώδικας της κλάσης RacingCar η οποία έχει μια μέθοδο και μια μεταβλητή ορισμένες. Χαρακτηριστική είναι η χρήση της λέξης extends που χρησιμοποιούμε για να δηλώσουμε μια υποκλάση κατά την δήλωση της.
/**
 * <p>Title:RacingCar class </p>
 * <p>Description:Ilustrates subclasing and inheritance </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaHellug</p>
 * @author JavaHellug
  * @version 1.0
 */
 
 public class RacingCar extends Car {
  //a message that indicates that the object is a racing car
  public String sRacingCarMessage ="I am racing Car";
 
  //default constructor
  public RacingCar() {
    // Call super-class method to set the colour.
    setColor("red");
  }
 
  //secondary constructor
  public RacingCar(String aColor,String aManufacturer){
 
    //call to the super class contstructor to do the job!
    super(aColor,aManufacturer);
  }
 
  //special method of the RacingCar
  public void useTurboBoost(){
    System.out.println("Turbo was turned on");
    super.increaseSpeed(300);
  }
 
}//end of class
Από τη στιγμή που η κλάση RacingCar κληρονομεί συμπεριφορά από την υπερκλάση τότε μπορούμε επίσης να καλέσουμε και μεθόδους της κλάσης Car μέσα από τη RacingCar όπως για παράδειγμα καλούμε τη setColor μέσα από τον κατασκευαστή και αλλάζουμε το χρώμα του αγωνιστικού αυτοκινήτου σε κόκκινο. Η Εικονική Μηχανή θα καλέσει τη μέθοδο της υπερκλάσης αυτονόητα, χωρίς να χρειάζεται να χρησιμοποιήσουμε τη λέξη super.
Βέβαια θα μπορούσαμε να γράψουμε τη δική μας setColor (που θα προέχει της setColor της υπερκλάσης) και να της δώσουμε τα δικά μας χαρακτηριστικά. Για παράδειγμα θα μπορούσαμε να ελέγχουμε αν ήδη το αυτοκίνητο έχει αυτό το χρώμα που προσπαθούμε να του δώσουμε:
/**
   * It checks if the car is already painted to the colour we pass. If not
   * it sets a new color to the car.
   * @param aColor The new color of your car
   */
  public void setColor(String aColor){
    if (aColor.equals(getColor()))
        this.sColor = aColor;
    else
        System.out.println("Car has already the colour you are trying to set");
 
Αν ήδη υπάρχει μία μέθοδος με το όνομα setColor στην κλάση RacingCar τότε καλώντας τη setColor από τον κατασκευαστή της κλάσης (παράδειγμα πιο πάνω) η Εικονική μηχανή θα καλέσει τη setColor της κλάσης και όχι τη setColor της υπερκλάσης. Αν για οποιονδήποτε λόγο θέλουμε να καλέσουμε τη setColor της υπερκλάσης τότε πρέπει να την καλέσουμε ρητώς χρησιμοποιώντας τη λέξη super (π.χ. super.setColor('red')).
Αφηρημένες κλάσεις (Abstract Classes)
Στον αντικειμενοστραφή προγραμματισμό οι αφηρημένες κλάσεις παρέχουνε μία γενική συμπεριφορά αλλά και εφαρμογή των μεθόδων τους για όλες τις υποκλάσεις τους. Για να καταλάβουμε καλύτερα το ρόλο των αφηρημένων κλάσεων ας δούμε το παρακάτω παράδειγμα.
/**
 * <p>Title: Vehicle class </p>
 * <p>Description: Illustrates abstract classes and inheritance </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaInsomniacs</p>
 * @author JavaInsοmniacs
 * @version 1.0
 */
 
public abstract class Vehicle{
    private int distance = 10;   // Distance in kilometers.
   
    public abstract void calculateSpeed();
    public void moveOneKmForward()
    {
        distance = distance + 1;
    }
}
Η κλάση Vehicle είναι μία αφηρημένη κλάση που παρέχει δύο μεθόδους. Η μία είναι η αφηρημένη μέθοδος calculateSpeed και η άλλη  η moveOneKmForward. Όλες οι υποκλάσεις της Vehicle πρέπει να εφαρμόσουνε τη δική τους calculateSpeed μέθοδο, η κάθε μία με το δικό της τρόπο. Για παράδειγμα αλλιώς υπολογίζεις την ταχύτητα ενός πλοίου και αλλιώς ενός ποδηλάτου. Η moveOneKmForward μπορεί να μείνει ακριβώς η ίδια και να την καλούνε όλες οι υποκλάσεις.
/**
 * <p>Title: Ship class </p>
 * <p>Description: Illustrates abstract classes and inheritance </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaΗellug</p>
 * @author JavaHellug
  * @version 1.0
 */
 
public class Ship extends Vehicle{
    private float speed = 0;
    private int gears = 2;
    private int wind = 8;
 
    public void calculateSpeed(){
        // Calculate speed based on ship data
        speed = gears * wind * .56;
    }
 
    public void move(){
        moveOneKmForward();    // Vehicle's method
    }
}
 
/**
 * <p>Title: Bicycle class </p>
 * <p>Description: Illustrates abstract classes and inheritance </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaInsomniacs</p>
 * @author JavaInsοmniacs
 * @version 1.0
 */
 
public class Bicycle extends Vehicle{
    private float bicycleSpeed = 0;
    private int gears = 6;
    private boolean tired = true;
 
    public void calculateSpeed(){
        // Calculate speed based on bicycle data
        if (tired)
            bicycleSpeed = gears * 15 / 4;
        else
            bicycleSpeed = gears * 15 / 2;
    }
 
    public void moveForward(){
        moveOneKmForward();    // Vehicle's method.
    }
}


Διεπαφές (Interfaces)
Οι διεπαφές, σε αντίθεση με τις αφηρημένες κλάσεις, δεν μπορούνε να περιέχουνε εφαρμογή των μεθόδων τους παρά μόνο παρέχουνε τις υπογραφές των μεθόδων. Όλες οι κλάσεις που εφαρμόζουνε μία (ή περισσότερες) διεπαφή πρέπει να προβάλλουν τη δική τους εφαρμογή των μεθόδων. Για παράδειγμα το παρακάτω είναι  η αφηρημένη κλάση που έχει μετατραπεί σε διαπαφή. Πρέπει να προσέξουμε ότι η calculateSpeed έχει αλλάξει και δεν είναι πια αφηρημένη και ότι η moveOneKmForward είναι κενή και υπάρχει μόνο η υπογραφή της. Οι κλάσεις που εφαρμόζουνε τη διεπαφή δε χρησιμοποιούνε τη λέξη extends πια αλλά τη λέξη implements (εφαρμόζει).
/**
 * <p>Title: Vehicle class </p>
 * <p>Description: Illustrates interfaces </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Group: JavaHellug.org</p>
 * @author JavaHellug
  * @version 1.0
 */
 
public intercafe Vehicle{
    public void calculateSpeed();
    public void moveOneKmForward();
}
 
public class Ship implements Vehicle{
    private float speed = 0;
    private int gears = 2;
    private int wind = 8;
    private int distance = 20;  // Distance in Km
 
    public void calculateSpeed()
    {
        // Calculate speed based on ship data
        speed = gears * wind * .56;
    }
 
    public void moveOneKmForward()
    {
        distance = distance + 1;
    }
}
 
public class Bicycle implements Vehicle{
    private float bicycleSpeed = 0;
    private int gears = 6;
    private boolean tired = true;
    private distance = 15;   // Distance in Kms.
 
    public void calculateSpeed()
    {
        // Calculate speed based on bicycle data
        if (tired)
            bicycleSpeed = gears * 15 / 4;
        else
            bicucleSpeed = gears * 15 / 2;
    }
 
    public void moveOneKmForward()    {
        if (distance == 20)
            System.out.println("You have reached the end of your destination");
        else
            distance = distance + 1;
    }
}
Βλέπουμε ότι η κάθε υποκλάση αναπτύσσει την κάθε μέθοδο της διεπαφής με διαφορετικό τρόπο. Αν ξεχάσουμε να αναπτύξουμε μία μέθοδο αυτό είναι compile-time σφάλμα. Αν δε θέλουμε να αναπτύξουμε μία μέθοδο της διεπαφής τότε πρέπει να προβάλλουμε μία κενή εφαρμογή της. Στο παραπάνω παράδειγμα αν ήδη είχαμε φτάσει στον προορισμό μας και δε θέλαμε να ταξιδέψουμε 1 χιλιόμετρο παραπάνω τότε θα μπορούσαμε να έχουμε κάτι σαν:
public void moveOneKmForward() {}

Επίλογος
Το παραπάνω κειμενο προσπάθησε να μας δώσει τις βασικές αρχές και χαρακτηριστικά του αντικειμενουστραφούς προγραμματισμού. Σίγουρα δεν είναι δυνατόν μέσα σε μερικές σελίδες να κατανοήσουμε όλη την λογική και το μοντέλο ανάπτυξης που κρύβεται γύρω του. Παρολα αυτά με μία γλώσσα προγραμματισμού όπως η Java είναι πιο εύκολο απο ποτέ νά κάνουμε τα πρώτα βήματα μας στον χώρο κατι πολύ σημαντικό αν σκεφτούμε την σημαντικότητα και την χρήση που έχει τις τελευταιες δεκαετίες το συγκεκριμένο μοντέλο στην βιομηχανια αναπτυξης λογισμικού.

Δεν υπάρχουν σχόλια:

Δημοσίευση σχολίου