[Java/el] Translated Java to Greek

[Java/el] Translated Java to Greek

1 files changed, 858 insertions, 0 deletions

diff --git a/el-gr/java-gr.html.markdown b/el-gr/java-gr.html.markdown
new file mode 100644
index 00000000..10784d54
--- /dev/null
+++ b/el-gr/java-gr.html.markdown
@@ -0,0 +1,858 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+filename: LearnJava.java
+translators:
+  - ["Andreas Loizou" , "https://github.com/lack3r/"]
+lang: el-gr
+---
+
+H Java είναι μία γενικού-σκοπού, συντρέχων (concurrent), βασισμένη σε κλάσεις, 
+αντικειμενοστρεφής (object oriented) γλώσσα προγραμματισμού.
+[Διαβάστε περισσότερα εδώ.](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Τα σχόλια μονής γραμμής ξεκινούν με //
+/*
+Τα σχόλια πολλών γραμμών μοιάζουν κάπως έτσι.
+*/
+/**
+Τα σχόλια JavaDoc μοιάζουν κάπως έτσι. Χρησιμοποιούνται για να περιγράψουν την 
+Κλάση ή διάφορα χαρακτηριστικά της Κλάσης.
+*/
+
+// Εισαγωγή της κλάσης ArrayList η οποία βρίσκεται εντός του πακέτου java.util
+import java.util.ArrayList;
+// Εισαγωγή όλων των κλάσεων που βρίσκονται εντός του πακέτου java.security
+import java.security.*;
+
+// Κάθε αρχείο .java περιέχει μία δημόσια(public) κλάση εξωτερικού-επιπέδου 
+// (outer-level), η οποία έχει το ίδιο ονομα με το αρχείο.
+public class LearnJava {
+
+    // Για να τρέξει ένα πρόγραμμα java, πρέπει να έχει μία κύρια μέθοδο (main 
+    // method) ως αρχικό σημείο.
+    public static void main (String[] args) {
+
+        // Χρησιμοποιούμε τη μέθοδο System.out.println() για να τυπώσουμε 
+        // γραμμές.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Για να τυπώσουμε χωρίς να τυπωθεί αλλαγή γραμμής (newline), 
+        // χρησιμοποιούμε System.out.print().
+        System.out.print("Hello ");
+        System.out.print("World");
+
+        // Χρησιμοποιούμε τη μέθοδο System.out.printf() για έυκολη μορφοποίηση 
+        // της εκτύπωσης.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        ///////////////////////////////////////
+        // Μεταβλητές(Variables)
+        ///////////////////////////////////////
+
+        /*
+        *  Δήλωση Μεταβλητών
+        */
+        // Δηλώνουμε μία μεταβλητή χρησιμοποιώντας τη μορφή 
+        // <Τύπος Μεταβλητής> <Όνομα Μεταβλητής>
+        int fooInt;
+        // Δηλώνουμε πολλαπλές μεταβλητές ίδιου τύπου χρησιμοποιώντας τη μορφή 
+        // <Τύπος> <Όνομα1>, <Όνομα2>, <Όνομα3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Αρχικοποίηση Μεταβλητών
+        */
+
+        // Αρχικοποιούμε μια μεταβλητή χρησιμοποιώντας τη μορφή 
+        // <τύπος> <όνομα> = <τιμή>
+        int fooInt = 1;
+        // Αρχικοποιούμε πολλαπλές μεταβλητές ιδίου τύπου με την ίδια τιμή 
+        // χρησιμοποιώντας <τύπος> <Όνομα1>, <Όνομα2>, <Όνομα3> = <τιμή>
+        int fooInt1, fooInt2, fooInt3;
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Τύποι μεταβλητών
+        */
+        // Byte - 8-bit signed two's complement integer
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - 16-bit signed two's complement integer
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-bit signed two's complement integer
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - 64-bit signed two's complement integer
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // Το L χρησιμοποιείται για να δηλώσει ότι η συγκεκριμένη τιμή της 
+        // μεταβλητής είναι τύπου Long;
+        // Ό,τιδήποτε χρησιμοποιείται χωρίς αυτό τυχαίνει μεταχείρισης όπως 
+        // μία τιμή μεταβλητής integer by default.
+
+        // Σημείωση: Η Java δεν έχει unsigned τύπους.
+
+        // Float - Single-precision 32-bit IEEE 754 Floating Point
+        // 2^-149 <= float <= (2-2^-23) * 2^127 
+        float fooFloat = 234.5f;
+        // f or F χρησιμοποιείται για να δηλώσει ότι η συγκεκριμένη τιμή 
+        // μεταβλητής είναι τύπου float;
+        // αλλιώς τυγχαίνει μεταχείρισης όπως μία τιμή μεταβλητής double.
+
+        // Double - Double-precision 64-bit IEEE 754 Floating Point
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Boolean - Αληθής και Ψευδής (true & false)
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - Ένας μόνο χαρακτήρας 16-bit Unicode
+        char fooChar = 'A';
+
+        // Οι μεταβλητές final δεν μπορούν να ανατεθούν ξανά σε άλλο 
+        // αντικείμενο,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // αλλά μπορούν να αρχικοποιηθούν αργότερα.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger - Immutable αυθαίρετης-ακρίβειας ακέραιος
+        //
+        // Ο BigInteger είναι ένας τύπος δεδομένων ο οποίος επιτρέπει στους 
+        // προγραμματιστές να χειρίζονται ακέραιους μεγαλύτερους από 64-bits. 
+        // Οι ακέραιοι αποθηκεύονται ως πίνακας από bytes και τυχαίνουν 
+        // επεξεργασίας χρησιμοποιώντας συναρτήσεις εσωματωμένες στην κλάση 
+        // BigInteger
+        // Ένας BigInteger μπορεί να αρχικοποιηθεί χρησιμοποιώντας ένα πίνακα 
+        // από bytes ή γραμματοσειρά (string).
+        
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+
+        // BigDecimal - Immutable, αυθαίρετης-ακρίβειας, εμπρόσημος (signed)
+        //  δεκαδικός αριθμός
+        //
+        // Ένας BigDecimal παίρνει δύο μέρη: Μία αυθαίρετης ακρίβειας, 
+        // ακέραια, unscaled τιμή και μία κλιμάκωση(scale) ως ένα 32-bit 
+        // ακέραιο (integer).
+        //
+        // Ο BigDecimal επιτρέπει στον προγραμματιστή να έχει πλήρη έλεγχο 
+        // όσον αφορά τη δεκαδική στρογγυλοποίηση (rounding). Προτείνεται η 
+        // χρήση του BigDecimal με τιμές νομισμάτων και όπου απαιτείται η 
+        // ακριβής δεκαδική ακρίβεια.
+        //
+        // Ο BigDecimal μπορεί να αρχικοποιηθεί με int, long, double ή String
+        // ή με την αρχικοποίηση της unscaled τιμής (BigInteger) και της 
+        // κλίμακας (scale) (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+        
+        // Χρειάζεται να είμαστε προσεκτικοί με τον κατασκευαστή (constructor) 
+        // ο οποίος παίρνει float ή double καθώς η ανακρίβεια του float/double 
+        // θα αντιγραφεί στον BigDecimal.
+        // Είναι προτιμότερο να χρησιμοποιείται ο κατασκευαστής String (String 
+        // constructor) όταν χρειάζεται ακριβής τιμή.
+        
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+        // Strings - Γραμματοσειρές
+        String fooString = "My String Is Here!";
+
+        // Ο χαρακτήρας \n είναι ένας χαρακτήρας διαφυγής (escaped character) 
+        // ο οποίος ξεκινά μία νέα γραμμή
+        String barString = "Printing on a new line?\nNo Problem!";
+        // Ο χαρακτήρας \t είναι ένας χαρακτήρας διαφυγής (escaped character)
+        // ο οποίος προσθέτει ένα χαρακτήρα tab
+        String bazString = "Do you want to add a tab?\tNo Problem!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Πίνακες (Arrays)
+        // Το μέγεθος του πίνακα πρέπει να αποφασιστεί με την αρχικοποίηση του
+        // πίνακα
+        // Οι ακόλουθες μορφές μπορούν να χρησιμοποιηθούν για την δήλωση ενός 
+        // πίνακα 
+        // <Τυπος δεδομένων>[] <Όνομα Μεταβλητής> = new <Τύπος Δεδομένων>[<μέγεθος πίνακα>];
+        // <Τυπος δεδομένων> <Όνομα Μεταβλητής>[] = new <Τυπος δεδομένων>[<μέγεθος πίνακα>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Ακόμη ένας τρόπος για να δηλώσεις (to declare) και να 
+        // αρχικοποιήσεις ένα πίνακα
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Ευρετηρίαση (indexing) ενός πίνακα - Πρόσβαση (accessing) ενός 
+        // στοιχείου
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Οι πίνακες ξεκινούν από το μηδέν (zero-indexed) και είναι ευμετάβλητοι (mutable).
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Παρόμοια
+        // ArrayLists - Παρόμοιοι με τους πίνακες με τη διαφορά ότι προσφέρουν 
+        // περισσότερη λειτουργικότητα και το μέγεθος είναι ευμετάβλητο 
+        // (mutable).
+        // LinkedLists - Υλοποίηση διπλά-συνδεδεμένης λίστας(doubly-linked 
+        // list). Όλες οι λειτουργίες εκτελώνται όπως αναμένεται σε μία διπλά 
+        // συνδεδεμένη (doubly-linked) λίστα.
+        // Maps - Ένα σύνολο αντικειμένων τα οποία συνδέου (map) κλειδιά (keys)
+        // σε τιμές (values). Ο Map είναι διεπαφή (interface) και συνεπώς δεν 
+        // μπορεί να συγκεκριμενοποίηθεί (instantiated).
+        // Ο τύπος των κλειδιών και των τιμών τα οποία συμπεριλαμβάνονται σε 
+        // ένα Map πρέπει να καθοριστεί κατά τη διάρκεια της 
+        // συγκεκριμενοποίησης (instantiation) της κλάσης που υλοποιεί τη 
+        // διεπαφή Map. Κάθε κλειδί (key) μπορεί να συνδεθεί (map) σε μόνο μία 
+        // αντίστοιχη τιμή και κάθε κλειδί μπορεί να εμφανιστεί μόνο μία φορά 
+        // (no duplicates).
+        // HashMaps - Η κλάση αυτή χρησιμοποιεί ένα πίνακα-κατακερματισμού 
+        // (hashtable) για να υλοποιήσει τη διεπαφή Map. Αυτό επιτρέπει το 
+        // χρόνο εκτέλεσης βασικών λειτουργιών, όπως της get και insert 
+        // στοιχείου να παραμείνει σταθερός (constant) ακόμη και για μεγάλα 
+        // σύνολα (sets.)
+
+
+        ///////////////////////////////////////
+        // Τελεστές (Operators)
+        ///////////////////////////////////////
+        System.out.println("\n->Operators");
+
+        int i1 = 1, i2 = 2; // Συντομογραφία για πολλαπλές δηλώσεις
+
+        // Οι αριθμητικοί τελεστές είναι απλοί
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns int)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Υπόλοιπο (Modulo)
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Τελεστές σύγκρισης
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Λογικοί Τελεστές (Boolean)
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Τελεστές πράξεων με bits (Bitwise)!
+        /*
+        ~      bitwise τελεστής μοναδιαίου συμπληρώματος (Unary bitwise complement)
+        <<     Προσημασμένη ολίσθηση αριστερά (Signed left shift)
+        >>     Προσημασμένη/Αριθμητική ολίσθηση Δεξιά (Signed/Arithmetic right shift)
+        >>>    Μη προσημασμένη/Λογική ολίσθηση δεξιά (Unsigned/Logical right shift)
+        &      Διαδικός τελεστής AND (Bitwise AND)
+        ^      Διαδικός τελεστής XOR (Bitwise exclusive OR)
+        |      Διαδικός τελεστής OR (Bitwise inclusive OR)
+        */
+
+        // Αυξητικοί τελεστές
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementation");
+        // Οι τελεστές ++ και -- μειώνουν και αυξάνουν κατά 1 αντίστοιχα.
+        // Εάν τοποθετητούν πριν τη μεταβλητή, αυξάνουν και μετά επιστρέφουν.
+        // Μετά τη μεταβλητή επιστρέφουν και μετά αυξάνουν.
+        System.out.println(i++); // i = 1, τυπώνει 0 (post-increment)
+        System.out.println(++i); // i = 2, τυπώνει 2 (pre-increment)
+        System.out.println(i--); // i = 1, τυπώνει 2 (post-decrement)
+        System.out.println(--i); // i = 0, τυπώνει 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Δομές ελέγχου (Control Structures)
+        ///////////////////////////////////////
+        System.out.println("\n->Control Structures");
+
+        // Οι δηλώσεις If είναι c-like
+        int j = 10;
+        if (j == 10) {
+            System.out.println("I get printed");
+        } else if (j > 10) {
+            System.out.println("I don't");
+        } else {
+            System.out.println("I also don't");
+        }
+
+        // Επανάληψη While (While loop)
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Άυξησε τον μετρητή
+            // Επανάλαβε 100 φορές, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("fooWhile Value: " + fooWhile);
+
+        // Επανάληψη Do While (Do While Loop)
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Άυξησε το μετρητή(counter)
+            // Επανάλαβε 99 times, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("fooDoWhile Value: " + fooDoWhile);
+
+        // Επανάληψη For (For Loop)
+        // Δομή επανάληψης for => 
+        // for(<Αρχική Δήλωση>; <προυπόθεση (conditional)>; <βήμα (step)>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iterated 10 times, fooFor 0->9
+        }
+        System.out.println("fooFor Value: " + fooFor);
+        
+        // Έξοδος από εμφωλευμένη (nested) επανάληψη For με ετικέττα (Label)
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // δραπετεύει εκτός της εξωτερικής(outer) επανάληψης αντί μόνο της εσωτερικής
+            }
+          }
+        }
+        
+        // Επανάληψη For Each
+        // Η επανάληψη for είναι επίσης ικανή να επαναλαμβάνεται τόσο σε 
+        // πίνακες όσο και σε αντικείμενα τα οποία υλοποιούν τη διεπαφή 
+        // Iterable.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // Σύνταξη της επανάληψης for each => for (<αντικείμενο> : <iterable>)
+        // Διαβάζεται ως: Για κάθε αντικείμενο στο iterable
+        // Σημείωση: ο τύπος του αντικειμένου πρέπει να τεριάζει με τον τύπο του στοιχείου του iterable.
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //Επαναλαμβάνεται 9 φορές και τυπώνει 1-9 σε καινούριες γραμμές
+        }
+
+        // Switch Case
+        // Ένα switch δουλέυει με byte, short, char, και int τύπους δεδομένων.
+        // Δουλέυει επίσης με τύπους enumerated (Συζήτηση στους τύπους Enum), 
+        // τη κλάση String, και μερικές ειδικές περιπτώσεις οι οποίες 
+        // περιλαμβάνουν primitive τύπους: Character, Byte, Short, and Integer.
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "January";
+                    break;
+            case 2: monthString = "February";
+                    break;
+            case 3: monthString = "March";
+                    break;
+            default: monthString = "Some other month";
+                     break;
+        }
+        System.out.println("Switch Case Result: " + monthString);
+        
+        // Αρχίζοντας από τη Java 7, switching για Strings δουλεύει έτσι:
+        String myAnswer = "maybe";
+        switch(myAnswer) {
+            case "yes":
+                System.out.println("You answered yes.");
+                break;
+            case "no":
+                System.out.println("You answered no.");
+                break;
+            case "maybe":
+                System.out.println("You answered maybe.");
+                break;
+            default:
+                System.out.println("You answered " + myAnswer);
+                break;
+        }
+
+        // Συντομογραφία του Conditional
+        // Μπορείς να χρησιμοποιήσεις τον τελεστή '?' για γρήγορες αναθέσεις ή 
+        // logic forks. Διαβάζεται ως "Αν η (πρόταση) είναι αληθής, 
+        // χρησιμοποίησε <την πρώτη τιμή>, αλλιώς, χρησιμοποία <την δεύτερη 
+        // τιμή>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Prints A, because the statement is true
+
+
+        ////////////////////////////////////////
+        // Μετατροπή Τύπων Δεδομένων και Typecasting
+        ////////////////////////////////////////
+
+        // Μετατροπή δεδομένων
+
+        // Μετατροπή από String σε Integer
+        Integer.parseInt("123");//returns an integer version of "123"
+
+        // Μετατροπή από Integer σε String
+        Integer.toString(123);//returns a string version of 123
+
+        // Για άλλες μετατροπές δες τις ακόλουθες κλάσεις:
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // Μπορείς επίσης να κάνεις cast αντικείμενα Java. Υπάρχουν πολλές 
+        // λεπτομέρειες και μερικές πραγματεύονται κάποιες πιο προχωρημένες 
+        // ένοιες. Για δες εδώ:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Κλάσεις και Συναρτήσεις
+        ///////////////////////////////////////
+
+        System.out.println("\n->Classes & Functions");
+
+        // (Ο ορισμός της κλάσης Bicycle ακολουθεί)
+
+        // Χρησιμοποία το new για να δημιουργήσεις ένα αντικείμενο μίας κλάσης
+        Bicycle trek = new Bicycle();
+
+        // Κλήση μεθόδων του αντικειμένου
+        trek.speedUp(3); // Πάντοτε πρέπει να χρησιμοποιείς μεθόδους setter 
+        // και getter
+        trek.setCadence(100);
+
+        // Το toString επιστρέφει την αναπαράσταση σε String μορφή του 
+        // αντικειμένου αυτού.
+        System.out.println("trek info: " + trek.toString());
+
+        // Double Brace Initialization
+        // Η Γλώσσα Java δεν έχει σύνταξη για το πως να δημιουργήσεις static 
+        // Collections με κάποιο εύκολο τρόπο. Συνήθως θα το κάνεις αυτό με 
+        // τον παρακάτω τρόπο:
+
+        private static final Set<String> COUNTRIES = new HashSet<String>();
+        static {
+           validCodes.add("DENMARK");
+           validCodes.add("SWEDEN");
+           validCodes.add("FINLAND");
+        }
+
+        // Αλλά υπάρχει ένας κομψός τρόπος να επιτύχεις το ίδιο πράγμα
+        // ευκολότερα, χρησιμοποιώντας κάτι το οποίο λέγεται Double Brace
+        // Initialization.
+
+        private static final Set<String> COUNTRIES = new HashSet<String>() {{
+            add("DENMARK");
+            add("SWEDEN");
+            add("FINLAND");
+        }}
+
+        // Η πρώτη αγκύλη δημιουργεί μία νέα AnonymousInnerClass και η
+        // δεύτερη δηλώνει ένα instance initializer block. Το block
+        // καλείται όταν η ανώνυμη εσωτερική κλάση δημιουργηθεί.
+        // Η μέθοδος αύτή δεν δουλεύει μόνο για τις Collections, αλλά για όλες 
+        // τις non-final κλάσεις.
+
+    } // Τέλος μεθόδου main
+} // Τέλος κλάσης LearnJava
+
+
+// Μπορείς να κάνεις include άλλες, όχι-δημόσιες (non-public) 
+// εξωτερικού-επιπέδου (outer-level) κλάσεις σε ένα αρχείο .java, αλλά δεν 
+// είναι καλή πρακτική. Αντί αυτού, διαχώρησε τις κλάσεις σε ξεχωριστά αρχεία.
+
+// Σύνταξη Δήλωσης Κλάσης (Class Declaration Syntax):
+// <public/private/protected> class <class name> {
+//    // Συμπεριλαμβάνονται πεδία δεδομένων (data fields), κατασκευαστές (constructors), συναρτήσεις (functions) .
+//    // Οι συναρτήσεις ονομάζονται "μεθόδοι" στη Java.
+// }
+
+class Bicycle {
+
+    // Πεδία/μεταβλητές της Κλάσης Bicycle
+    // Public(Δημόσιες): Μπορούν να γίνουν προσβάσιμες από παντού
+    public int cadence; 
+    // Private(Ιδιωτικές): Προσβάσιμες μόνο εντός της κλάσης
+    private int speed;  
+    // Protected(Προστατευμένες): Προσβάσιμες από την κλάση και τις υποκλάσεις (subclasses) της
+    protected int gear; 
+    String name; // Προκαθορισμένο: Προσβάσιμη μόνο εντός του πακέτου
+
+    static String className; // Static μεταβλητή κλάσης
+
+    // Static block 
+    // H Java δεν υποστηρίζει υλοποίησεις στατικών κατασκευαστών (static 
+    // constructors), αλλά έχει ένα static block το οποίο μπορεί να 
+    // χρησιμοποιηθεί για να αρχικοποιήσει στατικές μεταβλητές (static 
+    // variables). Το block αυτό θα καλεσθεί όταν η κλάση φορτωθεί.
+    static {
+        className = "Bicycle";
+    }
+
+    // Οι κατασκευαστές (constructors) είναι ένας τρόπος για δημιουργία κλάσεων
+    // Αυτός είναι ένας κατασκευαστής (constructor)
+    public Bicycle() {
+        // Μπορείς επίσης να καλέσεις άλλο κατασκευαστή:
+        // this(1, 50, 5, "Bontrager");
+        gear = 1;
+        cadence = 50;
+        speed = 5;
+        name = "Bontrager";
+    }
+
+    // Αυτός είναι ένας κατασκευαστής ο οποίος δέχεται arguments
+    public Bicycle(int startCadence, int startSpeed, int startGear,
+        String name) {
+        this.gear = startGear;
+        this.cadence = startCadence;
+        this.speed = startSpeed;
+        this.name = name;
+    }
+
+    // Οι μεθόδοι (Methods) συντάσσονται ως ακολούθως:
+    // <public/private/protected> <return type> <όνομα μεθόδου>(<args>)
+
+    // Οι κλάσεις Java συχνά υλοποιούν getters and setters for their fields
+
+    // Σύνταξη δήλωσης μεθόδου:
+    // <Προσδιοριστές πρόσβασης> <τύπος επιστροφής> <όνομα μεθόδου>(<args>)
+    public int getCadence() {
+        return cadence;
+    }
+
+    // Οι μεθόδοι void δεν απαιτούν return statement
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+
+    public void slowDown(int decrement) {
+        speed -= decrement;
+    }
+
+    public void setName(String newName) {
+        name = newName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    //Μέθοδος η οποία επιστρέφει ως String τις τιμές των χαρακτηριστικών του 
+    // αντικειμένου.
+    @Override // Χρησιμοποιείται, καθώς η συγκεκριμένη μέθοδος κληρονομήθηκε από τη κλάση Object.
+    public String toString() {
+        return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+            " name: " + name;
+    }
+} // Τέλος κλάσης Bicycle
+
+// Η PennyFarthing είναι υποκλάση της Bicycle
+class PennyFarthing extends Bicycle {
+    // (Tα Penny Farthings είναι τα ποδήλατα με τον μεγάλο μπροστινό τροχό.
+    // Δεν έχουν ταχύτητες.)
+
+    public PennyFarthing(int startCadence, int startSpeed) {
+        // Κάλεσε τον parent constructor χρησιμοποιώντας το super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // Χρειάζεται να μαρκάρεις τη μέθοδο την οποία κάνεις overriding 
+    // χρησιμοποιώντας ένα @annotation.
+    // Για να μάθεις περισσότερα σχετικά με το τι είναι οι επισημάνσεις 
+    // (annotations) και τον σκοπό τους δες αυτό: 
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int gear) {
+        gear = 0;
+    }
+}
+
+// Διεπαφές (Interfaces)
+// Σύνταξη δήλωσης διεπαφής
+// <access-level> interface <interface-name> extends <super-interfaces> {
+//     // Σταθερές (Constants)
+//     // Δηλώσεις Μεθόδων (Method declarations)
+// }
+
+// Παράδειγμα - Food:
+public interface Edible {
+    public void eat(); // Κάθε κλάση η οποία υλοποιεί τη διεπαφή αυτή πρέπει 
+    // να υλοποιήσει τη συγκεκριμένη μέθοδο.
+}
+
+public interface Digestible {
+    public void digest();
+}
+
+
+// Μπορούμε να δημιουργήσουμε μία κλάση η οποία υλοποιεί και τις δύο αυτές διεπαφές.
+public class Fruit implements Edible, Digestible {
+  
+    @Override
+    public void eat() {
+        // ...
+    }
+
+    @Override
+    public void digest() {
+        // ...
+    }
+}
+
+// Στην Java, μπορείς να κληρονομήσεις (extend) από μόνο μία κλάση,
+// αλλά μπορείς να υλοποιήσεις πολλές διεπαφές. Για παράδειγμα:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+    InterfaceTwo {
+
+    @Override
+    public void InterfaceOneMethod() {
+    }
+
+    @Override
+    public void InterfaceTwoMethod() {
+    }
+
+}
+
+// Abstract (Αφηρημένες) Κλάσεις
+
+// Σύνταξη Δήλωσης Abstract Κλάσης
+// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
+//     // Σταθερές και μεταβλητές
+//     // Δηλώσεις μεθόδων
+// }
+
+// Μαρκάροντας μία κλάση ως abstract σημαίνει ότι περιέχει abstract μεθόδους
+// οι οποίες πρέπει να οριστούν σε μία κλάση παιδί (child class).
+// Παρόμοια με τις διεπαφές (interfaces), οι abstract κλάσεις δεν μπορούν να
+// γίνουν instantiated, αλλά αντί αυτού πρέπει να γίνει extend και οι abstract
+// μεθόδοι πρέπει να οριστούν. Διαφορετικά από τις Διεπαφές, οι abstract 
+// κλάσεις μπορούν να περιέχουν τόσο υλοποιημένες όσο και abstract μεθόδους.
+// Οι μεθόδοι σε μια Διεπαφή δεν μπορούν να έχουν σώμα (δεν είναι υλοποιημένες 
+// δηλαδή εκτός εάν η μέθοδος είναι στατική και οι μεταβλητές είναι final by 
+// default αντίθετα απο μία abstract κλάση. Επίσης, οι abstract κλάσεις 
+// ΜΠΟΡΟΥΝ να έχουν την μέθοδο "main".
+
+public abstract class Animal
+{
+    public abstract void makeSound();
+
+    // Οι μεθόδοι μπορούν να έχουν σώμα (body)
+    public void eat()
+    {
+        System.out.println("I am an animal and I am Eating.");  
+        // Σημείωση: Μπορούμε να έχουμε πρόσβαση σε ιδιωτικές (private) μεταβλητές εδώ.
+        age = 30;
+    }
+
+    // Δεν χρειάζεται να αρχικοποιηθεί, εντούτοις σε ένα interface μία 
+    // μεταβλητή είναι implicitly final και έτσι χρειάζεται να αρχικοποιηθεί
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Οι Abstract κλάσεις μπορούν να έχουν συνάρτηση main.
+    public static void main(String[] args)
+    {
+        System.out.println("I am abstract");
+    }
+}
+
+class Dog extends Animal
+{
+    // Σημείωση ότι χρειάζεται να κάνουμε override τις abstract μεθόδους στην
+    // abstract κλάση.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Bark");
+        // age = 30;	==> ERROR!	Το πεδίο age είναι private στο Animal
+    }
+
+    // ΣΗΜΕΙΩΣΗ: Θα πάρεις error εάν χρησιμοποίησεις το
+    // @Override annotation εδώ, καθώς η java δεν επιτρέπει
+    // να γίνονται override οι static μεθόδοι.
+    // Αυτό που γίνεται εδώ ονομάζεται METHOD HIDING.
+    // Για δες αυτό το εξαιρετικό ποστ στο SO (Stack Overflow): http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Κλάσεις Final
+
+// Σύνταξη δήλωσης μίας Final κλάσης
+// <access-level> final <final-class-name> {
+//     // Σταθερές και μεταβλητές
+//     // Δήλωση μεθόδων
+// }
+
+// Οι κλάσεις Final είναι κλάσεις οι οποίες δεν μπορούν να κληρονομηθούν και 
+// συνεπώς είναι final child. In a way, final classes are the opposite of 
+// abstract classes because abstract classes must be extended, but final 
+// classes cannot be extended.
+public final class SaberToothedCat extends Animal
+{
+    // Σημείωση ότι χρειάζεται και πάλι να κάνουμε override τις abstract 
+    // μεθόδους στην abstract κλάση.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Τελικές (Final) μεθόδοι
+public abstract class Mammal()
+{
+    // Σύνταξη μίας Final μεθόδου:
+    // <Προσδιοριστής πρόσβασης (access modifier)> final <τύπος επιστροφής> <Όνομα μεθόδου>(<args>)
+
+    // Οι Final μεθόδοι, όπως και οι final κλάσεις δεν μπορούν να γίνουν 
+    // overridden από κλάση παιδί,
+    // και είναι συνεπώς η τελική υλοποίηση της μεθόδου.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+}
+
+
+// Τύποι Enum
+//
+// Ένας τύπος enum είναι ένας ειδικός τύπος δεδομένων, ο οποίος επιτρέπει σε 
+// μια μεταβλητή να είναι ένα σύνολο από προκαθορισμένες σταθερές. Η μεταβλητή 
+// πρέπει να είναι ίση με μία από τις τιμές αυτές που έχουν προκαθοριστεί. 
+// Επειδή είναι σταθερές, τα ονόματα ενός enum πεδίου γράφονται με κεφαλαίους 
+// χαρακτήρες. Στην γλώσσα προγραμματισμού Java, ορίζεις ένα τύπο enum 
+// χρησιμοποιώντας τη δεσμευμένη λέξη enum. Για παράδειγμα, θα μπορούσες να 
+// καθορίσεις ένα τύπο enum με όνομα days-of-the-week ως:
+
+public enum Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY 
+}
+
+// Μπορούμε να χρησιμοποιήσουμε τον enum Day όπως παρακάτω:
+
+public class EnumTest {
+    
+    // Μεταβλητή Enum
+    Day day;
+    
+    public EnumTest(Day day) {
+        this.day = day;
+    }
+    
+    public void tellItLikeItIs() {
+        switch (day) {
+            case MONDAY:
+                System.out.println("Mondays are bad.");
+                break;
+                    
+            case FRIDAY:
+                System.out.println("Fridays are better.");
+                break;
+                         
+            case SATURDAY: 
+            case SUNDAY:
+                System.out.println("Weekends are best.");
+                break;
+                        
+            default:
+                System.out.println("Midweek days are so-so.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        EnumTest firstDay = new EnumTest(Day.MONDAY);
+        firstDay.tellItLikeItIs(); // => Mondays are bad.
+        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+        thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
+    }
+}
+
+// Οι τύποι Enum είναι πολύ πιο δυνατοί από όσο έχουμε δείξει πιο πάνω. 
+// Το σώμα του enum (enum body) μπορεί να περιέχει μεθόδους και άλλα πεδία.
+// Μπορείς να δεις περισσότερα στο 
+// https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Επιπλέων διάβασμα
+
+Οι σύνδεσμοι που παρέχονται εδώ είναι απλά για να κατανοήσεις περισσότερο το θέμα.
+Σε προτρύνουμε να ψάξεις στο Google και να βρεις συγκεκριμένα παραδείγματα.
+
+**Eπίσημοι Οδηγοί της Oracle**:
+
+* [Φροντιστήριο εκμάθησης Java από τη Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Τροποποιητές επιπέδου πρόσβασης(Access level modifiers) Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Έννοιες αντικειμενοστραφούς (Object-Oriented) προγραμματισμού](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Κληρονομικότητα (Inheritance)](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Πολυμορφισμός (Polymorphism)](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Αφαιρετικότητα (Abstraction)](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Εξαιρέσεις (Exceptions)](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Διεπαφές (Interfaces)](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Συμβάσεις κώδικα Java (Code Conventions)](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+**Πρακτικές και Φροντιστήρια Online**
+
+* [Learneroo.com - Μάθε Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Βιβλία**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)