Scala oktatóanyag

Mi az a Scala?

Scala egy statikusan tipizált programozási nyelv, amely az objektumorientált és a funkcionális programozást ötvözi az alkalmazások skálázhatóságának javítása érdekében. A Scala elsősorban a JVM platformon fut, és a fejlesztők natív platformokra (Scala-Native) vagy böngészőhöz (ScalaJs) is írhatnak vele szoftvereket. JavaForgatókönyv futási idő.

A Scala egy skálázható nyelv, amelyet több platformra fejlesztenek szoftvereket, és pontosan innen ered a neve is. A nyelvet úgy tervezték, hogy megoldja a... Java miközben tömör maradt. Martin Odersky tervezte a Scalát, és az első nyilvános kiadás 2004-ben jelent meg.

Miért tanulja meg a Scalát?

Íme a Scala programozási nyelv elsajátításának fő okai:

• A Scala könnyen elsajátítható az objektumorientált programozók számára. Java fejlesztők, és az utóbbi években az egyik legnépszerűbb nyelvvé vált.
• A Scala első osztályú funkciókat kínál a felhasználóknak.
• A Scala futtatható a következőn: JVM, megnyitva az utat a más nyelvekkel való interoperabilitás előtt.
• Olyan alkalmazásokhoz tervezték, amelyek párhuzamosak, elosztottak és rugalmasak, üzenetvezéreltek, ami az évtized egyik legkeresettebb nyelvévé teszi.
• Ez egy tömör, hatékony nyelv, amely gyorsan fejlődhet a felhasználói igényeknek megfelelően.
• Objektumorientált és számos funkcionális programozási funkciót tartalmaz, így a fejlesztőknek nagy rugalmasságot biztosít a kódírásban.
• A Scala Duck Ty-t kínáljaping szerkezeti típusok révén.
• Kevesebb sablonos szerkezettel rendelkezik, mint Java.
• A Scalában írt Lift and Play keretrendszerek folyamatosan fejlődnek és egyre népszerűbbek.

A Scala telepítése

Scala programok írásának megkezdéséhez telepítenie kell a programot a számítógépére. Ehhez látogassa meg a hivatalos weboldalt a következő címen: https://www.scala-lang.org/download/ a Scala legújabb verziójának letöltéséhez.

A linkre kattintva két lehetőség közül választhat a Scala telepítéséhez. Ebben a Scala oktatóanyagban a következőt fogjuk használni: IntelliJ IDEA, amely kiváló Scala-támogatást nyújt alapból.

Miután megnyitottad a letöltési linket, az IntelliJ IDE két kiadását találod.

Ehhez a Scala oktatóanyaghoz letöltjük a Community Editiont, amely ingyenes és mindent tartalmaz, amire szükséged van a Scala programok írásához.

Step 1) Válaszd a Közösségi kiadást.
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 és a JBR letöltésére, amely egy JDK implementációt tartalmaz (Java Development Kit), például OpenJDK, amelyre a Scalának szüksége van a kód fordításához és futtatásához.

Step 2) Futtassa a telepítést.
Miután letöltötte az IntelliJ-t, kattintson duplán a telepítőre, és kövesse a képernyőn megjelenő varázsló utasításait.

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

Ha nem a JDK-t tartalmazó csomagot töltötted le, a telepítő továbbra is kéri a JDK hozzáadását egy jelölőnégyzet segítségével a telepítés során.

Step 4) Kattintson a Tovább gombra.
Hagyja a többi alapértelmezett beállítást úgy, ahogy van, és kattintson a Tovább gombra.

Scala Hello World Program

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

Továbbra is hozzá kell adnod a Scala bővítményt az IntelliJ-hez. Kattints a képernyő jobb alsó sarkában található konfigurációs menü legördülő menüjére, és válaszd a Bővítmények lehetőséget.

A Piactér lapon keressen rá a Scala bővítményre. A bővítmény az első találatként jelenik meg a Nyelvek címke alatt.

Step 6) Telepítse a bővítményt.
A Scala bővítmény letöltésének megkezdéséhez kattintson a Telepítés gombra.

Step 7) Indítsd újra az IDE-t.
A letöltés befejezése után a rendszer kéri az IDE újraindítását, hogy a telepített bővítmény elkezdhesse működni.

Újraindítás után ugyanarra az oldalra tér vissza, mint korábban, de most a Scala bővítmény telepítve van és használatra kész.

