Αντικειμενοστραφής Προγραμματισμός Java Δημήτριος Μετάφας ΤΕΙ Πειραιά

Αντικειμενοστραφής
Προγραμματισμός
ΕΛΛΗΝΙΚΗ
ΔΗΜΟΚΡΑΤΙΑ
Ανώτατο Εκπαιδευτικό
Ίδρυμα Πειραιά
Τεχνολογικού Τομέα Δρ. Χαράλαμπος Ζ. Πατρικάκης
Τμήμα Ηλεκτρονικών Μηχανικών Τ.Ε
Ενότητα 1: Εισαγωγή στον

αντικειμενοστραφή προγραμματισμό,
εισαγωγή στη γλώσσα
προγραμματισμού Java.
Βιβλιογραφία
• Harvey Deitel,Paul Deitel , «Java Προγραμματισμός, 8η έκδοση»,

Γκιούρδας, 2010.
• Γιώργος Λιακέας, «Εισαγωγή στη Java», Κλειδάριθμος, 2009.
• Χρήστος Κυτάγιας, Κώστας Δ. Κυτάγιας, Γιώργος Πρεζεράκος,
Δημήτρης Κυτάγιας, «Αντικειμενοστραφής Προγραμματισμός με
Java», Σύγχρονη Εκδοτική, 2013.
• Wanda Dann, Stephen Cooper, and Randy Pausch, «Learning to
program with Alice» 3rd edition, Pearson Education, 2012.
• Michael Kölling, «Introduction to Programming with Greenfoot».
• «Object-Oriented Programming in Java with Games and
Simulations», Pearson Education, August 2009.
• Οι σημειώσεις είναι βασισμένες και σε υλικό του καθηγητή του ΤΕΙ
Πειραιά Γ. Πρεζεράκου.
Περιεχόμενα
1.1 Αντικειμενοστραφής Προγραμματισμός
1.2 Η γλώσσα προγραμματισμού Java
6
Προσδοκώμενα Αποτελέσματα
Στην ενότητα αυτή θα μάθετε για:
 Τις βασικές έννοιες του Προγραμματισμού,

 Τα διαφορετικά είδη Προγραμματισμού,
 Ανάπτυξη προγραμμάτων με χρήση
αντικειμενοστραφούς προγραμματισμού,
 Πλεονεκτήματα από την χρήση της Java,
 Τυπικό περιβάλλον και χρήση εργαλείων για
δημιουργία κώδικα σε Java.
1.1 Αντικειμενοστραφής
8
Ας θυμηθούμε κάποια πράγματα για τον
προγραμματισμό
• Ο προγραμματισμός των ηλεκτρονικών υπολογιστών

βασίζεται στην επίλυση προβλημάτων μέσω της
συνδυασμένης χρήσης τεσσάρων θεμελιωδών
λειτουργιών :
– Λειτουργίες εισόδου – εξόδου.
– Αριθμητικές λειτουργίες.
– Διακίνηση πληροφοριών μέσα στην κεντρική μονάδα
επεξεργασίας.
– Λογικές πράξεις και πράξεις σύγκρισης.
Βασικές έννοιες προγραμματισμού
• Πρόγραμμα – Ένα σύνολο εντολών που καθοδηγούν τον

υπολογιστή στην εκτέλεση συγκεκριμένων λειτουργιών.
• Γλώσσα Μηχανής – Γλώσσα προγραμματισμού το σύνολο των

συμβόλων της οποίας είναι άμεσα κατανοητό από τον επεξεργαστή
του υπολογιστή.
• Γλώσσα Προγραμματισμού Υψηλού Επιπέδου – Γλώσσα

προγραμματισμού το σύνολο των συμβόλων της οποίας
προσιδιάζει στην φυσική (ανθρώπινη) γλώσσα.
• Συντακτικό – Οι κανόνες που καθορίζουν τον τρόπο συνδυασμού

των διαφόρων συμβόλων της γλώσσας προγραμματισμού έτσι
ώστε να σχηματιστεί το πρόγραμμα.
10
Γενιές γλωσσών προγραμματισμού
γλώσσες «χαμηλού επιπέδου»

• Πρώτη γενιά : Γλώσσες μηχανής
(low level languages)

(0,1)
• Δεύτερη γενιά : Συμβολικές γλώσσες
(get, store)
Τρίτη γενιά : Γλώσσες υψηλού επιπέδου
(Pascal, C, ADA)
• Τέταρτη γενιά : Ειδικές γλώσσες για την
εξυπηρέτηση συγκεκριμένων αναγκών
(SQL)
11
Επεξεργασία κώδικα υψηλού επιπέδου
• (Compiler) Μεταγλωττιστής – Μετατροπή από κώδικα

υψηλού επιπέδου σε γλώσσα μηχανής. Εκτέλεση του
προγράμματος που προκύπτει.
• (Interpreter) Διερμηνευτής – Ο κώδικας υψηλού

επιπέδου εκτελείται γραμμή προς γραμμή κατά τη
διάρκεια εκτέλεσης του προγράμματος.
12
Διαδικασιακός (δομημένος) Προγραμματισμός
• Σύμφωνα με αυτόν, εργαζόμαστε προς τη δημιουργία

μιας διαδικασίας ή αλλιώς ενός συνόλου εργασιών οι
οποίες δίνονται με καθορισμένο τρόπο και σειρά στο
πρόγραμμα για την εκπλήρωση ενός συγκεκριμένου
στόχου.
• Μια διαδικασία, από τη στιγμή που θα περιγραφτεί
μπορεί να χρησιμοποιηθεί και σαν τμήμα μιας άλλης
διαδικασίας, χτίζοντας τελικά ένα σύνολο ενεργειών το
οποίο υλοποιεί τον αλγόριθμο του προγράμματος που
θέλουμε να δημιουργήσουμε.
• Οι περισσότερες γλώσσες προγραμματισμού που
χρησιμοποιούνται σήμερα για εφαρμογές γενικού τύπου
είναι γλώσσες διαδικασιακές.
13
Αντικειμενοστραφής Προγραμματισμός (Object

Oriented Programming)
• Βασίζεται στη λογική ότι ένα πρόγραμμα είναι ένα σύνολο

από αντικείμενα τα οποία επικοινωνούν και παράγουν τα
επιδιωκόμενα αποτελέσματα.
• Τα αντικείμενα αυτά έχουν δύο βασικά στοιχεία: μεθόδους
και ιδιότητες (δεδομένα).
• Η δημιουργία των προγραμμάτων βασίζεται στην εύρεση ή
δημιουργία των κατάλληλων αντικειμένων και του ορισμού
του τρόπου λειτουργίας και αλληλεπίδρασης μεταξύ τους
για την επίτευξη του στόχου του προγράμματος.
• Με τη χρήση των αντικειμένων υπάρχει η δυνατότητα για
την διανομή των αντικειμένων και την
επαναχρησιμοποίησή τους σε άλλα προγράμματα,
διευκολύνοντας έτσι τη διαδικασία του προγραμματισμού.
14
Προγραμματισμός βασισμένος σε γεγονότα
(Εvent Driven Programming)
• Στηρίζεται στις αρχές του προγραμματισμού βασισμένου σε

αντικείμενα, χρησιμοποιώντας την έννοια της ανάθεσης
ενεργειών σε διάφορα αντικείμενα, ως αντίδραση σε κάποια
εξωτερική ενέργεια.
• Παράδειγμα:
– Μπορούμε να αναθέσουμε τη δημιουργία κάποιου ήχου σαν
αποτέλεσμα του πατήματος κάποιου πλήκτρου.
– Αν σε αυτό το παράδειγμα το πλήκτρο είναι το αντικείμενό μας, αρκεί
να γράψουμε τον κώδικα ο οποίος θα δημιουργεί κάποιο ήχο, όταν το
αντικείμενο-πλήκτρο καταλάβει την ενέργεια πατήματός του: on click
(me) play (sound).
15
Τι σημαίνει Αντικειμενοστραφής
Προγραμματισμός;
• Ο κώδικας είναι οργανωμένος σε κλάσεις αντικειμένων.
• Δημιουργία αντικειμένων βασισμένων στις παραπάνω

κλάσεις.
• Δεν υπάρχουν:
– Μεμονωμένες συναρτήσεις.
– Μεμονωμένα τμήματα κώδικα.
• Η εκτέλεση του προγράμματος πραγματοποιείται με

αρχικοποίηση αντικειμένων που ανταλλάσσουν μηνύματα
(δυνατότητα για προγραμματισμό βασισμένο σε γεγονότα=
event driven).
16
Αντικείμενα, Κλάσεις, Μέθοδοι, Ιδιότητες
• Ο κώδικας οργανώνεται σε αντικείμενα.

• Κάθε αντικείμενο (object) αποτελείται από:
– Ιδιότητες (δεδομένα - attributes).
– Υπορουτίνες κώδικα που εκτελούν συγκεκριμένες λειτουργίες
(μέθοδοι - methods), οι οποίες αποτελούν τη διεπαφή του
αντικειμένου προς τον έξω κόσμο (κατά βάση προς άλλα αντικείμενα).
• Κάθε αντικείμενο ανήκει σε κάποια οικογένεια

αντικειμένων γνωστή ως κλάση (class).
17
Αντικείμενα και κλάσεις

• Σε ένα πρόγραμμα μπορεί να
υπάρχουν πολλά αντικείμενα
• Κλάση  Περιγραφή
της ίδιας κλάσης. • Αντικείμενο  Ρόλος
– Η κλάση (class) περιγράφει τις – Προκύπτει από την
ιδιότητες και τις μεθόδους του περιγραφή.
αντικειμένου.
– Μπορεί να του ζητηθεί η
– Το αντικείμενο (object) πρέπει
παροχή πληροφοριών, ή η
να δημιουργηθεί από την
κλάση.
εκτέλεση κάποιων
– Το αντικείμενο αποτελεί ενεργειών.
στιγμιότυπο (instance) της
κλάσης. 18
Μεθοδολογία ανάπτυξης προγραμμάτων σε
αντικειμενοστραφές περιβάλλον
• Μελετάμε το πρόβλημα.
• Το αποσυνθέτουμε σε κλάσεις οι οποίες συνήθως
αντιστοιχούν σε οντότητες του πραγματικού κόσμου.
– Προσπαθούμε να κάνουμε χρήση από έτοιμες κλάσεις (από
προηγούμενες εφαρμογές ή από βιβλιοθήκες κλάσεων) όπου αυτό
είναι εφικτό.
– Κάθε κλάση αντικειμένων έχει μεθόδους οι οποίες καλούν μεθόδους
άλλων κλάσεων.
• Δημιουργούμε αντικείμενα ανάλογα με το πρόγραμμα που
θέλουμε να αναπτύξουμε και τα βάζουμε να
αλληλεπιδρούν.
19
Πλεονεκτήματα αντικειμενοστραφούς
προγραμματισμού
• Ευκολότερη συντήρηση του κώδικα.

• Βελτίωση της αξιοπιστίας.
– Αλλαγές στην εσωτερική δομή μιας μεθόδου δεν επηρεάζουν
τυχόν άλλες κλάσεις που τυχόν την χρησιμοποιούν.
– Ομοίως αλλαγές στην εσωτερική δομή ενός αντικειμένου
επηρεάζουν μόνο το εν λόγω αντικείμενο.
• Περισσότερες δυνατότητες για επαναχρησιμοποίηση
κώδικα.
• Δυνατότητα για εργασία σε ομάδες.
– Δεν απαιτείται η μια ομάδα ανάπτυξης να ξέρει τη δομή των κλάσεων
που δημιουργούνται από μια άλλη ομάδα. Αρκεί να ξέρει ποιες
μεθόδους να καλέσει.
20
Χαρακτηριστικά Αντικειμενοστραφών Γλωσσών
• Αφαίρεση (Abstraction)
– Άρα ο προγραμματιστής δουλεύει σε υψηλό επίπεδο, με λιγότερες
λεπτομέρειες και σαφώς καθορισμένες διεπαφές.
• Ενθυλάκωση (Encapsulation)
– Προστασία των δεδομένων και των μεθόδων.
• Κληρονομικότητα (Inheritance)
– Επιτρέπει την δημιουργία νέων κλάσεων βάσει προηγουμένων.
• Πολυμορφισμός (Polymorphism)
– Χρήσιμη ιδιότητα που πρέπει να υπάρχει σε κάθε αντικειμενοστραφή
γλώσσα και επιτρέπει την αλλαγή της συμπεριφοράς κλάσεων.
21
Αντικειμενοστραφείς γλώσσες
προγραμματισμού
• C++ • Ruby
• C# • Perl (v5)
• Java • PHP5
• VB.Net • Object Pascal
• Lingo • Python
22
24
Γιατί Java;
• Αντικειμενοστραφής
• Ανεξάρτητη από συγκεκριμένη αρχιτεκτονική
υπολογιστικού συστήματος.
- Δυνατότητα εκτέλεσης σε οποιαδήποτε πλατφόρμα και πάνω από
οποιοδήποτε λειτουργικό.
• Εκτελέσιμη μέσα από το διαδίκτυο
• Δυνατότητα ανάπτυξης
- Αυτόνομων εφαρμογών.
- Εφαρμογών Παγκοσμίου Ιστού.
• Διανέμεται δωρεάν.
25
Πλεονεκτήματα της γλώσσας
• Ακολουθεί φιλοσοφία της C αλλά αφήνει έξω δύσκολα

χαρακτηριστικά όπως οι δείκτες, οι δομές (structures) και οι ενώσεις
(unions).
• Είναι αντικειμενοστραφής, υιοθετώντας πάλι ένα πιο απλό
μοντέλο, χωρίς την πολλαπλή κληρονομικότητα.
• Είναι και μεταγλωττίσιμη και μεταφράσιμη, χρησιμοποιώντας
τα πλεονεκτήματα και των δύο μοντέλων παραγωγής κώδικα, ενώ
μπορεί (JIT compilers) να δημιουργήσει και εκτελέσιμο κώδικα.
• Είναι ασφαλής λόγω περιορισμών στη διαχείριση μνήμης και
πόρων, ενώ έχει ενσωματωμένο μηχανισμό διαχείρισης σφαλμάτων.
• Υποστηρίζει πολυνημάτωση (multi-threading) επιτρέποντας την
ανεξάρτητη και παράλληλη εκτέλεση διεργασιών.
• Κάνει αυτόματη διαχείριση μνήμης και διαγραφή άχρηστων
δεδομένων (garbage collection).
26
Λίγη ιστορία
• Αναπτύχθηκε από την εταιρεία Sun Microsystems το 1995.

• Σχεδιάστηκε έχοντας κατά νου τη διαδραστική τηλεόραση!
• Αρχηγός της ομάδας ανάπτυξης ήταν ο James Gosling.
• "Write Once, Run Anywhere" (WORA)
• OAK GREEN  JAVA
• Το όνομα προέρχεται:
– Από μια ποικιλία καφέ που πουλούσε η τοπική καφετέρια (?)
– Από κάποια από τα ονόματα των δημιουργών της γλώσσας (?):
(James Gosling, Arthur Van Hoff, Andy Bechtolsheim)
27
Οι αρχές (principles) ανάπτυξης της Java
• "απλή, αντικειμενοστραφής και οικεία“.

