[
πηγή]
Εισαγωγή
Αν ρωτήσουμε
δέκα προγραμματιστές
για το τι είναι
αντικειμενοστραφής
προγραμματισμός
(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 είναι πιο
εύκολο απο ποτέ νά κάνουμε τα πρώτα βήματα μας στον χώρο κατι πολύ
σημαντικό αν σκεφτούμε την σημαντικότητα και την χρήση που έχει τις
τελευταιες δεκαετίες το συγκεκριμένο μοντέλο στην βιομηχανια αναπτυξης
λογισμικού.