Δευτέρα, 14 Νοεμβρίου 2011

Ορισμός συνάρτησης

[πηγή]
Όπως και με τις μεταβλητές, πριν κάνετε χρήση κάποιας συνάρτησης θα πρέπει να δώσετε οδηγίες στη γλώσσα για τη μορφή της ώστε να ξέρει πως θα τη χρησιμοποιήσει. Ο ορισμός μιας απλής συνάρτησης είναι ο ακόλουθος:
void typestars ()
{
for (int i=0; i<20; i++)
   cout << ‘*’;
cout << endl;
}
Για να ορίσουμε μία συνάρτηση πρώτα δηλώνουμε τον τύπο των δεδομένων που θα επιστρέφει, μετά το όνομά της και τέλος τα ορίσματα που θα δέχεται μέσα σε παρενθέσεις. Ας τα εξετάσουμε ένα προς ένα:
Εάν η συνάρτηση δεν επιστρέφει κάποια τιμή στο κυρίως πρόγραμμα που την καλεί, τότε πριν το όνομά της γράφουμε τη λέξη void (κενό). Όταν η συνάρτηση δεν επιστρέφει κάποια τιμή που να τη χρησιμοποιεί το κυρίως πρόγραμμα, λειτουργεί ως διαδικασία, δηλαδή απλώς κάτι κάνει. Στην περίπτωσή μας τυπώνει 20 φορές το σύμβολο του αστεριού (*) στην οθόνη. Εάν όμως η συνάρτηση επιστρέφει κάποια τιμή στο σημείο του προγράμματος που την καλεί τότε θα πρέπει πριν το όνομά της να δηλώσουμε τον τύπο των δεδομένων που επιστρέφει. Έτσι αν επιστρέφει ακέραια τιμή θα γράφαμε πρώτα int και μετά το όνομά της, αν επιστρέφει πραγματικό αριθμό θα γράφαμε πρώτα float και μετά το όνομά της κ.λ.π.
Το σημαντικό που θα πρέπει να παρατηρήσετε στις περιπτώσεις που η συνάρτηση επιστρέφει τιμή είναι η εντολή return μέσα στο σώμα της συνάρτησης. Μετά τη δεσμευμένη λέξη return ακολουθεί η παράσταση με την επιστρεφόμενη τιμή. Φυσικά ο τύπος δεδομένων της τιμής που επιστρέφεται θα πρέπει να είναι ίδιος με τον τύπο δεδομένων που προηγείται του ονόματος της συνάρτησης.
Εάν πριν από το όνομα της συνάρτησης δεν υπάρχει η λέξη void αλλά ένας τύπος δεδομένων είτε από τους ενσωματωμένους της γλώσσας είτε ορισμένος από το χρήστη, τότε μέσα στο σώμα της συνάρτησης θα πρέπει να υπάρχει εντολή return.
Η τιμή αυτή που επιστρέφεται μπορεί να χρησιμοποιηθεί στον υπολογισμό μιας παράστασης ή να αποδοθεί σε μια μεταβλητή.

Για το όνομα της συνάρτησης ισχύει ότι και για τα ονόματα των μεταβλητών. Θα πρέπει να χρησιμοποιείται πάντα το όνομα της συνάρτησης όπως είναι στο σημείο ορισμού της και να μη μπερδεύετε μικρούς με κεφαλαίους χαρακτήρες.
Μετά το όνομα της συνάρτησης υπάρχουν τα ορίσματά της μέσα σε παρενθέσεις. Ακόμα και όταν δεν υπάρχουν ορίσματα είμαστε υποχρεωμένοι να γράφουμε πάντα τις παρενθέσεις. Οι παρενθέσεις είναι τα σύμβολα που ξεχωρίζουν τις συναρτήσεις από τις μεταβλητές.
Στο παραπάνω παράδειγμα η συνάρτηση typestars () τυπώνει 20 φορές ένα σύμβολο στην οθόνη. Εάν την αλλάξουμε λίγο έτσι ώστε ο χρήστης να αποφασίζει πόσες φορές θα τυπωθεί το σύμβολο, θα γράφαμε:
void typestars (int n)
{
for (int i=0; i<n; i++)//n επαναλήψεις του βρόχου
   cout << ‘*’;
cout << endl;
}