Step 8) Válassza a Projekt létrehozása lehetőséget, amely egy olyan oldalra vezet, ahol kiválaszthatja a projekt nyelvét.

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

Step 10) Válasszon ki egy helyet a projektfájl mentéséhez, és adjon nevet a projektnek.

Ha a könyvtár nem létezik, az IntelliJ engedélyt kér a mappa létrehozására. Fogadd el, majd kattints a Befejezés gombra. Ezután a Scala projektedhez jutsz, amely jelenleg nem tartalmaz Scala kódot.

Az indexek betöltése eltart egy ideig, ezért ne aggódjon, ha nem tud kommunikálni az IDE-vel, miközben az alsó részen egy folyamatjelző sáv látható. Az IDE betölti a Scala futtatásához és az automatikus kiegészítés biztosításához szükséges fájlokat.

Step 11) Kattintson az IDE bal oldalán található Projekt fülre, és bontsa ki a projekt tartalmának megtekintéséhez.

Ezen a ponton a projekt üres, és csak egy .idea mappát és az IDE által generált hello-world.iml fájlt tartalmaz. A lényeg az src mappa, amely a projekt forráskódját tartalmazza. Itt hozod létre az első Scala fájlodat.

Step 12) Kattintson a jobb gombbal az src fájlra egy menü megnyitásához és egy új Scala fájl létrehozásához.

Válasszon nevet a fájlnak. Ehhez a Scala oktatóanyaghoz használja a következőt: szia, majd válassza az Objektum lehetőséget a legördülő menüből a Scala-fájl tartalomtípusához.

Ha ezt megtette, lesz egy Scala-fájlja, amely egy singleton objektumot tartalmaz, amelyet a kód futtatásához fog használni.

Most, hogy van egy Hello objektummal rendelkező Scala fájlod, írd meg az első programodat a létrehozott objektum App kulcsszóval való kiterjesztésével.

Az objektum App paranccsal való kiterjesztése megmondja a fordítónak, hogy melyik kódot futtassa a program indulásakor. Közvetlenül az App paranccsal való kiterjesztés után egy zöld nyíl jelenik meg a bal oldalon, jelezve, hogy a program most már futtatható.

A Hello objektumon belül írd meg a println() függvényt, ami kiírja a szöveget a konzolra. A program futtatásához kattints a zöld nyílra.

A nyílra kattintva megjelenik a Run Hello opció. Kiválasztásával lefordítható a kód, és néhány másodperc múlva a program kimenete megjelenik az IntelliJ konzolon.

Most már sikeresen telepítetted a Scalát, és futtattad az első programodat.

Mit tehet a Scalával

A Scalát széles körben használják számos területen rugalmassága és JVM-kompatibilitása miatt. Gyakori használati esetek:

• Frontend webfejlesztés ScalaJS-sel.
• Mobil fejlesztés Android és iOS-en a Scala Native segítségével.
• Szerveroldali kódtárak, például HTTP4S, Akka-Http és a Play Framework.
• Dolgok Internete (IoT) alkalmazások.
• Játékfejlesztés.
• Természetes nyelvi feldolgozás a ScalaNLP könyvtárcsomag használatával.
• Haladó technikák, például funkcionális programozás és objektumorientált programozás együttes gyakorlása.
• Aktorokat használó, nagymértékben egyidejű kommunikációs alkalmazások, egy Erlang ihlette JVM-könyvtár.
• Gépi tanulás olyan könyvtárakkal, mint a Figaro valószínűségi programozáshoz és az Apache Spark nagyméretű adatfeldolgozáshoz.

Névtelen funkciók

A Scala nyelv támogatja az anonim függvényeket, más néven függvényliterálokMivel a Scala egy funkcionális nyelv, a fejlesztők gyakran a nagy problémákat sok kisebb feladatra bontják, és sok függvényt hoznak létre. Ennek megkönnyítése érdekében a Scala lehetővé teszi a függvények használatát. név nélkül példányosítvaKözvetlenül változókhoz vagy definíciókhoz rendelheti őket a következő használatával: def, ahogy az a következő Scala példában is látható:

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

Ezután paraméterek átadásával használhatod őket, mint a szokásos függvényeket:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Ezek a metódusok akkor jöhetnek jól, ha tiszta és tömör kódra van szükség. Az anonim függvények akkor hasznosak, ha olyan metódusokat definiálunk, amelyek kicsik és nem igényelnek sok kódot a törzsükben. Nagyon egyszerűek és nem igényelnek semmilyen ceremóniát a létrehozásuk.

