Εκμάθηση Scala

Σύνοψη φροντιστηρίου Scala

Αυτό το σεμινάριο scala καλύπτει όλες τις πτυχές και τα θέματα του scala. Θα μάθετε όλες τις βασικές αρχές από την αρχή, όπως Τι είναι η κλίμακα, τη διαδικασία εγκατάστασης της κλίμακας, προγράμματα Scala, Λειτουργίες Scala, τεμπέλης αξιολόγηση, διεπαφή τύπου, κλάσεις και αντικείμενα, κληρονομικότητα, αφαιρέσεις, Java και διαφορές κλίμακας κ.λπ.

Η Scala είναι μια κλιμακούμενη γλώσσα που χρησιμοποιείται για τη σύνταξη λογισμικού για πολλές πλατφόρμες. Ως εκ τούτου, πήρε το όνομα "Scala". Αυτή η γλώσσα προορίζεται να λύσει τα προβλήματα του Java ενώ ταυτόχρονα είναι πιο συνοπτικό. Αρχικά σχεδιάστηκε από τον Martin Odersky, κυκλοφόρησε το 2003.

Γιατί να μάθεις Scala

Εδώ είναι οι κύριοι λόγοι για την εκμάθηση της γλώσσας προγραμματισμού Scala:

• Το Scala είναι εύκολο στην εκμάθηση για αντικειμενοστραφή προγραμματιστές, Java προγραμματιστές. Γίνεται μια από τις δημοφιλείς γλώσσες τα τελευταία χρόνια.
• Η Scala προσφέρει λειτουργίες πρώτης κατηγορίας για τους χρήστες
• Το Scala μπορεί να εκτελεστεί στο FMV, ανοίγοντας έτσι το δρόμο για τη διαλειτουργικότητα με άλλες γλώσσες.
• Έχει σχεδιαστεί για εφαρμογές που βασίζονται σε ταυτόχρονες, κατανεμημένες και ανθεκτικές σε μηνύματα. Είναι μια από τις πιο απαιτητικές γλώσσες αυτής της δεκαετίας.
• Είναι συνοπτική, ισχυρή γλώσσα και μπορεί να αναπτυχθεί γρήγορα σύμφωνα με τη ζήτηση των χρηστών της.
• Είναι αντικειμενοστραφή και έχει πολλά λειτουργικά χαρακτηριστικά προγραμματισμού παρέχοντας μεγάλη ευελιξία στους προγραμματιστές να κωδικοποιούν με τον τρόπο που θέλουν.
• Η Scala προσφέρει πολλούς τύπους πάπιας
• Έχει λιγότερη λέβητα αν έρχεστε από Java
• Τα πλαίσια Lift και Play που γράφτηκαν στο Scala βρίσκονται στην καμπύλη ανάπτυξης.

Πώς να εγκαταστήσετε το Scala

Για να ξεκινήσετε τη σύνταξη προγραμμάτων Scala, πρέπει να το έχετε εγκαταστήσει στον υπολογιστή σας. Για να το κάνετε αυτό, θα πρέπει να επισκεφτείτε τον ιστότοπό τους https://www.scala-lang.org/download/ για να κατεβάσετε την πιο πρόσφατη έκδοση του Scala.

Ακολουθώντας τον σύνδεσμο, οδηγούμαστε σε δύο επιλογές που μπορούμε να επιλέξουμε για να εγκαταστήσουμε το Scala στα μηχανήματα μας. Για αυτό το σεμινάριο Scala, θα κατεβάσουμε το IntelliJ IDEA.

Μόλις επισκεφτείτε τον σύνδεσμο λήψης, θα βρείτε δύο εκδόσεις του IntelliJ IDE.

Για αυτό το σεμινάριο Scala, θα κατεβάσουμε την Έκδοση Κοινότητας, η οποία είναι δωρεάν και συνοδεύεται από όλα όσα χρειάζεστε για να γράψετε προγράμματα Scala.

Βήμα 1) Επιλέξτε Έκδοση Κοινότητας
Στη σελίδα, κάντε κλικ στο αναπτυσσόμενο μενού στην Έκδοση Κοινότητας.