Τα ορίσματα τα οποία εσωκλείονται μέσα σε παρενθέσεις είναι μεταβλητές οι οποίες δέχονται τιμές από το σημείο κλήσης της συνάρτησης. Μέσα στις παρενθέσεις γίνεται δήλωση των μεταβλητών, για αυτό και η σημειογραφία:
int n
Εάν είναι περισσότερα του ενός, τα ορίσματα χωρίζονται μεταξύ τους με κόμμα. Τα ορίσματα είναι που κάνουν τις συναρτήσεις να εκτελούν διαφορετικά πράγματα, ανάλογα με την είσοδο που δέχονται. Ειδάλλως χωρίς ορίσματα, οι συναρτήσεις θα επαναλάμβαναν τις ίδιες εντολές κάθε φορά που θα τις καλούσαμε.

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

Η γλώσσα C++

τελειώνω για σήμερα για να μην την χάσω βάζω εδώ την γλώσσα:

[πηγή]

These tutorials explain the C++ language from its basics up to the newest features of ANSI-C++, including basic concepts such as arrays or classes and advanced concepts such as polymorphism or templates. The tutorial is oriented in a practical way, with working example programs in all sections to start practicing each lesson right away.

[ Download the entire tutorial as a PDF file ]


Introduction


Basics of C++


Control Structures


Compound Data Types


Object Oriented Programming


Advanced Concepts


C++ Standard Library

Οι λέξεις κλειδιά CONST και VOLATILE - CONCOM.CPP

[πηγή]


Στις αρχικές δηλώσεις υπάρχουν δυο νέες λέξεις κλειδιά, οι οποίες δεν υπήρχαν στην
αρχική C, αλλά είναι τμήμα του προτύπου ANSI-C. Η λέξη const χρησιμοποιείται για 
να ορίσει μια σταθερά. Η σταθερά START είναι ακέραιου τύπου (int) και παίρνει αρχική 
τιμή 3. Ο μεταγλωττιστής δεν επιτρέπει την ηθελημένη ή κατά λάθος αλλαγή της τιμής 
της START γιατί έχει δηλωθεί σαν σταθερά. Οποιαδήποτε απόπειρα αλλαγής της τιμής 
μιας σταθεράς θα έχει σαν αποτέλεσμα την εμφάνιση ενός μηνύματος λάθους. Εφόσον δεν 
επιτρέπεται η αλλαγή της τιμής μιας σταθεράς, είναι καλό να αρχικοποιείται όταν 
δηλώνεται, ώστε να έχει μια χρήσιμη τιμή. Ο μεταγλωττιστής δεν απαιτεί την αρχικοποίηση 
της και δεν εμφανίζει μήνυμα λάθους αν αυτή δεν γίνει. 

Θα παρατηρήσατε ότι η λέξη const επίσης χρησιμοποιείται στην δήλωση της συνάρτησης,
για να δείξει ότι η τυπική παράμετρος data_value είναι μια σταθερά για την συνάρτηση.
Κάθε προσπάθεια να αλλαχθεί η τιμή σε αυτή την μεταβλητή θα δώσει λάθος. Αυτή είναι 
μια απλή τεχνική που μπορεί να προστεθεί στο πρόγραμμα ώστε να αυξήσει την ικανότητα 
του μεταγλωττιστή να ανιχνεύει λάθη για τον χρήστη. 

Η λέξη κλειδί volatile επίσης υπάρχει στην ANSI-C αλλά όχι και στην αρχική C. Η τιμή
μιας volatile μεταβλητής δεν μπορεί να αλλάξει από τον προγραμματιστή, μπορεί όμως να
υπάρξει κάποιος μηχανισμός που να αποτρέπει την αλλαγή, όπως μια διακοπή χρονομέτρου 
που θα προκαλέσει αύξηση της τιμής της. Ο μεταγλωττιστής πρέπει να γνωρίζει ότι αυτή η
τιμή μπορεί να αλλάξει από κάποια εξωτερική δύναμη, όταν βελτιστοποιεί τον κώδικα. 
Η μελέτη της βελτιστοποίησης του κώδικα είναι αρκετά ενδιαφέρουσα, αλλά έξω από τους
σκοπούς αυτού του συγγράμματος. Σημειώνεται ότι και μια σταθερά μπορεί να γίνει volatile,
που σημαίνει ότι δεν μπορεί ο προγραμματιστής να την αλλάξει, αλλά η αλλαγή μπορεί να 
γίνει από κάποια λειτουργία του υλικού ή του λειτουργικού συστήματος. 

Προσωρινά αφήνουμε τις προτάσεις εξόδου. Θα τις μελετήσουμε αργότερα στο κεφάλαιο. Αν 
είστε εξοικειωμένοι στον προγραμματισμό με τον αρχικό ορισμό της C, σίγουρα θα βρείτε 
το πρόγραμμα κάπως παράξενο. Εδώ φαίνεται η προτυποποίηση και ο νέος τρόπος ορισμού
των συναρτήσεων, όπως ορίζεται στο πρότυπο ANSI-C. Η προτυποποίηση είναι προαιρετική 
στη C,αλλά απολύτως αναγκαία στη C++. Γι’ αυτό το κεφάλαιο 4 ασχολείται με αυτό το θέμα. 

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

