Scala oktatóanyag: Scala programozási nyelv példa és kód

A Scala oktatóanyagának összefoglalása

Ez a scala oktatóanyag lefedi a scala minden vonatkozását és témáját. A nulláról megtanulja az összes alapvet, mint például a scala, a scala telepítési folyamata, a Scala programok, a Scala függvények, a lusta kiértékelés, a típusfelület, az osztályok és objektumok, az öröklődés, az absztrakciók, Java és scala különbségek stb.

A Scala egy méretezhető nyelv, amelyet szoftverek írásához használnak több platformra. Ezért kapta a „Scala” nevet. Ez a nyelv célja, hogy megoldja a problémákat Java miközben egyben tömörebb is. Eredetileg Martin Odersky tervezte, de 2003-ban adták ki.

Miért tanulja meg a Scalát?

Íme a Scala programozási nyelv tanulásának fő okai:

• A Scala könnyen megtanulható az objektum-orientált programozók számára, Java fejlesztők. Az utóbbi években az egyik legnépszerűbb nyelv.
• A Scala első osztályú funkciókat kínál a felhasználók számára
• A Scala végrehajtható JVM, ezzel megnyitva az utat a más nyelvekkel való interoperabilitás előtt.
• Olyan alkalmazásokhoz készült, amelyek párhuzamos, elosztott és rugalmas üzenetvezérelt. Ez az évtized egyik legigényesebb nyelve.
• Tömör, erőteljes nyelvezet, és gyorsan növekedhet a felhasználók igényei szerint.
• Objektum-orientált, és számos funkcionális programozási funkcióval rendelkezik, amelyek nagy rugalmasságot biztosítanak a fejlesztőknek, hogy a kívánt módon kódoljanak.
• A Scala számos kacsatípust kínál
• Ha honnan jössz, kevesebb a kazánlemeze Java
• A Scalában írt Lift and Play keretrendszerek a növekedési görbében vannak.

A Scala telepítése

A Scala programok írásának megkezdéséhez telepítenie kell azokat a számítógépére. Ennek érdekében meg kell látogatnia a webhelyüket https://www.scala-lang.org/download/ a Scala legújabb verziójának letöltéséhez.

A linket követően két lehetőséghez jutunk, amelyek közül választhatunk a Scala telepítéséhez a gépeinkre. Ehhez a Scala oktatóanyaghoz letöltjük a IntelliJ IDEA.

Miután meglátogatta a letöltési linket, az IntelliJ IDE két verzióját találja.

Ehhez a Scala-oktatóanyaghoz letöltjük a Community Edition-t, amely ingyenes, és mindent tartalmaz, ami a Scala programok írásához szükséges.

Step 1) Válassza a Community Edition lehetőséget
Az oldalon kattintson a közösségi kiadás legördülő menüjére.

Lehetőséget kínál az IntelliJ IDE letöltésére a JBR-rel együtt, amely tartalmaz egy JDK implementációt (Java Development Kit) OpenJDK, amelyre a Scalának szüksége van a kód lefordításához és futtatásához.

Step 2) Futtassa a telepítést
Az IntelliJ letöltése után kattintson duplán a telepítővarázsló futtatásához, és kövesse a párbeszédpanelt.

Step 3) Válasszon egy helyet
Válasszon helyet az IDE telepítéséhez.

Ha véletlenül nem a JDK-val rendelkezőt töltötte le, akkor is kapunk egy felszólítást, ahol a jelölőnégyzet bejelölésével ellenőrizhetjük a letöltést.

Step 4) Kattintson a következőre
Hagyja meg a többi alapértelmezett értéket, és kattintson a Tovább gombra.

Step 5) Kattintson az indítási ikonra
A telepítés befejezése után futtassa az IntelliJ IDE-t az indítási ikonra kattintva az indítási menüben, mint egy normál alkalmazást.