• "αξιόπιστη και ασφαλής“.
• "ανεξάρτητη από το λειτουργικό σύστημα και φορητή“.
• "υψηλή απόδοση“.
• " διερμηνεύσιμη, υποστηρίζει threads, δυναμική“.
28
Ένα απλό πρόγραμμα σε Java: Hello.java
class Hello {
class Hello {
public static void main(String [] args){
public System.out.println("Hello
static void main(StringWorld");
[] args){
}
} System.out.println("Hello World");
}
}
29
Κατηγορίες Προγραμμάτων Java
• Java applications – Αυτόνομα

προγράμματα. • Java για κινητά
– J2ME
• Java applets – Προγράμματα
ενσωματωμένα σε Ιστοσελίδα. • JavaCard
• Java servlets – Προγράμματα – Έξυπνες κάρτες που
που εκτελούνται από προγραμματίζονται σε Java
διακομιστές Παγκοσμίου Ιστού • Πιστωτικές
(Web Servers) στα πλαίσια • ΑΤΜ
εφαρμογών client-server. • Ηλεκτρονικές κλειδαριές
• Enterprise Java Beans – κ.α.
Προγράμματα για ανάπτυξη
εταιρικών εφαρμογών με την
αρχιτεκτονική τριών επιπέδων
(3-tier) J2EE.
30
Eικονική μηχανή της Java (Java Virtual Machine -

JVM)
Πηγαίος κώδικας
σε Java
• H Java εκτελείται σε έναν υποθετικό
υπολογιστή που ονομάζεται Java Virtual
Machine (JVM) Java compiler
• Βήματα δημιουργίας και εκτέλεσης
προγραμμάτων στη Java
– Συγγραφή κώδικα. Java Virtual
– Μεταγλώττιση σε ενδιάμεσο κώδικα (bytecode). Machine
– Εκτέλεση του ενδιαμέσου κώδικα από την JVM. Java interpreter
Λειτουργικό
σύστημα
31
Πλατφόρμες και περιβάλλοντα ανάπτυξης
• Open Source
• JSDK
Περιβάλλοντα
– http://java.sun.com – Eclipse
– Κατεβάζουμε το Java (http://www.eclipse.org)
Service Development – NetBeans

(http://www.netbeans.org)
Kit (JSDK) – JEdit (http://www.jedit.org)
– Αυτόματη • Εμπορικά περιβάλλοντα
εγκατάσταση στα – Sun Java Studio
Windows – Borland/CodeGear JBuilder
– IBM Visual Age
– Oracle JDeveloper 32
Τυπικό περιβάλλον ανάπτυξης σε Java (1/3)
• Συνήθως τα προγράμματα στη Java ακολουθούν

πέντε στάδια:
– επεξεργασία
– μεταγλώττιση
– φόρτωση
– επαλήθευση
– εκτέλεση
33
Τυπικό περιβάλλον ανάπτυξης σε Java (2/3)
Το πρόγραμμα δημιουργείται με
Στάδιο 1: έναν συντάκτη και αποθηκεύεται
Συντάκτης στον δίσκο σε ένα αρχείο με
Επεξεργασία Δίσκος
κατάληξη .java
Ο μεταγλωττιστής δημιουργεί
Στάδιο 2: bytecodes και τα αποθηκεύει στον
Μεταγλωττιστής
Μεταγλώττιση Δίσκος δίσκο σε ένα αρχείο με κατάληξη
.class
Πρωτεύουσα
μνήμη
Στάδιο 3:
Φορτωτής κλάσης
Φόρτωση
Ο φορτωτής κλάσης διαβάζει τα
.class αρχεία που περιέχουν τα
bytecodes από τον δίσκο και
μεταφέρει τα bytecodes αυτά στη
μνήμη
Δίσκος
34
Τυπικό περιβάλλον ανάπτυξης Java (3/3)
μνήμη
Στάδιο 4: Eπαληθευτής
Επαλήθευση Bytecode
Ο bytecode επαληθευτής,
επιβεβαιώνει πως όλα τα bytecodes
είναι έγκυρα και δεν παραβιάζουν τους
περιορισμούς ασφαλείας της Java.
μνήμη Για την εκτέλεση του προγράμματος η
Στάδιο 5: Eικονική μηχανή εικονική μηχανή της Java (JVM) διαβάζει τα
Εκτέλεση της Java (JVM)
bytecodes και ακριβώς όταν χρειάζεται (just-
in-time, JIT) τα μεταγλωττίζει (μεταφράζει)
σε μια γλώσσα που ο υπολογιστής μπορεί να
καταλάβει. Κατά τη διάρκεια της εκτέλεσης
του προγράμματος, αποθηκεύει δεδομένα
στην κύρια μνήμη.
35
Χρήση εργαλείων για δημιουργία κώδικα σε
Java (1/3)
• Με Development μελετάμε τα στάδια αυτά στα πλαίσια

του Java SE Kit 8 (JDK8) από την Oracle.
• Κατεβάζουμε την τελευταία έκδοση του JDK και την
τεκμηρίωσή του από:
oracle.com/technetwork/java/javase/downloads
• Αρχάριοι στην Java:
oracle.com/technetwork/topics/newtojava/
36

Java (2/3)
• Το στάδιο 1 αποτελείται από την επεξεργασία ενός αρχείου

με ένα πρόγραμμα σύνταξης (ή απλά συντάκτης).
– Γράφουμε ένα πρόγραμμα σε Java (πηγαίος κώδικας) με τον
συντάκτη (editor).
– Πραγματοποιούμε τις απαραίτητες διορθώσεις
– Σώζουμε το πρόγραμμα.
Ένα αρχείο με την κατάληξη .java υποδεικνύει ότι το αρχείο
περιέχει πηγαίο κώδικα Java.
– Συντάκτες σε Linux: vi, emacs, jedit, geany, gedit …
– Συντάκτες σε Windows: Notepad, Notepad++ (www.notepad-plus-
plus.org), EditPlus (www.editplus.com), TextPad
(www.textpad.com) , jEdit (www.jedit.org) ...
37
Java (3/3)
• Ολοκληρωμένα περιβάλλοντα ανάπτυξης

(Integrated Development Environments, IDEs)
– Προσφέρουν εργαλεία που υποστηρίζουν όλη τη διαδικασίας
ανάπτυξης εφαρμογών, συμπεριλαμβανομένου του συντάκτη για
εγγραφή και επεξεργασία προγραμμάτων και προγράμματος
εντοπισμού σφαλμάτων για τον εντοπισμό λογικών σφαλμάτων.
• Δημοφιλή IDEs
– Eclipse ( www.eclipse.org )
– NetBeans ( www.netbeans.org )
– IntelliJ IDEA ( www.jetbrains.com/idea )
– JBuilder ( www.codegear.com )
– JCreator ( www.jcreator.com )
– BlueJ ( www.blueJ.org )
– jGRASP ( www.jgrasp.org )
38
Μεταγλώττιση κώδικα σε Java (1/3)
• Στάδιο 2
– Με χρήση της εντολής javac (ο μεταγλωττιστής Java)
μεταγλωττίζουμε το πρόγραμμα. Παράδειγμα: για
μεταγλώττιση του προγράμματος με όνομα Welcome.java,
πληκτρολογούμε
javac Welcome.java
– Αν το πρόγραμμα μεταγλωττιστεί επιτυχώς, δημιουργείται ένα
.class αρχείο με όνομα Welcome.class που περιέχει την
μεταγλωττισμένη έκδοση του προγράμματος.
39
• Ο μεταγλωττιστής μεταφράζει τον πηγαίο κώδικα Java σε

bytecodes που αντιπροσωπεύουν τις διεργασίες προς εκτέλεση.
• Τα bytecodes εκτελούνται από την Εικονική Μηχανή της Java
(JVM) – ένα μέρος του JDK και το θεμέλιο της πλατφόρμας Java.
• Εικονική μηχανή (Virtual machine,VM)— μία εφαρμογή
λογισμικού που προσομοιώνει ένα υπολογιστή
– Απομονώνει το υποκείμενο λειτουργικό σύστημα και το
υλισμικό από τα προγράμματα που αλληλεπιδρούν με αυτό.
• Εάν η ίδια εικονική μηχανή υλοποιείται σε παραπάνω
πλατφόρμες, τα προγράμματα που εκτελούνται σε αυτήν
μπορούν να χρησιμοποιηθούν σε όλες αυτές τις πλατφόρμες.
40
• Τα Bytecodes είναι ανεξάρτητα από την πλατφόρμα

– Δεν εξαρτούνται από κάποια συγκεκριμένη πλατφόρμα υλισμικού
(hardware).
• Τα Bytecodes είναι φορητά
– Τα ίδια bytecodes μπορούν να εκτελεστούν σε οποιαδήποτε
πλατφόρμα περιέχει μία εικονική μηχανή της Java (JVM) που
καταλαβαίνει την έκδοση της Java στην οποία μεταγλωττίστηκαν.
• Η JVM επικαλείται από την εντολή java . Για
παράδειγμα για να εκτελέσουμε μία Java εφαρμογή με
όνομα Welcome, θα πληκτρολογούσαμε την εντολή:
java Welcome
41
Φόρτωση κλάσεων σε Java
• Στάδιο 3
– Η JVM μεταφέρει το πρόγραμμα στην μνήμη για εκτέλεση
• Η διαδικασία είναι γνωστή ως φόρτωση.
– Ο φορτωτής των κλάσεων (class loader) λαμβάνει τα
.class αρχεία που περιέχουνε τα bytecodes του
προγράμματος και τα μεταφέρει στην κύρια μνήμη.
– Φορτώνει επίσης όσα .class αρχεία παρέχονται από
την Java τα οποία χρησιμοποιεί το πρόγραμμά μας.
• Τα .class αρχεία μπορούν να φορτωθούν από έναν δίσκο στο
σύστημά μας ή και μέσω δικτύου.
42
Επαλήθευση bytecode σε Java
• Στάδιο 4
– Καθώς οι κλάσεις φορτώνονται, ο επαληθευτής bytecode
(Bytecode verifier) εξετάζει τα bytecodes τους:
Εξασφαλίζει ότι είναι έγκυρα και δεν παραβιάζουν τους
περιορισμούς ασφαλείας της Java.
– Η Java επιβάλει ισχυρή ασφάλεια ώστε να εξασφαλίσει
ότι τα προγράμματα Java που φθάνουν από το δίκτυο δεν
βλάπτουν τα αρχεία του συστήματός μας (όπως κάνουν οι
ιοί στους υπολογιστές).
43
Σφάλματα στη Java
• Συντακτικά σφάλματα – Προκύπτουν όταν παραβιάζουμε τους

κανόνες δόμησης του προγράμματος.
– Ανιχνεύονται πάντοτε από το πρόγραμμα μεταγλώττισης.
• Σφάλματα εκτέλεσης – Λάθη εξαιτίας των οποίων το πρόγραμμα
παράγει λανθασμένα αποτελέσματα ή διακόπτεται.
– Η διακοπή εκτέλεσης στην Java συνοδεύεται από τη δημιουργία
κατάστασης εξαίρεσης (exception).
• Λογικά σφάλματα – Λάθη στη λογική δημιουργίας του προγράμματος
– Οδηγούν σε συμπεριφορά του προγράμματος αντίθετη με την
αναμενόμενη.
– Μπορεί να μην οδηγήσουν σε κάποιο πρόβλημα για αρκετό καιρό, και να
διαφύγουν της προσοχής μας.
44
Το «λεξικό» της γλώσσας
abstract assert boolean break byte case

catch char class const continue default
double do else enum extends false
final finally float for goto if
implements import instanceof int interface long
native new null package private protected
public return short static strictfp super
switch synchronized this throw throws transient
true try void volatile while
String?
45
Ονομασία μεταβλητών
• Ονόματα έως 255 χαρακτήρες.

• Μπορούν να αρχίζουν από γράμμα, $, _ (_hello, $hello).
• Υποστηρίζονται Unicode χαρακτήρες (안녕하세요).
• Δεν μπορούμε να χρησιμοποιήσουμε κενά ή σύμβολα
(hello!, hello there).
• Είναι case sensitive.
• Δεν μπορούμε να χρησιμοποιήσουμε δεσμευμένες
λέξεις.
46
Συμβάσεις για χρήση ονομάτων στη Java (1/2)
• Τα ονόματα των Packages πρέπει να είναι με μικρούς χαρακτήρες

(lowercase).
– Σε μικρά projects με λίγα packages μπορούμε να δίνουμε μικρά (αλλά πάντα
με νόημα) ονόματα: package pokeranalyzer, package mycalculator
– Σε εταιρίες λογισμικού και μεγάλα projects όπου τα packages μπορεί να
εισαχθούν σε άλλες κλάσεις, τα ονόματα κανονικά υποδιαιρούνται. Συνήθως
ξεκινάμε με το όνομα της εταιρίας πριν περάσουμε σε διαίρεση σε layers ή
features: package com.mycompany.utilities, package
org.bobscompany.application.userinterface
• Κλάσεις: Τα ονόματα πρέπει να είναι σε CamelCase.
– Προσπαθούμε να χρησιμοποιούμε ουσιαστικά, αφού μια κλάση συνήθως
εκφράζει κάτι από τον πραγματικό κόσμο: class Customer, class Account
• Διεπαφές: Τα ονόματα πρέπει να είναι σε CamelCase.
– Συνήθως έχουν ένα όνομα που περιγράφει την πράξη που μπορεί να
πραγματοποιηθεί από την κλάση: interface Comparable, interface
Enumerable
– Σημείωση: Κάποιοι προγραμματιστές προτιμούν να ξεχωρίζουν τις διεπαφές,
ξεκινώντας το όνομα με "I": interface Icomparable, interface IEnumerable
47
Συμβάσεις για χρήση ονομάτων στη Java (2/2)
• Μέθοδοι: Τα ονόματα πρέπει να είναι σε mixed case.

– Χρησιμοποιούμε ρήματα για να περιγράψουμε το τι κάνει η μέθοδος:
void calculateTax(), string getSurname().
• Μεταβλητές: Τα ονόματα πρέπει να είναι σε mixed case.
– Τα ονόματα πρέπει να εκφράζουν τις τιμές που παίρνει η μεταβλητή:
string firstName, int orderNumber.
– Χρησιμοποιούμε πολύ μικρά ονόματα όταν οι μεταβλητές έχουν πολύ
μικρό χρόνο ζωής, όπως μέσα σε for loops: for (int i=0; i<20;i++).
• Σταθερές: Τα ονόματα πρέπει να είναι με κεφαλαίους
χαρακτήρες: static final int DEFAULT_WIDTH, static final int
MAX_HEIGHT.
48
Σε αυτή την ενότητα μιλήσαμε για:
50
Ενότητα 2: Τύποι δεδομένων,
μεταβλητές, τελεστές και
παραστάσεις.
2.1 Τύποι δεδομένων, μεταβλητές και τελεστές
2.2 Περισσότεροι τύποι δεδομένων
2.3 Μέθοδοι
6
 Τους βασικούς τύπους δεδομένων των μεταβλητών,

 Τελεστές, χαρακτήρες και αλφαριθμητικά (String),
 Τη σειρά εκτέλεσης των πράξεων και μετατροπές
τύπων δεδομένων
 Δημιουργία μεθόδων και τις παραμέτρους τους.
2.1 Τύποι δεδομένων, μεταβλητές και

τελεστές
8
Τύποι Δεδομένων
• Τα είδη των τιμών που μπορούμε να αποθηκεύουμε

σε μεταβλητές και να τις χειριζόμαστε.
Μήκος σε Αρχική
Τύπος τιμών Πεδίο τιμών
bytes τιμή
byte 1 -128 . . . 127 0
short 2 -32768 . . . 32767 0
Ακέραιος
int 4 -231 . . . 231-1 / 0 . . . 232-1 (Java SE8) 0
long 8 -263 . . . 263-1 / 0 . . . 264-1 (Java SE8) 0
float 4 single-precision 32-bit IEEE 754 floating point 0
Κινητής
double υποδιαστολής 8 double-precision 32-bit IEEE 754 floating point 0
char Χαρακτήρας 2 \u0000' (0) . . . '\uffff' (65.535) 0

boolean Λογική τιμή ? false - true false
9
Μεταβλητές
• Τοποθεσίες στη μνήμη του υπολογιστή, τις

οποίες έχουμε ονομάσει και στις οποίες
αποθηκεύεται μία τιμή.
Παράδειγμα:
String a = "a";
String b = "letter b";
int k = 15;
a = "letter a";
String c = a + "and" + b;
10
Μεταβλητές και Σταθερές
• Μία μεταβλητή • Μία σταθερά

– Μπορεί να παίρνει – Παίρνει μία τιμή (μπορεί και
διαφορετικές τιμές κατά τη μετά τη δήλωσή της ).
διάρκεια του προγράμματος. – Δηλώνεται σε ένα σημείο του
– Μπορεί να δηλωθεί σε κάποιο κώδικα και δεν μπορεί να
σημείο και να πάρει (και να ξαναδηλωθεί.
ξαναπάρει) τιμή αλλού. – Η σύμβαση λέει ότι πρέπει να
χρησιμοποιούνται κεφαλαία
int numberOfHoursInADay= 67; γράμματα και το σύμβολο _ για
numberOfHoursInADay= 24; την ονομασία της.
final int NUMBER_OF_HOURS_IN_A_DAY
= 24;
11
Τελεστές
• Σύμβολα που υλοποιούν απλούς

υπολογισμούς και πράξεις.
Ανάθεση: =
Πρόσθεση: +
Αφαίρεση: -
Πολ/μός: *
Διαίρεση: /
12
Χαρακτήρες
• Δηλώνονται με το char.
• Μπορούν να περιλαμβάνουν οποιοδήποτε χαρακτήρα
(γράμμα, ψηφίο, σημείο στίξης κ.λ.π).
• Οι ειδικοί χαρακτήρες χρησιμοποιούν τις ακολουθίες
διαφυγής (escape sequences) στην αναπαράστασή τους.
– \b  backspace
– \t  tab
– \n  line feed
– \f  form feed
– \r carriage return
– \"  διπλά εισαγωγικά
– \’  απλό εισαγωγικό
– \\  backslash
13
Αλφαριθμητικά (String)
• Υπάρχουν διάφορες κλάσεις για αποθήκευση και διαχείριση αλφαριθμητικών. Οι

πιο σημαντικές είναι οι String και StringBuffer.
• Ένα String περικλείεται μέσα σε διπλά εισαγωγικά: "Hello".
• Μπορούμε να συνδέσουμε δύο Strings με χρήση του συμβόλου +:
String1+String2.
• Μπορούμε να αναθέσουμε μία νέα τιμή σε ένα String αλλά όχι να το
τροποποιήσουμε.
• Μέθοδοι (χαρακτηριστικές) του αντικειμένου String.
Μέθοδος Λειτουργία
charAt(int index) Επιστρέφει το χαρακτήρα στη θέση index
compareTo(String anotherString) Συγκρίνει δύο strings
contains(CharSequence s) Επιστρέφει true μόνο εάν το string περιέχει τη σειρά χαρακτήρων s
indexOf(int ch) Επιστρέφει τη θέση στην οποία θα συναντήσει για πρώτη φορά το
χαρακτήρα ch στο string
isEmpty() Επιστρέφει true, εάν το string είναι κενό (δηλαδή έχει μηδενικό μήκος)
Length() Επιστρέφει το μήκος ενός string
replace(char oldChar, char newChar) Αντικαθιστά όλες τις εμφανίζεις του oldChar με newChar.
toLowerCase() / toUpperCase() Μετατρέπει όλους τους χαρακτήρες στο string σε lowercase/uppercase
14
StringBuffer
• Για να έχουμε τη δυνατότητα να τροποποιήσουμε ένα

αλφαριθμητικό, χρησιμοποιούμε την κλάση StringBuffer.
• Τα αντικείμενα τύπου StringBuffer μπορούν να περιέχουν
αχρησιμοποίητο χώρο για χαρακτήρες (ενώ τα τύπου String δεν
μπορούν).
– StringBuffer sb = newStringBuffer(10)  κρατάει χώρο για 10
χαρακτήρες στο αντικείμενο sb.
• Οι μέθοδοι length() και capacity() μας δείχνουν το μήκος και τη
χωρητικότητα ενός αντικειμένου τύπου StringBuffer.
• Μπορούμε να μετατρέψουμε ένα αντικείμενο StringBuffer σε
String, με χρήση της μεθόδου toString().
• Η Stringbuffer παρέχει και τη δυνατότητα αντιστροφής
χαρακτήρων με τη μέθοδο reverse().
15
Μαθηματικές συναρτήσεις
• Περιλαμβάνονται στην κλάση Math.

• Ορισμένες μέθοδοι.
Μέθοδος Λειτουργία
abs(όρισμα) Επιστρέφει την απόλυτη τιμή του ορίσματος
ceil(όρισμα) Επιστρέφει την τιμή του μικρότερου ακέραιου που
είναι μεγαλύτερος ή ίσος με το όρισμα
cos(όρισμα) Επιστρέφει το (τύπου double)συνημίτονο του (τύπου
double) ορίσματος
exp(όρισμα) Επιστρέφει το (τύπου double) eορίσματος
log(όρισμα) Επιστρέφει τον (τύπου double) φυσικό λογάριθμο του
ορίσματος
round(όρισμα) Επιστρέφει τον πλησιέστερο προς το όρισμα ακέραιο
random() Επιστρέφει έναν τυχαίο αριθμό ανάμεσα σε 0 και 1
min(όρισμα1,όρισμα2) Επιστρέφει το μικρότερο των δύο ορισμάτων
16
Παράδειγμα
• class GravityCalculator {
public static void main(String[]args){
double gravity = -9.81;
double initialVelocity = 0.0;
double fallingTime = 10.0;
double initialPosition = 0.0;
double finalPosition = .5 * gravity * fallingTime *
fallingTime;
finalPosition = finalPosition + initialVelocity *
fallingTime;
finalPosition = finalPosition + initialPosition;
System.out.println("I thesi enos antikeimenou meta apo " +
fallingTime + " sec einai " + finalPosition + " m.");
}
}
17
• finalPosition = finalPosition + initialVelocity *

fallingTime;
finalPosition = finalPosition + initialPosition;
finalPosition += initialVelocity * fallingTime;

finalPosition += initialPosition;
18
20
Διαίρεση
• Η διαίρεση ("/") λειτουργεί διαφορετικά

στους ακέραιους και στους πραγματικούς.
• Δίνεται προτεραιότητα, όπως
double a= 5.0/2.0; // a = 2.5 και στα μαθηματικά, στην
int b = 4/2; // b = 2 εκτέλεση των πράξεων από τα
αριστερά προς τα δεξιά.
int c = 5/2; // c = 2
double d = 5/2; // d = 2.0
21
Σειρά Εκτέλεσης των Πράξεων
• Εκτιμάμε το δεξί μέρος του τελεστή ανάθεσης

("=") πρώτα.
• Οι παρενθέσεις έχουν τη μεγαλύτερη
προτεραιότητα.
double x = 3 / 2 + 1; // x = 2.0
double y = 3 / (2+1); // y = 1.0
22
"Αταίριαστοι" Τύποι Δεδομένων
• H Java επαληθεύει ότι δεν ταιριάζουν όλοι οι τύποι

δεδομένων:
String five = 5; // ΛΑΘΟΣ! Αναμονή για συμβολοσειρά και όχι νούμερο
• Εμφανίζεται το εξής μήνυμα λάθους:

test.java.2: incompatible types
found: int
required: java.lang.String
String five = 5;
23
Μετατροπές Τύπου Δεδομένων (Casting)
• Μπορεί να εφαρμοστεί σε μεταβλητές και κλάσεις
• Τοποθετούμε τον επιθυμητό τύπο μεταβλητής σε

παρένθεση και στη συνέχεια το όνομα της
μεταβλητής στην οποία θέλουμε να κάνουμε τη
μετατροπή:
(επιθυμητός τύπος) όνομα μεταβλητής
24
Μετατροπές Τύπου Δεδομένων (Casting)
int a = 2; // a = 2
double a = 2; // a = 2.0 (Έμμεση Μετατροπή)
int a = 18.7; // ΛΑΘΟΣ!

int a = (int) 18.7; // a = 18
int a = 2; // a = 2
double a = (double) 2/3; // a = 0.6666…
25
Ιεραρχία τύπων δεδομένων και implicit typecast
• Οι τύποι δεδομένων στη Java είναι ιεραρχημένοι.

• Το νόημα είναι να μπορεί ένας αριθμός που ανήκει σε τύπο πιο
ψηλά στην ιεραρχία, να συγκρατήσει την ακρίβεια του
χαμηλότερου στη μετατροπή (άρα όσο πιο ψηλά, τόσο μεγαλύτερη
ακρίβεια ενός τύπου)
• Η ιεραρχία είναι:
1. double
2. float
3. long
4. int
5. short
6. Byte
• Implicit typecast: Αναβαθμίζει τον τύπο, σύμφωνα με την ιεραρχία
26
Explicit typecast
• Κατά την ανάθεση, χρησιμοποιούμε το (new type) πριν τα

δεδομένα τα οποία ήταν στον παλιό τύπο.
• Εδώ μπορούμε να κατέβουμε την ιεραρχία, αλλά θα χάσουμε
σε ακρίβεια.
• Παράδειγμα
– int x = (int)3.7;
Εδώ το x θα πάρει την τιμή 3
– byte bt = (byte) 200;
Εδώ το bt θα πάρει την τιμή -56 (αναδίπλωση)
(μπορείτε να εξηγήσετε γιατί;)
27
Ποιά από τα παρακάτω επιτρέπονται;

• int x = 3.5;
Δεν επιτρέπεται γιατί το 3.5 δεν χωράει στο int
• float x = 3;
Επιτρέπεται γιατί το 3 είναι τύπου int που που χωράει στο float
• long i = 3;
Επιτρέπεται γιατί το 3 είναι τύπου int που που χωράει στο long
• byte x = 155;
Δεν επιτρέπεται γιατί το 155 είναι πολύ μεγάλο για να χωρέσει ένα
byte (<=127)
• double d = 3.14159F;
Επιτρέπεται γιατί to 3.14159F είναι τύπου float, που χωράει στο
double
28
2.3 Μέθοδοι
30
Μέθοδοι
Public static void main (String[] arguments)

{
System.out.println("hi");
}
31
Δημιουργώντας Μεθόδους
public static void NAME() {

ΕΝΤΟΛΕΣ
}
• Η μέθοδος έχει τη μορφή:

ΝΑΜΕ( ) ;
32
class NewLine {
public static void newLine() {
System.out.println("");
}
public static void threeLines() {
newLine(); newLine(); newLine();
}
public static void main(String[] arguments) {

System.out.println("Line 1");
threeLines();
}
}
33
class NewLine {
}
}

threeLines();
}
} 34
class NewLine {
}
}

threeLines();
}
} 35
Παράμετροι
public static void NAME(TYPE NAME) {

ΕΝΤΟΛΕΣ
}
Η μέθοδος έχει τη μορφή:

NAME (EXPRESSION);
36
class Square {
public static void printSquare(int x) {
System.out.println(x*x);
}

int value = 2;
printSquare(value);
printSquare(3);
printSquare(value*2);
}
}
Σωστό Πρόγραμμα!
37
class Square2 {
public static void printSquare(int x) {
}

printSquare("hello");
printSquare(5.5);
}
}
Πού βρίσκεται το λάθος στην κλάση Square 2;
38
class Square3 {
public static void printSquare(double x) {
}

printSquare(5);
}
}
Πού βρίσκεται το λάθος στην κλάση Square 3;
39
Πολλαπλοί Παράμετροι
[…]NAME(TYPE NAME, TYPE NAME){

ΕΝΤΟΛΕΣ
}
Η μέθοδος έχει τη μορφή:

ΝΑΜΕ (arg1, arg2);
40
class Multiply {
public static void times (double a, double b) {
System.out.println(a*b);
}

times(2.0,2.0); //Σωστό
times(3,4); // Λάθος
}
}
41
Τιμές που Επιστρέφονται
Public static TYPE NAME() {

ΕΝΤΟΛΕΣ
return ΕΚΦΡΑΣΗ;
}
• Το "void" σημαίνει ότι η συνάρτηση δεν επιστρέφει

κάποιον τύπο δεδομένων.
42
class Square3 {
public static void printSquare(double x) {
}

printSquare(5);
}
}
43
class Square4 {
public static double square(double x) {
return x*x;
}

System.out.println(square(5));
System.out.println(square(2))
}
}
44
Πεδίο Εμβέλειας Μεταβλητών
• Το πεδίο ορατότητας (ή ισχύος) μιας μεταβλητής είναι το

block "{ }", στο οποίο ορίζονται (πεδίο εμβέλειας).
• Οι παράμετροι σε μια μέθοδο είναι οι μεταβλητές που

ορίζονται μέσα στη μέθοδο.
45
class SquareChange {
public static void printSquare(int x){
System.out.println("printSquare x =" + x); //printSquare x= 5
x = x*x;
System.out.println("printSquare x =" + x); //printSquare x= 25
}
public static void main(String [] arguments) {

int x = 5;
System.out.println("main x =" + x); //main x= 5
printSquare(x);
System.out.println("main x =" + x); //main x= 5
}
}
46
class Scope {
int x = 5;
if (x == 5) {
int x = 6;
int y = 72;
System.out.println("x = " + x + " y = " + y );
}
System.out.println("x = " + x + " y = " + y);
}
}
47
Μέθοδοι: Φτιάχνοντας Blocks
• Τα μεγάλα προγράμματα φτιάχνονται από πολλές μικρές

μεθόδους.
• Οι μέθοδοι μπορούν να αναπτυχθούν, να δοκιμαστούν
και να επαναχρησιμοποιηθούν μεμονομένα.
• Η χρήση μιας μεθόδου δεν προαπαιτεί να γνώριζει
κανείς τον τρόπο που αυτή λειτουργεί.
• Στη γλώσσα των υπολογιστών αυτό ονομάζεται
«αφαίρεση».
48
Μαθηματικές Συναρτήσεις
• Math.sin(x)
• Math.cos(Math.PI/2)
• Math.pow(2, 3)
• Math.log(Math.log(x + y))
49
2.1 Τύποι δεδομένων, μεταβλητές και τελεστές
2.3 Μέθοδοι
51
Ενότητα 3: Έλεγχος ροής και
επαναλήψεις.
3.1 Εντολές Ελέγχου Ροής
3.2 Βρόχοι Επαναλήψεων
6
 Τις εντολές ελέγχου ροής ενός προγράμματος (if,

if..else),
 Τις εντολές δημιουργίας βρόγχων επαναλήψεων,
 Την εντολή break για πρώιμη έξοδο από τέτοιον
βρόγχο.

(Conditionals)
8
Συνθήκη if
if (ΣΥΝΘΗΚΗ) {
ΚΑΤΑΣΤΑΣΕΙΣ
}
public static void test(int x){

if (x > 5){
System.out.println(x + " einai > 5");
}
}
public static void main(String[] arguments){

test(6);
test(5);
test(4);
}
10
Παραστάσεις – αναθέσεις - εκχωρήσεις
• Μία παράσταση χρησιμοποιείται για να αναπαραστήσει ένα

αποτέλεσμα το οποίο προκύπτει από τον υπολογισμό της
εφαρμογής τελεστών και συναρτήσεων σε μεταβλητές ή/και
σταθερές
• Όπως και στη C, υπάρχει προτεραιότητα στην εφαρμογή
τελεστών η οποία είναι η παρακάτω:
– Πρώτα υπολογίζονται οι παρενθέσεις (πρώτα οι εσωτερικές) από
– Στη συνέχεια εκτελούνται οι πολλαπλασιασμοί και οι διαιρέσεις από
– Στη συνέχεια εκτελούνται οι προσθέσεις και οι αφαιρέσεις από
– Στο τέλος εκχωρείται η τιμή η οποία βρίσκεται δεξιά από το ίσον (=)
στη μεταβλητή η οποία βρίσκεται αριστερά του.
11
Τελεστές
Τελεστής Τύπος τελεστή Περιγραφή Τελεστής Τύπος τελεστή Περιγραφή

> Μεγαλύτερο && Λογικό ΚΑΙ
Λογικοί
>= Μεγαλύτερο ή ίσο || Λογικό Ή
τελεστές
== Τελεστές Ίσο ! Άρνηση
< ισότητας/ανισότητας Μικρότερο ++ Αύξηση κατά 1
Τελεστές
<= Μικρότερο ή ίσο -- αυξομείωσης Μείωση κατά 1
!= Διαφορετικό & Ανάθεση/καταχώρηση
= Τελεστής αντιστοίχησης Ανάθεση/καταχώρηση | Πρόσθεση
+ Πρόσθεση ^ Τελεστές Αφαίρεση
πράξεων με
- Αφαίρεση ~ bits Αντιστροφή
Αριθμητικοί τελεστές
* Πολλαπλασιασμός >> Ολίσθηση δεξιά
/ Διαίρεση << Ολίσθηση αριστερά
% Υπόλοιπο
+= Πρόσθεση και αντικατάσταση
-= Αφαίρεση και αντικατάσταση
*= Τελεστές αντικατάστασης Πολλαπλασιασμός και αντικατάσταση
/= Διαίρεση και αντικατάσταση
%= Υπόλοιπο και αντικατάσταση
12
Συνθήκη else
} else {
}
13

if (x > 5){
} else {
System.out.println(x + “den einai > 5”);
}
}

test(6);
test(5);
test(4);
}
14
ELSE IF
} else if (ΣΥΝΘΗΚΗ) {
} else if (ΣΥΝΘΗΚΗ) {
} else {
}
15

if (x > 5){
} else if (x == 5) {
System.out.println(x + “isoutai me 5”);
} else {
System.out.println(x + “einai < 5”);
}
}
test(6);
test(5);
test(4);
}
16
Μετατροπή τύπου δεδομένων με μέθοδο
• Ακέραιος σε συμβολοσειρά:
String five = 5; // ΛΑΘΟΣ!
String five = Integer.toString(5);
String five = “” + 5; // five = “5”
• Συμβολοσειρά σε ακέραιο:
int foo = “18” // ΛΑΘΟΣ!
int foo = Integer.parseInt (“18”);
17
Τελεστές Σύγκρισης
• Συμβουλή: ΜΗΝ χρησιμοποιείτε το == στους

πραγματικούς!
• double a = Math.cos (Math.PI / 2);