Αποτελέσματα εκτέλεσης

The value of the index is  3
The value of the index is  4
The value of the index is  5
The value of the index is  6
The value of the index is  7
The value of the index is  8
 
#include "iostream.h"      '*this is the stream definition 
file */

void print_it(const int dara_value);

main()
{

const int START = 3;        // The value of START cannot be 
changed
const int STOP = 9;         // The value of STOP cannot be 
changed
volatile int CENTER = 6;    /* The value of CENTER may be 
changed
                                 by something external to 
this
                                 program.             */
int index;                  /* A normal C variable     */

   for (index = START ; index < STOP ; index++)
      print_it(index);
}     /* End of program */

void print_it(const int data_value)
{
   cout << "The value of the index is  " << data_value << "\n";
}
}CONCOM.CPP



  
Κατεβάστε το πρόγραμμα στον υπολογιστή σας  

Τα σχολια στην C++ - CONCOM.CPP

[πηγή]


Τα σχόλια στη C++ αρχίζουν με διπλή κάθετο "//", αρχίζουν οπουδήποτε στη γραμμή
και εκτείνονται ως το τέλος της γραμμής, όπου αυτόματα τερματίζονται. Ο παλιός 
τρόπος ορισμού των σχολίων, που χρησιμοποιείται και στην ANSI-C, μπορεί να 
χρησιμοποιηθεί και στη C++, όπως φαίνεται στο παράδειγμα. Ο νέος τρόπος είναι
προτιμότερος γιατί αποφεύγεται η κατά λάθος αποκοπή γραμμών προγράμματος με 
μορφή σχολίων. Αυτό μπορεί να γίνει, στον παλιό τρόπο, απλά ξεχνώντας να κλείσουμε
τα σχόλια. Μια καλή προγραμματιστική τεχνική είναι να χρησιμοποιείται ο νέος 
τρόπος για τον σχολιασμό και ο παλιός για την αποκοπή τμημάτων του προγράμματος κατά
την αποσφαλμάτωση.

Θα ήταν προτιμότερο να μην χρησιμοποιούνται σχόλια όταν το ίδιο νόημα μπορεί να βγει 
από άλλα στοιχεία του προγράμματος, όπως ονόματα μεταβλητών, σταθερών και συναρτήσεων.
Η σωστή ονοματολογία κάνει τον κώδικα ευανάγνωστο και κατανοητό και θα ήταν καλό να 
γίνεται σε κάθε πρόγραμμα. 

Εξετάστε το πρόγραμμα CONCOM.CPP σαν ένα παράδειγμα αρκετών νέων στοιχείων στη C++. 
Θα ασχοληθούμε με τα νέα στοιχεία στη γλώσσα, ένα κάθε φορά, ξεκινώντας με τα σχόλια.
 
 
 
#include "iostream.h"      '*this is the stream definition 
file */

void print_it(const int dara_value);

main()
{

const int START = 3;        // The value of START cannot be 
changed
const int STOP = 9;         // The value of STOP cannot be 
changed
volatile int CENTER = 6;    /* The value of CENTER may be 
changed
                                 by something external to 
this
                                 program.             */
int index;                  /* A normal C variable     */

   for (index = START ; index < STOP ; index++)
      print_it(index);
}     /* End of program */

void print_it(const int data_value)
{
   cout << "The value of the index is  " << data_value << "\n";
}
}CONCOM.CPP



  
Κατεβάστε το πρόγραμμα στον υπολογιστή σας  

Τα απλά της C++

[πηγή]



Πριν ξεκινήσουμε τη μελέτη της γλώσσας C++ και του αντικειμενοστραφή προγραμματισμού, θα αναφέρουμε μερικά πράγματα. Επειδή το πεδίο του αντικειμενοστραφή προγραμματισμού είναι καινούργιο είναι αρκετά μεγάλη η νέα ορολογία που θα πρέπει να μάθει κανείς.Γι’ αυτό θα προσθέτουμε μερικές νέες δομές σε κάθε κεφάλαιο ώστε να γίνει ευκολότερη η εκμάθηση της γλώσσας. Τα κεφάλαια 1 ως 4 αναφέρονται σε προσθήκες στην C++, αλλά όχι στον αντικειμενοστραφή προγραμματισμό. Οι τεχνικές του αντικειμενοστραφή προγραμματισμού αναφέρονται από το κεφάλαιο 5 και μετά. Σε αυτό το κεφάλαιο θα δούμε τη μορφή που έχουν τα σχόλια, τον τελεστή εμβέλειας, την βιβλιοθήκη iostream, τις λειτουργίες των αρχείων ρευμάτων και τέλος τον ορισμό των μεταβλητών.