Továbbra is el kell végeznie egy további lépést: hozzáadnia kell a Scala beépülő modult az IntelliJ-hez; ehhez kattintson a képernyő jobb alsó sarkában található konfigurációs menü legördülő menüjére, és válassza ki a bővítmény opciót.

A Piactér lapon a Scala kifejezésre keresve a beépülő modul első találatként jelenik meg a Nyelvek címke alatt.

Step 6) Telepítse a bővítményt
Kattintson a telepítés gombra, amely elindítja a beépülő modul letöltését.

Step 7) Indítsa újra az IDE-t
A letöltés befejezése után a rendszer felkéri az IDE újraindítására, hogy a telepített beépülő modul működni tudjon.

Újraindítás után ugyanazon az oldalon találja magát, mint korábban, amikor az IDE-t futtattuk, de ezúttal már telepítettük a Scala bővítményt.

Scala Hello World Program

Step 1) Válassza a Projekt létrehozása opciót, amely egy oldalra vezet, ahol kiválaszthatjuk, hogy projektünk milyen nyelvet fog használni.

Step 2) válassza a Scalát a Scala jelölőnégyzet bejelölésével, és kattintson a Tovább gombra.

Step 3) Válasszon egy helyet a projektfájlunk mentéséhez, és adjon nevet projektünknek.

Ha a könyvtár nem létezik, az IntelliJ felkér bennünket, hogy kérjünk engedélyt a mappa létrehozásához. Fogadja el, és kattintson a Befejezés gombra. A rendszer a Scala-projekthez irányítja, amely jelenleg nem rendelkezik Scala-kóddal.

Néhány index betöltése eltart egy ideig, ezért ne aggódjon, ha nem tud azonnal semmit tenni, miközben az IDE alján van egy folyamatjelző sáv, ez egyszerűen azt jelenti, hogy az IDE betölt néhány fájlt, amelyek szükségesek a Scala futtatásához és segítség az IDE automatikus kiegészítésében.

Step 4) Ezután kattintson az IDE bal oldalán található projektek fülre, és bontsa ki, hogy láthassa projektünk tartalmát.

Jelenleg a projekt üres, és csak egy .idea mappát és az IDE által generált hello-world.iml fájlt tartalmaz. Érdekességünk az src mappa. Az Src az a hely, ahol a projektünk forráskódját tároljuk. Itt hozzuk létre az első Scala-fájlt.

Step 5) Kattintson a jobb gombbal az src-re egy új Scala-fájl létrehozásához szükséges menü megnyitásához.

Ezután létrehozunk egy nevet a fájlnak, ebben a Scala oktatóanyagban a hello szót használjuk, majd a legördülő menüből kiválasztjuk, hogy mit helyezzünk el a Scala fájl tartalmának. Válassza az "Objektum" lehetőséget

Miután ezt megtettük, lesz egy Scala-fájlunk, amely egy Singleton objektumot tartalmaz, amelyet a kódunk futtatására fogunk használni.

Most, hogy van egy Hello objektumot tartalmazó Scala-fájlja. Az első programot az App kulcsszóval létrehozott objektum kiterjesztésével fogja megírni.

Az objektum alkalmazással való kiterjesztése mondja meg a fordítónak, hogy melyik kódot futtassa, amikor elindítja a programot. Közvetlenül az alkalmazás kiterjesztése után egy zöld nyíl jelenik meg a bal oldalon, jelezve, hogy most már futtathatja a programot.

A Hello objektumon belül írunk egy println() függvényt, amely a benne lévő szöveg kinyomtatására szolgál a konzolra. A kódunkat a zöld nyílra kattintva futtatjuk.

A nyílra kattintva a Futtatás opció jelenik meg, helló, rákattintásra elindul a kódunk fordítása, és néhány másodperc múlva láthatjuk a programunk eredményét az IntelliJ IDE-be épített konzolról nyomtatva.