• double b = 0.0;
• a = 6.123233995736766E-17
• a == b επιστρέφει ΛΑΝΘΑΣΜΕΝΗ τιμή!
18
19
Βρόχος Επανάληψης
20
Βρόχος επανάληψης
static void main (String[] arguments) {

System.out.println( “Rule #1” );
}
• Αν θέλουμε να το επαναλάβουμε για 200 κανόνες?
21
Βρόχος επανάληψης
• Οι τελεστές επανάληψης επιτρέπουν την επανάληψη

μέσω ενός block του κώδικα.
• Υπάρχουν αρκετοί τελεστές επανάληψης στη Java (for,

while, κ.ά).
22
O Τελεστής while
while (συνθήκη) {
εντολές
}
23
O Τελεστής while
int i= 0;
while(i < 3) {
System.out.println( “Rule #“ + i);
i = i+1;
}
• Υπολογίστε προσεκτικά.
• Σιγουρευτείτε ότι ο βρόχος της επανάληψης έχει την
ευκαιρία να τερματίσει.
– Αλλιώς το πρόγραμμα θα πέσει σε ατέρμονο βρόχο
επανάληψης (Infinite loop).
24
Ο Τελεστής for
for ( αρχικοποίηση; συνθήκη; ενημέρωση ) {

εντολές
}
25
Ο Τελεστής for
for (int i = 0; i < 3; i = i + 1 ) {

System.out.println ( “Rule #” + i ) ;
}
• Σημείωση: Το i = i + 1 μπορεί να αντικατασταθεί

από το i++.
• Γενικά x++ σημαίνει αύξηση της τιμής της
μεταβλητής κατά ένα.
26
Kαταστάσεις Διακλάδωσης
• Το break τερματίζει έναν for ή while βρόχο.
for ( int i = 0 ; i < 100 ; i++) {

if (i==50)
break;
System.out.println( “Rule #” + i ) ;
}
27
Kαταστάσεις Διακλάδωσης
• Το break τερματίζει ένα for ή while βρόχο.
for ( int i = 0 ; i < 100 ; i++) {

if (i==50)
break;
System.out.println( “Rule #” + i ) ;
28
Ενσωματωμένοι βρόχοι
for ( int i = 0 ; i < 3 ; i++ ) {

for ( int j = 2 ; j < 4 ; j++ ) {
System.out.println (i + “ ” + j ) ;
}
}
• Πεδίο εμβέλειας της μεταβλητής που ορίζεται στην
αρχικοποίηση: το αντίστοιχο for μπλοκ μέσα στο
οποίο ορίστηκαν.
29
30
Ενότητα 4: Πίνακες, Συνδυασμός
Βρόχων Επαναλήψεων και Πινάκων.
4.1 Πίνακες
4.2 Συνδυάζοντας Βρόχους Επαναλήψεων και Πίνακες
6
 Τον τρόπο δημιουργίας και τα διάφορα είδη

πινάκων,
 Πολυδιάστατους Πίνακες,
 Παραδείγματα για να διατρέξετε έναν πίνακα
αποκτώντας πρόσβαση στα στοιχεία του.
4.1 Πίνακες
8
Πίνακες
• Ένας πίνακας είναι ένα ευρετήριο τιμών.
• Μπορείτε να φτιάξετε έναν πίνακα για κάθε

μεταβλητή int, double, string, κοκ…
• Προσοχή: Όλα τα στοιχεία ενός πίνακα πρέπει να

είναι του ίδιου τύπου.
Πίνακες
• Αρίθμηση στοιχείων ενός πίνακα
10
Πίνακες
• Παράδειγμα: Πίνακας double[]
11
Πίνακες
• Ο δείκτης αρχίζει από το μηδέν και τελειώνει στο μηκος -1.
int[] values = new int[5];
values[0] = 12; // ΣΩΣΤΟ
values[4] = 12; // ΣΩΣΤΟ
values [5] = 12; // ΛΑΘΟΣ!! Συντακτικά είναι σωστό
// αλλά εμφανίζεται σφάλμα κατά την
// εκτέλεση, καθώς τα στοιχεία
βρίσκονται // στις θέσεις από 0 έως 4.
• Φτιάξτε ένα πρόγραμμα με το σφάλμα αυτό και δοκιμάστε

να το τρέξετε.
12
Πίνακες
• Ένας πίνακας εισάγεται καλώντας ARRAY_TYPE [ ].
• Οι πίνακες είναι απλά ένας ακόμα τύπος δεδομένων.

int [ ] values; // πίνακας int μεταβλητών
int [ ] [ ] values; // int [ ] είναι ένας τύπος
δεδομένων
13
Πίνακες
• Για να δημιουργήσουμε πίνακα συγκεκριμένου

μεγέθους, χρησιμοποιούμε τον τελεστή new :
int [ ] values = new int [5];
ή μία μεταβλητή για να καθορίσουμε το μέγεθος:
int size = 12;

int [ ] values = new int [size];
14
Αρχικοποίηση Πίνακα
• Άγκιστρα μπορούν να χρησιμοποιηθούν για

να αρχικοποιήσουμε έναν πίνακα.
• Μπορούν ωστόσο να χρησιμοποιηθούν
ΜΟΝΟ όταν ορίζουμε τη μεταβλητή/ πίνακα.
int [ ] values = { 12, 24, -23, 47 } ;
15
Ώρα για Quiz!
• Υπάρχει λάθος σε αυτόν το τμήμα κώδικα;
int[ ] values = {1, 2.5, 3, 3.5, 4};
16
Πρόσβαση στα Στοιχεία Πινάκων
• Για να έχουμε πρόσβαση στα στοιχεία του πίνακα,

χρησιμοποιούμε τον τελεστή [ ]:
values [index]
int [ ] values = { 12, 24, -23, 47 };
values [3] = 18; // { 12, 24 , -23, 18 }
int x = values[1] + 3; // { 12, 24 , -23, 18 }
// x = 27
17
Η Εντολή length
• Κάθε πίνακας έχει μια ενσωματωμένη εντολή length

η οποία και περιέχει το μήκος του πίνακα.
• int [ ] values = new int [12];

• int size = values.length; // η απάντηση είναι 12
• int [ ] values2 = { 1, 2, 3, 4, 5}
• int size2 = values2.length; // 5
18
Πoλυδιάστατοι πίνακες
• Ένας πολυδιάστατος πίνακας ακολουθεί τους

κανόνες δήλωσης πινάκων, αλλά έχει περισσότερες
από μία διαστάσεις.
int [ ] [ ] values = new int [6][5]; // πίνακας 2

διαστάσεων
• Εδώ η πρώτη αγκύλη είναι για τις γραμμές και η
δεύτερη για τις στήλες.
19
Πίνακες Συμβολοσειρών
• public static void main (String [ ] arguments) {

System.out.println (arguments.length);
System.out.println (arguments [0]);
System.out.println (arguments [1]);
}
20
4.2 Συνδυάζοντας Βρόχους Επαναλήψεων
και Πίνακες
21
Διατρέχοντας έναν Πίνακα Με τη Βοήθεια Ενός

βρόχου
• Παράδειγμα 1:
int [ ] values = new int[5];
for (int i=0; i<values.length; i++) {

values[i] = i;
int y = values[i] * values[i];
System.out.println(y);
}
Ερώτηση: Εξηγήστε τι κάνει το παραπάνω πρόγραμμα

22
Διατρέχοντας έναν Πίνακα Με τη Βοήθεια Ενός
βρόχου
• Παράδειγμα 2:
int [ ] values = new int [5];
int i = 0;
while (i < values.length) {
values[i] = i;
int y = values[i] * values[i];
System.out.println(y);
i++;
}
23
Ένα παράδειγμα με πίνακα 2 διαστάσεων
• Ο ακόλουθος κώδικας εκτυπώνει όλα τα στοιχεία

ενός πίνακα 2 διαστάσεων.
int rows =3;
int columns = 2;
int [ ] [ ] values = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } };
for (int i=0; i<rows; i++) {
for (int j=0; j<columns; j++) {
System.out.println(values[i][j]+” “);
}
}
24
4.1 Πίνακες
4.2 Συνδυάζοντας Βρόχους Επαναλήψεων και Πίνακες
26
Ενότητα 5: Αντικείμενα και Κλάσεις

5.1 Καθοριστικά Πρόσβασης
5.2 Παραδείγματα Μεθόδων
5.3.1 Καθορίζοντας μια Κλάση
5.3.2 Εμβέλεια της Κλάσης
5.3.3 Βασικοί Τύποι vs Αναφορές
5.3.4 Στατικός Τύπος (Static) και Μέθοδοι
 Τα καθοριστικά πρόσβασης ενοτήτων, ιδιοτήτων

και μεθόδων (public, private),
 Την έννοια του Αντικειμενοστραφούς
Προγραμματισμού με τη σύνταξη μιας Κλάσης ενός
Αντικειμένου,
 Για Δημιουργούς Κλάσεων και
 Για Αναφορές Αντικειμένων.
7
Καθοριστικά πρόσβασης
• H Java ορίζει καθοριστικά πρόσβασης για:

– Κλάσεις
– Ιδιότητες
– Μεθόδους
• Τα καθοριστικά πρόσβασης αποτελούν σημαντικό τμήμα
στη σχεδίαση μιας εφαρμογής
– Καθορίζουν την πρόσβαση που έχει η μια κλάση στην άλλη
9
Καθοριστικά πρόσβασης - public
• Κλάση
– Προσβάσιμη από οποιαδήποτε κλάση
– Πρέπει να βρίσκεται σε αρχείο της μορφής <class
name>.java
• Ιδιότητα
• Μέθοδος
10
Καθοριστικά πρόσβασης - private
• Κλάση
– Δεν γίνεται να είναι private (γιατί;)
– Προσβάσιμη μόνο από την κλάση της
• Μέθοδος
– Προσβάσιμη μόνο από την κλάση της
11
Καθοριστικά πρόσβασης - final
• Κλάση
– Δεν μπορεί να κληρονομηθεί
– Δε μπορεί να αλλάξει (σταθερά)
• Μέθοδος
– Δεν μπορεί να υπερκαλυφθεί
12
Καθοριστικά πρόσβασης - protected
– Προσβάσιμη μόνο από μέλη της ίδιας κλάσης και μέλη των
υποκλάσεων της
• Μέθοδος
– Προσβάσιμη μόνο από μέλη της ίδιας κλάσης και μέλη των
υποκλάσεων της
13
public class bank_balance
{
public String owner;
private int balance;
public bank_balance( String name, int dollars )

public class bank_balance {
{ owner = name;
public String owner; if (dollars >= 0)
public int balance; balance = dollars;
else
public bank_balance( String name, int dollars ) dollars =0;
{ }
owner = name;
public int getBalance()
if (dollars >= 0) balance = dollars; {
else dollars =0; return balance;
} }
}
public void setBalance(int dollars)
{
if (dollars >= 0) balance = dollars;
else dollars = 0;
}
14
}
15
public static int getMinIndex ( int[] values ) {
int minValue = Integer.MAX_VALUE;

int minIndex = -1;
Πρόγραμμα εύρεσης θέσης i
στον πίνακα με το μικρότερο
for( int i=0; i<values.length; i++) στοιχείο.
if ( values[i] < minValue ) {
minValue = values[i];
minIndex = i;
}
return minIndex;
}
16
public static int getSecondMinIndex ( int[] values ) {

int secondIdx = -1;
int minIdx= getMinIndex ( values ) ;
for( int i=0 ; i<values.length ; i++ ) {

if ( i == minIdx )
continue;
if ( secondIdx == -1 ||
values[i] < values[secondIdx] )
secondIdx = i ;
}
return secondIdx ;
}
• Τί συμβαίνει αν values = {0}? values = {0, 0}? values = {0,1}?
17
Περίπτωση 1
• Πίνακας Θέσεων (Index) vs Πίνακας Τιμών (Value)

int[] values = {99, 100,101};
System.out.println(values[0] ); // 99
Τιμές
Θέσεις
18
• Αγκύλες { … } μετά από if/else, for/while

for (int i= 0; i< 5; i++)
System.out.println( “Hi” );
System.out.println( “Bye” );
• Τι εκτυπώνει;
19
• Αρχικοποίηση Μεταβλητών: Εύρεση Ελάχιστου Όρου

int getMinValue(int[] vals) {
int min = 0;
for (int i = 0; i < vals.length; i++) {
if (vals[i] < min) {
min = vals[i]
}
}
}
• Τι συμβαίνει αν vals = {1,2,3}; ← Θα υπάρξει πρόβλημα;;;

• Θέτουμε min = Integer.MAX_VALUE ή vals[0]
20
• Αρχικοποίηση Μεταβλητών: Εύρεση Δεύτερου

Ελάχιστου Όρου– secondMinIndex
int minIdx = getMin(vals)
int secondIdx = 0;
if (i == minIdx) continue;
if (vals[i] < vals[secondIdx])
secondIdx = i;
}
• Τι συμβαίνει αν vals={0, 1, 2} ;
• Δείτε τις λύσεις
21
Ορισμός μιας μεθόδου μέσα σε άλλη μέθοδο.

public static void foobar () {
}
}
22
Μέθοδοι Εντοπισμού Σφαλμάτων 1
• Χρησιμοποιείστε System.out.println μέσα

στον κώδικά σας για να δείτε τι κάνει.
for ( int i=0; i< vals.length; i++) {

if ( vals[i] < minVal) {
System.out.println( “cur min: ” + minVal);
System.out.println( “new min: ” + vals[i]);
minVal = vals[i];
}
}
23
Μέθοδοι Εντοπισμού Σφαλμάτων 2
• Μορφοποιούμε τον κώδικα μας με χρήση του

Ctrl-Shift-f!
if (vals[i] < vals[minIdx]) {
minIdx=i; }
return minIdx;}
• Υπάρχει σφάλμα;; Διαβάζεται δύσκολα για να

είμαστε σίγουροι.
24
5.3 Αντικειμενοστραφής
25
Αντικειμενοστραφής Προγραμματισμός
• Αντιπροσωπεύει τον πραγματικό κόσμο
Μωρό
26
• Αντιπροσωπεύει τον πραγματικό κόσμο
Μωρό
Όνομα
Φύλο
Βάρος
Decibels
Δόντια
27
• Ομαδοποίηση αντικειμένων:
– Βασικοί τύποι μεταβλητών (int, double, char, etc..)
– Αντικείμενα (Strings, etc.. )
Μωρό
Όνομα: String onoma
Φύλο: boolean einaiAgori
Βάρος: double varos
Decibels: double decibels
Δόντια: int numDontia
28
Γιατί Χρησιμοποιούμε Κλάσεις;
• Γιατί όχι μόνο βασικούς τύπους μεταβλητών;
// όνομα πρώτου αντικειμένου (Alex)

String onomaAlex;
double varosAlex;
// όνομα δεύτερου αντικειμένου (David)
String onomaDavid;
double varosDavid;
29
• Γιατί να μην χρησιμοποιούμε μόνο βασικούς τύπους

μεταβλητών;
// όνομα πρώτου αντικειμένου (Alex)
String onomaAlex;
double varosAlex; 500 Μωρά;
// όνομα δεύτερου αντικειμένου (David) ΠΟΛΥ ΔΥΣΧΡΗΣΤΟ!
String onomaDavid;
double varosDavid;
// όνομα τρίτου αντικειμένου (David)
String onomaDavid2;
double varosDavid2;
David2?
Άβολο !!!
30
Όνομα
Βάρος
Φύλο
…
Μωρό1
31
Όνομα Όνομα Όνομα Όνομα 496

Βάρος Βάρος Βάρος Βάρος
Φύλο Φύλο Φύλο Φύλο ακόμα
… … … … Μωρά
Μωρό1 Μωρό2 Μωρό3 Μωρό4 …
32
Όνομα Όνομα Όνομα Όνομα

Βάρος
Φύλο
Βάρος
Φύλο
Βάρος
Φύλο
Βάρος
Φύλο
496 ακόμα
… … … …
μωρά…
Μωρό1 Μωρό2 Μωρό3 Μωρό4
Βρεφοκομείο 33
Περισσότερες
Νοσοκόμα1 Νοσ/μα2 Νοσ/μα3 Νοσ/μα4 νοσοκόμες…
496 ακόμα
Μωρό1 Μωρό2 Μωρό3 Μωρό4
μωρά…
[]
Νοσοκόμα1
[]
Μωρό1
[]
Νοσοκόμα1
Εντατική Μονάδα
[] Θεραπείας
Μωρό1
Βρεφοκομείο
Νοσοκομείο 36
5.3.1 Καθορίζοντας μια κλάση
37
Κλάση
public class Baby{

String name;
boolean isABoy; Ορισμός
double weight;
double decibels;
Κλάσης
int numberOfTeeth = 0;
void newTooth() {
numberOfTeeth += 1;
System.out.println( “Mama ” + “my teeths hurt!” ) ;
}
}
38
Κλάση
Baby myBaby = new Baby(); Στιγμιότυπο

Κλάσης
39
Ας ορίσουμε την κλάση Baby
public class Baby {
40
Ας ορίσουμε την κλάση Baby
public class Baby {
41
Σημείωση
• Τα ονόματα μιας κλάσης χρησιμοποιούν κεφαλαία

γράμματα για κάθε καινούργια λέξη μέσα στο
όνομα.
• 1 Κλάση πρέπει να γραφτεί σε 1 Αρχείο το οποίο θα
έχει το ίδιο όνομα με την κλάση.
• Η κλάση μπορεί να τρέξει αν περιέχει μία μέθοδο
main.
42
Πεδία Κλάσης Baby
public class Baby {
TYPE var_name;
TYPE var_name = some_value;
43
Πεδία Κλάσης Baby
public class Baby {

String name;
double weight= 5.0;
boolean isABoy;
}
44
Υπάρχουν Αδέλφια??
public class Baby {

String onoma;
double varos = 5.0;
boolean einaiAgori;
int numPoops = 0;
Baby [ ] brother;
}
45
Δημιουργία Στιγμιότυπου της Κλάσης Baby
Baby ourBaby = new Baby();
Αλλά το όνομα; Το φύλο;

46
Δημιουργοί (Constructors)
public class CLASSNAME {

CLASSNAME ( ) {
}
CLASSNAME ( [ ARGUMENTS ] ) {
}
}
CLASSNAME obj1 = new CLASSNAME ( ) ;
CLASSNAME obj2 = new CLASSNAME ( [ ARGUMENTS ] );
47
Δημιουργοί (Constructors)
• Όνομα δημιουργού == όνομα της κλάσης.

• Καμία επιστρέψιμη τιμή – ποτέ δεν επιστρέφουν τίποτα.
• Αρχικοποιούν (συνήθως) τα πεδία της κλάσης.
• Όλες οι κλάσεις χρειάζονται τουλάχιστον έναν
δημιουργό.
- Αν δεν γράψετε έναν, χρησιμοποιείται το
προκαθορισμένο:
CLASSNAME ( ) {
48
Κλάση Baby - Δημιουργοί
public class Baby {

string name;
boolean isABoy;
Baby ( String myname, boolean agori) {
onoma = myName ;
einaiAgori = agori;
}
}
49
Κλάση Baby - Μέθοδοι
public class Baby {

String name = “Slim Shady”;
...
void sayHi ( ) {
System.out.println( “Hi, my name is“ +
name);
}
}
50
Κλάση Baby - Μέθοδοι
public class Baby {

String weight = 5.0;
void eat ( double foodWeight ) {

if ( foodWeight >= 0 && foodWeight < weight ) {
weight = weight + foodWeight ;
}
}
}
51
Κλάση Baby
public class Baby {

String name;
double weight= 5.0 ;
boolean isABoy ;
Baby[ ] brother ;
void sayHi() {…}

void food(double foodWeight) { … }
}
52
5.3.2 Εμβέλεια Κλάσης
53
Ανασκόπηση της Εμβέλειας
public static ScopeReview {

void scopeMethod ( int var1 ) {
String var2 ;
if ( var1 >0 ) {
var2 = “above 0” ;
} else {
var2 = “less than or equal to 0” ;
System.out.println ( var2 ) ;
}
}
54

private int var3 ;
var3 = var1 ;
String var2 ;
if ( var1 >0 ) {
} else {
}
}
55

private int var3 ;
var3 = var1 ;
String var2 ;
if ( var1 >0 ) {
} else {
}
}
56
Εμβέλεια
• Ακριβώς όπως οι μέθοδοι έτσι και οι μεταβλητές είναι

προσβάσιμες μέσα στις αγκύλες { } που ορίζονται.
- Από τα προηγούμενα μαθήματα: εμβέλεια μεθόδου
void method ( int arg1 ) {
int arg2 = arg1 + 1 ;
}
-Σε αυτό το μάθημα: εμβέλεια κλάσης
class Examplevariable {
int membervariable;
void setVariable ( int newVal ) {
memberVariable += newVal ;
}
}
57
Η Λέξη-Κλειδί ‘this’
• Διευκρινίζει την εμβέλεια

• Σημαίνει ‘το αντικείμενο μου’
Χρήση:
class Example {
int memberVariable ;
void setVariable ( int newVal ) {
this.memberVariable += newVal ;
}
}
58
Μόνο οι Μεταβλητές ‘servings’ της Μεθόδου έχουν

Ανανεωμένες Τιμές
public class Baby {

int servings ;
void feed ( int servings ) {
servings = servings + servings ;
}
void dontia( ) {
System.out.println ( “All better!” ) ;
servings = 0 ;
}
}
59
Μόνο οι Μεταβλητές ‘servings’ της Μεθόδου έχουν
Ανανεωμένες Τιμές
public class Baby {

int servings ;
void feed ( int servings ) {
this.servings = this.servings + servings ;
}
void teeth( ) {
System.out.println ( “All better!” ) ;
servings = 0 ;
}
}
60
Κλάσεις και Αντικείμενα
// Ορισμός κλάσης
public class Baby { … }
// Αντικείμενα κλάσης
Baby shiloh = new Baby ( “Shiloh Jolie-Pitt” , true ) ;
Baby knox = new Baby ( “Knox Jolie-Pitt” , true ) ;
61
Πρόσβαση σε Πεδία Αντικειμένων των Κλάσεων
• Αποκτούμε πρόσβαση στο πεδίο ενός αντικειμένου

ως εξής: Object.FIELDNAME
• Baby shiloh = new Baby ( “Shiloh Jolie-Pitt” , true );

• System.out.println ( shiloh.name ) ;
• System.out.println ( shiloh.numDontia ) ;
62
Καλούμενη Μέθοδος
• Object. METHODNAME ( [ ARGUMENTS ] )
• Baby shiloh = new Baby ( “Shiloh Jolie-Pitt” , true );

• shiloh.sayHi ( ) ; // “Hi, my name is…”
• Shiloh.eat (1) ;
63
64
Βασικοί Τύποι vs Αναφορές
• Οι βασικοί τύποι της Java είναι, όπως έχουμε πει:

- int, long, double, boolean, char, short, byte, float.
- Οι πραγματικές τιμές είναι αποθηκευμένες στις
μεταβλητές.
• Οι τύποι αναφοράς είναι πίνακες και αντικείμενα

– String, int [ ],
– Baby, …
65
Πως η Java Αποθηκεύει τους Βασικούς Τύπους;
• Οι μεταβλητές είναι σαν φλιτζάνια σταθερού

μεγέθους.
• Οι βασικοί τύποι είναι αρκετά μικροί ώστε να
χωράνε στο φλιτζάνι.
66
Πως η Java Αποθηκεύει Αντικείμενα
• Τα αντικείμενα είναι υπερβολικά μεγάλα για να

χωρέσουν σε μία μεταβλητή.
– Αποθηκεύονται κάπου αλλού στη μνήμη.
– Οι μεταβλητές αποθηκεύουν έναν αριθμό που προσδιορίζει
τη θέση του αντικειμένου.
67
Πως η Java Αποθηκεύει Αντικείμενα
• Τα αντικείμενα είναι υπερβολικά μεγάλα για να

χωρέσουν σε μία μεταβλητή
– Αποθηκεύονται κάπου αλλού.
– Οι μεταβλητές αποθηκεύουν έναν αριθμό που προσδιορίζει
τη θέση του αντικειμένου.
68
Αναφορές
• Η τοποθεσία του αντικειμένου ονομάζεται αναφορά.

• Το διπλό ίσον ( == ) συγκρίνει τις αναφορές
– Baby shiloh1 = new Baby ( “shiloh” ) ;
– Baby shiloh2 = new Baby ( “shiloh” ) ;
Ερώτηση: Ισχύει shiloh1 == shiloh2 ;
ΟΧΙ!
69
Αναφορές
Baby shiloh1 = new Baby ( “shiloh” ) ;

Baby shiloh2 = new Baby ( “shiloh” ) ;
70
Αναφορές
Baby mybaby = new Baby(“davy”, true);

mybaby.name = “david” ;
71
Αναφορές
Baby mybaby = new Baby(‘davy’, true);

mybaby.name = ‘david’;
72
Αναφορές
• Χρησιμοποιείστε ίσον ( = ) για την ενημέρωση

των αναφορών
baby1 = baby2
73
Αναφορές
• Χρησιμοποιείστε ίσον ( = ) για την ενημέρωση

των αναφορών
baby1 = baby2
74
Αναφορές
• Χρησιμοποιήστε [ ] ή •
– ακολουθεί την αναφορά στο αντικείμενο.
– ίσως τροποποιεί το αντικείμενο, αλλά ποτέ την αναφορά.
• Φανταστείτε ότι:
– ακολουθείτε οδηγίες για να βρείτε ένα σπίτι.
– μετακινείτε ένα έπιπλο τριγύρω.
• Είναι ανάλογο με το να:
– ακολουθείτε την αναφορά σε ένα αντικείμενο.
– αλλάζετε τα πεδία σε ένα αντικείμενο.
75
Μέθοδοι και Αναφορές
void doSomething ( int x , int[ ] ys , Baby b ) {

x = 99 ;
ys [0] = 99 ;
b.name = “99” ;
}
...
int i = 0 ;
int [ ] j = {0} ;
Baby k = new Baby ( “50” , true ) ;
doSomething (i, j, k) ;
i=? j=? k=?

76
77
Στατικός Τύπος (Static)
• Αναφέρεται σε πεδία και σε μεθόδους.

• Στοχεύει στο πεδίο ή τη μέθοδο:
- είναι προσδιορισμένο για τη δήλωση της κλάσης,
- δεν είναι κατάλληλο για κάθε περιστατικό.
78
Στατικός Τύπος (Static)
public class Baby {

static int numBabiesMade = 0 ;
}
Baby.numBabiesMade = 100 ;
Baby b1 = new Baby ( ) ;
Baby b2 = new Baby ( ) ;
Baby.numBabiesMade = 2;
Τι είναι:
b1.numBabiesMade?
b2.numBabiesMade?
79
Static - Παράδειγμα
• Μετρήστε τον αριθμό των μωρών που

γεννηθήκανε.
public class Baby {

int numBabiesMade = 0 ;
Baby ( ) {
numBabiesMade += 1 ;
}
}
80
Static - Πεδίο
• Μετρήστε τον αριθμό των μωρών που

γεννηθήκανε.
public class Baby {

Static int numBabiesMade = 0 ;
Baby ( ) {
numBabiesMade += 1 ;
}
}
81
Static - Μέθοδος
public class Baby {

static void cry ( Baby thebaby ) {
System.out.println ( thebaby.name + “is crying” ) ;
}
}
Ή
public class Baby {
void cry ( ) {
System.out.println (name + “is crying” ) ;
}
}
82
Static - Σημειώσεις
• Μη-στατικές μέθοδοι μπορούν να αναφερθούν σε

στατικές μεθόδους, αλλά όχι το αντίστροφο.
- Γιατί;
public class Baby {

String name = “DMX” ;
static void whoami ( ) {
System.out.println(name) ;
}
}
83
Main
• Γιατί είναι η μέθοδος main τύπου static?

}
84
5.3.1 Καθορίζοντας μια Κλάση
5.3.2 Εμβέλεια της Κλάσης
86
Ενότητα 6: Κληρονομικότητα,
Interfaces και I/O
6.1 Κληρονομικότητα
6.2 Interfaces (Διεπαφές)
6.3 Είσοδος – Έξοδος (I/O)
6
 Την έννοια και την χρήση της κληρονομικότητας,

 Τον τρόπο χρήσης των διεπαφών,
 Τις εντολές για προσδιορισμό του τρόπου εισόδου
και εξόδου σε ένα πρόγραμμα.
8
Βασική Κλάση
• Φτιάχνοντας ένα παιχνίδι: Φτιάχνουμε μια κλάση για τη

δημιουργία ενός χαρακτήρα.
public class Person {

public String name;
public int hp = 100;
public int mp = 0;
public void sayName() {

System.out.println(name);
}
public void punchFace(Person target) {
target.hp -= 10;
}
}
Κληρονομικότητα
• Τώρα φτιάχνουμε ένα Μάγο (Wizard)...
public class Wizard {

// πρέπει να αντιγράψουμε τον κώδικα
// από την κλάση Person.
// Θα μπορούσε να αποφευχθεί;
}
10
Κληρονομικότητα;
Αλλά περιμένετε!
Ένας Μάγος μπορεί και κάνει οτιδήποτε ένας
Person μπορεί και κάνει!
11
Κληρονομικότητα;
Μην δράσετε αμέσως!

Δε χρειάζεται να κάνετε αντιγραφή και
επικόλληση!
12
Χρήση Κληρονομικότητας
• Ο Wizard είναι μία υποκατηγορία της κλάσης Person
public class Wizard extends Person {

}
13
• Ο Wizard μπορεί να χρησιμοποιήσει ό,τι* το Person έχει!

wizard1.hp += 1;
• O Wizard μπορεί να κάνει ό,τι* το Person κάνει!

wizard1.punchFace (person1);
• Μπορείτε να χρησιμοποιήσετε ένα Wizard όπως και ένα

Person επίσης!
person1.punchface(wizard1);
*εκτός των ιδιωτικών πεδίων και μεθόδων
14
• Τώρα αυξάνει ένα Wizard
public class Wizard extends Person {

public void cast(String spell) {
// κώδικας της μεθόδου
...
mp -= 10;
}
}
15
Κληρονομώντας από Κλάσεις που Έχουν

Κληρονομήσει
• Τι συμβαίνει με το Grand Wizard;
public class GrandWizard extends Wizard {

public void sayName() {
System.out.println(“Grand wizard” + name)
}
}
grandWizard1.name = “Flash”
grandWizard1.sayName();
((Person)grandWizard1).sayName();
16
Πως το Καταφέρνει Αυτό η Java;
• Πως συμπεριφέρεται η Java όταν βλέπει

grandWizard1.punchFace(person1)
1. Ψάχνει για punchFace() στην κλάση GrandWizard.

2. Δεν είναι εδώ! Έχει το GrandWizard κληρονομιά;
3. Ναι. Ψάχνει για punchFace() στην κλάση Wizard.
4. Δεν είναι εδώ! Έχει το Wizard κληρονομιά;
5. Ναι. Ψάχνει το punchFace() στην κλάση Person.
6. To βρήκε! Καλεί το punchFace()
7. Αφαιρεί hp από το person1
17
Πως το καταφέρνει αυτό η Java;
• Πως συμπεριφέρεται η Java όταν βλέπει

((Person)grandWizard1).sayName()
1. Η μετατροπή σε Person λέει στην Java να αναζητήσει αρχικά τη

μέθοδο στην κλάση Person.
2. Ψάχνει για το sayName() στην κλάση Person.
3. To βρήκε! Καλεί το sayName()
18
Τι Συμβαίνει στο Παράδειγμα μας;
• Πατέρας των Wizard και Elf. Person
• Παιδί του Person.

Wizard Thief Elf
• Παιδί του Wizard.

Grand
Wizard
19
Μπορείτε να Κληρονομήσετε Μόνο από μία Κλάση
20
21
• Έστω ότι τόσο η κλάση Thief όσο και η

κλάση Elf έχουν μια μέθοδο: public void
sneakUp(), την οποία και υλοποιούν με
διαφορετικό τρόπο.
• Αν η κλάση Bad Elf καλούσε τη μέθοδο
sneakUp() τότε ποια υλοποίηση θα
έπρεπε να πραγματοποιηθεί;
22
Για να Διαβάσετε Περισσότερα:
• http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html
• http://home.cogeco.ca/~ve3ll/jatutor5.htm
• http://en.wikipedia.org/wiki/Inheritance_(computer_science)
• http://www.google.com
23
6.2 Διεπαφές (Interfaces)
24
Υλοποίηση/ Διεπαφή
25
Διεπαφές Java
• Με τις διεπαφές μπορείτε να χειριστείτε τα

αντικείμενα, χωρίς να γνωρίζετε πως λειτουργούν.
• Είναι ωφέλιμο να έχετε παρόμοια αλλά όχι
ταυτόσημα αντικείμενα.
• Είναι ωφέλιμο να χρησιμοποιείτε κώδικα γραμμένο
από άλλους.
26
Παράδειγμα Διεπαφής: Σχεδιασμός ενός Κουτιού
public class BouncingBox {

public void draw(Graphics surface) {
// … κώδικας σχεδιασμού ενός κουτιού…
}
}
// … Σχεδιασμός κουτιών…
for (BouncingBox box : boxes) {
box.draw(surface);
}
27
Παράδειγμα Διεπαφής: Σχεδιασμός ενός Λουλουδιού
public class Flower {

// … κώδικας σχεδιασμού ενός λουλουδιού…
}
}
// … Σχεδιασμός λουλουδιών…
for (Flower flower : flowers) {
flower.draw(surface);
}
28
public class DrawGraphics {

ArrayList<BouncingBox> boxes = new ArrayList<BouncingBox>();
ArrayList<Flower> flowers = new ArrayList<Flower>();
ArrayList<Car> cars = new ArrayList<Car>();
for (BouncingBox box : boxes) {
box.draw(surface);
}
}
for (Car car : cars) {
car.draw(surface);
}
}
}
29
public class DrawGraphics {

ArrayList<Drawable> shapes = new ArrayList<Drawable>();
ArrayList<Flower> flowers = new ArrayList<Flower>();
ArrayList<Car> cars = new ArrayList<Car>();
for (Drawable shape : shapes) {
shape.draw(surface);
}
}
for (Car car : cars) {
car.draw(surface);
}
}
}
30
Διεπαφές
• Συλλογές κλάσεων που μοιράζονται μεθόδους.
• Δηλώνετε μία διεπαφή με μία συνήθη μέθοδο.
• Μπορείτε στη συνέχεια να χρησιμοποιήσετε την