Η προέλευση της C++

[πηγή]


Η γλώσσα προγραμματισμού C αναπτύχθηκε στην AT&T με σκοπό τη δημιουργία ενός λειτουργικού συστήματος για τη σειρά υπολογιστών PDP-11, που τελικά έγινε το λειτουργικό σύστημα Unix. Η C αναπτύχθηκε με πρωταρχικό σκοπό την αποδοτικότητα. Ο Bjarne Stroustrup, επίσης της AT&T, ανέπτυξε την C++ με πρωταρχικό σκοπό την προσθήκη αντικειμενοστραφών δομών στη γλώσσα. Επειδή η αντικειμενοστραφής τεχνολογία ήταν καινούργια και όλες οι αντικειμενοστραφείς υλοποιήσεις που υπήρχαν ήταν αρκετά αργές και μη αποδοτικές, ένας δευτερεύων σκοπός της C++ ήταν να διατηρήσει την αποδοτικότητα της C.
Η C++ μπορεί να θεωρηθεί μια διαδικαστική γλώσσα με κάποιες επιπλέον δομές, μερικές από τις οποίες προστέθηκαν για αντικειμενοστραφή προγραμματισμό, ενώ άλλες για την βελτίωση του συντακτικού της γλώσσας. Ένα καλογραμμένο πρόγραμμα πρέπει να έχει στοιχεία τόσο αντικειμενοστραφή όσο και κλασσικού διαδικαστικού προγραμματισμού. Η C++ είναι ουσιαστικά μια επεκτάσιμη γλώσσα αφού μπορούμε να ορίσουμε νέους τύπους με τέτοιο τρόπο ώστε να λειτουργούν σαν τους προκαθορισμένους τύπους, που είναι τμήμα της γλώσσας. Η C++ σχεδιάστηκε για την ανάπτυξη μεγάλων προγραμμάτων.
Η γλώσσα προγραμματισμού C ορίστηκε αρχικά στο κλασσικό σύγγραμμα των Kernigham και Ritchie "The C Programming Language", και ήταν το πρότυπο που χρησιμοποιούσαν όλοι οι προγραμματιστές στη C. Το πρότυπο ANSI για τη C τελικά εγκρίθηκε τον Δεκέμβριο του 1989 και έγινε το επίσημο πρότυπο για τον προγραμματισμό στη C. Το πρότυπο ANSI εισήγαγε αρκετά νέα στοιχεία, που δεν υπήρχαν στην αρχική έκδοση των Kernigham και Ritchie, και άλλαξε κάποια άλλα, έτσι ώστε τα δύο πρότυπα δεν είναι τελείως συμβατά.
Η μελέτη αυτού του εγχειριδίου προϋποθέτει την γνώση της γλώσσας προγραμματισμού C, και εξηγεί εν συντομία τα βασικά στοιχεία της γλώσσας. Ωστόσο, επειδή πολλοί προγραμματιστές μπορεί να είναι εξοικειωμένοι με την ορολογία των Kernigham και Ritchie, κάποια τμήματα θα εξηγούν τις αλλαγές που έγιναν από την ANSI-C.
Ο καλύτερος τρόπος για να μάθει κανείς τη C++ είναι να την χρησιμοποιήσει.Ο πιο καλός τρόπος για να μάθει κανείς τη γλώσσα C++ είναι να μάθει τις νέες δομές χρησιμοποιώντας τις σε κάθε νέο πρόγραμμα. Θα ήταν λάθος να προσπαθήσει κανείς να χρησιμοποιήσει όλες τις νέες δομές της γλώσσας στο πρώτο του πρόγραμμα στη C++. Θα ήταν πιο σωστό σε κάθε πρόγραμμα να γίνεται η προσθήκη λίγων νέων στοιχείων ώστε να εξοικειωθείτε μαζί τους.

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

[πηγή]


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

Προγραμματιστικά περιβάλλοντα

[πηγή]