És itt vagyunk, sikeresen telepítettük a Scalát, és futtattuk az első programunkat.

Mit tehet a Scalával

• Frontend webfejlesztés ScalaJS segítségével
• Mobilfejlesztés, mindkettő Android Fejlesztés és IOS – a Scala Native segítségével
• Szerveroldali könyvtárak, például HTTP4S, Akka-Http, Play Framework
• A dolgok internete használata
• Játékfejlesztés
• NLP – Természetes nyelvi feldolgozás a ScalaNLP könyvtárak segítségével
• Fejlett programozási technikák tesztelése, mint például a funkcionális programozás és az objektum-orientált programozás
• Készítsen rendkívül egyidejű kommunikációs alkalmazást a szereplők segítségével az Erlang által ihletett JVM-hez
• Használja gépi tanuláshoz olyan könyvtárak használatával, mint a Figaro, amely valószínűségi programozást végez és az Apache Spark hogy

Névtelen funkciók

A Scala nyelvnek anonim függvényei vannak, amelyeket szintén hívnak függvényliterálok. Mivel a Scala funkcionális nyelv, gyakran azt jelenti, hogy a fejlesztők a nagy problémákat sok kis feladatra bontják, és számos funkciót hoznak létre a problémák megoldására. A funkciók létrehozásának megkönnyítése érdekében a Scala ezeket a funkciókat tartalmazza név nélkül példányosítva. Közvetlenül hozzárendelhetjük őket „def” változókhoz vagy definíciókhoz, amint az az alábbi Scala példában látható:

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

Ezután használhatjuk a függvényeket a szokásos módon úgy, hogy paramétereket adunk át nekik.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Ezek a módszerek akkor hasznosak, ha tiszta és tömör kódot szeretnénk kapni. Anonim függvényeket használhatunk olyan metódusok definiálásakor, amelyek nem nagyok és nem igényelnek sok kódot a törzsükben. Nagyon egyszerűek, és nincs szükség ceremóniára az elkészítéshez.

Ezek a metódusok nem korlátozódnak az argumentumokkal rendelkező függvényekre, és használhatók olyan metódusok példányosítására, amelyek nem vesznek fel semmilyen argumentumot.

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

A legtöbb névtelen függvényt kódunk más részeiben használjuk, ahol egy gyors függvényt kell létrehoznunk.

Egy másik ok, amiért ezeket a funkciókat úgy is nevezik inline függvények. Az anonim függvények használata egy gyakori minta, amelyet a gyűjtemények könyvtárában széles körben használnak a gyűjtemény feletti gyors műveletek végrehajtására.

Például van egy szűrőmódszerünk, amely egy soron belüli függvényt/névtelen függvényt vesz igénybe egy másik gyűjtemény létrehozásához, amely csak olyan elemekkel rendelkezik, amelyek megfelelnek az általunk az anonim függvényben meghatározott feltételeknek.

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)

Itt az anonim függvényként használt metódusok azok, amelyek ellenőrzik, hogy a listából kapott érték páros és páratlan-e, és visszaadják az elemet.

//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

A Scalában olyan helyettesítő karakterek is használhatók, ahol a névtelen függvényünk paraméterei nincsenek megnevezve. Például

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Ebben a forgatókönyvben nem nevezzük meg az átadott paramétert. Az egyetlen dolog, amit aláhúzásjellel ábrázolunk.

Lusta értékelés

A legtöbb nyelv egymás után értékeli ki a változókat és a függvényparamétereket. A Scalában van egy lusta kulcsszó, amely segít kezelni azokat az értékeket, amelyeket nem akarunk értékelni, amíg nem hivatkozunk rájuk.

A lustaként megjelölt változó nem kerül kiértékelésre ott, ahol definiálva van, ez az úgynevezett „eager értékelés”, csak akkor kerül kiértékelésre, ha a kód későbbi részében hivatkoznak rá.