διεπαφή, χωρίς να ξέρετε το συγκεκριμένο τύπο του
αντικειμένου.
31
Διεπαφές: Σχεδιάζοντας Σχήματα
import java.awt.Graphics;
interface Drawable {
void draw(Graphics surface);
void setColor(Color color);
}
32
Υλοποιώντας Διεπαφές
• Οι υλοποιήσεις των διεπαφών παρέχουν πλήρεις

μεθόδους:
import java.awt.Graphics;
class Flower implements Drawable {
// ... Υπόλοιπος κώδικας...
// ... Κώδικας σχεδιασμού flower εδώ...
}
}
33
Παρατηρήσεις
• Έχουν μόνο μεθόδους (ως επί το πλείστον αληθές).
• Δεν παρέχουν κώδικα, μόνο τον ορισμό

(ονομάζονται υπογραφές).
• Μία κλάση μπορεί να εκτελέσει έναν αριθμό

διεπαφών.
34
35
Ένας Τρόπος Εξόδου που Γνωρίζουμε
• System.out.println(“some string”);
36
Η Ολοκληρωμένη Εικόνα
37
InputStream
• InputStream είναι μια σειρά από bytes

– Διαβάζει το ένα Βyte μετά το άλλο με χρήση του read().
• Ένα byte είναι απλά ένας αριθμός
– Τα δεδομένα του σκληρού σας δίσκου αποθηκεύονται σε
Βytes.
– Τα Bytes μπορούν να ερμηνευτούν ως χαρακτήρες,
αριθμοί…
InputStream stream = System.in;
38
InputStreamReader
• O Reader είναι μια κλάση για μια σειρά χαρακτήρων

– Διαβάζει τον ένα χαρακτήρα μετά τον άλλο με χρήση του read()
• To InputStreamReader παίρνει ένα InputStream και
μετατρέπει τα bytes σε χαρακτήρες
• Και πάλι δεν είναι πολύ βολικό: Μπορεί να διαβάσει
μόνο ένα χαρακτήρα τη φορά
new InputStreamReader(stream)
39
BufferReader
• Ο BufferReader ρυθμίζει μία σειρά χαρακτήρων ώστε να

μπορείτε να διαβάσετε τη μία σειρά μετά την άλλη
- String readLine()
new BufferedReader(
new InputStreamReader(System.in));
40
Είσοδος Χρήστη
InputStreamReader ir = new
InputStreamReader(System.in);
BufferedReader br = new BufferedReader(ir);
br.readLine();
41
FileReader
• Ο FileReader παίρνει ένα αρχείο κειμένου

- Το μετατρέπει σε σειρά χαρακτήρων.
- FileReader(“PATH TO FILE”);
• Χρησιμοποιήστε αυτό καθώς και τον BufferReader για να

διαβάσετε αρχεία!
FileReader fr = new FileReader(“readme.txt”);

BufferedReader br = new BufferedReader(fr);
42
Κώδικας FileReader
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ReadFile {
public static void main(String[] args) throws IOException {

// Τα ονόματα των διαδρομών είναι σχετικά με τη θέση του φακέλου του project
FileReader fr = new FileReader("./src/readme");
BufferedReader br = new BufferedReader(fr);
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
}
}
43
Για περισσότερα σχετικά με Ι/Ο
• http://java.sun.com/docs/books/tutorial/essential/io/
44
Εργασία
• Μαγικά Τετράγωνα
• Διαβάστε δύο αρχεία
• Ελέγξτε ότι όλες οι σειρές και οι στήλες έχουν άθροισμα
15
45
6.2 Interfaces (Διεπαφές)
47
Ενότητα 7: Εξαιρέσεις (Exceptions),
Εντοπισμός Σφαλμάτων (Debugging)
7.1 Εξαιρέσεις (Exceptions)
7.2 Εντοπισμός Σφαλμάτων (Debugging)
6
 Τις εξαιρέσεις και ως τις αντιμετωπίζουμε σε ένα

πρόγραμμα,
 Βασικά βήματα για τον εντοπισμό και την
αντιμετώπιση σφαλμάτων στο πρόγραμμα.
8
Παραδείγματα Εξαιρέσεων (Exceptions)
• NullPointerException
• ArrayIndexOutOfBoundsException
• ClassCastException
• RuntimeException
Τί Είναι μία Εξαίρεση;
• Γεγονός που συμβαίνει όταν γίνεται κάτι απροσδόκητο

- null.someMethod();
- (new int[1])[1] = 0;
- int i = “string”;
10
Γιατί Χρησιμοποιούμε μία Εξαίρεση;
• Για να πει σε ένα κώδικα που χρησιμοποιεί τη μέθοδο

μας ότι κάτι πάει στραβά.
Exception in thread "main"

java.lang.ArrayIndexOutOfBoundsException: 5
at RuntimeException.main(RuntimeException.java:8)
- Δείκτης πρόσβασης σε στοιχείο = 5, ο οποίος δείχνει
έξω από τα όρια του πίνακα
- Μέθοδος που το κάλεσε : main
11
Πως Δημιουργούνται «Εξαιρέσεις»
• Όταν η Java δεν γνωρίζει τι θα κάνει, επομένως:

– Δημιουργεί ένα αντικείμενο Εξαίρεσης,
– Συμπεριλαμβάνει χρήσιμες πληροφορίες για αυτήν.
– «πετάει» (throws) την Εξαίρεση.
• Μπορείτε να δημιουργήσετε και να «πετάξετε»
εξαιρέσεις (throw).
• Επίσης να δηλώσετε ποιες εξαιρέσεις θα πετάξετε
(throws).
12
Public class Εξαίρεση
• Η Εξαίρεση είναι μία κλάση

• Στο παρακάτω παράδειγμα μόλις κληρονομήσατε από
αυτή!
public class MyException extends Exception
{
}
• Ή μπορείτε να χρησιμοποιήσετε μία ήδη υπάρχουσα
Εδώ θα βρείτε μία λίστα: http://rymden.nu/exceptions.html
13
Προειδοποιήστε τη Java Σχετικά με την Εξαίρεση
public Object get(int index) throws

ArrayOutOfBoundsException {
If (index < 0 || index >= size())
throw new
ArrayOutOfBoundsException(“”+index);
}
• Η λέξη throws λέει στη Java ότι το αντικείμενο get μπορεί να

εμφανίσει την Εξαίρεση ArrayOutOfBounds.
• Προσοχή μη μπερδέψετε το throws με το throw
14
Πιάνοντας μια Εξαίρεση
• Η Java τώρα περιμένει να βρει κώδικα, ο οποίος καλεί το

get για να αντιμετωπίσει την εξαίρεση:
- πιάνοντας την,
- Πετώντας την.
15
• Τι πρέπει να κάνουμε:
-προσπαθούμε (try) να τρέξουμε κώδικα ο οποίος
εμφανίζει μια εξαίρεση
- και στη συνέχεια να πιάσουμε (catch)την εξαίρεση
try {
get(-1);
} catch (ArrayOutOfBoundsException err) {
System.out.println(“oh dear!”);
}
16
• Μπορεί να θέλετε να δημιουργήσετε (να πετάξετε) εσείς

μία εξαίρεση αντί να περιμένετε να εμφανιστεί.
• Ίσως επίσης δε θέλετε να αντιμετωπίσετε μία εξαίρεση.
• Πείτε στην Java ότι η μέθοδος σας την εμφανίζει
void doBad() throws ArrayOutOfBoundsException {

get(-1);
}
17
Πετώντας μια Εξαίρεση
18
19
20
21
22
23
24
25
26
27
Τι Συμβαίνει αν Κανείς δεν “Αντιμετωπίσει την

Εξαίρεση”;
• Αν τρέξετε
public static void main(String[] args) throws Exception {
doBad();
}
• Η Java τυπώνει το μήνυμα σφάλματος που βλέπετε
Exception in thread "main"

java.lang.ArrayIndexOutOfBoundsException: -1 at
YourClass.get(YourClass.java:50)at YourClass.doBad(YourClass.java:11)at
YourClass.main(YourClass.java:10)
28
Περισσότερες Πληροφορίες;
• http://java.sun.com/docs/books/tutorial/essential/exceptions
• http://en.wikipedia.org/wiki/Exceptions
29
30
Εντοπισμός Σφαλμάτων
• Η διαδικασία της εύρεσης και διόρθωσης ενός

σφάλματος σε ένα πρόγραμμα.
• Μία θεμελιώδης δεξιότητα του προγραμματισμού.
31
Βήμα 1: Μην Κάνετε Λάθη
• Αρχικά μην εισάγετε σφάλματα.
32
Βήμα 1: Μην Κάνετε Λάθη
• Αρχικά μην εισάγετε σφάλματα.
• Επαναχρησιμοποίηση: Βρείτε έναν ήδη υπάρχοντα

κώδικα που κάνει αυτό που θέλετε.
• Σχέδιο: σκεφτείτε πριν γράψετε τον κώδικα.
• Η καλύτερη εξάσκηση: Προτεινόμενη διαδικασία/τεχνική
ώστε να αποφύγουμε συνήθη προβλήματα.
33
Σχέδιο: Ψευδοκώδικας
• Μία υψηλού επιπέδου κατανοητή περιγραφή του

σκοπού που θέλουμε να έχει το πρόγραμμα.
• Μην ανησυχείτε για λεπτομέρειες του κώδικα αλλά για

τη δομή του.
34
Ψευδοκώδικας: Έλεγχος Διαστήματος
– Είναι ένας αριθμός στο διάστημα [x,y);
• Αν ισχύει αριθμός < x να επιστρέφει λανθασμένο.

• Αν ισχύει αριθμός >= y να επιστρέφει λανθασμένο.
• Αλλιώς να επιστρέφει αληθές.
35
Σχέδιο
• Εικονικό σχέδιο για αντικείμενα ή για το πώς λειτουργεί

ένα πρόγραμμα.
• Μην ανησυχήσετε για μία συγκεκριμένη σημείωση,

απλά να κάνετε κάτι που να έχει νόημα για εσάς.
• Τα άχρηστα χαρτιά είναι χρήσιμα.
36
37
Βήμα 2: Βρείτε τα Σφάλματα Νωρίς
• Είναι πιο εύκολο να διορθώσουμε τα λάθη όσο πιο

σύντομα τα βρούμε.
– Ελέγξτε το σχέδιο.
– Χρησιμοποιήστε εργαλεία για εντοπισμό πιθανών λαθών.
– Ελέγξτε την υλοποίηση σας.
– Ελέγξτε την εργασία σας βάζοντας συνθήκες.
38
Δοκιμή: Σημαντικοί Είσοδοι
• Θέλουμε να ελέγξουμε όλα τα “μονοπάτια” του

προγράμματος.
• Σκεφτείτε ένα παράδειγμα για κάθε “μονοπάτι”.
– Είναι ένας αριθμός στο διάστημα [x,y);
39
Διαστήματα: Σημαντικές Περιπτώσεις
• Κάτω από το χαμηλότερο όριο.

• Ίσο με το χαμηλότερο όριο.
• Μέσα στο διάστημα.
• Ίσο με το υψηλότερο όριο.
• Πάνω από το υψηλότερο όριο.
40
Διαστήματα: Σημαντικές Περιπτώσεις
• Τι συμβαίνει αν το χαμηλότερο όριο είναι μεγαλύτερο

από το υψηλότερο;
– lower bound > upper bound
• Τι συμβαίνει αν το χαμηλότερο όριο ισούται με το
υψηλότερο όριο;
– lower bound == upper bound
41
Είναι ένας αριθμός στο διάστημα [x,y);
Είναι το 5 στο διάστημα [3,5);

• Αν ισχύει αριθμός > y= να επιστρέφει λανθασμένο.
42
• Είναι ένας αριθμός στο διάστημα [x,y);
• Είναι το 5 στο διάστημα [3,5);

• Αν ισχύει αριθμός > y να επιστρέφει λανθασμένο.
43
Εργαλεία: Προειδοποιήσεις του Eclipse
• Προειδοποιήσεις: ίσως δεν πρόκειται για ένα σφάλμα,

αλλά πιθανόν και να πρόκειται.
• Προτάσεις: πάντα πρέπει να διορθώνουμε τις

προειδοποιήσεις.
• Επιπλέον έλεγχοι: FindBugs και σχετικά εργαλεία

• Έλεγχος ενότητας: Junit κάνει τον έλεγχο ευκολότερο
44
Εξακρίβωση
• Επαληθεύστε ότι ο κώδικας κάνει αυτό για το οποίο τον

προορίζατε.
– Αν είναι σωστό: δε συμβαίνει τίποτα
– Αν είναι λάθος: το πρόγραμμα σταματάει με ένα σφάλμα
– Απενεργοποιημένη από προεπιλογή
• assert difference >= 0;
45
void printDifferenceFromFastest(int[] marathonTimes) {

int fastestTime = findMinimum(marathonTimes);
for (int time : marathonTimes) {

int difference = time -fastestTime;
assert difference >= 0;
System.out.println("Difference: " + difference);
}
}
46
Βήμα 3: Αναπαράγετε το Σφάλμα
• Υπολογίστε πώς να επαναλάβετε το σφάλμα.

• Δημιουργήστε μια σύντομη περίπτωση ελέγχου.
• Επιστρέψτε σε μία έκδοση που ήδη λειτουργεί και

εισάγετε μία αλλαγή κάθε φορά μέχρι να επανέλθει το
σφάλμα.
• Εξαλείψτε το επιπλέον υλικό που δε χρησιμοποιείται.
47
Βήμα 4: Δημιουργία Υπόθεσης
• Τι πηγαίνει στραβά;
• Τι μπορεί να έχει προκαλέσει το σφάλμα;
• Αμφισβητείστε τις παραδοχές: “το x δεν είναι πιθανό:”

• Αν οφείλεται σε κάτι άλλο;
48
50
Οδηγίες χρήσης και σύντομη εισαγωγή στην πλατφόρμα Greenfoot
Version 1.1
Επιμέλεια Σημειώσεων1: Πατρικάκης Χαράλαμπος,
Λάζαρος Τουμανίδης,
Κόγιας Δημήτριος
1
Οι σημειώσεις βασίζονται στους αντίστοιχους οδηγούς που βρίσκονται στην ιστοσελίδα του Greenfoot, και στην ελληνική
μετάφραση αυτών (Mantzas Ioannis, Milolidakis Giannis).
Εργαστήριο Αντικειμενοστραφούς προγραμματισμού: Εισαγωγή στην πλαφόρμα Greenfoot [1]
Πίνακας περιεχομένων
Οδηγός 1: Αλληλεπιδρώντας με το Greenfoot .......................................................................................................... 3
Η διεπαφή Greenfoot ............................................................................................................................................ 3
Εισαγωγή αντικειμένων στον κόσμο ..................................................................................................................... 6
Ενεργοποίηση των αντικειμένων........................................................................................................................... 7
Εκτέλεση σεναρίου ................................................................................................................................................ 9
Άμεση εκτέλεση μεθόδων ................................................................................................................................... 10
Δημιουργία ενός νέου κόσμου ............................................................................................................................ 10
Κλήση μεθόδων του “κόσμου” ............................................................................................................................ 10
Οδηγός 2: Κίνηση και κλειδιά ελέγχου .................................................................................................................... 13
Το σενάριο Crabs ................................................................................................................................................. 13
Οδηγός 3: Εντοπισμός και αφαίρεση των Actors και δημιουργία μεθόδων .......................................................... 17
Τρώγοντας σκουλήκια ......................................................................................................................................... 17
Refactoring – ‘Η αλλιώς ανακατασκευή του κώδικα μας.................................................................................... 20
Οδηγός 4: Αποθήκευση του κόσμου, αναπαραγωγή και καταγραφή ήχου ........................................................... 22
Αποθήκευση του κόσμου..................................................................................................................................... 22
Αναπαραγωγή και αποθήκευση ήχων ................................................................................................................. 23
Οδηγός 5: Προσθήκη τυχαία κινούμενου εχθρού ................................................................................................... 24
Προσβασιμότητα ενός αντικειμένου από ένα άλλο ............................................................................................ 26
Παράρτημα Α: Λήψη, εγκατάσταση και χρήση του Greenfoot ............................................................................... 31
Παράρτημα Β: Χρήσιμοι σύνδεσμοι ........................................................................................................................ 32

Οδηγός 1: Αλληλεπιδρώντας με το Greenfoot
Αυτός ο οδηγός εξηγεί τα βασικά στοιχεία της διεπαφής Greenfoot, και πως γίνεται η αλληλεπίδραση
με αυτήν.
Αλλαγή διεπαφής στα Ελληνικά για παλαιότερες εκδόσεις

Για να αλλάξουμε την διεπαφή του Greenfoot στα Ελληνικά ακολουθούμε τα εξής
βήματα:
1. Εντοπίζουμε το αρχείο greenfoot.defs. Το αρχείο θα το βρείτε στο:
<φάκελος_greenfoot> / lib / greenfoot.defs
2. Αυτό το αρχείο περιέχει παραμέτρους της εφαρμογής στην μορφή:
όνομα_παραμέτρου = τιμή
3. Εντοπίζουμε την παράμετρο στο αρχείο που ονομάζεται:
bluej.language
4. Σε αυτήν την παράμετρο θέτουμε την γλώσσα στην οποία επιθυμούμε να
εμφανίζεται η διεπαφή μας. Για τα Ελληνικά δώστε το εξής:
bluej.language = greek
5. Αυτό ήταν όλο. Έχετε κατά νου ότι η αλλαγές που κάναμε θα μεταφράσουν
την διεπαφή στα Ελληνικά αλλά όχι και τον κώδικα των σεναρίων που
εκτελείται ή τα ονόματα των κλάσεων.
Αλλαγή διεπαφής στα Ελληνικά για νεότερες εκδόσεις
Για να αλλάξουμε την διεπαφή του Greenfoot στα Ελληνικά σε νεότερες εκδόσεις η
διαδικασία έχει απλουστευθεί.
1. Επιλέγουμε από το μενού Edit  Preferences.
2. Επιλέγουμε την ταμπέλα Interface και στο Language επιλέγουμε Greek.
3. Επανεκκινούμε το Greenfoot και πλέον η διεπαφή μας είναι στα Ελληνικά.
Προσέξτε ότι ισχύει ότι ειπώθηκε παραπάνω πως μόνο η διεπαφή είναι στα
Ελληνικά και όχι ο κώδικας των διαφόρων σεναρίων.
Η διεπαφή Greenfoot
Ο οδηγός αυτός χρησιμοποιεί ένα σενάριο που ονομάζεται ‘wombats’ το οποίο διανέμεται με το
Greenfoot αλλά μπορείτε να το βρείτε και στην πλατφόρμα του μαθήματος και να το κατεβάσετε.
Ανοίγουμε το σενάριο wombats στο Greenfoot επιλέγοντας Scenario και Open και κατόπιν
διαλέγουμε τη θέση του αρχείου Project για το wombat στον σκληρό μας.

Επιλέγουμε την τοποθεσία όπου θέλουμε να αποθηκεύσουμε το σενάριο και λαμβάνουμε την
παρακάτω οθόνη:

Αρχικά διαλέγουμε την επιλογή “compile” , ώστε να γίνει η μεταγλώττιση του κώδικα και να
εμφανιστεί ο νέος “κόσμος” (world).
Η μεγάλη περιοχή με το πλέγμα που καλύπτει την πλειοψηφία του παραθύρου, ονομάζεται “The
World’ δηλαδή “Ο Κόσμος” της εφαρμογής μας. Εφόσον έχουμε ένα σενάριο το οποίο έχει να κάνει με
wombats βλέπουμε ένα wombat world.
Στην δεξιά μεριά του παραθύρου είναι η οθόνη των κλάσεων. Εδώ μπορούμε να δούμε όλες τις
κλάσεις τις java που εμπεριέχονται στο σενάριο (project). Οι κλάσεις ‘world’ και ‘actor’ θα είναι
πάντα εκεί καθώς έχουν προστεθεί από το σύστημα του Greenfoot. Οι υπόλοιπες κλάσεις ανήκουν
στο σενάριο wombat και θα είναι διαφορετικές ανάλογα με το σενάριο που ανοίγουμε ή
δημιουργούμε. Κάτω από τον “Κόσμο” είναι τα εργαλεία εκτέλεσης (Η περιοχή με τα κουμπιά “Act”,
“Run” “Reset” και τον ρυθμιστή της ταχύτητας).

Ο κόσμος
Οι κλάσεις
Τα εργαλεία εκτέλεσης
Εισαγωγή αντικειμένων στον κόσμο
Για την εισαγωγή αντικειμένων στον νέο κόσμο, επιλέγουμε με δεξί κλικ (σε υπολογιστές Mac, όπου
υπάρχει δεξί κλικ στον οδηγό αυτόν ο αντίστοιχος συνδυασμός είναι Control-κλικ) την κλάση Wombat
από την περιοχή όπου υπάρχουν όλες οι κλάσεις. Το αναδυόμενο μενού είναι το παρακάτω:

Επιλέγουμε 'new Wombat()' από το μενού και κάνουμε κλικ οπουδήποτε
μέσα στον κόσμο. Μόλις δημιουργήσαμε ένα “wombat” (σε ορολογία της
Java ένα αντικείμενο) και το τοποθετήσαμε στον κόσμο.
Τα Wombats τρώνε φύλλα, οπότε ας προσθέσουμε και μερικά φύλλα στον

κόσμο. Όπως και πριν, με δεξί κλικ στην κλάση Leaf, επιλέγουμε 'new
Leaf()' και το τοποθετούμε στον κόσμο.
Αν θέλουμε να τοποθετήσουμε περισσότερα αντικείμενα (της ίδιας

κλάσης) μπορούμε έχοντας επιλέξει την κλάση (με αριστερό κλικ πάνω της
το μαύρο περίγραμμα γίνεται πιο έντονο) και κρατώντας πατημένο το
πλήκτρο Shift με κάθε αριστερό κλικ μέσα στον κόσμο προσθέτουμε και
από ένα αντικείμενο.
Αν θέλουμε να αφαιρέσουμε ένα αντικείμενο από τον κόσμο, μπορούμε να το κάνουμε με την
επιλογή που εμφανίζεται με δεξί κλικ πάνω στο αντικείμενο αυτό.
Ενεργοποίηση των αντικειμένων

Πατώντας το κουμπί 'Act' από τα εργαλεία εκτέλεσης, κάθε αντικείμενο ενεργοποιείται και κάνει ότι
έχει προγραμματιστεί για να κάνει. Στο παράδειγμά μας, τα φύλλα είναι προγραμματισμένα να μην
κάνουν τίποτα, ενώ τα wombats είναι προγραμματισμένα να κινούνται με τη φορά που είναι
τοποθετημένα. Αν τοποθετήσουμε δύο wombats στον κόσμο και επιλέξουμε Act θα κινηθούν και τα
δύο.

Στα wombats όπως είπαμε αρέσει να τρώνε φύλλα, οπότε αν βρουν κάποιο φύλλο στο δρόμο τους, θα
το φάνε. Αν τοποθετήσουμε κάποια φύλλα μπροστά τους, αφού βρεθούν στο ίδιο τετράγωνο, στο
επόμενο Act τα φύλλα θα έχουν εξαφανιστεί.

Εκτέλεση σεναρίου
Πατώντας το κουμπί ‘Run’, γίνεται εκτέλεση του σεναρίου. Αυτό είναι ισοδύναμο με την διαρκή
εκτέλεση της εντολής ‘Act’. Παρατηρούμε πως μετά την εκτέλεση του ‘Run’ το κουμπί αλλάζει σε
‘Pause’. Αν το πατήσουμε, οτιδήποτε είναι ενεργό σταματάει. Με τον ρυθμιστή δίπλα από τα κουμπιά
εκτέλεσης μπορούμε να καθορίσουμε την ταχύτητα εκτέλεσης του σεναρίου.

Άμεση εκτέλεση μεθόδων
Εάν αντί για εκτέλεση ολόκληρου του σεναρίου, μπορούμε απλά να καλέσουμε μεθόδους. Μία
μέθοδος είναι μια μοναδική πράξη που ένα αντικείμενο μπορεί να εκτελέσει.
Με δεξί κλικ πάνω σε ένα αντικείμενο (και χωρίς να εκτελείται το σενάριο) μπορούμε να δούμε τις
διαθέσιμες μεθόδους που σχετίζονται με αυτό και να επιλέξουμε οποιαδήποτε από αυτές.
Μπορούμε να επιλέξουμε μια μέθοδο που θα ζητάει από

το αντικείμενο να εκτελέσει μια πράξη, όπως για
παράδειγμα να στρίψει αριστερά: turnLeft() ή απλά να
κινηθεί κατά μία θέση: move().
Κάποιες άλλες μέθοδοι απλά επιστρέφουν μια απάντηση

σε ερώτηση που κάνουμε. Η μέθοδος getLeavesEaten(),
για παράδειγμα, μας επιστρέφει τον αριθμό των φύλλων
που το wombat έχει φάει μέχρι στιγμής.
Βλέπουμε επίσης πως υπάρχει και η μέθοδος ‘act()’. Αυτή

είναι η μέθοδος που καλείται κάθε φορά που πατάμε το
αντίστοιχο κουμπί. Εδώ έχουμε την επιλογή της κλήσης
μόνο για ένα αντικείμενο, αντί για όλα στον κόσμο.
Δημιουργία ενός νέου κόσμου

Αν έχουμε πολλά αντικείμενα στον κόσμο που δεν τα χρειαζόμαστε και θέλουμε να ξεκινήσουμε από
την αρχή, ένας εύκολος τρόπος είναι να καταργήσουμε τον κόσμο αυτό και να δημιουργήσουμε έναν
νέο. Αυτό γίνεται με την επιλογή του κουμπιού ‘Reset’ από τα εργαλεία εκτέλεσης. Ο παλιός κόσμος
συμπεριλαμβανομένων των αντικειμένων που υπήρχαν παύει να υπάρχει και δημιουργείται ένας νέος
κενός κόσμος. Αξίζει να σημειώσουμε πως μπορούμε να έχουμε μόνο έναν κόσμο ανά σενάριο.
Κλήση μεθόδων του “κόσμου”