Μας παρουσιάζει μια επιλογή λήψης του IntelliJ IDE μαζί με το JBR που περιέχει μια υλοποίηση JDK(Java Development Kit) OpenJDK το οποίο χρειάζεται η Scala για να μεταγλωττίσει και να εκτελέσει τον κώδικα.

Βήμα 2) Εκτελέστε την εγκατάσταση
Μόλις κάνετε λήψη του IntelliJ, κάντε διπλό κλικ σε αυτό για να εκτελέσετε τον οδηγό εγκατάστασης και ακολουθήστε το παράθυρο διαλόγου.

Βήμα 3) Επιλέξτε μια τοποθεσία
Επιλέξτε μια τοποθεσία για να εγκαταστήσετε το IDE.

Εάν κατά τύχη δεν κατεβάσατε αυτό με το JDK, θα συνεχίσουμε να λαμβάνουμε ένα μήνυμα προτροπής όπου μπορούμε να ελέγξουμε τη λήψη του επιλέγοντας το πλαίσιο ελέγχου.

Βήμα 4) Κάντε κλικ στο επόμενο
Αφήστε τις υπόλοιπες προεπιλογές ως έχουν και κάντε κλικ στο επόμενο.

Βήμα 5) Κάντε κλικ στο εικονίδιο εκκίνησης
Μόλις ολοκληρωθεί η εγκατάσταση, εκτελέστε το IntelliJ IDE κάνοντας κλικ στο εικονίδιο εκκίνησης στο μενού εκκίνησης όπως μια κανονική εφαρμογή.

Πρέπει ακόμα να περάσετε από ένα επιπλέον βήμα για την προσθήκη της προσθήκης Scala στο IntelliJ. το κάνετε κάνοντας κλικ στο αναπτυσσόμενο μενού στο μενού διαμόρφωσης που βρίσκεται κάτω δεξιά στην οθόνη και επιλέγοντας την επιλογή προσθήκης.

Στην καρτέλα Marketplace, μια αναζήτηση για το Scala θα εμφανίσει την προσθήκη ως το πρώτο αποτέλεσμα κάτω από την ετικέτα Γλώσσες.

Βήμα 6) Εγκαταστήστε την προσθήκη
Κάντε κλικ στην εγκατάσταση, η οποία θα οδηγήσει την προσθήκη στην αρχή της λήψης.

Βήμα 7) Επανεκκινήστε το IDE
Μετά την ολοκλήρωση της λήψης, θα σας ζητηθεί να επανεκκινήσετε το IDE, ώστε το εγκατεστημένο πρόσθετο να αρχίσει να λειτουργεί.

Μετά την επανεκκίνηση, θα βρεθείτε στην ίδια σελίδα με πριν όταν εκτελούσαμε το IDE, αλλά αυτή τη φορά έχουμε ήδη εγκαταστήσει το πρόσθετο Scala.

Πρόγραμμα Scala Hello World

Βήμα 1) Επιλέξτε την επιλογή Δημιουργία έργου, η οποία θα μας οδηγήσει σε μια σελίδα όπου μπορούμε να επιλέξουμε το είδος της γλώσσας που θα χρησιμοποιεί το έργο μας.

Βήμα 2) επιλέξτε Scala επιλέγοντας το πλαίσιο ελέγχου Scala και κάντε κλικ στο επόμενο.

Βήμα 3) Επιλέξτε μια τοποθεσία για να αποθηκεύσετε το αρχείο των έργων μας και δώστε ένα όνομα στο έργο μας.

Εάν ο κατάλογος δεν υπάρχει, το IntelliJ θα μας ζητήσει να μας ζητήσουμε άδεια για τη δημιουργία του φακέλου. Αποδοχή και κάντε κλικ στο Τέλος. Θα μεταφερθείτε στο έργο σας Scala, το οποίο προς το παρόν δεν διαθέτει κωδικό Scala.

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

Βήμα 4) Στη συνέχεια, θα κάνουμε κλικ στην καρτέλα έργα στα αριστερά του IDE και θα επεκτείνουμε ώστε να μπορούμε να δούμε τα περιεχόμενα του έργου μας.