Ez akkor lehet hasznos, ha egy érték kiértékelése költséges számítás lehet, ha nem az a helyzet, hogy az értékre mindig szükség van, megkímélhetjük magunkat egy drága számítástól, amely lelassíthatja szoftverünket azáltal, hogy változónkat lustává teszi.

lazy val myExpensiveValue = expensiveComputation

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

Nem ez az egyetlen eset a lusta változókhoz. Segítenek a kódban megjelenő körkörös függőséggel kapcsolatos problémák kezelésében is.

Ha a beállítások hamisak, előfordulhat, hogy nem kell használnunk a myExpensiveValue-t, ami megkímélhet minket egy költséges számítás elvégzésétől, ami segít abban, hogy a felhasználók jól érezzék magukat az alkalmazásunk használatával, mivel egyéb igényeiket megfelelően kiszámíthatjuk anélkül, hogy túlterhelnénk. a Kos.

Ha a beállítások hamisak, előfordulhat, hogy nem kell használnunk a myExpensiveValue-t, ami megkímélhet minket egy költséges számítás elvégzésétől, ami segít abban, hogy a felhasználók jól érezzék magukat az alkalmazásunk használatával, mivel egyéb igényeiket megfelelően kiszámíthatjuk anélkül, hogy túlterhelnénk. a Kos.

A lustaság a függvény argumentumainak is segít, ahol az argumentumok csak akkor használatosak, ha a függvényen belül hivatkoznak rájuk. Ezt a koncepciót Call-by-name paramétereknek nevezik.

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

Sok nyelv a call-by-value módszert használja az argumentumok kiértékelésére. A név szerinti híváson keresztül átadott paraméter csak akkor kerül kiértékelésre, ha szükséges a függvénytörzsben, és ezt megelőzően nem. Az érték kiértékelése után eltárolódik, és később újrafelhasználható anélkül, hogy újra kellene értékelni. Memoization néven ismert fogalom.

Típus Következtetés

A Scalában nem kell minden létrehozott változóhoz típust deklarálni. Ennek az az oka, hogy a Scala fordító a jobb oldal kiértékelése alapján típuskövetkeztetést tud végezni a típusokra. Ez lehetővé teszi, hogy kódja tömörebb legyen – megszabadít minket attól, hogy olyan sablont írjunk, ahol a várt típus nyilvánvaló

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

Magasabb rendű funkció

A magasabb rendű függvény olyan függvény, amely függvényeket vehet fel argumentumként, és egy függvényt visszatérési típusként adhat vissza. A Scalában a funkciók első osztályú állampolgároknak számítanak. Ezen funkciók ilyen módon történő használata lehetővé teszi számunkra, hogy nagyon rugalmasak legyünk abban, hogy milyen programokat készíthetünk. Dinamikusan létrehozhatunk függvényeket, és dinamikusan betáplálhatjuk a funkcionalitást más függvényekbe.

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

A fenti függvényben átadunk egy int és egy olyan függvényt, amely int-et vesz fel és int-et ad vissza. Az aláírás bármely funkcióját átadhatjuk. Aláírás alatt egy függvény bemenetét és kimenetét értjük. Az Int=>Int aláírása azt jelenti, hogy egy függvény egy Int-et vesz bemenetként, és egy Int-t ad vissza kimenetként.

Az ()=>Int aláírása azt jelenti, hogy egy függvény semmit sem vesz fel bemenetként, és egy Int értéket ad vissza kimenetként. Példa egy ilyen függvényre, amely egy véletlenszerű int-et generál nekünk.

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

A fenti függvény aláírása ()=>Int

Lehet egy olyan függvényünk, aminek van egy aláírása scala ()=>Unit. Ez azt jelenti, hogy a függvények nem vesznek fel semmit, és nem adnak vissza típust. A függvény lehet valamilyen számítás elvégzése oly módon, hogy valamit előre meghatározottra változtat.