Κάθε πρόγραμμα που γράφτηκε σε οποιαδήποτε γλώσσα προγραμματισμού, για να εκτελεσθεί σε ένα υπολογιστή πρέπει να μετατραπεί σε μορφή αναγνωρίσιμη και εκτελέσιμη από τον υπολογιστή, δηλαδή σε εντολές γλώσσας μηχανής.
Η μετατροπή αυτή επιτυγχάνεται με τη χρήση ειδικών μεταφραστικών προγραμμάτων. Υπάρχουν δύο μεγάλες κατηγορίες τέτοιων προγραμμάτων οι  μεταγλωττιστές (compilers) και οι διερμηνευτές (interpreters). Ο μεταγλωττιστής δέχεται στην είσοδο ένα πρόγραμμα γραμμένο σε μια γλώσσα υψηλού επιπέδου και παράγει ένα ισοδύναμο πρόγραμμα σε γλώσσα μηχανής. Το τελευταίο μπορεί να εκτελείται οποτεδήποτε από τον υπολογιστή και είναι τελείως ανεξάρτητο από το αρχικό πρόγραμμα. Αντίθετα ο διερμηνευτής διαβάζει μία προς μία τις εντολές του αρχικού προγράμματος και για κάθε μια εκτελεί αμέσως μια ισοδύναμη ακολουθία εντολών μηχανής.
Το αρχικό πρόγραμμα λέγεται πηγαίο πρόγραμμα (source) ενώ το πρόγραμμα που παράγεται από τον μεταγλωττιστή λέγεται αντικείμενο πρόγραμμα (object).
Το αντικείμενο πρόγραμμα είναι μεν σε μορφή κατανοητή από τον υπολογιστή, αλλά συνήθως δεν είναι σε θέση να εκτελεστεί. Χρειάζεται να συμπληρωθεί και να συνδεθεί με άλλα τμήματα προγράμματος απαραίτητα για την εκτέλεση του, τμήματα που είτε τα γράφει ο προγραμματιστής είτε βρίσκονται στις βιβλιοθήκες (libraries) της γλώσσας. Το πρόγραμμα που επιτρέπει αυτή τη σύνδεση ονομάζεται συνδέτης-φορτωτής (linker-loader). Το αποτέλεσμα του συνδέτη είναι η παραγωγή του εκτελέσιμου προγράμματος (executable), το οποίο είναι το τελικό πρόγραμμα που εκτελείται από τον υπολογιστή. Για τον λόγο αυτό η συνολική διαδικασία αποκαλείται μεταγλώττιση και σύνδεση.
   
Αρχικό 
Πρόγραμμα
Μεταγλωτ-
τιστής
Τελικό
Πρόγραμμα
Συνδέτης
Εκτελέσιμο
Πρόγραμμα
 

Μεταγλώττιση και σύνδεση του προγράμματος


Η χρήση μεταγλωττιστή έχει το μειονέκτημα, ότι προτού χρησιμοποιηθεί ένα πρόγραμμα πρέπει να περάσει από τη διαδικασία της μεταγλώττισης και σύνδεσης. Από την άλλη μεριά η χρήση διερμηνευτή έχει το πλεονέκτημα της άμεσης εκτέλεσης του προγράμματος καθίσταται πιο αργή, σημαντικά μερικές φορές, από εκείνη του ισοδύναμου εκτελέσιμου προγράμματος που παράγει ο μεταγλωττιστής. Πάντως τα σύγχρονα προγραμματιστικά περιβάλλοντα παρουσιάζονται συνήθως με μεικτές υλοποιήσεις όπου χρησιμοποιείται διερμηνευτής κατά τη φάση δημιουργίας του προγράμματος και μεταγλωττιστής για την τελική έκδοση και εκμετάλλευση του προγράμματος.
Για την αρχική σύνταξη των προγραμμάτων και τη διόρθωση τους στη συνέχεια χρησιμοποιείται ένα ειδικό πρόγραμμα που ονομάζεται συντάκτης (editor). Ο συντάκτης είναι ουσιαστικά ένας "μικρός" επεξεργαστής κειμένου δηλαδή με μειωμένες δυνατότητες επεξεργασίας κειμένου, αλλά με δυνατότητες όμως που διευκολύνουν τη γρήγορη εγγραφή των εντολών των προγραμμάτων.
Για τη δημιουργία, τη μετάφραση και την εκτέλεση ενός προγράμματος απαιτούνται τουλάχιστον τρία προγράμματα: ο συντάκτης, ο μεταγλωττιστής και ο συνδέτης. Τα σύγχρονα προγραμματιστικά περιβάλλοντα παρέχουν αυτά τα προγράμματα με ενιαίο τρόπο.
Το κάθε προγραμματιστικό περιβάλλον έχει διαφορετικά εργαλεία και ιδιότητες.
 

Διαδικασία μετάφρασης και εκτέλεσης ενός προγράμματος