Αυτή τη στιγμή το έργο είναι κενό και περιέχει μόνο έναν φάκελο .idea και ένα αρχείο hello-world.iml που δημιουργήθηκε από το IDE. Το σημείο ενδιαφέροντός μας είναι ο φάκελος src. Το Src είναι όπου αποθηκεύουμε τον πηγαίο κώδικα για το έργο μας. Εκεί θα δημιουργήσουμε το πρώτο μας αρχείο Scala.

Βήμα 5) Κάντε δεξί κλικ στο src για να ανοίξετε ένα μενού για να δημιουργήσετε ένα νέο αρχείο Scala.

Στη συνέχεια, θα δημιουργήσουμε ένα όνομα για το αρχείο, σε αυτό το σεμινάριο Scala θα χρησιμοποιήσουμε το hello και, στη συνέχεια, θα επιλέξουμε από ένα αναπτυσσόμενο μενού τι θα βάλουμε ως περιεχόμενο του αρχείου Scala. Επιλέξτε "Αντικείμενο"

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

Τώρα που έχετε ένα αρχείο Scala με ένα αντικείμενο Hello. Θα γράψετε το πρώτο σας πρόγραμμα επεκτείνοντας το αντικείμενο που έχετε δημιουργήσει χρησιμοποιώντας τη λέξη-κλειδί App.

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

Μέσα στο αντικείμενο Hello, γράφουμε μια συνάρτηση println() που χρησιμοποιείται για την εκτύπωση του κειμένου μέσα σε αυτό στην κονσόλα. Θα τρέξουμε τον κωδικό μας κάνοντας κλικ στο πράσινο βέλος.

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

Και εδώ πάμε, εγκαταστήσαμε με επιτυχία το Scala και εκτελέσαμε το πρώτο μας πρόγραμμα.

Τι μπορείτε να κάνετε με τη Scala

• Ανάπτυξη ιστοσελίδων Frontend με ScalaJS
• Ανάπτυξη κινητής τηλεφωνίας και τα δύο Android Ανάπτυξη και IOS – με τη Scala Native
• Βιβλιοθήκες από την πλευρά του διακομιστή όπως HTTP4S, Akka-Http, Play Framework
• Χρήση του Διαδικτύου των πραγμάτων
• Ανάπτυξη παιχνιδιών
• NLP – Επεξεργασία φυσικής γλώσσας με χρήση μιας σειράς βιβλιοθηκών ScalaNLP
• Δοκιμή προηγμένων τεχνικών προγραμματισμού όπως ο Λειτουργικός Προγραμματισμός και ο Αντικειμενοστρεφής Προγραμματισμός
• Δημιουργήστε μια εξαιρετικά ταυτόχρονη εφαρμογή επικοινωνίας χρησιμοποιώντας ηθοποιούς μια βιβλιοθήκη για το JVM εμπνευσμένη από τον Erlang
• Χρησιμοποιήστε το για μηχανική εκμάθηση χρησιμοποιώντας βιβλιοθήκες όπως η Figaro που κάνει πιθανολογικό προγραμματισμό και Apache Spark ότι

Ανώνυμες Λειτουργίες

Η γλώσσα Scala έχει ανώνυμες λειτουργίες, οι οποίες ονομάζονται επίσης συνάρτηση κυριολεκτικά. Η Scala είναι μια λειτουργική γλώσσα συχνά σημαίνει ότι οι προγραμματιστές αναλύουν μεγάλα προβλήματα σε πολλές μικρές εργασίες και δημιουργούν πολλές λειτουργίες για την επίλυση αυτών των προβλημάτων. Για να είναι εύκολη η δημιουργία συναρτήσεων, το Scala περιέχει αυτές τις λειτουργίες που μπορούν να είναι στιγμιότυπα χωρίς όνομα. Μπορούμε να τα αντιστοιχίσουμε απευθείας σε μεταβλητές ή ορισμούς 'def' όπως φαίνεται στο παρακάτω παράδειγμα Scala:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n *3