Az ilyen típusú módszereket azonban nem javasoljuk, mivel fekete doboznak tűnnek, amely ismeretlen módon befolyásolhatja a rendszert. Ezek is tesztelhetetlenek. Az explicit bemeneti és kimeneti típusok lehetővé teszik számunkra, hogy megértsük, mit csinál a függvényünk.

Egy magasabb rendű függvény is visszaadhat függvényt.

Létrehozhatunk például egy olyan metódust, amely egy teljesítményfüggvényt hoz létre, azaz vesz egy számot, és hatványt alkalmaz rá.

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

A fenti függvény egy int. A visszatérési típusunk egy anonim függvény, amely egy Int x-et vesz fel, * az int x-et használjuk a hatványfüggvény argumentumaként.

Currying

A Scalában egy olyan függvényt konvertálhatunk, amely két argumentumot vesz fel, olyanná, amely egyszerre egy argumentumot vesz fel. Ha átadunk egy argumentumot, akkor azt részben alkalmazzuk, és egy olyan függvényt kapunk, amely egy argumentumot igényel a függvény befejezéséhez. A currying segítségével függvényeket hozhatunk létre néhány argumentum részleges hozzáadásával.

Ez hasznos lehet a függvények dinamikus létrehozásához, mielőtt még teljes argumentumkészletünk lenne

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

Ha létre kell hoznunk egy függvényt, amely bizonyos számmal szoroz, akkor nem kell másik szorzási módszert létrehoznunk.

Egyszerűen meghívhatjuk a .curried a fenti függvényünkön, és kapunk egy függvényt, amely először egy argumentumot vesz fel, és egy részben alkalmazott függvényt ad vissza.

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Mintaillesztés

A Scala egy hatékony beépített mechanizmussal segít ellenőrizni, hogy egy változó megfelel-e bizonyos kritériumoknak, hasonlóan ahhoz, ahogyan azt egy switch utasításban tennénk. Java vagy if/else állítások sorozatában. A nyelv rendelkezik mintaillesztéssel, amellyel ellenőrizhetjük, hogy egy változó egy adott típusú-e. A Scala mintaillesztése hatékony, és felhasználható az unapply metódussal rendelkező komponensek strukturálására annak érdekében, hogy a minket érdeklő mezőket közvetlenül az egyeztetett változóból kapjuk meg.

A Scala mintaillesztése kellemesebb szintaxist biztosít a switch utasításhoz képest.

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

Összehasonlítjuk a változónkat egy opciókészlettel, és ha az általunk egyeztetett változó megfelel a kritériumoknak, a kövér nyíl (=>) jobb oldalán lévő kifejezés kiértékeli, és az egyezés eredményeként kerül visszaadásra.

Aláhúzást használunk a kódunkban páratlan esetek felderítésére. A switch utasítások kezelésekor az alapértelmezett eset viselkedését tükrözi.

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
}

A fenti kódban megtudhatja a myItem változó típusát, és ennek alapján elágazhat egy bizonyos kódra.

A mintaillesztés ellenőrzi, hogy a változó egyezik-e

Az aláhúzás olyan helyőrzőként működik, amely megfelel minden olyan feltételnek, amely nem felel meg a fenti esetmeghatározások többi elemének. Vegyünk egy myItem változót, és meghívjuk a match metódust.

• ellenőrizzük, hogy a myItem igaz-e a „=>” kövér nyíl jobb oldalán, és logikázunk.
• Az aláhúzást használjuk, hogy megfeleljen minden olyan dolognak, amely nem egyezik a kódban definiált esetek egyikével sem.

A Case osztályokkal még tovább is léphetünk, és megsemmisíthetjük az osztályt, hogy mezőket kapjunk az objektumon belül.

Ha a lezárt kulcsszót használjuk osztályaink meghatározásához, akkor a fordító alaposan ellenőrzi azokat az eseteket, amelyekkel párosítani próbálunk, és figyelmeztet, ha elfelejtünk kezelni egy adott esetet.