Ezek a metódusok nem korlátozódnak argumentumokat tartalmazó függvényekre, és olyan metódusok példányosítására is használhatók, amelyek nem fogadnak el argumentumot.

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

Ezen anonim függvények nagy részét a kód más részein használják, ahol gyors függvényre van szükség. Emiatt más néven inline függvényekAz anonim függvények használata egy gyakori minta, amely a gyűjteménykönyvtárban megjelenik gyors műveletek végrehajtásához egy gyűjteményen.

Például a filter metódus egy beágyazott függvény segítségével hoz létre egy másik kollekciót, amely csak azokat az elemeket tartalmazza, amelyek megfelelnek az anonymous függvényben meghatározott kritériumoknak.

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ények ellenőrzik, hogy a lista értéke páros vagy páratlan, és visszaadják a megfelelő 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 lehetőség van helyettesítő karakterek használatára is, ha az anonim függvényparaméter nincs elnevezve. Például:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

Ebben az esetben nem kell elnevezni a paramétert. Az aláhúzásjelet használjuk annak ábrázolására.

Lusta értékelés

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

Egy lustaként megjelölt változó nem értékelődik ki ott, ahol definiálva van, ezt közismert nevén lelkes kiértékelésnek nevezik. Csak akkor értékelődik ki, amikor a kód későbbi részében hivatkozunk rá.

Ez akkor lehet hasznos, ha egy érték kiértékelése költséges számítást igényelne. Ha az értékre nincs mindig szükség, akkor megkímélhetjük magunkat egy költséges számítás futtatásától, amely a változó lustává tételével lelassíthatja a szoftvert.

lazy val myExpensiveValue = expensiveComputation

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

Ez nem az egyetlen felhasználási esete a lusta változóknak. A kódban található körkörös függőségek kezelésében is segítenek.

Ha a beállítások jelzője hamis, akkor nem kell a myExpensiveValue függvényt használnia, amely megkíméli Önt a költséges számításoktól. Ez segít biztosítani a felhasználók zökkenőmentes élményét, mivel az erőforrások nem pazarlódnak olyan értékekre, amelyeket soha nem olvasnak be.

A lustaság a függvényargumentumokkal is segít, ahol az argumentumok csak akkor használatosak, ha a függvényen belül hivatkozunk rájuk. Ezt a koncepciót név szerinti paramétereknek nevezik.

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

Sok nyelv az argumentumok kiértékelésére az érték alapú hívást alkalmazza. A név alapú híváson keresztül átadott paraméter csak akkor kerül kiértékelésre, ha a függvény törzsén belül szükség van rá. Miután az érték kiértékelésre került, azt tárolja a rendszer, és később újra felhasználható újrakiértékelés nélkül, ezt a koncepciót memoizációnak nevezik.

Típus Következtetés

A Scalában nem kell minden létrehozott változóhoz típust deklarálni, mivel a Scala fordítója a kifejezés jobb oldalából kikövetkeztetheti a típusokat. Ez lehetővé teszi, hogy a kód tömörebb legyen, és megszabaduljon attól, hogy sablonos kódokat írjon, ahol a várt típus nyilvánvaló.

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

Magasabb rendű függvény

A magasabb rendű függvény olyan függvény, amely argumentumként függvényeket fogadhat, és visszatérési típusként függvényt adhat vissza. A Scalában a függvények első osztályú polgároknak számítanak. A függvények ilyen módon történő használata nagy rugalmasságot tesz lehetővé a programkészítésben. Dinamikusan létrehozhat függvényeket, és dinamikusan táplálhatja a funkciókat 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 függvény, amely egy Int és visszaad egy IntBármelyik függvényt átadhatod, amely rendelkezik ezzel az aláírással. Aláírás alatt egy függvény bemenetét és kimenetét értjük. Egy ilyen aláírás Int => Int azt jelenti, hogy egy függvény egy egész számot fogad bemenetként, és egy egész számot ad vissza kimenetként.

Egy aláírás () => Int azt jelenti, hogy egy függvény semmit sem vesz bemenetként, és egy egész számot ad vissza kimenetként. Egy ilyen függvényre példa az, amelyik véletlenszerű egész számot generál.

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

A fenti függvénynek van egy aláírása () => Int.