Στη συνέχεια, μπορούμε να χρησιμοποιήσουμε τον κανονικό τρόπο που χρησιμοποιούμε τις συναρτήσεις περνώντας παραμέτρους σε αυτές που ακολουθεί.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

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

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

val sayHello = ()=>{ println("hello") }

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

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

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

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

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

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

Στο Scala, είναι επίσης δυνατή η χρήση χαρακτήρων μπαλαντέρ όπου η παράμετρος της ανώνυμης συνάρτησής μας δεν έχει όνομα. Για παράδειγμα

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Σε αυτό το σενάριο, δεν ονομάζουμε την παράμετρο που μεταβιβάζουμε. Το μόνο πράγμα που χρησιμοποιούμε μια υπογράμμιση για να την αντιπροσωπεύουμε.

Τεμπέλης Αξιολόγηση

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

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

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

lazy val myExpensiveValue = expensiveComputation

def runMethod()={
    if(settings == true){
        use(myExpensiveValue)
    }else{
        use(otherValue)
    }
}

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

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

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

Η τεμπελιά βοηθά επίσης με ορίσματα συναρτήσεων, όπου τα ορίσματα χρησιμοποιούνται μόνο όταν αναφέρονται μέσα στη συνάρτηση. Αυτή η έννοια ονομάζεται παράμετροι Call-by-name.

def sometimesUsedString(someValue:String, defaultValue:=> String)={
 if(someValue != null){
   use(defaultValue)
 }else{
   use(someValue)
   }
 }

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

Τύπος συμπέρασμα

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

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compile infers that third is of type String

Λειτουργία ανώτερης τάξης

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

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int ={
    myMathFunction(n)
}

Στην παραπάνω συνάρτηση περνάμε int και συνάρτηση που παίρνει int και επιστρέφει int. Μπορούμε να περάσουμε σε οποιαδήποτε λειτουργία αυτής της υπογραφής. Με τον όρο υπογραφή, εννοούμε την είσοδο και την έξοδο μιας συνάρτησης. Μια υπογραφή του Int=>Int σημαίνει ότι μια συνάρτηση παίρνει ένα Int ως είσοδο και επιστρέφει ένα Int ως έξοδο.

Μια υπογραφή του ()=>Int σημαίνει ότι μια συνάρτηση δεν παίρνει τίποτα ως είσοδο και επιστρέφει ένα Int ως έξοδο. Ένα παράδειγμα μιας συνάρτησης όπως αυτή θα ήταν αυτή που δημιουργεί ένα τυχαίο int για εμάς.

def generateRandomInt()={
 return scala.util.Random.nextInt()
}

Η παραπάνω συνάρτηση έχει υπογραφή ()=>Int

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

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

Μια συνάρτηση υψηλότερης τάξης μπορεί επίσης να επιστρέψει μια συνάρτηση.

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

def powerByFunction(n:Int):Int=>Int = {
  return (x:Int)=> scala.math.pow(x,n).toInt
}

Η παραπάνω συνάρτηση παίρνει ένα int. Ο τύπος επιστροφής μας είναι μια ανώνυμη συνάρτηση που παίρνει ένα Int x, * χρησιμοποιούμε το int x ως όρισμα για τη συνάρτηση ισχύος.

Κάρυ

Στο Scala, μπορούμε να μετατρέψουμε μια συνάρτηση που παίρνει δύο ορίσματα σε ένα που παίρνει ένα όρισμα τη φορά. Όταν περνάμε σε ένα όρισμα, το εφαρμόζουμε εν μέρει και καταλήγουμε σε μια συνάρτηση που χρειάζεται ένα όρισμα για να ολοκληρώσει τη συνάρτηση. Το Curry μας δίνει τη δυνατότητα να δημιουργήσουμε συναρτήσεις προσθέτοντας εν μέρει ορισμένα ορίσματα.

Αυτό μπορεί να είναι χρήσιμο για τη δυναμική δημιουργία συναρτήσεων πριν έχουμε ένα πλήρες σύνολο ορισμάτων

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Εάν πρέπει να δημιουργήσουμε μια συνάρτηση που πολλαπλασιάζεται με κάποιο συγκεκριμένο αριθμό, δεν χρειάζεται να δημιουργήσουμε άλλη μέθοδο πολλαπλασιασμού.