Állandóság

A val kulcsszó használatával olyan értékeket hozhat létre, amelyeket a Scala más funkciói nem módosíthatnak. Ezt ben érik el Java a végső kulcsszó használatával. A Scalában ezt úgy tesszük, hogy egy val kulcsszót használunk változó létrehozásakor a var helyett, amely alternatíva a változó változó létrehozásához.

A val kulcsszóval definiált változó csak olvasható, míg a varral definiált változó más függvényekkel vagy tetszőlegesen módosítható a kódban.

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

Ha megpróbál értéket rendelni a myNumber-hez, miután azt val-ként deklaráltuk, fordítási idejű hibát vagy „értékhez való visszarendelést” küld.

Miért használjuk a megváltoztathatatlanságot?

A változtathatatlanság segít abban, hogy megakadályozzuk, hogy a kód és más programozók váratlanul megváltoztassák az értékeinket, ami váratlan eredményekhez vezetne, ha az általunk tárolt értéket használnák, ehelyett másolatot készíthetnek róla. Ily módon megelőzhetők azok a hibák, amelyeket több szereplő ugyanazon változó megváltoztatása okozhat.

Osztályok és objektumok

Mindannyian tudjuk, hogy az objektumok a való világ entitásai, az osztály pedig egy objektumokat meghatározó sablon. Az osztályoknak van állapotuk és viselkedésük is. Az állapotok vagy értékek vagy változók. A viselkedésmódok a Scala módszerei.

Nézzük meg, hogyan határozhat meg egy osztályt, hogyan hozhatja létre és használhatja a Scala segítségével.

Itt a Rectangle nevű osztály, amelynek két változója és két függvénye van. Az l és b paramétereket közvetlenül is használhatja mezőként a programban. Van egy objektum, amelynek van egy fő metódusa, és két értékkel példányosította az osztályt.

Példa:

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)    
  }
}

Az összes mező és metódus alapértelmezés szerint nyilvános a Scalában. A felülírás használata elengedhetetlen, mert a toString metódus van definiálva az objektumhoz a Scalában.

Öröklés

A Scala többféle öröklődéssel rendelkezik (például egy-, többszintű, többszörös, hierarchikus, hibrid), amelyek sok közös vonást mutatnak a hagyományos formákkal. Java. Örökölhetsz osztályokból és tulajdonságokból egyaránt. Egy osztály tagjait egy másik osztályba örökölhetjük az „extends” kulcsszó használatával. Ez lehetővé teszi az újrafelhasználhatóságot.

Lehetséges egy osztályból vagy több osztályból örökölni. Az is lehetséges, hogy olyan alosztályokból örököljünk, amelyeknek maguknak is megvannak a szuperosztályai, így az öröklési hierarchiát létrehozva a folyamat során.

Az alábbi Scala példában az alaposztály a Circle, a származtatott osztály pedig a Sphere. Egy körnek van egy sugár nevű értéke, amely a Sphere osztályban öröklődik. A calcArea metódus felülírásra kerül a kulcsszó felülírásával.

Példa:

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 
    }
  }

Absztrakció

A Scalában absztrakt metódusokat és tagmezőket készíthetünk absztrakt osztályok és tulajdonságok segítségével. Az absztrakt osztályokon és tulajdonságokon belül absztrakt mezőket definiálhatunk anélkül, hogy feltétlenül implementálnánk azokat.

Példa:

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"
    }
}

Ezeket a mezőket a tulajdonságot vagy az absztrakt osztályt kiterjesztő osztályok valósítják meg. A tulajdonságok segítségével szerződéseket hozhat létre arra vonatkozóan, hogy az alkalmazásunk mire képes, majd később implementálja ezeket a módszereket.

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