Egy függvénynek lehet aláírása is. () => UnitEz azt jelenti, hogy a függvény nem fogad el semmit, és nem ad vissza típust. Ehelyett megváltoztathat valamilyen állapotot, vagy végrehajthat egy előre meghatározott műveletet.

Az ilyen típusú metódusokat nem javasoljuk, mivel fekete dobozként működhetnek, amelyek ismeretlen módon befolyásolják a rendszert. Nehezebb is tesztelni őket. Az explicit bemeneti és kimeneti típusok lehetővé teszik, hogy megfontoljuk a függvényünk működését.

Egy magasabb rendű függvény is visszaadhat egy függvényt. Létrehozhatsz például egy metódust, amely egy hatványozó függvényt ad vissza, egy olyat, amely egy számot vesz fel, és hatványozza azt.

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

A fenti függvény egy Int értéket fogad el. A visszatérési típusa egy anonim függvény, amely egy Int értéket fogad el. x és ezt használja a hatványfüggvény argumentumaként.

Currying

A Scalában egy két argumentumot fogadó függvényt egyetlen argumentumot fogadó függvényré alakíthatunk. Amikor átadunk egy argumentumot, akkor azt részben alkalmazzuk, és egy olyan függvényt kapunk, amely a fennmaradó argumentumot használja a hívás befejezéséhez. A Currying lehetővé teszi függvények építését néhány argumentum részleges hozzáadásával.

Ez akkor hasznos, ha dinamikusan szeretnénk létrehozni függvényeket, mielőtt rendelkeznénk a teljes argumentumkészlettel.

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

Ha egy olyan függvényre van szükséged, amely egy adott számmal szoroz, akkor nem kell külön szorzómetódust létrehoznod. Alkalmazhatsz egy argumentumot a curry függvényre, és újra felhasználhatod az eredményt:

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

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Mintaillesztés

A Scala egy hatékony beépített mechanizmussal rendelkezik, amely segít ellenőrizni, hogy egy változó megfelel-e bizonyos kritériumoknak, hasonlóan egy switch utasításhoz a Java vagy if/else utasítások láncolata. A nyelv támogatja a mintaillesztést, amellyel ellenőrizhető, hogy egy változó egy adott típusba tartozik-e. A Scala mintaillesztése hatékony, és képes destrukturálni azokat a komponenseket, amelyeknek van egy unapply metódus, amellyel a számunkra fontos mezőket közvetlenül a párosított változóból nyerhetjük ki.

A Scala mintaillesztése kellemesebb szintaxist is biztosít, mint egy switch utasítás.

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

A változót egy beállításkészlettel hasonlítjuk össze. Amikor a változó megfelel a kritériumoknak, a vastag nyíl (=>) jobb oldalán lévő kifejezés kiértékelődik és az egyezés eredményeként adja vissza az eredményt.

Az aláhúzásjel azokat az eseteket fogja meg, amelyek nem egyeznek a kódban, tükrözve az alapértelmezett eset viselkedését egy switch utasításban.

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 _ => //unknown type, do something else
}

A fenti kódban megtalálhatod a típusát myItem változót, és ennek alapján elágazhat egy adott kódhoz.

A mintaillesztés azt ellenőrzi, hogy a változó minden egyes esetre illeszkedik-e a sorrendben.

Az aláhúzásjel helykitöltőként működik, amely illeszkedik minden olyan feltételhez, amelyre a többi case utasítás nem. Vegyél egy változót myItem és felhívja a match módszer.

• Ellenőrzi, hogy myItem is true és futtasd a logikát a vastag nyíl („=>”) jobb oldalán.
• Az aláhúzásjellel olyan elemeket illeszthetsz be, amelyek nem egyeznek a kódban definiált case utasítások egyikével sem.

Esettanulmány-osztályokkal az osztályt ex-re destrukturálhatodtract mezők az objektumon belül.

A sealed kulcsszóval osztályokat definiálhatsz, akkor azt az előnyt élvezheted, hogy a fordító kimerítően ellenőrzi az egyeztetni próbált eseteket, és figyelmeztet, ha elfelejtesz egyet kezelni.

Állandóság

A Scala-ban olyan értékeket lehet létrehozni, amelyeket más függvények nem módosíthatnak a következő használatával: val kulcsszó. Ez a következőképpen érhető el: Java a final kulcsszó. A Scalában egy val változó létrehozásakor ahelyett, hogy var, ami a módosítható változók alternatívája.