Όπως είδαμε κάθε αντικείμενο στον κόσμο έχει και κάποιες
μεθόδους που μπορούμε να καλέσουμε από το αναδυόμενο
μενού που εμφανίζεται με δεξί κλικ σε αυτό. Αντίστοιχα και ο
ίδιος ο κόσμος έχει μεθόδους που μπορούμε να καλέσουμε
από αναδυόμενο μενού. Με δεξί κλικ σε κάποια κενή περιοχή
(κάπου όπου δεν υπάρχει αντικείμενο) ή στην γκρι περιοχή
δίπλα από τον κόσμο, μπορούμε να δούμε τις επιλογές που
έχουμε.

Μία από τις επιλογές αυτές είναι η ‘populate()’. Με την κλήση της μεθόδου αυτής δημιουργούνται
διάφορα φύλλα και wombats και τοποθετούνται στον κόσμο. Μπορούμε στη συνέχεια να
εκτελέσουμε το σενάριο.
Μία άλλη μέθοδος είναι η 'randomLeaves(int howMany)'. Με τη μέθοδο αυτή τοποθετούνται

ορισμένα φύλλα σε τυχαίες θέσεις στον κόσμο. Παρατηρούμε πως μετά το όνομα της μεθόδου και
μέσα στις παρενθέσεις έχουμε την παράμετρο ‘int howMany’, που σημαίνει πως πρέπει να
συμπεριλάβουμε κάποια επιπλέον πληροφορία με την κλήση της μεθόδου αυτής. Ο όρος ‘ int’
δηλώνει πως ένας ακέραιος αριθμός πρέπει να δηλωθεί και ο όρος ‘howMany’ μας προτρέπει να
δηλώσουμε τον αριθμό των φύλλων που θέλουμε να δημιουργηθούν και τοποθετηθούν.
Υπάρχει περίπτωση, αν μετρήσουμε τα φύλλα που βλέπουμε στον κόσμο μετά την κλήση της μεθόδου
αυτής, να δούμε πως υπάρχουν λιγότερα από αυτά που θέσαμε. Κάτι τέτοιο μπορεί να συμβεί σε
περίπτωση που κάποια φύλλα τοποθετούνται στην ίδια θέση, οπότε δεν μπορούμε τα ξεχωρίσουμε.
Αφού εξοικειωθούμε με το περιβάλλον του Greenfoot μπορούμε να προχωρήσουμε στο μέρος του
προγραμματισμού.

Aξίζει να παραθέσουμε μια σύντομη σημείωση σχετικά με τα σύμβολα οριοθέτησης (στην wikipedia
υπάρχει ένα αρκετά περιεκτικό άρθρο).Υπάρχουν τρία είδη συμβόλων οριοθέτησης στην Java:
Οι στρογγυλές παρενθέσεις στην Java, χρησιμοποιούνται σε μαθηματικές εκφράσεις, και για να

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

Οδηγός 2: Κίνηση και κλειδιά ελέγχου
Στον οδηγό αυτό, θα δούμε πώς μπορούμε να έχουμε κίνηση στο Greenfoot, καθώς και το πώς
μπορούμε να την ελέγξουμε με το πληκτρολόγιο.
Το σενάριο Crabs
Κατεβάζουμε το modern-crab.zip αρχείο και το

αποσυμπιέζουμε κάπου στον υπολογιστή μας. Στη
συνέχεια ανοίγουμε το σενάριο στην τοποθεσία
αυτή πατώντας πάνω στο αρχείο project (αυτό με
το εικονίδιο του Greenfoot), το μεταγλωττίζουμε
(compile) και βλέπουμε έναν άδειο κόσμο.
Με δεξί κλικ στην κλάση crab επιλέγουμε new Crab() και

τοποθετούμε με αριστερό κλικ το νέο καβούρι οπουδήποτε στον
κόσμο. Στη συνέχεια επιλέγουμε την εκτέλεση του σεναρίου(Run)
και παρατηρούμε πως δεν έχουμε καμία κίνηση. Για να δούμε τι
ακριβώς θα έπρεπε να κάνει το καβούρι, με δεξί κλικ στην κλάση
Crab επιλέγουμε ‘Open editor’ και βλέπουμε τον κώδικα Java για το
αντικείμενο Crab. Όπως βλέπουμε στα άγκιστρα κάτω από την
γραμμή public void act() δεν υπάρχει τίποτα.

Αν θέλουμε να προσθέσουμε κίνηση στο αντικείμενό μας πρέπει να προσθέσουμε τη εντολή move:
Χρειάζεται προσοχή έτσι ώστε να γράψουμε ακριβώς ότι βλέπουμε στην εικόνα, δηλαδή την εντολή
move ακολουθούμενη από παρενθέσεις που περιέχουν τον αριθμό 4 ακολουθούμενες από το
ελληνικό ερωτηματικό (;). Συνήθη λάθη είναι η χρήση κεφαλαίου M στο move (στη Java τα κεφαλαία
και τα μικρά γράμματα παίζουν ρόλο), η έλλειψη του ελληνικού ερωτηματικού, η χρήση λάθος
συμβόλων οριοθέτησης (παρένθεση) ή η από λάθος αφαίρεση των αγκίστρων {} πριν και μετά τον
κώδικα. Αν λάβετε κάποιο μήνυμα σφάλματος κατά τη διάρκεια του οδηγού αυτού, ελέγξτε αν έχετε
κάνει κάποιο από αυτά τα λάθη.
Αφού γράψουμε τον κώδικα, πατάμε το κουμπί Compile στην κεντρική διεπαφή του Greenfoot (ή
επάνω αριστερά στο παράθυρο του επεξεργαστή του κώδικα μας), τοποθετούμε ένα καβούρι (new
Crab()) και επιλέγουμε την εκτέλεση του σεναρίου (Run). Αυτή τη φορά το καβούρι κινείται κατά
μήκος του πλαισίου του κόσμου, έως ότου φτάσει
στο τέλος του πλαισίου και σταματήσει.

Στην πραγματικότητα το καβούρι δεν σταματάει, προσπαθεί να συνεχίσει να κινείται αλλά το
Greenfoot δεν το αφήνει να βγει έξω από τον κόσμο.
Μπορούμε επίσης να αλλάξουμε την τιμή 4 στον κώδικα που γράψαμε προηγουμένως με κάποια
άλλη, ώστε να διαμορφώσουμε την ταχύτητα κίνησης. Μεγαλύτερη τιμή θα δώσει μεγαλύτερη
ταχύτητα ενώ μικρότερη τιμή, μικρότερη ταχύτητα. Μπορούμε επίσης να δώσουμε και αρνητική τιμή
(τι θα αλλάξει στην κίνηση σε αυτή την περίπτωση;).
Αν θέλουμε το καβούρι να μην κινείται μόνο σε μια ευθεία, μπορούμε να προσθέσουμε και την
εντολή turn(n), ώστε να στρίβει κατά κάποιες μοίρες.
Σε αυτή την περίπτωση βλέπουμε πως το καβούρι τώρα ακολουθεί μια κυκλική τροχιά και ακόμα κι αν
βρεθεί σε κάποιο από τα όρια του κόσμου, κάποια στιγμή θα στρίψει και θα επιστρέψει εντός των
ορίων. Μπορούμε με αλλαγή της παραμέτρου της στροφής να αλλάξουμε την ακτίνα του κύκλου σε
μεγαλύτερη ή μικρότερη (Αν αλλάξουμε και την παράμετρο της μετακίνησης, τι αλλάζει στην τροχιά
της κίνησης και γιατί;).
Ας προσθέσουμε στον κώδικά μας λίγη διαδραστικότητα. Μπορούμε να πούμε στο καβούρι να
στρίβει μόνο αν πιέσουμε το πλήκτρο ‘→’ ή ‘←’ του πληκτρολογίου.
Χρησιμοποιούμε προκαθορισμένες μεθόδους του Greenfoot για να ελέγχουμε εάν ένα πλήκτρο είναι
πατημένο. Ανάμεσα στα εισαγωγικά είναι το όνομα του πλήκτρου, "left" είναι το πλήκτρο με το
αριστερό βελάκι, "right" είναι το πλήκτρο με το δεξί. Εάν θέλουμε κάτι σαν "a" ή "d", απλά

χρησιμοποιούμε αυτά τα γράμματα αντί για right και left στον παραπάνω κώδικα. O κώδικας μας λέει:
αν τα πλήκτρα είναι πατημένα, στρίψε κατά ένα συγκεκριμένο αριθμό.
Αν βάλουμε πολλά καβούρια στον κόσμο, θα δούμε ότι πατώντας τα πλήκτρα ελέγχου όλα μαζί
ταυτόχρονα με σωστό συγχρονισμό, θα υπάρξει υπερφόρτωση: όλα τα καβούρια εκτελούν τον ίδιο
κώδικα, έτσι ώστε αν πατήσουμε το αριστερό πλήκτρο, όλα τους θα δουν ότι το αριστερό πλήκτρο
είναι πατημένο, και όλα θα κινηθούν αναλόγως.
Τι θα συμβεί αν κρατήσουμε πατημένο και το αριστερό και το δεξί την ίδια στιγμή; Δοκιμάστε το και
ανακαλύψτε - στη συνέχεια εξετάστε τον κώδικα και δείτε αν μπορείτε να ανακαλύψετε το λόγο που
συμβαίνει αυτό.

Οδηγός 3: Εντοπισμός και αφαίρεση των Actors και δημιουργία μεθόδων
Στον οδηγό αυτό, θα εξετάσουμε πώς μπορούμε να διαπιστώσουμε ότι δύο αντικείμενα του κόσμου
έχουν έρθει σε επαφή και κατά συνέπεια να αφαιρέσουμε το ένα από αυτά. Επίσης θα δούμε πώς να
βελτιώσουμε τον κώδικά μας χρησιμοποιώντας μεθόδους.
Τρώγοντας σκουλήκια
Συνεχίζοντας από προηγούμενο μέρος, όπου είχαμε τα καβούρια να
κινούνται στο εσωτερικό του κόσμου μας, κάτω από τον έλεγχό μας. Θα
προσθέσουμε τώρα και μερικά σκουλήκια για να τρώνε τα καβούρια. Το
σκουλήκι θα είναι κι αυτό ένας Actor, οπότε για να φτιάξουμε την νέα
κλάση ‘worm’ με δεξί κλικ στην κλάση Actor, επιλέγουμε New subclass.
Εισάγουμε το όνομα της νέας κλάσης Worm – σημειώστε πως χρησιμοποιούμε το κεφαλαίο γράμμα
W. Πρόκειται για μια σύμβαση στην Java να χρησιμοποιούμε κεφαλαία για το πρώτο γράμμα του
ονόματος μιας κλάσης. Για εικόνα επιλέγουμε το αρχείο “worm.png” και πατάμε ok.

Η νέα μας κλάση δεν θα έχει καθόλου κώδικα να τρέξει, όπως και η κλάση crab όταν ξεκινήσαμε. Θα
την αφήσουμε ως έχει, αφού δεν χρειαζόμαστε να κάνουν κάτι τα αντικείμενα της κλάσης αυτής. Αυτό
που θα διαμορφώσουμε είναι η κλάση crab, ώστε κάθε φορά που κάποιο καβούρι περάσει πάνω από
ένα σκουλήκι, να το τρώει. Ανοίγουμε λοιπόν το αρχείο της κλάσης crab που μέχρι στιγμής είναι όπως
παρακάτω:
Στο τέλος της μεθόδου act(), θα πρέπει να δημιουργήσουμε ένα αντικείμενο της κλάσης Worm και να
προσθέσουμε, κατόπιν, μια εντολή που θα ελέγχει αν ένα καβούρι ακουμπάει το σκουλήκι που
δημιουργήσαμε.
Θα χρησιμοποιήσουμε την μέθοδο getOneObjectAtOffset. Η μέθοδος αυτή δέχεται τρεις

παραμέτρους. Οι δύο πρώτες εκφράζουν την οριζόντια (Χ) και κάθετη (Υ) απόκλιση (απόσταση) από
την τρέχουσα θέση του αντικειμένου μας. Θέλουμε να ξέρουμε τι βρίσκεται στην ίδια θέση με εμάς
οπότε θα θέσουμε στις παραμέτρους αυτές την τιμή 0 (καμία απόσταση). Η τρίτη παράμετρος μας
επιτρέπει να δηλώσουμε ποια κλάση μας ενδιαφέρει για την σύγκριση. Θα χρησιμοποιήσουμε την
κλάση worm για την ενέργεια αυτή μιας και μας ενδιαφέρει να μελετήσουμε αν το καβούρι
(αντικείμενο) ακουμπάει κάποιο σκουλήκι (worm).

Πρέπει να σημειώσουμε πως δεν καλούμε απλά την μέθοδο, αλλά αποθηκεύουμε και το αποτέλεσμα
της κλήσης της στην αριστερή πλευρά της εντολής (worm). Η μέθοδος αυτή επιστρέφει το αντικείμενο
(worm στην περίπτωση μας) που βρίσκεται στην απόσταση που έχουμε εισάγει, αν αυτό υπάρχει.
Οπότε στην μεταβλητή worm, που δηλώσαμε στην προηγούμενη γραμμή, θα εκχωρηθεί το
αποτέλεσμα της μεθόδου.
Αναλόγως την τιμή της μεταβλητής μας, μπορούμε να εξετάσουμε αν όντως υπάρχει κάποιο
αντικείμενο στην ίδια θέση με εμάς. Αν δεν υπάρχει, η μεταβλητή μας θα έχει την ειδική τιμή ‘null’,
οπότε μπορούμε να αφαιρέσουμε το σκουλήκι, μόνο εάν η μεταβλητή είναι διαφορετική από ‘null’,
συνεπώς και θα πρέπει να γίνει ο αντίστοιχος έλεγχος.

Ο τελεστής ‘!=’ είναι ο τελεστής ‘διάφορο από’ στην Java. Αυτό σημαίνει πως ο κώδικας θα εκτελεστεί
μόνο αν η μεταβλητή worm δεν έχει την τιμή null.
Ο κώδικας που εισάγαμε μέσα στον έλεγχο δουλεύει ως εξής: Πρώτα ορίζουμε μια μεταβλητή (με το
όνομα world) ώστε να μπορέσουμε να αλληλεπιδράσουμε με τον κόσμο μας και να του ζητήσουμε,
στη συνέχεια, να αφαιρέσει ένα αντικείμενο (δηλαδή το worm). Έπειτα, αρχικοποιούμε αυτήν την
μεταβλητή με τον συγκεκριμένο κόσμο που έχουμε δημιουργήσει με τη βοήθεια της εντολής
‘getWorld()’. Τέλος, αφαιρούμε το σκουλήκι από τον κόσμο με την μέθοδο ‘removeObject()’.
Refactoring – ‘Η αλλιώς ανακατασκευή του κώδικα μας

Πριν συνεχίσουμε θα πρέπει να κάνουμε μια αλλαγή στον κώδικα. Αυτό είναι κάτι που είναι γνωστό
ως refactoring: δηλαδή πρόκειται για αλλαγή στον κώδικα χωρίς να αλλάξει, όμως, η συμπεριφορά
του.
Στη μορφή που βρίσκεται τώρα, η μέθοδος ‘act()’ για το Καβούρι έχει δύο διαφορετικές
συμπεριφορές μέσα της: οι μισές συμπεριφορές έχουν να κάνουν με την κίνηση μέσα στον κόσμο, και
οι άλλες μισές έχουν να κάνουν με το φάγωμα των σκουληκιών. Θα ήταν πιο ευδιάκριτο αν τις
ονομάζαμε και τις χωρίζαμε, για να αποφύγουμε πιθανή σύγχυση στο μέλλον.
Αυτό μπορούμε να το καταφέρουμε με τη δημιουργία διαφορετικών μεθόδων για κάθε συμπεριφορά.

Στην πραγματικότητα έχουμε ήδη δει πώς γράφονται οι μέθοδοι: η act() είναι και αυτή μια μέθοδος.

Και οι δύο νέες μέθοδοι δεν απαιτούν παραμέτρους και δεν επιστρέφουν καμία τιμή, άρα μπορούν να
δηλώνονται ακριβώς με τον ίδιο τρόπο όπως και η ‘act()’;
Ο διαμορφωμένος κώδικάς μας φαίνεται παρακάτω:
Αν συγκρίνουμε τις δύο εκδόσεις θα δούμε πως δεν έχουμε αλλάξει ή αφαιρέσει καθόλου από τον
υπάρχοντα κώδικα. Μεταφέραμε το πρώτο μισό σε μια νέα μέθοδο moveAndTurn(), και το δεύτερο
μισό σε μια άλλη eat().
Στη συνέχεια αντικαταστήσαμε το περιεχόμενο της μεθόδου act() με κλήσεις των δύο νέων αυτών
μεθόδων έτσι ώστε να διατηρηθεί η ίδια συμπεριφορά στο πρόγραμμα μας.

Οδηγός 4: Αποθήκευση του κόσμου, αναπαραγωγή και καταγραφή ήχου
Στον οδηγό αυτό θα δούμε πώς μπορούμε να αρχικοποιήσουμε τον κόσμο μας με αντικείμενα χωρίς
να χρειάζεται να τα τοποθετήσουμε εμείς, καθώς και πώς μπορούμε να αναπαράγουμε και
αποθηκεύσουμε ήχους.
Αποθήκευση του κόσμου

Μέχρι τώρα, κάθε φορά που μεταγλωττίζουμε τον κώδικα, πρέπει στη συνέχεια να προσθέσουμε
μόνοι μας τα αντικείμενα που θέλουμε μέσα στον κόσμο. Με την προσθήκη, όμως, λίγο ακόμα
κώδικα, μπορούμε να επιτύχουμε να εισάγονται αυτόματα κάποια αντικείμενα (π.χ. ένα καβούρι και
μερικά σκουλήκια), μετά από κάθε μεταγλώττιση του προγράμματος μας, κατευθείαν από το
Greenfoot για εμάς!
Για να το επιτύχουμε αυτό, επιλέγουμε Reset και στη συνέχεια προσθέτουμε τα αντικείμενα που
θέλουμε να δημιουργούνται στον κόσμο μας. Πριν πατήσουμε Run, με δεξί κλικ στον κόσμο
επιλέγουμε ‘Save the World’.
Με αυτή την επιλογή, προσθέσαμε λίγο κώδικα στην κλάση CrabWorld, έτσι ώστε όποτε επιλέξουμε
Reset ή να κάνουμε κάποια μεταγλώττιση, να τοποθετούνται πάντα τα αντικείμενα που έχουμε βάλει
στο σενάριο αυτό, στις θέσεις που επιλέξαμε.
Δεν θα εμβαθύνουμε στον κώδικα αυτό τώρα, αλλά μπορείτε να τον δείτε στο παράθυρο που
αναδύεται μετά την επιλογή Save the World. Αν θέλουμε να επιστρέψουμε στην αρχική κατάσταση,
χωρίς την αυτόματη αρχική προσθήκη αντικειμένων στον κόσμο, θα έπρεπε να αφαιρέσουμε από την
κλάση CrabWorld τον κώδικα αυτό.

Για να μπορέσετε να το καταλάβετε καλύτερα, ανοίξτε στον editor τον κώδικα της κλάσης πριν
πατήσετε ‘Save the World’, μετά δημιουργήστε την αρχική εικόνα που επιθυμείτε και μελετήστε τον
κώδικα (αφού πατήσετε ‘Save the World’). Ό,τι έχει προστεθεί αφορά την αρχικοποίηση του κόσμου.
Αναπαραγωγή και αποθήκευση ήχων

Μπορούμε να προσθέσουμε ήχο στο σενάριό μας. Υπάρχει ήδη διαθέσιμο ένα αρχείο ήχου
‘eating.wav’ στο σενάριο που κατεβάσαμε στην αρχή. Μπορούμε να παίζουμε αυτόν τον ήχο κάθε
φορά που κάποιο καβούρι τρώει ένα σκουλήκι, προσθέτοντας μια μόνο γραμμή κώδικα στην κλάση
crab που καλεί την μέθοδο Greenfoot.playSound αφού αφαιρέσουμε το σκουλήκι από τον κόσμο:
Μπορούμε επίσης εάν διαθέτουμε μικρόφωνο στον υπολογιστή μας, να ηχογραφήσουμε τους δικούς
μας ήχους. Στο μενού Controls υπάρχει η επιλογή εμφάνισης του παραθύρου ηχογράφησης.
Αφού το επιλέξουμε πατάμε το κουμπί Record, μιλάμε ή κάνουμε

τον ήχο που θέλουμε και μετά πατάμε stop. Για να αφαιρέσουμε το
μέρος του ήχου στην αρχή (ή και στο τέλος) όπου υπάρχει ησυχία,
επιλέγουμε με αριστερό κλικ την αρχή από το μέρος που θέλουμε να
κρατήσουμε και σέρνουμε την επιλογή μας μέχρι το τέλος του. Στη
συνέχεια επιλέγουμε Trim to selection. Αφού καταλήξουμε στον ήχο
που θέλουμε να χρησιμοποιήσουμε και κρατήσουμε δίνουμε ένα
όνομα στο αρχείο που θα σώσουμε (π.χ. myeating) και επιλέγουμε
save.
Αφού κλείσουμε το παράθυρο της ηχογράφησης, επιστρέφουμε στον κώδικα και αντικαθιστούμε στην
γραμμή που υπάρχει το “eating.wav” σε “myeating.wav” (ή όποιο όνομα δώσατε στο αρχείο). Τώρα
κάθε φορά που θα ακούγεται ο ήχος θα είναι από το αρχείο που προσθέσαμε εμείς.
Οδηγός 5: Προσθήκη τυχαία κινούμενου εχθρού
Στο τέλος του προηγούμενου οδηγού είχαμε καταλήξει στο σενάριο όπου ένα καβούρι που μπορούμε
να ελέγξουμε, κινείται κυκλικά και τρώει σκουλήκια. Αν και είναι λίγο δύσκολο να ελέγξουμε την
κίνηση του καβουριού, το παιχνίδι είναι αρκετά εύκολο. Είναι καιρός να το δυσκολέψουμε λίγο
προσθέτοντας έναν εχθρό: έναν αστακό!
Ας ξεκινήσουμε προσθέτοντας έναν αστακό που κινείται σε μία ευθεία γραμμή και τρώει καβούρια.
Μπορούμε να το κάνουμε με κώδικα που έχουμε ήδη χρησιμοποιήσει προηγουμένως. Αρχικά
δημιουργούμε την κλάση Lobster κάνοντας δεξί κλικ στην κλάση Actor=> new subclass και δίνοντας
στην καινούργια κλάση το όνομα Lobster. Η εικόνα του αστακού βρίσκεται στη λίστα με τις εικόνες
στα αριστερά.
Έχοντας δημιουργήσει την κλάση Lobster, μπορούμε να περάσουμε τον απαραίτητο κώδικα για την
κίνηση και το φάγωμα του καβουριού. Όλα τα βήματα αυτά έχουν γίνει στους προηγούμενους
οδηγούς, οπότε δε παραθέτουμε κάποια εικόνα ή κάποιο κώδικα. Δοκιμάστε και αν δεν τα
καταφέρετε μπορείτε να δείτε τον κώδικα εδώ.
Μπορούμε να ελέγξουμε ότι ο αστακός συμπεριφέρεται όπως τον έχουμε προγραμματίσει,

τοποθετώντας έναν στα αριστερά ενός καβουριού, ξεκινώντας την εκτέλεση (Run) και αφήνοντας και
τους δύο να κινούνται στο δεξί μέρος του κόσμου όπου ο αστακός θα φάει τελικά το καβούρι.
Όλα καλά, αλλά ο αστακός μας δεν είναι και πολύ έξυπνος, αφού είναι εύκολο να τον αποφύγουμε
κινούμενοι κυκλικά δεξιά ή αριστερά με τα αντίστοιχα πλήκτρα. Επίσης, μόλις ο αστακός φτάσει στη
δεξιά άκρη του κόσμου, σταματάει, όπως έκανε και το καβούρι σε προηγούμενο οδηγό.
Ας δυσκολέψουμε λίγο το παιχνίδι, εισάγοντας λίγη τυχαιότητα στην κίνηση του αστακού. Το
Greenfoot μας παρέχει μία συνάρτηση ‘Greenfoot.getRandomNumber’ η οποία μας επιστρέφει έναν
τυχαίο αριθμό. Μια πρώτη δοκιμή στη συνάρτηση turn, όπου παράγουμε έναν τυχαίο αριθμό σαν
όρισμα της και επιτυγχάνουμε τυχαία στροφή περίπου ανά frame είναι η παρακάτω:
Με τον κώδικα αυτό έχουμε τυχαία στροφή σε κάθε frame κατά γωνία ανάμεσα σε 0
(συμπεριλαμβανομένου του 0) και 90 (χωρίς να συμπεριλαμβάνεται το 90) μοίρες (0 ≤ φ < 90).
Δοκιμάζοντάς τον κώδικα μας παρατηρούμε πως ο εχθρός που δημιουργήσαμε δεν είναι και πολύ
απειλητικός: ο αστακός περιστρέφεται ως επί το πλείστον σε ένα σημείο και γυρίζει πάντα προς τα
δεξιά. Ας διορθώσουμε αυτά τα προβλήματα ένα-ένα, ξεκινώντας με την περιστροφή γύρω από ένα
σημείο.
Μέχρι στιγμής, ο αστακός μας κινείται σε κάθε frame, κάτι που τον κάνει να περιστρέφεται και όχι να
περιπλανιέται. Υπάρχουν διάφοροι τρόποι, με τους οποίους θα μπορούσε να περιστρέφεται λιγότερο

συχνά. Μία λύση είναι να χρησιμοποιήσουμε μια μεταβλητή – μετρητή η οποία θα καταγράφει τον
χρόνο που πέρασε από την προηγούμενη περιστροφή, και να γίνεται στροφή για παράδειγμα κάθε 10
frames. Ένας άλλος τρόπος είναι να χρησιμοποιήσουμε μια γεννήτρια τυχαίων αριθμών για να γυρίζει
τυχαία, με μια ορισμένη συχνότητα (π.χ. κάθε 10 καρέ). Ας δούμε την χρήση της γεννήτριας τυχαίων
αριθμών, για να κάνουμε ένα λιγότερο προβλέψιμο αστακό.
Ας πούμε ότι ο αστακός έχει 10% πιθανότητα να περιστρέφεται ανά frame. Μπορούμε να το
προγραμματίσουμε αυτό, συγκρίνοντας το Greenfoot.getRandomNumber(100) με ένα δεδομένο
ποσοστό. Για το παράδειγμα μας, αφού το ποσοστό είναι 10%, θα συγκρίνουμε το
Greenfoot.getRandomNumber(100) με το 10:
Προσπαθήστε να σκεφτείτε πως δουλεύει ο παραπάνω κώδικας και, ιδιαίτερα, γιατί χρησιμοποιούμε
το σύμβολο < αντί για <=. Θα μπορούσαμε να το υλοποιήσουμε αυτό με διαφορετικό τρόπο;
Για παράδειγμα χρησιμοποιώντας Greenfoot.getRandomNumber(50) ή