Így meg tudjuk tervezni, hogyan fog kinézni az alkalmazásunk anélkül, hogy megvalósítanánk azokat a módszereket, amelyek segíthetnek elképzelni, hogyan fognak kinézni a különböző módszerek. Ez az absztrakciók programozásának nevezett minta mentén következik, és nem a tényleges megvalósítás.

Az absztrakt kulcsszóval előtagolt osztály absztrakt és nem absztrakt metódusokat is tartalmazhat. Az absztrakt osztály azonban nem támogatja a többszörös öröklődést. Tehát legfeljebb egy absztrakt osztályt bővíthet.

Singleton objektumok

A Singleton egy olyan osztály, amely csak egyszer példányosodik egy programban. Ez egy népszerű és hasznos programozási minta, az úgynevezett „singleton pattern”. Hasznos olyan példányok létrehozásában, amelyeket hosszú életűnek szántak, és általánosan elérhetők lesznek a programban, amelyek állapota szervesen kapcsolódik a rendszer eseményeinek koordinálásához. Egy ilyen osztály létrehozása a Scalában egyszerű, mivel a Scala egyszerű eszközt biztosít számunkra az objektum kulcsszó használatával szinglitonok létrehozására.

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

Ezután a programunk során hivatkozhatunk erre az objektumra, garantálva, hogy programunk minden része ugyanazokat az adatokat fogja látni, mivel csak egy példánya van.

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

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

A statikus tagok fogalma nem szerepel a Scalában, ezért kell egytagú objektumokat használni, amelyek egy osztály statikus tagjaiként működnek.

Implicit osztályok

Az implicit osztályok a 2.1-es verzió után hozzáadott új funkciók. Elsősorban az, hogy új funkciókat adjunk a zárt osztályokhoz.

Az implicit kulcsszót osztályban, objektumban vagy tulajdonságban kell meghatározni. Egy implicit osztály elsődleges konstruktorának pontosan egy argumentumnak kell lennie az első paraméterlistában. Tartalmazhat egy további implicit paraméterlistát is.

Az alábbi Scala-példában új funkció került hozzáadásra a karakterlánc magánhangzóinak *-ra cserélésére.

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

Abban az osztályban kell importálnia, ahol használja.

import StringUtil.StringEnhancer

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

Objektum-orientált programozás (OOP) kontra Funkcionális programozás (FP)

Az OOP-ban a programok az adatok és az azokon működő funkciók szorosan összekapcsolt egységekbe csoportosításával jönnek létre. Az objektumok a rajtuk működő mezőkben és módszerekben hordozzák adataikat. Ebben a programozási stílusban a fő absztrakciót az adatok jelentik, mivel a létrehozott metódusok az adatokkal való működésre szolgálnak.

Funkcionális programozás, másrészt elkülöníti az adatokat és az adatokon működő funkciókat. Ez lehetővé teszi a fejlesztők számára, hogy a függvényeket absztrakcióként és hajtóerőként kezeljék a programok modellezése során.

A Scala lehetővé teszi a funkcionális programozást azáltal, hogy a függvények első osztályú állampolgárok, így értékként átadhatók más függvényeknek, és értékként is visszaadhatók. E két paradigma kombinációja a Scalát nagyszerű választássá tette összetett szoftverek készítéséhez különböző iparágakban, például az adattudományban.

Fontos keretrendszerek a Scalában

Íme néhány fontos Scala keretrendszer

• játszani egy nyílt forráskódú webalkalmazás-keretrendszer, amely a MVC architektúra. A 2007-ben kiadott és most Apache licenc alatt álló keretrendszer lett a legnépszerűbb keretrendszer a GitHubon 2013-ban. Olyan cégek használják ezt a keretrendszert, mint a LinkedIn, a Walmart, a Samsung, az Eero.
• Lift egy másik, 2007-ben elindított, Scalában írt ingyenes webes keretrendszer. A Foursquare a Lift keretrendszert használja. Nagy teljesítményű, gyorsabban felépíthető keretrendszer.
• Mint
• Macskák
• Spark