Egy változó, amelyet a val kulcsszó csak olvasható, míg egy a következővel definiált var később más függvények vagy a felhasználó által a kódban olvashatók és módosíthatók.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Értéket próbálok rendelni hozzá myNumber miután kijelentette, hogy val fordítási idejű hibát dob: „áthelyezés az értékhez.”

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

A megváltoztathatatlanság segít megakadályozni, hogy a kód és más programozók váratlanul megváltoztassák az értékeket, ami kiszámíthatatlan eredményekhez vezetne. Ha egy érték felhasználóinak módosítaniuk kell azt, ehelyett másolatot készíthetnek róla. Így megakadályozhatók azok a hibák, amelyeket az okoz, hogy több szereplő módosítja ugyanazt a változót.

Osztályok és objektumok

Az objektumok valós entitások, az osztály pedig egy sablon, amely definiálja az objektumokat. Az osztályoknak van állapotuk és viselkedésük is. Az állapotok vagy értékek, vagy változók. A viselkedések a Scala metódusai.

A következő szakasz bemutatja, hogyan definiálhatunk egy osztályt, hogyan példányosíthatjuk azt, és hogyan használhatjuk Scalában.

Itt van egy Rectangle nevű osztály, aminek két értéke és két függvénye van. Használhatod a paramétereket is. l és a b közvetlenül mezőkként a programban. Van egy objektumod, aminek van egy main metódusa, és két értékkel példányosítja 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 a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

A Scalában alapértelmezés szerint minden mező és metódus nyilvános. Használatuk elengedhetetlen override mert toString már minden Scala objektumhoz definiálva van.

Öröklés

A Scalának többféle öröklődési típusa van (egy-, többszintű, többszörös, hierarchikus és hibrid), amelyek sok közös vonást mutatnak a hagyományos, a ...-ban található formákkal. JavaOsztályokból és tulajdonságokból is örökölhetsz. Az egyik osztály tagjait a kulcsszó használatával örökölheted egy másik osztályba. extendsEz lehetővé teszi az újrafelhasználhatóságot.

Lehetséges egy vagy több osztályból örökölni. Az is lehetséges, hogy olyan alosztályokból örökölünk, amelyeknek maguknak is vannak saját szuperosztállyaik, így létrehozva egy öröklési hierarchiát.

Az alábbi Scala példában az alaposztály a következő: Circle, és a származtatott osztály SphereEgy körnek van egy sugara nevű értéke, amelyet a Sphere osztály örököl. A metódus calcArea kulcsszó felülírja override.

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

AbstracCIÓ

A Scalában hasizmokat készíthetsztract metódusok és tagmezők absz használatávaltract osztályok és tulajdonságok. Belső hasizmoktract osztályok és tulajdonságok, definiálhatod a hasizmokattract mezők implementálása nélkül.

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 azok az osztályok valósítják meg, amelyek kiterjesztik a tulajdonságot vagy az abszcissziót.tract osztály. A tulajdonságok segítségével conokat hozhatsz létre.tracts metódusokat arra vonatkozóan, hogy mit kell tennie egy alkalmazásnak, majd ezeket a metódusokat később implementáljuk.

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

Így megtervezheted, hogyan fog kinézni egy alkalmazás anélkül, hogy implementálnád a metódusokat, helping elképzeled, hogyan fognak kinézni a különböző módszerek. Ez egy hasizmok programozásának nevezett mintát követ.tracinkább a tényleges megvalósításra, mintsem a megvalósításra.

Egy osztály, amelynek előszavában szerepel a abstract a kulcsszó tartalmazhat mind az abs-t, mind atract és nem hasizomtract metódusok. Az absz módszer azonban nem támogatja a többszörös öröklődést.tract órák, így csak egy hasizmot tudsz nyújtanitract osztály.

Singleton objektumok

Az egyelemű osztály egy olyan osztály, amely csak egyszer példányosodik egy programban. Egy népszerű és hasznos programozási mintából, az úgynevezett „egyelemű mintából” származik. Hasznos olyan példányok létrehozására, amelyek hosszú életűek és a programban gyakran elérhetők, ahol az állapot szerves része a rendszer eseményeinek koordinálásának. Egy ilyen osztály létrehozása Scalában egyszerű, mivel a Scala egyszerű módszert kínál az egyelemű osztályok létrehozására a következő használatával: object kulcsszó.

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