Greenfoot.getRandomNumber(10); Τι γίνεται με: Greenfoot.getRandomNumber(5);
Ο παραπάνω κώδικας μας θα κάνει τον αστακό μας να γυρίζει (κατά μέσο όρο) κάθε 10 καρέ. Αν το
μεταγλωττίσουμε, θα δούμε πως ο αστακός κινείται κυρίως σε μια ευθεία, περιστασιακά στρίβοντας
δεξιά. Αυτό είναι αποδεκτό, και μας φέρνει πίσω στο άλλο πρόβλημά μας: ο αστακός γυρίζει πάντα
δεξιά.
Γνωρίζουμε από το καβούρι μας ότι ο τρόπος για να στρίψει αριστερά είναι να χρησιμοποιήσουμε
έναν αρνητικό αριθμό για τη γωνία. Αν μπορούσαμε να αλλάξουμε τη στροφή του αστακού μας από
την εμβέλεια 0ο έως 90 ο στην εμβέλεια -45 ο έως 45 ο, θα έφτιαχνε το πρόβλημα μας.
Υπάρχουν αρκετοί τρόποι για να επιτευχθεί αυτό, αλλά θα δούμε τον απλούστερο, κατά τη γνώμη
μας: Κοιτάξτε ότι εάν αφαιρέσουμε από τον τυχαία παραγόμενο αριθμό το 45, θα καταλήξουμε με
έναν αριθμό στη σωστή εμβέλεια. Ας προσαρμόσουμε λοιπόν ανάλογα τον κώδικα μας:

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

προγραμματίζοντας τους να κάνουν στροφή 180 μοιρών μόλις φτάσουν στην άκρη του κόσμου. Για να
ελέγξουμε αν είναι στην άκρη του κόσμου μπορούμε να κοιτάξουμε αν η συντεταγμένη Χ τους είναι
κοντά στο μηδέν, ή κοντά στο πλάτος του κόσμου. Κατόπιν, χρησιμοποιούμε παρόμοια λογική για την
συντεταγμένη Υ (και το ύψος του κόσμου, αυτήν την φορά). Ο κώδικας είναι παρακάτω:
Με αυτό τελειώνουμε και τον οδηγό για τα καβούρια. Μπορείτε να πειραματιστείτε, προσθέτοντας
νέα χαρακτηριστικά (όπως ένας δεύτερος παίχτης), ή να χρησιμοποιήσετε ότι μάθατε για να
δημιουργήσετε ένα νέο σενάριο.
Προσβασιμότητα ενός αντικειμένου από ένα άλλο

Μια συνήθης ερώτηση που ρωτάνε οι αρχάριοι στο
Greenfoot είναι:
Πώς μπορώ να έχω πρόσβαση στις μεταβλητές (ή τις

μεθόδους) ενός αντικειμένου/κλάσης από μία άλλη;
Φυσικά η διατύπωση της ερώτησης συνήθως γίνεται
διαφορετικά, αφού συνήθως οι αρχάριοι τις έννοιες
“μεταβλητή” ή “αντικείμενο” δεν τις κατανοούν πλήρως.
Συνεπώς, η ερώτησh για το παιχνίδι που βλέπετε στην

εικόνα, μπορεί να τεθεί ως εξής: Πώς μπορώ να ενημερώνω το σκορ κάθε φορά που ένας
αστεροειδής καταστρέφεται από έναν πύραυλο;
Ας δούμε το παρακάτω σενάριο στο Greenfoot:
tut-access-p1 (ανοίγουμε τον σύνδεσμο σε νέο παράθυρο ή νέα καρτέλα) Το σενάριο αυτό είναι ένα
απλό παιχνίδι όπου, όταν πατάμε το πλήκτρο του κενού (Space bar) ένας πύραυλος πυροβολεί τους
αστεροειδής που περνάνε. Επίσης, υπάρχει ένας μετρητής του σκορ, αλλά δεν λειτουργεί ακόμα.
Ανοίγουμε το σενάριο από την τοποθεσία στον υπολογιστή μας όπου κατεβάσαμε το αρχείο και
ξεκινάμε.
Στο παράδειγμα αυτό, υπάρχουν διάφορες κλάσεις όπως “Counter”, “Rocket” και “Shot”. Η κλάση
Counter έχει μια μέθοδο “bumpCount()” η οποία αυξάνει το σκορ που εμφανίζει ο μετρητής:
Δεν πειράζει αν δεν καταλαβαίνετε ακόμα τον κώδικα. Το σημαντικό που πρέπει να κρατήσουμε είναι
το εξής: αν καλέσουμε την μέθοδο bumpCount(), ο αριθμός που εμφανίζει ο μετρητής θα αυξηθεί
κατά το ποσό που έχουμε καθορίσει κατά την κλήση της συνάρτησης (δηλαδή το amount στο
παραπάνω πρόγραμμα).
Στην κλάση Shot τώρα, μπορούμε να έχουμε μία μέθοδο η οποία και θα καλείται από την μέθοδο act()
της ίδιας κλάσης, όποτε χτυπάμε έναν αστεροειδή:

Ανοίγουμε την επεξεργαστή της κλάσης Shot (διπλό κλικ στην κλάση “Shot” στα δεξιά ή δεξί κλικ και
Open Editor). Αν προσπαθήσουμε να καλέσουμε απλά τη μέθοδο “bumpCount” από την κλάση
Counter, στην μεταγλώττιση λαμβάνουμε σφάλμα:
Λαμβάνουμε το σφάλμα αυτό γιατί ο μεταγλωττιστής ψάχνει μόνο στην ίδια κλάση (την Shot) για την
“bumpCount()” μέθοδο, η οποία φυσικά και δεν υπάρχει σε αυτή την κλάση. Επομένως, θα πρέπει με
κάποιο τρόπο να πούμε στον μεταγλωττιστή να ψάξει για τη μέθοδο “bumpCount()” στην κλάση
Counter. Πριν συνεχίσουμε, αφαιρούμε τον κώδικα κλήσης της μεθόδου “bumpCount()” από τη
μέθοδο “hitAnAsteroid()” ώστε να αποφύγουμε το παραπάνω σφάλμα μεταγλώττισης.
Λύση: Αποθήκευση της αναφοράς στον κόσμο σε δημιουργία του αντικειμένου
Σε αυτή τη λύση, θα αποθηκεύσουμε μια αναφορά στο μετρητή του σκορ στον κόσμο, ώστε να
μπορούμε να τον ανακτήσουμε από εκεί όποτε αυτό χρειαστεί.
Ας δούμε τον κατασκευαστή (constructor) στην κλάση “Space”:

Όπως βλέπετε είναι μια μέθοδος που δεν επιστρέφει κάποια τιμή και έχει το ίδιο όνομα με την κλάση.
Στη συνέχεια, πρέπει να μεριμνήσουμε για δύο πράγματα: αρχικά, να δηλώσουμε ένα πεδίο όπου θα
αποθηκεύσουμε την αναφορά στον μετρητή και μετά να εκχωρίσουμε τη μεταβλητή αυτή όταν
δημιουργείται ο μετρητής.
Αφού σιγουρευτούμε ότι ο κώδικας μεταγλωττίζεται κανονικά, παρατηρούμε ότι έχουμε προσθέσει
μια δήλωση για μια μεταβλητή “theCounter”. Πρόκειται για μια μεταβλητή στιγμιότυπου, που
σημαίνει ότι θέλουμε να κρατήσουμε την τιμή της για όσο υπάρχει ο κόσμος, γι ‘αυτό δηλώνεται
εκτός του κατασκευαστή SpaceWorld (αλλά εντός της κλάσης SpaceWorld).
Τώρα προσθέτουμε μια μέθοδο στην κλάση Space που λαμβάνει την τιμή του “theCounter” ώστε να
μπορεί αυτή να είναι προσβάσιμη από τον πύραυλο.
Τώρα μπορούμε να έχουμε πρόσβαση στον κόσμο από την κλάση Shot και να καλέσουμε την μέθοδο
getCounter() στον κόσμο έτσι ώστε να αποκτήσουμε μια αναφορά στον μετρητή μας. Τέλος καλούμε
τη μέθοδο bumpCount() στην αναφορά του μετρητή μας.
Σύμφωνα με τα παραπάνω, η μέθοδος hitAnAsteroid() στην κλάση Shot που περιλαμβάνει όλα τα
παραπάνω, θα πρέπει να είναι:

Λύσαμε λοιπόν το πρόβλημα μας. Τώρα, όταν ένα επιτυχημένο χτύπημα σε αστεροειδή πρέπει να
αυξήσει τον μετρητή, θα ζητάει μία αναφορά από τον κόσμο, και μετά θα τροποποιεί τον μετρητή
χρησιμοποιώντας την αναφορά αυτή. Όλη η λύση είναι διαθέσιμη εδώ:
tut-access-p2

Παράρτημα Α: Λήψη, εγκατάσταση και χρήση του Greenfoot
Για την λήψη του Greenfoot μεταβαίνουμε με τον περιηγητή μας στον ιστότοπο του προγράμματος
και επιλέγουμε την λήψη (download). Όπως βλέπουμε και στον ιστότοπο για να μπορέσουμε να
χρησιμοποιήσουμε το πρόγραμμα πρέπει να έχουμε εγκατεστημένη την έκδοση 7 ή 8 του Java
Development Kit (JDK), το οποίο μπορούμε να κατεβάσουμε ξεχωριστά ή μαζί με το αρχείο
εγκατάστασης του Greenfoot. Αφού εγκαταστήσουμε το JDK και κατεβάσουμε το Greenfoot,
προχωράμε στη διαδικασία εγκατάστασης του τελευταίου:
Κατά την πρώτη εκκίνηση του προγράμματος, εμφανίζεται ένας διάλογος,

απ’ όπου επιλέγουμε τι θέλουμε να κάνουμε. Επειδή, αν επιλέξουμε την
πρώτη (Open tutorial and tutorial scenario) ή την δεύτερη (Choose a
scenario) επιλογή και ανοίξουμε ένα από τα σενάρια που βρίσκονται στον
φάκελο εγκατάστασης, θα λάβουμε μια προειδοποίηση που σχετίζεται με τα
δικαιώματα ανάγνωσης και γραφής στον φάκελο αυτό, όπου θα πρέπει να
δημιουργήσουμε έναν νέο φάκελο για το σενάριο που θα ανοίξουμε,

μπορούμε εκ των προτέρων να έχουμε ένα αντίγραφο των σεναρίων σε
κάποιον άλλο φάκελο όπου έχουμε όλα τα δικαιώματα, και να ανοίγουμε τα
σενάρια που θέλουμε από εκεί.

Παράρτημα Β: Χρήσιμοι σύνδεσμοι
Περιεχόμενο συνδέσμου Σύνδεσμος

Φάκελοι και αρχεία που
χρησιμοποιήθηκαν στους http://networklab.teipir.gr/cnlab/files/greenfoot-guide-files.rar
οδηγούς του εγγράφου αυτού
Ο Δικτυακός τόπος λήψης της
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Java
Δικτυακός χώρος του Greenfoot http://www.greenfoot.org/
To API του Greenfoot http://www.greenfoot.org/files/javadoc/

Εισαγωγή στο πρόγραμμα DrJava1
Version 2.0
Επιμέλεια:
Κόγιας Δημήτρης,
Χαράλαμπος Πατρικάκης,
Aliaksandr Barushka
1
Το κείμενο έχει γραφτεί χρησιμοποιώντας υλικό από τις οδηγίες για τους χρήστες του προγράμματος DrJava που
είναι διαθέσιμες στη σελίδα http://drjava.org
Εργαστήριο Αντικειμενοστραφούς προγραμματισμού [1]
Πίνακας Περιεχομένων
Κεφάλαιο 1. Εισαγωγή ........................................................................................................................................... 4

Κεφάλαιο 2. Οδηγίες Εγκατάστασης ..................................................................................................................... 4
Φιλοσοφία ......................................................................................................................................................... 4
Κατεβάζοντας και Εγκαθιστώντας το DrJava ..................................................................................................... 4
Τρέχοντας το DrJava σε Windows ...................................................................................................................... 4
Απαιτήσεις ......................................................................................................................................................... 4
Κεφάλαιο 3. Γράφοντας Προγράμματα ................................................................................................................. 6
Παράθυρο Ορισμών (Definitions Pane) ............................................................................................................. 6
Σύνταξη Κώδικα με Χρώματα ............................................................................................................................ 6
Αυτόματη Ενδοπαραγραφοποίηση ................................................................................................................... 7
Συνδυασμός Παρενθέσεων και Αγκυλών σε ζευγάρια...................................................................................... 7
Δημιουργία Σχολίων και Αφαίρεση αυτών ........................................................................................................ 7
Αυτόματη Συμπλήρωση ..................................................................................................................................... 7
Πολλαπλά Αρχεία............................................................................................................................................... 7
Αρίθμηση Γραμμών ............................................................................................................................................ 8
Σελιδοδείκτες (bookmarks) ................................................................................................................................ 8
Κεφάλαιο 4. Δημιουργία Ενός Project ................................................................................................................... 9
Δημιουργία Καινούργιων Project ...................................................................................................................... 9
Αποθήκευση ενός Project .................................................................................................................................. 9
Άνοιγμα ενός Project ......................................................................................................................................... 9
Μεταγλώττιση (Compile) ενός Project ............................................................................................................ 10
Ελέγχοντας τη λειτουργία ενός Project ........................................................................................................... 10
Εκτέλεση ενός Project ...................................................................................................................................... 10
Δημιουργία Αρχείου Jar Από το Project .......................................................................................................... 10
Ιδιότητες Ενός Project: Η Ρίζα του ................................................................................................................... 10
Ιδιότητες Ενός Project: Φάκελος Build ............................................................................................................ 10
Ενεργός Φάκελος ............................................................................................................................................. 11
Κλάση Main ...................................................................................................................................................... 11
Κεφάλαιο 5. To Παράθυρο Αλληλεπίδρασης ...................................................................................................... 12
Πως Χρησιμοποιείται ....................................................................................................................................... 12
Τρέχοντας τη Μέθοδο Main ............................................................................................................................ 13
Κεφάλαιο 6. Μεταγλώττιση Προγραμμάτων ...................................................................................................... 14
Μεταγλωττίζοντας Αρχεία ............................................................................................................................... 14
Βλέποντας τα Σφάλματα της Μεταγλώττισης ................................................................................................. 14
Επιλέγοντας Μεταγλωττιστή ........................................................................................................................... 14
Κεφάλαιο 7. Εντοπισμός Σφαλμάτων (Debugging) ............................................................................................. 16

Χρησιμοποιώντας τον Εντοπισμό Σφαλμάτων ................................................................................................ 16
Σημεία Διακοπής (Breakpoints ) ...................................................................................................................... 16
Panel Σημάτων Διακοπής ................................................................................................................................. 17
Αλληλεπίδραση σε Ένα Σημείο Διακοπής ........................................................................................................ 17
Βηματική ή ολική εκτέλεση ............................................................................................................................. 17
Το Panel του Εντοπισμού Σφαλμάτων (Debug Panel) ..................................................................................... 18
Παρακολουθώντας Πεδία και Μεταβλητές ..................................................................................................... 18
Κεφάλαιο 8. Δημιουργία Τεκμηριώσεων (documentation) με Χρήση του Javadoc ........................................... 19
Γράφοντας Σχόλια σε Javadoc ......................................................................................................................... 19
Απλά Σχόλια ..................................................................................................................................................... 19
Χρήση Ετικετών ................................................................................................................................................ 20
Κεφάλαιο 9. Το Πρώτο Πρόγραμμα στο DrJava .................................................................................................. 21

Κεφάλαιο 1. Εισαγωγή
Το DrJava είναι ένα περιβάλλον προγραμματισμού σε Java, που προορίζεται κυρίως για να
βοηθήσει τους σπουδαστές να επικεντρωθούν περισσότερο στο σχεδιασμό ενός προγράμματος και
όχι τόσο στην κατανόηση των χαρακτηριστικών για τη χρήση ενός περίπλοκου περιβάλλοντος
ανάπτυξης (Integrated Development Environment). Ταυτόχρονα, όμως, το πρόγραμμα παρέχει και
πολλά προηγμένα χαρακτηριστικά χρήσιμα για έμπειρους προγραμματιστές. Αυτά τα
χαρακτηριστικά επικεντρώνονται γύρω από το Παράθυρο Αλληλεπίδρασης (Interactions Pane) του
DrJava, το οποίο επιτρέπει στους χρήστες να αναπτύσσουν εύκολα προγράμματα σε Java και να
κάνουν δοκιμές και ελέγχους σφαλμάτων με ένα διαδραστικό τρόπο.
Κεφάλαιο 2. Οδηγίες Εγκατάστασης

Το κεφάλαιο αυτό περιγράφει τα βασικά για το πώς να εγκαταστήσετε και να χρησιμοποιήσετε το
DrJava.
Φιλοσοφία
Η γενική ιδέα πίσω από το DrJava είναι να αποτελέσει ένα ισχυρό εργαλείο ανάπτυξης, το οποίο να
μπορεί να χρησιμοποιηθεί όσο γίνεται πιο εύκολα.
Για το λόγο αυτό, το DrJava είναι απλό για να το τρέξει και να το καταλάβει ο χρήστης,
χρησιμοποιώντας μια απλή διεπαφή χρήστη, ευκολόχρηστα παράθυρα και μια ευανάγνωστη
γραμμή εργαλείων. Επιπλέον, επιδιώκει τη διευκόλυνση των αρχάριων χρηστών στην εξοικείωση
τους με τη σύνταξη κώδικα Java, επιτρέποντάς τους να αξιολογούν γρήγορα εκφράσεις στο
Παράθυρο Αλληλεπίδρασης του DrJava.
Κατεβάζοντας και Εγκαθιστώντας το DrJava

Μπορείτε να κατεβάσετε τις τελευταίες κυκλοφορίες του DrJava ως αρχείο .jar από τη σελίδα
http://www.drjava.org/ ή από τη σελίδα http://sourceforge.net/projects/drjava/ του SourceForge.
Τρέχοντας το DrJava σε Windows

Εάν χρησιμοποιείτε Windows, μπορείτε να κατεβάσετε DrJava ως ένα εκτελέσιμο αρχείο από την
ιστοσελίδα που δόθηκε και έπειτα μπορείτε να το τρέξετε σαν ένα κανονικό πρόγραμμα των
Windows.
Απαιτήσεις
Το DrJava απαιτεί Java 5 ή νεότερη έκδοση. Σημειώστε ότι θα πρέπει να έχετε εγκατεστημένο το JDK
(όχι το JRE), εάν επιθυμείτε να χρησιμοποιήσετε το πρόγραμμα εντοπισμού σφαλμάτων (debugger)
ή να δημιουργήσετε Javadoc εντός DrJava. Σας συνιστούμε να κατεβάσετε και να χρησιμοποιήσετε
το τελευταίο JDK για την ομαλή λειτουργία του προγράμματος.

Κατέβασμα του αρχείου από την επίσημη σελίδα της εφαρμογής

Κεφάλαιο 3. Γράφοντας Προγράμματα
Βασική συνιστώσα του DrJava είναι ένας editor για το γράψιμο κώδικα σε Java. Όπως και οι
περισσότεροι συντάκτες κειμένου (text editors), έτσι και το DrJava υποστηρίζει ένα ευρύ φάσμα
χαρακτηριστικών σύνταξης, όπως "Find/Replace", "Go to Line", "Go to File", καθώς επίσης και την
παροχή περισσοτέρων προηγμένων χαρακτηριστικών που θα συζητήσουμε στη συνέχεια.
Το περιβάλλον της εφαρμογής
Παράθυρο Ορισμών (Definitions Pane)

Το παράθυρο ορισμών είναι το κύριο παράθυρο του DrJava, καθώς σε αυτό εμφανίζεται το ενεργό
πηγαίο αρχείο (source file) στο οποίο δουλεύουμε. Κατά την επεξεργασία ενός αρχείου σε αυτό το
παράθυρο, το DrJava βοηθά με πολλές χρήσιμες λειτουργίες.
Σύνταξη Κώδικα με Χρώματα

Το DrJava χρωματίζει ειδικούς τύπους του κειμένου με διαφορετικό χρώμα για να βοηθήσει να γίνει
πιο εμφανής η δομή του προγράμματος. Τα σχόλια εμφανίζονται με πράσινο χρώμα, ενώ οι λέξεις-
κλειδιά και οι τύποι εμφανίζονται με μπλε χρώμα. Τα strings εμφανίζονται με κόκκινο και οι
χαρακτήρες με σκούρο μωβ (magenta), ενώ όλο το άλλο κείμενο με μαύρο χρώμα. Αυτά τα
χρώματα είναι όλα ρυθμιζόμενα.
Μια αξιοσημείωτη διαφορά μεταξύ της σύνταξης κώδικα με χρώματα του DrJava και άλλων κοινών
editors (π.χ., το Emacs), είναι ότι το DrJava χρησιμοποιεί πλήρως σωστό (fully correct) χρωματισμό
κατά την επεξεργασία του εγγράφου. Για παράδειγμα, πληκτρολογώντας απλά την αρχή ενός
σχολίου μπλοκ ("/*") θα ενημερώσει αμέσως το χρωματισμό του συνολικού εγγράφου, σε αντίθεση
με κάποιους άλλους editors, που θα ενημερώσουν μόνο το χρώμα της γραμμής που
επεξεργαζόμαστε. Η δυνατότητα προσδιορισμού μιας ακριβούς εικόνας του προγράμματος είναι
μια σημαντική πτυχή στην κατανόηση της δομής του.

Αυτόματη Ενδοπαραγραφοποίηση
Το κλειδί για να δημιουργήσουμε τα απαραίτητα κενά σε κώδικα στο DrJava, είναι το πλήκτρο Tab.
Καθώς πληκτρολογούμε πολλές γραμμές κώδικα, το DrJava δημιουργεί εσοχές αυτόματα σε κάθε
γραμμή, χρησιμοποιώντας την ίδια λογική. Από προεπιλογή, δύο κενά (spaces) χρησιμοποιούνται
για κάθε επίπεδο εσοχής, αν και αυτό μπορεί να ρυθμιστεί και στο παράθυρο Επιλογών. (Στο DrJava
ο κώδικας έχει πάντα εσοχές με κενά σύμφωνα και με τη ρύθμιση αυτή).
Συνδυασμός Παρενθέσεων και Αγκυλών σε ζευγάρια

Για να σας βοηθήσει να ταιριάξετε τις ανοικτές με τις κλειστές παρενθέσεις, το DrJava αναδεικνύει
την περιοχή που περικλείεται ανάμεσα σε ζεύγη αυτών. Με τον τρόπο αυτόν, αν τοποθετήσετε τον
κέρσορα αμέσως μετά από μια κλειστή παρένθεση ή αγκύλη, τότε όλο το κείμενο μεταξύ εκείνου
του χαρακτήρα και της αντίστοιχης ανοικτής παρένθεσης ή αγκύλης τονίζεται σε άλλο χρώμα.
Δημιουργία Σχολίων και Αφαίρεση αυτών

Για να μπορέσετε να γράψετε εύκολα σχόλια πολλών γραμμών, το DrJava προσθέτει αυτόματα
χώρους και έναν αστερίσκο σε κάθε νέα γραμμή. Επιπλέον, υπάρχει μια επιλογή στην ενότητα
"Miscellaneous" του παραθύρου Επιλογών (Preferences), η οποία χρησιμοποιείται για να κλείσει
αυτόματα τα σχόλια πολλαπλών γραμμών. Σχολιάζοντας ένα μπλοκ του κώδικα σας, το DrJava θα
προσθέσει "//" δείκτες στην αρχή της κάθε γραμμής στο μπλοκ, διατηρώντας παράλληλα την
ενδοπαραγραφοποίηση του κώδικα.
Αυτόματη Συμπλήρωση
Το DrJava υποστηρίζει μια πολύ περιορισμένη έννοια της αυτόματης συμπλήρωσης μιας λέξης, που
είναι ωστόσο πολύ χρήσιμη. Αυτό το χαρακτηριστικό ενεργοποιείται με την επιλογή "Auto-
Complete Word Under Cursor" στο Edit μενού και ως προεπιλεγμένη συντόμευση πληκτρολογίου με
την χρήση των πλήκτρων Ctrl-Shift-Space.
Όταν το καλέσουμε το DrJava θα εξετάσει τη λέξη στα αριστερά του κέρσορα και θα προσπαθήσει
να την ολοκληρώσει. Αν δεν υπάρχει ένα μοναδικό ταίρι, το DrJava εμφανίζει ένα προβλεπόμενο
διάλογο επιλογής με τις υποψήφιες εντολές συμπλήρωσης. Επίσης, όταν ένα project είναι ανοιχτό,
το DrJava μπορεί να ρυθμιστεί ώστε να σαρώσει όλα τα αρχεία των κλάσεων και μετά από μια
μεταγλώττιση να αποκτήσει τις απαραίτητες πληροφορίες ολοκλήρωσης. Με αυτό το σύνολο
επιλογών, το DrJava μπορεί αυτόματα να ολοκληρώσει τα ονόματα όλων των τάξεων στο έργο σας,
ακόμη και εκείνων των εσωτερικών τάξεων.
Πολλαπλά Αρχεία
Τα περισσότερα προγράμματα Java είναι γραμμένα σε πολλά συγγενή πηγαία αρχεία, έτσι το DrJava
υποστηρίζει το ταυτόχρονο άνοιγμα πολλών αρχείων. Μια λίστα με τα ονόματα όλων των ανοιχτών
εγγράφων εμφανίζεται σε ένα παράθυρο προς τα αριστερά, ταξινομώντας τα αρχεία με τη σειρά
που έχουν ανοιχτεί. Μπορείτε να δείτε και να επεξεργαστείτε ένα συγκεκριμένο έγγραφο
επιλέγοντάς το από τη λίστα, ή χρησιμοποιώντας τις εντολές Previous και Next Document του Edit
menu.
Η πλήρης διαδρομή του αρχείου του τρέχοντος εγγράφου εμφανίζεται στη γραμμή τίτλου και στη
γραμμή κατάστασης στο κάτω μέρος του παραθύρου.

Αρίθμηση Γραμμών
Το DrJava εμφανίζει τον τρέχοντα αριθμό της γραμμής και της στήλης του δρομέα στη δεξιά πλευρά
της γραμμής κατάστασης στο κάτω μέρος του παραθύρου. Ο αριθμός της γραμμής παρουσιάζεται
στα αριστερά και ξεκινά από 1, και ο αριθμός της στήλης εμφανίζεται στα δεξιά και ξεκινά από 0.
Σελιδοδείκτες (bookmarks)
Το DrJava σας επιτρέπει να θέσετε σελιδοδείκτες στον κώδικά σας στα σημεία που θεωρείτε
σημαντικά. Πατώντας Ctrl-Shift-M ή χρησιμοποιώντας το στοιχείο "Bookmarks" στο μενού
Εργαλείων (Tools menu), μπορείτε να εμφανίσετε τη λίστα των σελιδοδεικτών στο παράθυρο
"Bookmarks". Οι σελιδοδείκτες ταξινομούνται με το έγγραφο και τον αριθμό της γραμμής.
Με τη συντόμευση πληκτρολογίου Ctrl-M ή το "Toggle Bookmark" από το μενού Εργαλείων,
μπορείτε να προσθέσετε και να αφαιρέσετε σελιδοδείκτες. Αν δεν έχει επιλεγεί κείμενο, το "Toggle
Bookmark" θα προσθέσει ή θα αφαιρέσει ένα σελιδοδείκτη για ολόκληρη τη γραμμή που βρίσκεται
ο κέρσορας. Εάν έχει επιλεγεί κείμενο, τότε ο σελιδοδείκτης θα προστεθεί στο κείμενο αυτό.
Με την επιλογή ενός σελιδοδείκτη στο παράθυρο "Bookmarks" και πατώντας το κουμπί "Go to",
μπορείτε να μεταβείτε στη θέση που σχετίζεται με το σελιδοδείκτη. Μπορείτε επίσης να επιλέξετε
έναν ή περισσότερους σελιδοδείκτες και να τα αφαιρέσετε με το κουμπί "Remove" ή να διαγράψετε
ολόκληρη τη λίστα με το κουμπί "Remove All".