Egyidejű támogatás

• A Scala értékei alapértelmezés szerint megváltoztathatatlanok. Ez nagyon jól alkalmazkodik az egyidejű környezethez.
• A Scala számos olyan funkcióval rendelkezik, amelyek a legjobban alkalmassá teszik a párhuzamos alkalmazásokhoz.
• A Futures and Promises megkönnyíti az adatok aszinkron feldolgozását, így támogatja a párhuzamosságot.
• Akka – Actor párhuzamossági modellt használó eszközkészlet. Számos színész cselekszik, amikor üzeneteket kap.
• Egyidejűség szálak használatával Java Scalában is támogatható.
• Az adatfolyam-feldolgozás egy másik nagyszerű funkció, amely lehetővé teszi az adatok folyamatos, valós idejű feldolgozását.

A Scala rendelkezik a legjobb párhuzamossági könyvtárakkal Java ökoszisztéma.

• Bennszülött Java szálak
• Szálak olyan könyvtárakból, mint a Vertex
• ZIO – egy olyan könyvtár, amely primitívekkel segít megbirkózni a párhuzamossággal és az aszinkron számítással
• STM – Tranzakció
• Jövő – a Scala nyelvbe beépített

Java vs. Scala

Itt vannak a főbbek a különbség köztük Java és a Scala.

Scala	Java
Kompaktabb és tömörebb	Viszonylag nagyobb kóddarabok
Úgy tervezték és fejlesztették, hogy egyszerre legyen objektum- és funkcionális orientált nyelv. Támogatja a funkcionális programozási funkciók széles skáláját, mint például a párhuzamosságot, a megváltoztathatatlanságot.	Eredetileg objektum-orientált nyelvként fejlesztették ki, és az elmúlt napokban kezdett el támogatni a funkcionális programozási funkciókat. Funkcionális programozási nyelvként még mindig nem erős.
Színészmodellt használ a párhuzamosság támogatására, amely modern	A párhuzamossághoz a hagyományos szál alapú modellt használja.
Támogatja a keretrendszereket – Play, Lift	Támogatja a tavaszt, a Grálokat és még sok mást
Támogatja a lusta értékelést	Nem támogatja a lusta értékelést
Nincsenek statikus tagok	Statikus tagokat tartalmaz
Támogatja a kezelő túlterhelését	Nem támogatja a kezelő túlterhelését
A forráskód fordítása viszonylag lassú	A forráskód összeállítása gyorsabb, mint a Scala
Tulajdonságok – viselkedj úgy Java 8 interfész	Java 8 interfész próbálja áthidalni az osztályok és interfészek közötti szakadékot
Újraírás szükséges	Újraírás nem szükséges
Nincs garancia a hibamentes kódokra	A kisebb hibák teljes körű biztosítása
Támogatja a visszafelé kompatibilitást.	A Scala nem támogatja a visszamenőleges kompatibilitást.
Operaa torokat eltérően kezelik Java és nem metódushívások.	A bejegyzések összes operátora a Scalában nevezett metóduson keresztül történik.
Támogatja a többszörös öröklődést osztályok használatával, de nem absztrakt osztályokkal	Nem támogatja a többszörös öröklődést osztályok használatával, hanem interfészek szerint
A kód kompakt formában van írva.	A kód hosszú formában van írva.
A Scala nem tartalmazza a statikus kulcsszót.	Java tartalmazza a static kulcsszót.

Összegzésként

Ebből az oktatóanyagból megtanulta, hogyan kezdje el a Scalát. Megtanulta a funkcionális és objektumorientált funkciókat is. Ön is felfedezte a hasonlóságokat és a különbségeket Java és a Scala. Ennek az oktatóanyagnak sokféle példával kellett volna segítenie, amelyek jól be vannak mutatva.