Μπορούμε απλά να καλέσουμε το .curried στη συνάρτησή μας παραπάνω και να λάβουμε μια συνάρτηση που παίρνει πρώτα ένα όρισμα και να επιστρέψει μια μερικώς εφαρμοσμένη συνάρτηση

def multiplyTwoNumbers(n:Int)(m:Int): Unit ={
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Αντιστοίχιση μοτίβου

Το Scala διαθέτει έναν ισχυρό ενσωματωμένο μηχανισμό που μας βοηθά να ελέγξουμε εάν μια μεταβλητή ταιριάζει με ορισμένα κριτήρια, όπως θα κάναμε σε μια δήλωση switch στο Java ή σε μια σειρά από δηλώσεις if/else. Η γλώσσα έχει αντιστοίχιση προτύπων που μπορούμε να χρησιμοποιήσουμε για να ελέγξουμε αν μια μεταβλητή είναι συγκεκριμένου τύπου. Η αντιστοίχιση μοτίβων στο Scala είναι ισχυρή και μπορεί να χρησιμοποιηθεί για την αποδομή των στοιχείων που έχουν μέθοδο μη εφαρμογής, προκειμένου να λάβουμε πεδία που μας ενδιαφέρουν απευθείας από τη μεταβλητή που αντιστοιχίζουμε.

Η αντιστοίχιση μοτίβων της Scala παρέχει επίσης μια πιο ευχάριστη σύνταξη σε σύγκριση με τη δήλωση διακόπτη.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

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

Χρησιμοποιούμε μια υπογράμμιση για να εντοπίσουμε περιπτώσεις που δεν ταιριάζουν στον κώδικά μας. Αντικατοπτρίζει τη συμπεριφορά της προεπιλεγμένης περίπτωσης όταν ασχολούμαστε με δηλώσεις διακόπτη.

class Animal(var legs:Int,var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //case we have a type we don't recognize do sth else
}

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

Η αντιστοίχιση προτύπων ελέγχει εάν η μεταβλητή ταιριάζει

Η υπογράμμιση λειτουργεί ως σύμβολο κράτησης θέσης που αντιστοιχεί σε οποιαδήποτε άλλη συνθήκη που δεν αντιστοιχεί στα άλλα στοιχεία στις παραπάνω δηλώσεις πεζών κεφαλαίων. Παίρνουμε μια μεταβλητή myItem και καλούμε τη μέθοδο αντιστοίχισης.

• ελέγχουμε αν το myItem είναι αληθές χρησιμοποιώντας και κάνουμε λίγη λογική στη δεξιά πλευρά του βέλους "=>".
• χρησιμοποιούμε την υπογράμμιση για να ταιριάξουμε με οτιδήποτε δεν ταιριάζει με καμία από τις δηλώσεις πεζών-κεφαλαίων που έχουμε ορίσει στον κώδικα.

Με τις κατηγορίες Case, μπορούμε ακόμη και να προχωρήσουμε περαιτέρω και να καταστρέψουμε την κλάση για να λάβουμε πεδία μέσα στο αντικείμενο.

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

Αμετάβλητο

Είναι δυνατό να δημιουργήσετε τιμές που δεν μπορούν να αλλάξουν από άλλες συναρτήσεις στο Scala χρησιμοποιώντας τη λέξη-κλειδί val. Αυτό επιτυγχάνεται σε Java χρησιμοποιώντας την τελική λέξη-κλειδί. Στο Scala, το κάνουμε χρησιμοποιώντας μια λέξη-κλειδί val όταν δημιουργούμε μια μεταβλητή αντί να χρησιμοποιούμε var, η οποία είναι η εναλλακτική που θα χρησιμοποιούσαμε για να δημιουργήσουμε μια μεταβλητή μεταβλητή.

Μια μεταβλητή που ορίζεται χρησιμοποιώντας τη λέξη-κλειδί val είναι μόνο για ανάγνωση, ενώ αυτή που ορίζεται με var μπορεί να διαβαστεί και να αλλάξει από άλλες συναρτήσεις ή αυθαίρετα από τον χρήστη στον κώδικα.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Η προσπάθεια εκχώρησης μιας τιμής στο myNumber αφού την έχουμε δηλώσει ως val δημιουργεί ένα σφάλμα χρόνου μεταγλώττισης ή "εκ νέου ανάθεση στο val".

Γιατί να χρησιμοποιήσετε το Immutability;

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

Μαθήματα και αντικείμενα

Όλοι γνωρίζουμε ότι τα αντικείμενα είναι οι οντότητες του πραγματικού κόσμου και η κλάση είναι ένα πρότυπο που ορίζει αντικείμενα. Οι τάξεις έχουν και κατάσταση και συμπεριφορές. Οι καταστάσεις είναι είτε τιμές είτε μεταβλητές. Οι συμπεριφορές είναι οι μέθοδοι στη Scala.

Ας δούμε πώς μπορείτε να ορίσετε μια κλάση, να την δημιουργήσετε και να τη χρησιμοποιήσετε χρησιμοποιώντας το Scala.

Εδώ, η κλάση ονομάζεται Rectangle, η οποία έχει δύο μεταβλητές και δύο συναρτήσεις. Μπορείτε επίσης να χρησιμοποιήσετε τις παραμέτρους l και b απευθείας ως πεδία στο πρόγραμμα. Έχετε ένα αντικείμενο που έχει μια κύρια μέθοδο και έχει δημιουργήσει την κλάση με δύο τιμές.

Παράδειγμα:

class Rectangle( l: Int,  b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Όλα τα πεδία και η μέθοδος είναι από προεπιλογή δημόσια στο Scala. Είναι απαραίτητο να χρησιμοποιήσετε την παράκαμψη επειδή η μέθοδος toString έχει οριστεί για το αντικείμενο στο Scala.

Κληρονομία

Η Scala έχει πολλούς τύπους κληρονομικότητας (όπως απλή, πολλαπλή, πολλαπλή, ιεραρχική, υβριδική) που μοιράζονται πολλά κοινά με τις παραδοσιακές μορφές που βρίσκονται στο Java. Μπορείτε να κληρονομήσετε τόσο από τάξεις όσο και από χαρακτηριστικά. Μπορείτε να κληρονομήσετε τα μέλη μιας τάξης σε μια άλλη κλάση χρησιμοποιώντας τη λέξη-κλειδί "extends". Αυτό επιτρέπει την επαναχρησιμοποίηση.

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

Στο παρακάτω παράδειγμα Scala, η κλάση Base είναι Circle και η παραγόμενη κλάση είναι Sphere. Ένας κύκλος έχει μια τιμή που ονομάζεται ακτίνα, η οποία κληρονομείται στην κλάση Sphere. Η μέθοδος calcArea παρακάμπτεται χρησιμοποιώντας την παράκαμψη λέξης-κλειδιού.

Παράδειγμα:

class Circle {
  val radius = 5;
  def calcArea = {
    println(radius * radius )
  }
}
class Sphere extends Circle{
 override def calcArea = {
    println(radius * radius * radius )
  }
}
  object SphereObject{
    def main(args : Array[String]){
      new Sphere().calcArea 
    }
  }

Αφαίρεση

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

Παράδειγμα:

trait MakesSound{
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int){
    val creatureName:String

    def printLegs():String={
        return s"$creatureName has this number of legs: $legs"
    }
}

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

trait DatabaseService{
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

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

Η κλάση που προλογίζεται με τη λέξη-κλειδί abstract μπορεί να περιέχει τόσο αφηρημένες όσο και μη αφηρημένες μεθόδους. Ωστόσο, οι πολλαπλές κληρονομιές δεν υποστηρίζονται στην αφηρημένη κλάση. Έτσι, μπορείτε να επεκτείνετε το πολύ μια αφηρημένη τάξη.

Αντικείμενα Singleton

Ένα Singleton είναι μια κλάση που δημιουργείται μόνο μία φορά σε ένα πρόγραμμα. Είναι από ένα δημοφιλές και χρήσιμο μοτίβο προγραμματισμού που είναι γνωστό ως "μονόχρωμο μοτίβο". Είναι χρήσιμο για τη δημιουργία περιπτώσεων που προορίζονται να είναι μακροχρόνιες και θα είναι κοινά προσβάσιμες σε όλο το πρόγραμμά σας, η κατάσταση των οποίων είναι αναπόσπαστο μέρος του συντονισμού των συμβάντων ενός συστήματος. Η δημιουργία μιας τέτοιας κλάσης στο Scala είναι εύκολη καθώς η Scala μας παρέχει έναν απλό τρόπο δημιουργίας singletons χρησιμοποιώντας τη λέξη-κλειδί αντικείμενο.

object UserProfile{
    var userName=""
    var isLoggedIn:Boolean = false
}

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

def getLoggedInStatus():Boolean={
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean={
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return  UserProfile.isLoggedIn
}

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

Τάξεις σιωπηρών

Οι σιωπηρές κλάσεις είναι η νέα λειτουργικότητα που προστέθηκε μετά την έκδοση 2.1. Είναι πρωτίστως η προσθήκη νέων λειτουργιών στις κλειστές τάξεις.

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

Στο παρακάτω παράδειγμα Scala, προστίθεται νέα λειτουργία για την αντικατάσταση φωνηέντων μιας συμβολοσειράς με *.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Πρέπει να κάνετε εισαγωγή στην τάξη όπου το χρησιμοποιείτε.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Αντικειμενοστραφής προγραμματισμός (OOP) έναντι λειτουργικού προγραμματισμού (FP)

Στο OOP τα προγράμματα κατασκευάζονται ομαδοποιώντας τα δεδομένα και τις λειτουργίες που λειτουργούν σε αυτά τα δεδομένα σε πολύ συνδεδεμένες μονάδες. Τα αντικείμενα μεταφέρουν τα δεδομένα τους στα πεδία και τις μεθόδους που λειτουργούν σε αυτά. Σε αυτό το στυλ προγραμματισμού, η κύρια αφαίρεση είναι τα δεδομένα καθώς οι μέθοδοι που δημιουργούνται προορίζονται να λειτουργήσουν στα δεδομένα.

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

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

Σημαντικά πλαίσια στο Scala

Εδώ, είναι μερικά σημαντικά πλαίσια της Scala

• Δοκιμάστε να παίξετε είναι ένα πλαίσιο εφαρμογών ιστού ανοιχτού κώδικα που χρησιμοποιεί Αρχιτεκτονική MVC. Κυκλοφόρησε το 2007 και τώρα με άδεια χρήσης Apache, έγινε το πιο δημοφιλές πλαίσιο στο GitHub το 2013. Εταιρείες όπως οι LinkedIn, Walmart, Samsung, Eero χρησιμοποιούν αυτό το πλαίσιο.
• Ανύψωση είναι ένα άλλο δωρεάν πλαίσιο ιστού γραμμένο στη Scala που κυκλοφόρησε το 2007. Το Foursquare χρησιμοποιεί το πλαίσιο Lift. Έχει υψηλή απόδοση, πιο γρήγορο στην κατασκευή πλαισίου.
• Ακκά
• Γάτες
• Spark

Υποστήριξη συγχρονισμού

• Οι τιμές στο Scala είναι από προεπιλογή αμετάβλητες. Αυτό το καθιστά πολύ προσαρμοστικό στο ταυτόχρονο περιβάλλον.
• Υπάρχουν πολλές δυνατότητες στο Scala που το καθιστούν καλύτερο για ταυτόχρονες εφαρμογές.
• Τα Futures και Promises διευκολύνουν την ασύγχρονη επεξεργασία δεδομένων, υποστηρίζοντας έτσι τον παραλληλισμό.
• Akka – εργαλειοθήκη που χρησιμοποιεί μοντέλο συγχρονισμού Actor. Υπάρχει ένας αριθμός ηθοποιών που ενεργούν όταν λαμβάνουν μηνύματα.
• Συγχρονισμός με χρήση νημάτων από Java μπορεί επίσης να υποστηριχθεί στο Scala.
• Η επεξεργασία ροής είναι ένα άλλο εξαιρετικό χαρακτηριστικό που επιτρέπει τη συνεχή επεξεργασία δεδομένων σε πραγματικό χρόνο.

Η Scala διαθέτει μερικές από τις καλύτερες βιβλιοθήκες ταυτόχρονης χρήσης Java οικοσύστημα.

• Native Java θέματα
• Ίνες από βιβλιοθήκες όπως η Vertex
• ZIO – μια βιβλιοθήκη που έχει πρωτόγονα για να μας βοηθήσει να αντιμετωπίσουμε τον συγχρονισμό και τον ασύγχρονο υπολογισμό
• STM – Συναλλαγή
• Μέλλον – ενσωματωμένο στη γλώσσα Scala

Java εναντίον Σκάλας

Εδώ είναι τα κύρια διαφορά μεταξύ Java και τη Σκάλα.

Scala	Java
Πιο συμπαγές και συνοπτικό	Συγκριτικά μεγαλύτερα κομμάτια κώδικα
Σχεδιάστηκε και αναπτύχθηκε για να είναι γλώσσα αντικειμενικού και λειτουργικού προσανατολισμού. Υποστηρίζει μια μεγάλη ποικιλία λειτουργικών χαρακτηριστικών προγραμματισμού, όπως ταυτόχρονο, Αμετάβλητο.	Αναπτύχθηκε αρχικά ως αντικειμενοστραφή γλώσσα και άρχισε να υποστηρίζει λειτουργίες λειτουργικού προγραμματισμού τις τελευταίες ημέρες. Η Still δεν είναι ισχυρή ως λειτουργική γλώσσα προγραμματισμού.
Χρησιμοποιεί μοντέλο ηθοποιού για την υποστήριξη συγχρονισμού που είναι σύγχρονο	Χρησιμοποιεί το συμβατικό μοντέλο που βασίζεται σε νήματα για ταυτόχρονη χρήση.
Υποστηρίζει πλαίσια – Play, Lift	Υποστηρίζει Spring, Grails, πολλά άλλα
Υποστηρίζει τεμπέλης αξιολόγηση	Δεν υποστηρίζει τεμπέλης αξιολόγηση
Χωρίς στατικά μέλη	Περιέχει στατικά μέλη
Υποστηρίζει υπερφόρτωση χειριστή	Δεν υποστηρίζει υπερφόρτωση χειριστή
Η συλλογή του πηγαίου κώδικα είναι σχετικά αργή	Η μεταγλώττιση του πηγαίου κώδικα είναι ταχύτερη από το Scala
Χαρακτηριστικά - συμπεριφέρεστε όπως Java 8 διεπαφές	Java 8 διεπαφές προσπαθούν να γεφυρώσουν το χάσμα μεταξύ κλάσεων και διεπαφών
Χρειάζεται ξαναγραφή	Δεν απαιτείται επανεγγραφή
Καμία βεβαιότητα σχετικά με τους κωδικούς χωρίς σφάλματα	Πλήρης διασφάλιση μικρότερων ελαττωμάτων
Υποστηρίζει συμβατότητα προς τα πίσω.	Το Scala δεν υποστηρίζει συμβατότητα προς τα πίσω.
Operatortor αντιμετωπίζονται διαφορετικά σε Java και δεν είναι κλήσεις μεθόδου.	Όλοι οι τελεστές στις καταχωρήσεις ar μέσω μιας μεθόδου που ονομάζεται Scala.
Υποστηρίζει πολλαπλές κληρονομιές χρησιμοποιώντας κλάσεις αλλά όχι αφηρημένες κλάσεις	Δεν υποστηρίζει πολλαπλές κληρονομιές χρησιμοποιώντας κλάσεις, αλλά με διεπαφές
Ο κώδικας είναι γραμμένος σε συμπαγή μορφή.	Ο κώδικας είναι γραμμένος σε μακρά μορφή.
Το Scala δεν περιέχει τη στατική λέξη-κλειδί.	Java περιέχει τη στατική λέξη-κλειδί.

Περίληψη

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