Ezután a programban végig hivatkozhatsz erre az objektumra, garantálva, hogy a program minden része ugyanazt az adatot látja, mivel csak egyetlen példánya létezik.

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

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

A statikus tagok fogalma nem létezik a Scalában, ezért használunk egyetlen objektumot, ami egy osztály statikus tagjaiként viselkedik.

Implicit osztályok

Az implicit osztályok a 2.10-es verzióban hozzáadott funkciók, és elsősorban a meglévő zárt osztályokhoz való új funkciók hozzáadására szolgálnak.

Az implicit A kulcsszót egy osztályban, objektumban vagy tulajdonságban kell definiálni. Egy implicit osztály elsődleges konstruktorának pontosan egy argumentummal kell rendelkeznie az első paraméterlistájában. Tartalmazhat egy további implicit paraméterlistát is.

Az alábbi Scala példában új funkció került hozzáadásra, amellyel a karakterláncok magánhangzóit * jellel (*) lehet helyettesíteni.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Importálnod kell az implicit osztályt abba az osztályba, ahol használod.

import StringUtil.StringEnhancer

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

Objektumorientált programozás (OOP) vs. funkcionális programozás (FP)

Az OOP-ban a programokat csoportosan építik fel.ping az adatokat és az azokon működő függvényeket szorosan összekapcsolt egységekbe. Az objektumok mezőkben hordozzák az adataikat, a metódusok pedig ezeken dolgoznak. Ebben a programozási stílusban a fő abstracA lényeg az adat, mivel a létrehozott metódusok az adatokon való működésre szolgálnak.

Funkcionális programozás... viszont elválasztja az adatokat és az azokon dolgozó függvényeket. Ez lehetővé teszi a fejlesztők számára, hogy a függvényeket az absz.tracés hajtóerő a programok modellezésekor.

A Scala lehetővé teszi a funkcionális programozást azáltal, hogy a függvényeket első osztályú polgárokként kezeli, lehetővé téve azok értékként való átadását más függvényeknek, és szintén értékként való visszaadását. E két paradigma kombinációja tette a Scalát nagyszerű választássá komplex szoftverek fejlesztéséhez olyan iparágakban, mint az adattudomány.

Fontos keretrendszerek a Scalában

Íme néhány fontos keretrendszer a Scala számára:

• játszani egy nyílt forráskódú webalkalmazás-keretrendszer, amely a MVC architektúra. 2007-ben jelent meg, és most Apache alatt licencelt, 2013-ra a GitHubon az egyik legnépszerűbb keretrendszerré vált. Olyan cégek, mint a LinkedIn, WalmartA Samsung, az Eero és az Eero is ezt a keretrendszert használja.
• Lift egy másik ingyenes, Scalában írt webes keretrendszer, amelyet 2007-ben indítottak. A Foursquare a Lift keretrendszert használja. Ez egy nagy teljesítményű keretrendszer, amellyel gyorsan lehet építeni.
• Mint eszközkészletet biztosít nagymértékben egyidejű, elosztott és rugalmas üzenetvezérelt alkalmazások JVM-en történő létrehozásához.
• Macskák egy könyvtár, amely hasizmokat kínáltracfunkcionális programozáshoz.
• Spark egy egységes analitikai motor nagyméretű adatfeldolgozáshoz, amelyet széles körben használnak big data és gépi tanulási munkafolyamatokban.

Egyidejű támogatás

• A Scala értékei alapértelmezés szerint megváltoztathatatlanok, ami nagyon adaptívvá teszi az egyidejű környezetekhez.
• A Scala számos olyan funkcióval rendelkezik, amelyek ideálissá teszik egyidejű alkalmazásokhoz.
• A Futures and Promises megkönnyíti az adatok aszinkron feldolgozását, így támogatja a párhuzamosságot.
• Az Akka egy eszközkészlet, amely az Actor konkurencia modelljét használja. Az Actorok akkor cselekszenek, amikor üzeneteket kapnak.
• Egyidejűség szálak használatával Java a Scalában is támogatott.
• A streamfeldolgozá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 Vertx.
• ZIO, egy olyan könyvtár, amely primitíveket tartalmaz a párhuzamosság és az aszinkron számítás kezeléséhez.
• Szoftveres tranzakciós memória (STM) tranzakciókhoz.
• Future, amely be van építve a Scala nyelvbe.

Java vs. Scala

Itt vannak a főbbek közötti különbségek Java és a Scala.

GYIK