Κεφάλαιο 4. Δημιουργία Ενός Project
Το DrJava περιλαμβάνει τη δυνατότητα δημιουργίας project για τη διαχείριση πολλών αρχείων. Η
δυνατότητα αυτή σας επιτρέπει να αποθηκεύσετε τα ανοιχτά σας αρχεία σε ένα αρχείο project και
να ανοίξτε ξανά αυτό το αρχείο σε μεταγενέστερο χρόνο για να το επεξεργαστείτε.
Δημιουργία Καινούργιων Project

Για να δημιουργήσετε ένα καινούργιο project είτε επιλέξτε "New" στο Project menu για ένα project
που είναι αρχικά άδειο ή επιλέξτε "Save As" στο Project menu, όταν έχετε ένα ή περισσότερα
αρχεία ήδη ανοιχτά. Η επιλογή "Save As" στο Project menu θα δημιουργήσει ένα νέο project από τα
ανοιχτά αρχεία.
Δημιουργία καινούργιου project
Αποθήκευση ενός Project

Για να αποθηκεύσετε ένα project είτε επιλέξτε "Save" στο Project menu είτε επιλέξτε "Save As" στο
Project menu. Σημειώστε ότι όταν αποθηκεύετε το project, αποθηκεύει μόνο τη λίστα των αρχείων
που βρίσκονται στο project και όχι τα αρχεία τα ίδια. Αποθήκευση του project δε σημαίνει
αποθήκευση των αρχείων τα οποία είναι μέλη του project. Χρησιμοποιήστε το "Save All", αν θέλετε
να αποθηκεύσετε όλα τα αρχεία, καθώς και το αρχείο του project στο οποίο ανήκουν.
Με την αποθήκευση ενός project, θα διατηρηθεί επίσης η διάταξη (layout) του δέντρου του project
(project tree), έτσι ώστε αν ορισμένοι φάκελοι (folders) κατέρρευσαν όταν γινόταν η αποθήκευση
του project, τότε οι φάκελοι αυτοί θα είναι στις ίδιες θέσεις την επόμενη φορά που θα ανοίξει αυτό.
Άνοιγμα ενός Project

Για να ανοίξετε ένα project, επιλέξτε "Open" στο Project menu και στη συνέχεια επιλέξτε ένα
πρόσφατα αποθηκευμένο αρχείο project. Μπορείτε επίσης να επιλέξετε να ανοίξετε ένα από τα
πρόσφατα ανοιγμένα projects. Απλά ανοίξτε το Project Menu και κάντε κλικ στο όνομα του project,
έτσι ώστε να ανοίξετε αυτό.

Μεταγλώττιση (Compile) ενός Project
Υπάρχουν δύο επιλογές για να μεταγλωττίσετε ένα project: να μεταγλωττίσετε τα ανοιχτά αρχεία
του project ή να μεταγλωττίσετε ολόκληρο το project. Για να μεταγλωττίσετε τα ανοιχτά αρχεία του
project επιλέξτε "Compile Open Project Files" στο Project menu ή κάντε δεξί κλικ στη ρίζα του
δέντρου και επιλέξτε "Compile Open Project Files."
Ομοίως, για να μεταγλωττίσετε όλα τα αρχεία του project, ακόμα κι αν αυτά δεν είναι ανοικτά
εκείνη τη στιγμή στο DrJava, επιλέξτε "Compile Project" από το Project Menu. Επίσης, με το κουμπί
"Compile All" μεταγλωττίζονται όλα τα ανοιχτά αρχεία (files), αν και στο project view, το κουμπί
αυτό μεταγλωττίζει μόνο το ανοικτό project.
Ελέγχοντας τη λειτουργία ενός Project

Υπάρχουν δύο επιλογές για τον έλεγχο ενός project: να ελέγξετε τα ανοιχτά αρχεία του project ή να
ελέγξετε ολόκληρο το project. Για να ελέγξετε όλα τα ανοιχτά αρχεία του project, επιλέξτε "Test
Open Project Files" στο Project menu. Αυτή η διαδικασία θα δοκιμάσει όλα τα ανοιχτά JUnit αρχεία
ελέγχου (test files) στο Source Files project branch, καθώς και τα Auxiliary Files. Δε θα συμβεί το
ίδιο όμως και στα αρχεία στο εξωτερικό branch (στον φάκελο των Εξωτερικών Αρχείων).
Για να ελέγξετε όλα τα αρχεία του project, συμπεριλαμβανομένων και των αρχείων που δεν είναι
ανοικτά στο DrJava, επιλέξτε "Test Project" στο project menu. Με αυτήν τη διαδικασία θα
αναζητηθούν στον φάκελο του project τα αρχεία πηγής και θα δοκιμαστούν όλα όσα βρέθηκαν σ’
αυτήν την περίπτωση. Επίσης, θα δοκιμαστούν όλα τα αρχεία ελέγχου στο φάκελο των Βοηθητικών
αρχείων (Auxiliary Files) του project.
Εκτέλεση ενός Project

Για να εκτελέσετε τη main μέθοδο ενός project, επιλέξτε "Run Main Class" από το Project menu.
Αυτή η επιλογή είναι διαθέσιμη μόνο εάν έχετε καθορίσει ένα αρχείο που περιέχει τη main μέθοδο
του project στο παράθυρο διαλόγου "Project Properties" από το Project menu.
Δημιουργία Αρχείου Jar Από το Project

Μπορείτε να δημιουργήσετε ένα αρχείο τύπου jar που να περιέχει τον πηγαίο κώδικα του project,
τα μεταγλωττισμένα (compiled) αρχεία κλάσεων, ή και τα δύο με επιλογή του "Create Jar File from
Project" από το Project menu. Αυτό θα εμφανίσει ένα παράθυρο διαλόγου που σας επιτρέπει να
ορίσετε την τοποθεσία που θα αποθηκευτεί το αρχείο jar και να ορισθεί τι μπορεί να τεθεί σε αυτό.
Αν τοποθετήσετε αρχεία κλάσεων στο αρχείο jar, μπορείτε να κάνετε εκτελέσιμο το αρχείο αυτό
επιλέγοντας "Make executable" και εισάγοντας την κλάση main.
Ιδιότητες Ενός Project: Η Ρίζα του

Η ρίζα του project καθορίζει τον φάκελο που αντιστοιχεί στο προεπιλεγμένο πακέτο του project.
Όλα τα αρχεία του project θα πρέπει να βρίσκονται σε αυτό τον φάκελο ή σε έναν υποφάκελο
αυτού.
Ιδιότητες Ενός Project: Φάκελος Build

Το project facility επιτρέπει στο χρήστη να ορίσει φάκελο χτισίματος (build), όπου θα γίνεται η
διαμόρφωση στα αρχεία των κλάσεων. Αυτό δίνει στο χρήστη τη δυνατότητα να διαχωρίσει τα
αρχεία πηγαίου κώδικα και τα αρχεία των κλάσεων. Αυτή η ρύθμιση απαιτείται για να
λειτουργήσουν σωστά τα χαρακτηριστικά "Clean Build Directory" και "Create Jar from Project". Για
να καθαρίσετε τον φάκελο build, ανοίξτε το Project Menu και κάνετε κλικ στο "Clean Build
Directory." Αυτό θα αφαιρέσει όλα τα αρχεία κλάσεων και τα κενά αρχεία από τον φάκελο build.
Ενεργός Φάκελος
Ο ενεργός φάκελος αντιστοιχεί στον «τρέχοντα» φάκελο του project.
Κλάση Main
Το project facility επιτρέπει στο χρήστη να καθορίσει μια κλάση "Main" για το project. Όταν πατηθεί
το πλήκτρο "Run Project" ή το"Run Main Class of Project" τότε στη συνέχεια επιλέγεται στο Project
menu, η μέθοδος main της "Κλάσης Main" και εκτελείται. Αν δεν έχει καθοριστεί η "Κλάση Main",
το στοιχείο "Run Main Document of Project" δεν θα είναι διαθέσιμο, και το κουμπί "Run Project"
αντικαθίσταται από το κουμπί "Run", που τρέχει τη μέθοδο main του τρέχοντος εγγράφου.
Η "Main Class" μπορεί να οριστεί ως ένα αρχείο, χρησιμοποιώντας το αρχείο διαλόγου επιλογής ή
ως ένα πλήρως αναγνωρισμένο όνομα της κλάσης που εγγράφονται απευθείας στο πεδίο (field).
Σημειώστε ότι για να τρέξει εσωτερικές κλάσεις, το όνομα πρέπει να εισάγονται απευθείας.

Κεφάλαιο 5. To Παράθυρο Αλληλεπίδρασης
Ένα από τα βασικά χαρακτηριστικά γνωρίσματα του DrJava είναι το παράθυρο Αλληλεπίδρασης, το
οποίο σας επιτρέπει να εισάγετε και να αξιολογείτε τις δηλώσεις Java και τις εκφράσεις στη στιγμή
(on the fly). Αυτό είναι εξαιρετικά χρήσιμο για τους αρχάριους μαθητές, οι οποίοι δεν χρειάζεται
πλέον να μάθουν να γράφουν μεθόδους main, να μεταγλωττίζουν και να εκτελούν τα προγράμματα
από μια γραμμή εντολών απλά για να δοκιμάσουν πώς μια νέα κλάση ή μέθοδος συμπεριφέρεται.
Από την άποψη της διδασκαλίας, το παράθυρο Αλληλεπίδρασης είναι ένας πολύ εύκολος τρόπος
για να βοηθά τους μαθητές να μάθουν να γράφουν κώδικα σε Java, χωρίς να χρειάζεται να
εξηγήσουν την πλήρη έννοια της σύνταξης της εντολής, όπως για παράδειγμα "public static void
main" και παρέχει επίσης έναν ιδανικό τρόπο για να γίνονται παρουσιάσεις. Το παράθυρο
Αλληλεπίδρασης μπορεί επίσης να χρησιμοποιείται για να πειραματιστείτε με τα δικά σας
προγράμματα ή νέες βιβλιοθήκες ή ακόμα και για τη δημιουργία γραφικών διαδραστικών
διεπαφών χρήστη.
Παράδειγμα χρήσης του παραθύρου Αλληλεπίδρασης
Πως Χρησιμοποιείται
Το παράθυρο Αλληλεπίδρασης υποστηρίζει την εκτέλεση οποιωνδήποτε έγκυρων δηλώσεων καθώς
και την αξιολόγηση των εκφράσεων Java. Απλά ορίζετε τις μεταβλητές και τις μεθόδους κλήσης,
όπως θα κάνατε σε μια συνήθη μέθοδο, ή ακόμη ορίζετε νέες κλάσεις και μεθόδους και τις καλείτε
διαδραστικά. Σε γενικές γραμμές, κάθε δήλωση ή έκφραση που τελειώνει χωρίς ερωτηματικό θα
εμφανίσει το αποτέλεσμά της στο παράθυρο Αλληλεπίδρασης, ενώ εκείνες που τελειώνουν με ένα
ερωτηματικό θα ολοκληρωθούν χωρίς να εμφανιστεί το αποτέλεσμα.
Κάθε έξοδος του συστήματος θα πρέπει να εμφανίζεται στο παράθυρο Αλληλεπίδρασης με πράσινο
χρώμα (καθώς και στην καρτέλα Console), ενώ τα σφάλματα του συστήματος θα εμφανίζονται με
κόκκινο χρώμα από προεπιλογή. Κάθε είσοδος του συστήματος θα προκαλεί την εμφάνιση ενός
κουτιού για να εισαχθεί στο παράθυρο Αλληλεπίδρασης όπου μπορείτε να πληκτρολογήσετε ό,τι
θέλετε να διαβαστεί από το System.in. Αυτό το κείμενο θα είναι χρωματισμένο μωβ. Αυτά τα
χρώματα μπορούν να τροποποιηθούν στην ενότητα "Colors" από το παράθυρο Preferences.

Μπορείτε να δείτε στη συνέχεια ένα παράδειγμα για την χρήση του παραθύρου Αλληλεπίδρασης.
Τρέχοντας τη Μέθοδο Main

Για λόγους ευκολίας, το DrJava έχει τη δυνατότητα να καλέσει τη μέθοδο main μίας κλάσης στο
παράθυρο Αλληλεπίδρασης, πληκτρολογώντας απλά "java", ακολουθούμενο από το όνομα της
κλάσης και κάθε άλλο στοιχείο (παραμέτρους). Για παράδειγμα, για να τρέξει το: MyClass με
παραμέτρους "arg1" και "arg2", πληκτρολογήστε τα ακόλουθα στο παράθυρο Αλληλεπίδρασης:
java MyClass arg1 arg2
Σημειώστε ότι αυτή η λειτουργία δεν υποστηρίζει special flags ή παραμέτρους για το ίδιο το JVM,
όπως υποστηρίζεται στη γραμμή εντολών.

Κεφάλαιο 6. Μεταγλώττιση Προγραμμάτων
Οι compilers (μεταγλωττιστές) της Java ελέγχουν τα προγράμματά σας για λάθη και τα
μεταφράζουν σε αρχεία κλάσεων που μπορούν να χρησιμοποιηθούν. Κάθε φορά που αλλάζετε το
πηγαίο αρχείο κώδικα για μια κλάση, πρέπει να κάνετε μεταγλώττιση πριν να χρησιμοποιηθεί. Για
να το κάνετε αυτό σε DrJava, μπορείτε απλά να κάντε κλικ στο κουμπί "Compile All" στη γραμμή
εργαλείων ώστε να γίνει μεταγλώττιση σε κάθε ανοιχτό έγγραφο. Επίσης, τυχόν λάθη που
προκύπτουν επισημαίνονται στο έγγραφο.
Μεταγλωττίζοντας Αρχεία
Για να μεταγλωττίσετε αρχεία που έχετε ανοίξει στο DrJava, κάντε κλικ στο κουμπί "Compile All" στη
γραμμή εργαλείων, είτε επιλέξετε "Compile All" ή "Compile Current Document" από το Tools menu.
Πριν αρχίσει η μεταγλώττιση, όλα τα ανοιχτά αρχεία πρέπει να αποθηκευτούν, ακόμη και αν γίνεται
μεταγλώττιση μόνο στο τρέχον έγγραφο. Αυτό είναι απαραίτητο επειδή ένα αρχείο μπορεί να
εξαρτάται από άλλα αρχεία, και είναι σημαντικό το ότι τα αρχεία δεν τροποποιούνται όταν
εμφανίζονται σφάλματα. (Διαφορετικά, ένα λάθος επισημαίνεται στη γραμμή που έχει αλλάξει).
Μόλις μια μεταγλώττιση ολοκληρωθεί με επιτυχία, το παράθυρο Αλληλεπίδρασης επαναφέρεται,
έτσι ώστε να μπορούν να χρησιμοποιηθούν τα νέα αρχεία των κλάσεων. Η έξοδος για το παράθυρο
της Κονσόλας (Console) επαναφέρεται επίσης για να ξεκινήσει εκ νέου η συγγραφή, εκτός αν η
επιλογή "Clear Console After Interactions Reset" στο τμήμα "Miscellaneous" των Ρυθμίσεων είναι
απενεργοποιημένη. Στη λειτουργία του project, έχετε την επιλογή να μεταγλωττίσετε όλα τα πηγαία
αρχεία του project, ακόμη και αν αυτά τα αρχεία δεν είναι ανοιχτά στο DrJava. Για να
μεταγλωττίσετε όλα τα πηγαία αρχεία, κάντε κλικ στο κουμπί "Compile Open Project Files" στο
Project Menu.
Βλέποντας τα Σφάλματα της Μεταγλώττισης

Αν ο μεταγλωττιστής βρίσκει τυχόν λάθη στο πρόγραμμά σας, το DrJava τα εμφανίζει στη καρτέλα
Μεταγλώττισης στο κάτω μέρος του παραθύρου. Μια περίληψη του κάθε σφάλματος εμφανίζεται
στη λίστα, συμπεριλαμβανομένου του ονόματος αρχείου και του αριθμού της γραμμής. Μπορείτε
να κάνετε κλικ σε οποιοδήποτε σφάλμα ώστε να τονιστεί η αντίστοιχη γραμμή στο ίδιο το έγγραφο.
(Σημειώστε ότι ένα αρχείο θα ανοίξει αυτόματα εάν περιέχει σφάλματα που εντοπίστηκαν από τον
compiler.) Ομοίως, αν ο κέρσορας μετακινηθεί σε μια γραμμή κώδικα που περιέχει ένα σφάλμα,
ενώ είναι ενεργό το παράθυρο του Μεταγλωττιστή, αυτή η γραμμή και το αντίστοιχο μήνυμα
σφάλματος τονίζονται. Μπορείτε να απενεργοποιήσετε τα τονισμένα σφάλματα μεταγλώττισης
στην πηγή αναιρώντας την επιλογή "Highlight Source" στο παράθυρο του Μεταγλωττιστή ή με το
κλείσιμο του παραθύρου αυτού.
Επιλέγοντας Μεταγλωττιστή
Το DrJava υποστηρίζει τη χρήση διαφορετικών Java μεταγλωττιστών, όπως διαφορετικές εκδόσεις
του "Javac" compiler που παρέχεται με το JDK. Το DrJava θα προσπαθήσει να εντοπίσει από μόνο
του τον μεταγλωττιστή σας κατά την, αλλά μερικές φορές δεν είναι σε θέση να τον βρεί. Σε αυτή την
περίπτωση θα χρησιμοποιήσει τον συμπεριλαμβανόμενο μεταγλωττιστή του προγράμματος Eclipse.
Σημειώστε ότι η θέση του μεταγλωττιστή μπορεί να οριστεί στις Ρυθμίσεις. Εάν περισσότεροι από
ένα μεταγλωττιστή έχουν καθοριστεί, ο ενεργός μεταγλωττιστής μπορεί να επιλεγεί από ένα μενού
στο παράθυρο Μεταγλώττισης.
Το DrJava θα εμφανίσει μόνο ένα μεταγλωττιστή για κάθε σημαντική έκδοση, ακόμη και αν έχετε
περισσότερες από μία ενημερωμένες εκδόσεις του JDK εγκατεστημένες. (Παράδειγμα: έχετε JDK 6
Ενημερώσεις 10 και 14 εγκατεστημένο. Το DrJava θα εμφανίσει μόνο JDK 6 Update 14).

Εάν θέλετε να εμφανίσετε όλες τις εκδόσεις μεταγλωττιστή που βρέθηκαν, ενεργοποιήστε την
επιλογή "Show all compiler versions" στις Ρυθμίσεις.
Ο μεταγλωττιστής που προτιμάται μπορεί επίσης να επιλεγεί οριστικά με τη ρύθμιση Compiler
Preference στην κατηγορία των Ρυθμίσεων σχετικά με Επιλογές Μεταγλωττιστή. Το DrJava τότε θα
επιλέξει τον επιλεγμένο μεταγλωττιστή κατά την εκκίνηση.

Κεφάλαιο 7. Εντοπισμός Σφαλμάτων (Debugging)
Το DrJava παρέχει προηγμένα εργαλεία για τον εντοπισμό σφαλμάτων των προγραμμάτων σας στο
παράθυρο Αλληλεπίδρασης. Μπορείτε να ορίσετε σημεία διακοπής (breakpoints) στα πηγαία
αρχεία, να καλέστε μεθόδους που σταματούν στα σημεία διακοπής που φαίνονται στο παράθυρο
Αλληλεπίδρασης και στη συνέχεια να αλληλεπιδρούν με τα προγράμματα, ενώ αυτά έχουν
σταματήσει στα σημεία διακοπής. Μόλις επιτευχθεί ένα σημείο διακοπής, οι χρήστες μπορούν να
αλληλεπιδρούν με μεταβλητές, πεδία ή μεθόδους που βρίσκονται στη μέθοδο που έχει ανασταλεί.
Οι χρήστες μπορούν, επίσης, να επιλέξουν την ολοκλήρωση της μεθόδου, ή να περάσουν μέσα σ’
αυτήν, ελέγχοντας μια γραμμή κάθε φορά. Τέλος, οι τιμές τοπικών μεταβλητών και πεδίων
μπορούν να παρακολουθούνται εντός ενός πίνακα, καθώς η κλήση της μεθόδου εξελίσσεται.
Χρησιμοποιώντας τον Εντοπισμό Σφαλμάτων

Για να χρησιμοποιήσετε τον εντοπισμό σφαλμάτων του DrJava, επιλέξτε την εντολή "Debug Mode"
από το μενού Debugger. Ένας ενημερωτικός πίνακας θα εμφανιστεί μεταξύ του παραθύρου
Ορισμών και του παραθύρου Αλληλεπίδρασης, και διάφορα στοιχεία του μενού στον Debugger θα
ενεργοποιηθούν.
Σημείωση στην τροποποίηση αρχείων:

Όταν χρησιμοποιείτε το πρόγραμμα εντοπισμού σφαλμάτων, είναι σημαντικό να θυμάστε ότι τυχόν
τροποποιήσεις σε πηγαία αρχεία δεν αντικατοπτρίζονται στη συμπεριφορά του παραθύρου
Αλληλεπίδρασης ή στον Εντοπισμό Σφαλμάτων, μέχρι να κάνετε ξανά μεταγλώττιση στις κλάσεις.
Αλλαγή στο περιεχόμενο ενός πηγαίου αρχείου ενώ τρέχει ο Εντοπισμός Σφαλμάτων δεν
συνιστάται, αφού οι γραμμές που είναι τονισμένες από αυτόν μπορεί να μην αντιστοιχούν πλέον
στις γραμμές του τρέχοντος αρχείου της κλάσης. Για να σας βοηθήσει να ενημερωθείτε περί αυτού
του κινδύνου, το DrJava εμφανίζει ένα προειδοποιητικό μήνυμα στο παράθυρο Εντοπισμού
Σφαλμάτων εάν το τρέχον έγγραφο είναι εκτός συγχρονισμού με το αρχείο της κλάσης του.
Επειδή ο Εντοπισμός Σφαλμάτων εξαρτάται από τις κλάσεις που χρησιμοποιούνται στο παράθυρο
Αλληλεπίδρασης, αυτός επαναφέρεται αυτόματα κάθε φορά που οποιαδήποτε αρχεία
μεταγλωττίζονται ή επαναφέρονται (reset) στο παράθυρο Αλληλεπίδρασης.
Σημεία Διακοπής (Breakpoints )

Μπορείτε να ορίσετε ένα σημείο διακοπής σχεδόν σε κάθε γραμμή του κώδικα σε ένα αρχείο πηγής
στο παράθυρο Ορισμού, χρησιμοποιώντας είτε την εντολή "Toggle Breakpoint on Current Line" στο
Debugger menu είτε την εντολή "Toggle Breakpoint" στο context menu (δεξί κλικ) του παραθύρου
Ορισμών είτε πατώντας Ctrl + B. Όταν έχει οριστεί σημείο διακοπής, η γραμμή επισημαίνεται με
κόκκινο χρώμα και εμφανίζεται μια καταχώρηση στον πίνακα "Breakpoints", η οποία μπορεί να
δημιουργηθεί χρησιμοποιώντας την εντολή "Breakpoints" στο μενού Debugger ή πατώντας Ctrl +
Shift + B.
Όταν μια μέθοδος καλείται στο παράθυρο Αλληλεπίδρασης και η ροή ελέγχου φτάνει σε μια
γραμμή του κώδικα στην οποία έχει οριστεί ένα σημείο διακοπής, το DrJava αναστέλλει την
εκτέλεση του προγράμματος, τονίζει τη γραμμή σε έντονο μπλε και τυπώνει ένα μήνυμα στο
παράθυρο Αλληλεπίδρασης. Στη συνέχεια εμφανίζεται μια καινούρια υπαγόρευση στο παράθυρο
Αλληλεπίδρασης, επιτρέποντάς σας να αλληλεπιδράτε με το πρόγραμμα που έχει ανασταλεί μέχρι
αυτό να συνεχίσει την εκτέλεση του. Τα σημεία διακοπής θεωρούνται μέρος ενός project και
επομένως αποθηκεύονται και φορτώνονται από ένα αρχείο project.

Κατά τον καθορισμό των σημείων διακοπής, είναι σημαντικό να θυμάστε ότι μόνο γραμμές με
εκτελέσιμο κώδικα μπορεί να χρησιμοποιηθούν. Οι κενές γραμμές και τα σχόλια δεν θα
προκαλέσουν ένα σημείο διακοπής, ακόμη και αν η γραμμή επισημαίνεται με κόκκινο χρώμα.
Panel Σημάτων Διακοπής

Το panel των Σημάτων Δικαοπής μπορεί να εμφανιστεί με την εντολή "Breakpoints" στο Μενού
Debugger ή πατώντας Ctrl + Shift + B. Αυτό παραθέτει όλα τα σημεία διακοπής που έχουν οριστεί
στα τρέχοντα ανοιχτά έγγραφα, ταξινομημένα ανά έγγραφο και αριθμό γραμμής. Υπάρχουν πολλά
κουμπιά στη δεξιά πλευρά του πίνακα που σας βοηθούν να διαχειριστείτε τα σημεία διακοπής:
- Μπορείτε να επιλέξετε ένα ή περισσότερα σημεία διακοπής και πατήστε το κουμπί "Enable" ή
"Disable" για να ενεργοποιήσετε ή να απενεργοποιήσετε τα επιλεγμένα σημεία διακοπής. Όταν ένα
σημείο διακοπής είναι απενεργοποιημένο, παραμένει εγκατεστημένο, αλλά το πρόγραμμα δεν θα
ανασταλεί όταν φτάσει σε αυτό. Αυτό είναι χρήσιμο εάν χρειαστείτε το σημείο διακοπής ξανά
αργότερα, αλλά για τώρα θέλετε το πρόγραμμα να το αγνοήσει.
- Εάν επιλέξετε ακριβώς ένα σημείο διακοπής, μπορείτε να χρησιμοποιήσετε το κουμπί "Go to" για
να μεταβείτε στη θέση που σχετίζεται με το σημείο διακοπής.
- Με το κουμπί "Remove", μπορείτε να αφαιρέσετε ένα ή περισσότερα σημεία διακοπής που έχετε
επιλέξει. Μπορείτε επίσης να διαγράψετε ολόκληρη τη λίστα, χρησιμοποιώντας το κουμπί "Remove
All".
Αλληλεπίδραση σε Ένα Σημείο Διακοπής

Όταν το DrJava φθάνει σε ένα σημείο διακοπής, κατά τη διάρκεια της κλήσης μίας μεθόδου,
εμφανίζει μια νέα υπαγόρευση στο παράθυρο Αλληλεπίδρασης. Αυτός ο νέος διερμηνέας
(interpreter) έχει το πλαίσιο του προγράμματος που έχει ανασταλεί, συμπεριλαμβανομένων όλων
των μεταβλητών, των πεδίων (ακόμη και του "this"), και τις μεθόδους που βρίσκονται στο πεδίο της
μεθόδου που έχει ανασταλεί. (Το ίδιο το κείμενο υπαγόρευσης περιέχει το όνομα του thread που
έχει ανασταλεί). Μπορείτε να πληκτρολογήσετε το όνομα οποιασδήποτε μεταβλητής ή πεδίου για
να δείτε την τιμή του ή να του ορίσετε μια νέα τιμή, ή μπορείτε να καλέσετε οποιαδήποτε μέθοδο
στο πεδίο εφαρμογής ώστε να παρατηρήσετε τη συμπεριφορά του. Ωστόσο, υπάρχουσες γραμμές
του κώδικα στο πρόγραμμα δεν μπορούν να αλλάξουν ή να παραλειφθούν και η λέξη-κλειδί
"return" δεν είναι διαθέσιμη.
Τυχόν αλλαγές που κάνετε σε μεταβλητές ή πεδία αντικατοπτρίζονται στο πρόγραμμα όταν αυτό
εκτελείται, είτε βηματικά είτε εξολοκλήρου .
Βηματική ή ολική εκτέλεση

Αφότου το DrJava φθάσει σε ένα σημείο διακοπής, η μέθοδος που έχει κληθεί αναστέλλει τη
λειτουργία της και διάφορες εντολές στο Debug Menu και Debug Panel είναι διαθέσιμες. Η επιλογή
"Resume" επιτρέπει στην τρέχουσα μέθοδο να τελειώσει την εκτέλεση, τουλάχιστον μέχρις ότου
φτάσουμε σε ένα άλλο σημείο διακοπής. Εάν οποιαδήποτε άλλα threads ανασταλούν κατά την
εκτέλεση, το παράθυρο Αλληλεπίδρασης θα αλλάξει και θα παρουσιάσει το thread που
αναστάλθηκε πιο πρόσφατα. Σε αντίθετη περίπτωση η αρχική σειρά αποκαθιστάται. Εναλλακτικά,
μπορείτε να χρησιμοποιήσετε τις εντολές Step στο Debug menu ώστε να περάσετε μέσα από την
εκτέλεση της μεθόδου, στο σημείο διακοπής, και να τρέξετε το πρόγραμμα μία γραμμή κάθε φορά.
Κάθε φορά που ένα βήμα ολοκληρώνεται, το πρόγραμμα εντοπισμού σφαλμάτων υπογραμμίζει την
επόμενη γραμμή του κώδικα που πρέπει να εκτελεστεί. Εάν ο κωδικός είναι σε άλλο αρχείο, το
πρόγραμμα εντοπισμού σφαλμάτων θα ψάξει για το αρχείο και θα επιχειρήσει να το ανοίξει.

Step Into: Η εντολή Step Into θα περάσει στην εκτέλεση του προγράμματος, μέσα από την κλήση της
μεθόδου που εμφανίζεται στον κώδικα, πιθανώς ανοίγοντας πρόσθετα αρχεία.
Step Over: Με την εντολή Step Over δεν θα εισέλθει ο έλεγχος του προγράμματος μέσα στον
κώδικα της μεθόδου, αλλά θα τη μεταχειριστεί ως μία ενιαία πράξη και θα την εκτελέσει
εξολοκλήρου.
Step Out: Η εντολή Step Out θα τερματίσει τη λειτουργία της τρέχουσας μεθόδου και θα
προχωρήσει την εκτέλεση του προγράμματος στην επόμενη γραμμή κώδικα, από αυτήν της κλήσης
της μεθόδου.
Το Panel του Εντοπισμού Σφαλμάτων (Debug Panel)

Το Debug Panel εμφανίζεται όταν το Debug Mode είναι ενεργοποιημένο, με πολλές ενημερωτικές
καρτέλες και κουμπιά. Το DrJava εμφανίζει οθόνες με τα τρέχοντα πεδία και τις μεταβλητές με τις
τιμές τους σε έναν πίνακα στην καρτέλα Watches. Η καρτέλα Stack εμφανίζει το τρέχον stack trace
κάθε φορά που μια μέθοδος αναστέλλεται και η Threads tab δείχνει όλα τα τρέχοντα threads μαζί
με την κατάσταση τους σε εκείνο το σημείο στο χρόνο.
Παρακολουθώντας Πεδία και Μεταβλητές

Μπορείτε να παρακολουθείτε τις τιμές των πεδίων κλάσεων και τοπικών μεταβλητών, εισάγοντας
το όνομα του πεδίου ή της μεταβλητής σε μια σειρά στον πίνακα Watches. Κάθε φορά που μια
μέθοδος διακόπτεται προσωρινά (π.χ. μετά από ένα breakpoint), εμφανίζεται η τρέχουσα τιμή του
πεδίου ή της μεταβλητής (εάν υπάρχουν). Τα Watches μπορούν να αφαιρεθούν από τον πίνακα
διαγράφοντας το όνομα και πατώντας το πλήκτρο Enter. Δεν μπορείτε να εισάγετε εκφράσεις που
πρέπει να αξιολογηθούν στον πίνακα Watches. Για παράδειγμα, η εντολή "s.length" δεν είναι
έγκυρη καταχώριση του πίνακα Watches. Πρέπει να πληκτρολογήστε τέτοιες εκφράσεις στο
παράθυρο Αλληλεπίδρασης για να δείτε τις τιμές τους.

Κεφάλαιο 8. Δημιουργία Τεκμηριώσεων (documentation) με Χρήση του
Javadoc
Η τεκμηρίωση (documenting) του κώδικά σας είναι ζωτικής σημασίας για να βοηθήσει τους άλλους
να τον καταλάβουν, ακόμη και για να υπενθυμίσει σε σας αργότερα πώς λειτουργούν τα δικά σας
παλαιότερα προγράμματα. Δυστυχώς, είναι εύκολο για τα περισσότερα τέτοια αρχεία τεκμηρίωσης
να γίνουν ξεπερασμένα όσο αλλάζει το πρόγραμμα. Για το λόγο αυτό, είναι χρήσιμο να γράψετε
τεκμηριώσεις ως σχόλια στον ίδιο τον κώδικα σας, έτσι θα μπορούν εύκολα να ενημερωθούν με τις
όποιες αλλαγές σε αυτόν.
Το Javadoc είναι ένα εργαλείο τεκμηρίωσης το οποίο καθορίζει ένα πρότυπο για τέτοια σχόλια και
το οποίο μπορεί να δημιουργήσει τα HTML αρχεία όπου θα μπορείτε να δείτε τo αρχείο
τεκμηρίωσης που δημιουργήσατε από έναν web broswer. Μπορείτε να εκτελέσετε εύκολα to
Javadoc πάνω από τα προγράμματά σας μέσα από to DrJava, χρησιμοποιώντας τις εντολές "Javadoc
All Documents" και "Preview Javadoc for Current Document" στο μενού των Εργαλείων. Αυτές οι
εντολές θα δημιουργήσουν Javadoc HTML αρχεία από τα σχόλια που έχετε γράψει και θα τα
εμφανίσουν σε έναν browser.
Γράφοντας Σχόλια σε Javadoc

Σε γενικές γραμμές, τα σχόλια Javadoc είναι οποιαδήποτε σχόλια πολλών γραμμών ("/ ** ... * /"),
που τοποθετούνται πριν από την κλάση, το πεδίο ή τις δηλώσεις μεθόδων. Θα πρέπει να αρχίζουν
με ένα slash (/) και δύο αστερίσκους και μπορούν να περιλαμβάνουν ειδικές ετικέτες για να
περιγράψουν χαρακτηριστικά, όπως παραμέτρους της μεθόδου ή τιμές επιστροφής αυτής. Τα
αρχεία HTML που δημιουργούνται από Javadoc θα περιγράψουν κάθε πεδίο και μέθοδο μιας
κλάσης, χρησιμοποιώντας τα σχόλια Javadoc στον ίδιο τον πηγαίο κώδικα. Παραδείγματα
διαφορετικών σχολίων Javadoc αναφέρονται στη συνέχεια.
Απλά Σχόλια
Κανονικά σχόλια Javadoc μπορούν να τοποθετηθούν πριν από κάθε δήλωση κλάσης, πεδίου ή
μεθόδου για να περιγράψουν την πρόθεση ή τα χαρακτηριστικά του. Για παράδειγμα, η ακόλουθη
απλή κλάση Student έχει αρκετά σχόλια Javadoc.

Χρήση Ετικετών
Οι ετικέτες (tags) μπορούν να χρησιμοποιηθούν στο τέλος κάθε σχολίου Javadoc ώστε να
παρέχονται πιο δομημένες πληροφορίες σχετικά με τον κώδικα που περιγράφεται. Για παράδειγμα,
τα περισσότερα σχόλια Javadoc για τις μεθόδους περιλαμβάνουν ετικέτες "@param" και "@return"
κατά περίπτωση, για να περιγράψουν τις παραμέτρους της μεθόδου και την τιμή επιστροφής. Η
ετικέτα "@param" πρέπει να ακολουθείται από το όνομα της παραμέτρου και στη συνέχεια από μια
περιγραφή της παραμέτρου αυτής. Η ετικέτα "@return " ακολουθείται απλά από μια περιγραφή της
τιμής επιστροφής. Τα παραδείγματα αυτών των ετικετών δίνονται παρακάτω.
Άλλες κοινές ετικέτες περιλαμβάνουν "@throws e" (για να περιγράψει κάποια εξαίρεση (Exception)
"e" που έρχεται από μια μέθοδο) και @see #foo " (για να παράσχει ένα σύνδεσμο σε ένα πεδίο ή
μέθοδο που ονομάζεται "foo").
Κεφάλαιο 9. Το Πρώτο Πρόγραμμα στο DrJava
Στη συνέχεια, θα δημιουργήσουμε το πρώτο μας πρόγραμμα στο DrJava. Πρόκειται για ένα απλό
πρόγραμμα που θα εμφανίσει στην οθόνη έναν χαιρετισμό.
Στο πρώτο μας βήμα, πρέπει να δημιουργήσουμε ένα project. Για το λόγο αυτό πατάμε στην
επιλογή Project New και επιλέγουμε ένα όνομα για το project μας. Κατόπιν μας εμφανίζεται ένα
παράθυρο με τις ιδιότητες του project, τις οποίες αποδεχόμαστε και προχωράμε.
Τώρα είμαστε έτοιμοι να ξεκινήσουμε να γράφουμε στο νέο μας project. Επιλέγουμε το project μας,
το οποίο είναι κενό αρχικά και πατάμε στο FileNew Java Class. Στο παράθυρο που ανοίγεται
επιλέγουμε το όνομα της κλάσης. Αυτό είναι το όνομα που θα εμφανιστεί στον editor μας.
Προσέξτε στην προηγούμενη εικόνα ότι έχουμε επιλέξει να συμπεριλαμβάνεται στην κλάση μας η
μέθοδος main. Για να συμβαδίζει το όνομα στον editor με το όνομα του αρχείου πρέπει να πάμε να
ονομάσουμε και το αρχείο με τον ίδιο τρόπο. Έτσι πατάμε δεξί κλικ πάνω στο αρχείο μας (προς το
παρόν είναι Untitled) και επιλέγουμε Save File as και διαλέγουμε το ίδιο όνομα με αυτό που
δώσαμε στην κλάση μας. Στην περίπτωση μας έχουμε ονομάσει την κλάση (και το αρχείο μας) Hello.
Τον κώδικα του προγράμματος μας μπορούμε να τον δούμε στη συνέχεια. Περιλαμβάνει μέσα στη
μέθοδο main τον κώδικα για την εκτύπωση ενός απλού μηνύματος στην οθόνη μας.
Κώδικας πρώτου προγράμματος

Στη συνέχεια, πρέπει να μεταγλωττίσουμε το πρόγραμμα μας. Από το μενού project επιλέγουμε
Compile project και προσέχουμε στην καρτέλα Compiler Output αν θα μας εμφανιστεί κάποιο
μήνυμα λάθους.
Αν όλα πάνε καλά επιλέγουμε Run και τρέχουμε το πρόγραμμα μας. Θα πρέπει τότε στην καρτέλα
Interactions να μας εμφανίσει το μήνυμα που του έχουμε ζητήσει, όπως φαίνεται και στο σχήμα
που ακολουθεί.

Παραδείγματα Χρήσης του DrJava
Version 1.1
Επιμέλεια:
Κόγιας Δημήτρης,
Χαράλαμπος Πατρικάκης,

Πίνακας Περιεχομένων
Κεφάλαιο 1. Προγράμματα για εξάσκηση ............................................................................................................. 3

Παράδειγμα Κλάσης .......................................................................................................................................... 4
Μονά - Ζυγά ....................................................................................................................................................... 5
Πρώτοι Αριθμοί.................................................................................................................................................. 6
Πυραμίδα ........................................................................................................................................................... 7
Υπολογισμός Μέσου Όρου Πίνακα ................................................................................................................... 8
Ακολουθία Fibonacci.......................................................................................................................................... 9
Αντιστροφή Ψηφίων Ενός Αριθμού ................................................................................................................. 10

Κεφάλαιο 1. Προγράμματα για εξάσκηση
Στο έντυπο αυτό θα δούμε διάφορα προγράμματα που μπορούμε να τρέξουμε στο DrJava και θα τα
μελετήσουμε για να εξοικειωθούμε με τις βασικές έννοιες της γλώσσας Java, όπως τελεστές,
κλάσεις, βρόχους επαναλήψεων και ελέγχου ροής. Επιπλέον, θα μας βοηθήσουν τα παραδείγματα
αυτά να γνωρίσουμε καλύτερα το περιβάλλον του DrJava.
Να σημειωθεί, ότι τα προγράμματα είναι περασμένα με τη μορφή εικόνας (άρα το copy – paste δε
θα δουλέψει), όχι για να δυσκολέψουν τους φοιτητές, αλλά για να τους αναγκάσουν να περάσουν
τον κώδικα και να δουν τις δυνατότητες για στοίχιση, χρωματισμό, και αυτόματη συμπλήρωση που
παρέχει το Dr. Java, καθώς και μέσα από πιθανά λάθη πληκτρολόγησης, να μπορέσουν να
αντιμετωπίσουν σε μία πρώτη απλή μορφή, θέματα debugging.

Παράδειγμα Κλάσης
Στο πρώτο παράδειγμα που θα μελετήσουμε, θα ασχοληθούμε με τη δημιουργία μιας καινούργιας
κλάσης και, κατόπιν, θα δημιουργήσουμε ένα αντικείμενο της κλάσης αυτής με μια τιμή. Καταρχάς,
δημιουργούμε ένα καινούργιο project στο DrJava το οποίο ας το ονομάσουμε ClassExample.
Κατόπιν σε ένα καινούργιο αρχείο κλάσης γράφουμε την κλάση που βλέπουμε στη συνέχεια. Δεν
αμελούμε να την αποθηκεύσουμε με το ίδιο όνομα με το project.
Στο παραπάνω παράδειγμα βλέπουμε τη δημιουργία της κλάσης ClassExample που έχει 1
μεταβλητή (ιδιότητα) και 2 μεθόδους (setName, getName). Η πρώτη μέθοδος χρησιμοποιείται από
την κλάση για να δώσει τιμή στην ιδιότητα και η άλλη για να γίνει δυνατόν να έχουν πρόσβαση στο
διάβασμα της ιδιότητας της κλάσης και άλλες μέθοδοι, μιας και η ιδιότητα name είναι private.
Κατόπιν, ορίζουμε μια μέθοδο main και μέσα σε αυτήν δημιουργούμε ένα αντικείμενο από την
κλάση ClassExample και του δίνουμε μια τιμή και την παρουσιάζουμε στην οθόνη,
εκμεταλλευόμενοι τις μεθόδους της κλάσης.
Περάστε την κλάση στο DrJava και δείτε τι θα εκτυπωθεί στην οθόνη.
ΕΡΩΤΗΣΗ: Στο συγκεκριμένο παράδειγμα, παραβήκαμε έναν κανόνα από τις συμβάσεις που
έχουμε πει στην ονοματοδοσία στη Java. Μπορείτε να βρείτε ποιον; Υπάρχει κάποιο πρόβλημα;
Παραλλαγές:
- Δημιουργήστε ένα δεύτερο αντικείμενο της κλάσης το οποίο και θα του δώσετε το όνομα
Student. Εκτυπώστε το όνομα του στην οθόνη.
- Δημιουργήστε ένα ακόμα αντικείμενο και δώστε του το όνομα σας. Πως μπορείτε να
εκτυπώσετε στην οθόνη το παρακάτω μήνυμα:
Hello yourName! You are a good Student!
Όπου yourName το όνομα σας όπως το έχετε δώσει στο αντικείμενο που δημιουργήσατε.

Μονά - Ζυγά
Στο επόμενο πρόγραμμα θα δούμε πως μπορούμε να εκτυπώσουμε στην οθόνη του υπολογιστή μας
όλους τους μονούς και όλους τους ζυγούς αριθμούς από το 1 ως το 10. Όπως θα δείτε και στο
πρόγραμμα που ακολουθεί θα χρησιμοποιήσουμε έναν πίνακα για να βάλουμε όλους τους
αριθμούς και κατόπιν θα διατρέξουμε τον πίνακα αυτό για να εκτυπώσουμε την ιδιότητα τους.
Για να βρούμε αν ένας αριθμός είναι μονός ή ζυγός χρησιμοποιούμε το σύμβολο του modulo2,
δηλαδή το %. Η πράξη σε modulo2 μας επιστρέφει, στην ουσία, το υπόλοιπο της διαίρεσης ενός
αριθμού που δίνεται με το 2. Π.χ., 5 % 2 = 1. Όλοι οι μονοί αριθμοί θα έχουν υπόλοιπο 1 στην
περίπτωση αυτή και όλοι οι ζυγοί μηδέν.
Περάστε το παραπάνω πρόγραμμα και τρέξτε το. Τι θα δείτε στην οθόνη;

Παραλλαγές:
- Μπορείτε να εκτυπώσετε και πόσοι αριθμοί είναι άρτιοι και πόσοι περιττοί στο τέλος της
διαδικασίας;
- Μπορείτε να εκτυπώσετε τους άρτιους και ζυγούς αριθμούς από το 1 έως το 100;

Πρώτοι Αριθμοί
Στο παρακάτω πρόγραμμα μπορείτε να δείτε πως θα φτιάξετε ένα πρόγραμμα που θα εμφανίζει
όλους τους πρώτους αριθμούς από το 1 έως το 100. Υπενθυμίζεται ότι πρώτοι λέγονται οι αριθμοί
εκείνοι που διαιρούνται με το ένα και με τον εαυτό τους.
Ο έλεγχος για το εάν είναι πρώτος ο αριθμός φαίνεται στη γραμμή 18-22, όπου ουσιαστικά
ελέγχουμε αν ο αριθμός διαιρείται ακριβώς από κάποιον άλλο αριθμό στο εύρος των υποψηφίων
τιμών.
Παραλλαγή:
- Στο παρακάτω πρόγραμμα εκτυπώστε τους αριθμούς από το 1- 100 που είναι δίπλα σε έναν
πρώτο π.χ ένας πρώτος αριθμός είναι ο 3 θα εκτυπώσουμε 2 και 4 (ανεξαρτήτως αν είναι
πρώτοι).
- Εκτυπώστε από τους πρώτους αριθμούς που βρήκατε μόνο όσους είναι μονοί.

Πυραμίδα
Στο επόμενο πρόγραμμα, θα πρέπει να φτιάξουμε μια πυραμίδα από αστερίσκους,
όπως αυτή που φαίνεται δίπλα. *
Για να το πετύχουμε αυτό, θα πρέπει να γράψουμε μια καινούργια κλάση στο DrJava, **
η οποία να μετράει τον αριθμό των γραμμών και να συμπληρώνει στην κάθε γραμμή ***
τον αντίστοιχο αριθμό από αστερίσκους. ****
Ο κώδικας του προγράμματος φαίνεται στην εικόνα που ακολουθεί: *****
Παραλλαγή: *****
- Φτιάξτε μια πυραμίδα με 10 αστερίσκους στη βάση της.
****
- Φτιάξτε μια πυραμίδα ανάποδα σε σχέση με την πρώτη. Δηλαδή, να έχει τη
***
μεγάλη βάση προς τα πάνω και τη μικρή προς τα κάτω, όπως φαίνεται δίπλα.
- Συνδυάστε τα 2 τελευταία σχήματα για να παράγετε μια καινούργια πυραμίδα
**
διπλάσιου μεγέθους. *
- Αντί για αστερίσκους, φτιάξτε μια πυραμίδα με νούμερα όπως αυτή που φαίνεται παρακάτω.
1
12
123
1234
12345

Υπολογισμός Μέσου Όρου Πίνακα
Στο επόμενο μας πρόγραμμα, θα επιστρέψουμε στους πίνακες και θα δούμε κώδικα που μας
επιτρέπει να υπολογίζουμε τον μέσο όρο ενός πίνακα ακεραίων αριθμών. Για να το πετύχουμε αυτό
θα πρέπει να διατρέξουμε όλα τα στοιχεία του πίνακα, αθροίζοντας τις τιμές τους και στο τέλος, το
άθροισμα αυτό, να διαιρεθεί με τον αριθμό των στοιχείων του πίνακα, δηλαδή με το μέγεθος
αυτού.
Περάστε το πρόγραμμα και τρέξτε το. Τι αποτέλεσμα βγάζει; Πως θα μπορούσαμε να βρούμε τον
μέσο όρο με 2 δεκαδικά ψηφία;

Ακολουθία Fibonacci
Στο πρόγραμμα αυτό θα προσπαθήσουμε να υλοποιήσουμε την ακολουθία Fibonacci. Στην
ακολουθία αυτή ο κάθε όρος έχει προκύψει από το άθροισμα των δύο προηγούμενων όρων.
Γνωρίζοντας ότι οι 2 πρώτοι όροι της ακολουθίας είναι το 0 και το 1, οι 10 πρώτοι αριθμοί της
ακολουθίας είναι οι:
0 1 1 2 3 5 8 13 21
Στη συνέχεια θα δούμε ένα πρόγραμμα που θα υπολογίζει τους 20 πρώτους όρους της γνωστής
ακολουθίας.
Παραλλαγή:
- Φτιάξτε ένα πρόγραμμα που θα ελέγχει αν οι αριθμοί 500 και 987 είναι μέσα στους 20 πρώτους
όρους της ακολουθίας Fibonacci. Αν ναι, ποιοί όροι αυτής είναι;

Αντιστροφή Ψηφίων Ενός Αριθμού
Στο τελευταίο πρόγραμμα μας, θα δούμε πως μπορούμε να αντιστρέψουμε τα ψηφία ενός αριθμού,
δηλαδή αν έχουμε τον αριθμό 352 να πάρουμε τον αριθμό 253.
Για να το πετύχουμε αυτό θα πρέπει να κρατάμε το υπόλοιπο της διαίρεσης με το 10 και να το
προσθέτουμε στον αντίστροφο αφού σπρώξουμε ότι υπήρχε πριν μια θέση αριστερά. Η στροφή
αυτή γίνεται με πολλαπλασιασμό με το 10, μια τεχνική ιδιαίτερα δημοφιλή και στα υπόλοιπα
αριθμητικά συστήματα.
Στο παράδειγμα που ακολουθεί θα δείτε το τμήμα του κώδικα που επιτυγχάνει την αντιστροφή του
αριθμού 1234 σε 4321.
Περάστε το πρόγραμμα και τρέξτε το. Βεβαιωθείτε ότι αντιλαμβάνεστε τον τρόπο που λειτουργεί.
Αν δοκιμάζαμε έναν 6-ψήφιο αριθμό θα έτρεχε κανονικά το πρόγραμμα μας ή θα έπρεπε να
αλλάξουμε κάποιο σημείο του κώδικα μας;

Αντικειμενοστραφής Προγραμματισμός Java Δημήτριος Μετάφας ΤΕΙ Πειραιά

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Αντικειμενοστραφής Προγραμματισμός Java Δημήτριος Μετάφας ΤΕΙ Πειραιά

Uploaded by

Copyright:

Available Formats

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

Ενότητα 1: Εισαγωγή στον

• Harvey Deitel,Paul Deitel , «Java Προγραμματισμός, 8η έκδοση»,

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

1.2 Η γλώσσα προγραμματισμού Java

Στην ενότητα αυτή θα μάθετε για:

 Τις βασικές έννοιες του Προγραμματισμού,

• Ο προγραμματισμός των ηλεκτρονικών υπολογιστών

Βασικές έννοιες προγραμματισμού

• Πρόγραμμα – Ένα σύνολο εντολών που καθοδηγούν τον

• Γλώσσα Μηχανής – Γλώσσα προγραμματισμού το σύνολο των

• Γλώσσα Προγραμματισμού Υψηλού Επιπέδου – Γλώσσα

• Συντακτικό – Οι κανόνες που καθορίζουν τον τρόπο συνδυασμού

γλώσσες «χαμηλού επιπέδου»

(low level languages)

Επεξεργασία κώδικα υψηλού επιπέδου

• (Compiler) Μεταγλωττιστής – Μετατροπή από κώδικα

• (Interpreter) Διερμηνευτής – Ο κώδικας υψηλού

• Σύμφωνα με αυτόν, εργαζόμαστε προς τη δημιουργία

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

• Βασίζεται στη λογική ότι ένα πρόγραμμα είναι ένα σύνολο

• Στηρίζεται στις αρχές του προγραμματισμού βασισμένου σε

• Ο κώδικας είναι οργανωμένος σε κλάσεις αντικειμένων.

• Δημιουργία αντικειμένων βασισμένων στις παραπάνω

• Η εκτέλεση του προγράμματος πραγματοποιείται με

• Ο κώδικας οργανώνεται σε αντικείμενα.

• Κάθε αντικείμενο ανήκει σε κάποια οικογένεια

Αντικείμενα και κλάσεις

• Ευκολότερη συντήρηση του κώδικα.

• Ακολουθεί φιλοσοφία της C αλλά αφήνει έξω δύσκολα

• Αναπτύχθηκε από την εταιρεία Sun Microsystems το 1995.

• "απλή, αντικειμενοστραφής και οικεία“.

Ένα απλό πρόγραμμα σε Java: Hello.java

• Java applications – Αυτόνομα

Eικονική μηχανή της Java (Java Virtual Machine -

– Εκτέλεση του ενδιαμέσου κώδικα από την JVM. Java interpreter

Service Development – NetBeans

Τυπικό περιβάλλον ανάπτυξης σε Java (1/3)

• Συνήθως τα προγράμματα στη Java ακολουθούν

Τυπικό περιβάλλον ανάπτυξης Java (3/3)

• Με Development μελετάμε τα στάδια αυτά στα πλαίσια

Χρήση εργαλείων για δημιουργία κώδικα σε

• Το στάδιο 1 αποτελείται από την επεξεργασία ενός αρχείου

• Ολοκληρωμένα περιβάλλοντα ανάπτυξης

Μεταγλώττιση κώδικα σε Java (1/3)

• Ο μεταγλωττιστής μεταφράζει τον πηγαίο κώδικα Java σε

Μεταγλώττιση κώδικα σε Java (3/3)

• Τα Bytecodes είναι ανεξάρτητα από την πλατφόρμα

Επαλήθευση bytecode σε Java

• Συντακτικά σφάλματα – Προκύπτουν όταν παραβιάζουμε τους

Το «λεξικό» της γλώσσας

abstract assert boolean break byte case

• Ονόματα έως 255 χαρακτήρες.

Συμβάσεις για χρήση ονομάτων στη Java (1/2)

• Τα ονόματα των Packages πρέπει να είναι με μικρούς χαρακτήρες

• Μέθοδοι: Τα ονόματα πρέπει να είναι σε mixed case.

Σε αυτή την ενότητα μιλήσαμε για:

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

1.2 Η γλώσσα προγραμματισμού Java

2.1 Τύποι δεδομένων, μεταβλητές και τελεστές

2.2 Περισσότεροι τύποι δεδομένων

Στην ενότητα αυτή θα μάθετε για:

 Τους βασικούς τύπους δεδομένων των μεταβλητών,

2.1 Τύποι δεδομένων, μεταβλητές και