Scala õpetus

Scala õpetuse kokkuvõte

See scala õpetus hõlmab kõiki scala aspekte ja teemasid. Õpid nullist selgeks kõik põhialused, näiteks Mis on scala, scala installiprotsess, Scala programmid, Scala funktsioonid, laisk hindamine, tüübiliides, klassid ja objektid, pärimine, abstraktsioonid, Java ja scala erinevused jne.

Scala on skaleeritav keel, mida kasutatakse tarkvara kirjutamiseks mitmele platvormile. Seetõttu sai see nime "Scala". See keel on mõeldud probleemide lahendamiseks Java olles samal ajal sisutihedam. Algselt kujundas see Martin Odersky, see ilmus 2003. aastal.

Miks õppida Scalat

Siin on peamised põhjused Scala programmeerimiskeele õppimiseks:

• Scalat on objektorienteeritud programmeerijatele lihtne õppida, Java arendajad. See on viimastel aastatel muutumas üheks populaarsemaks keeleks.
• Scala pakub kasutajatele esmaklassilisi funktsioone
• Scalat saab käivitada FMV, sillutades seega teed koostalitlusvõimele teiste keeltega.
• See on mõeldud rakendustele, mis on samaaegsed, hajutatud ja vastupidavad sõnumipõhised. See on selle kümnendi üks nõudlikumaid keeli.
• See on sisutihe, võimas keel ja võib kiiresti kasvada vastavalt kasutajate nõudmistele.
• See on objektorienteeritud ja sellel on palju funktsionaalseid programmeerimisfunktsioone, mis pakuvad arendajatele palju paindlikkust, et nad saaksid soovitud viisil kodeerida.
• Scala pakub palju parditüüpe
• Kui te pärit olete, on sellel vähem katlakivi Java
• Scalas kirjutatud raamistikud Lift ja Play on kasvukõveras.

Kuidas installida Scala

Scala programmide kirjutamise alustamiseks peab see olema arvutisse installitud. Selleks peate külastama nende saiti https://www.scala-lang.org/download/ Scala uusima versiooni allalaadimiseks.

Pärast linki jõuame kahe võimaluseni, mille abil saame Scala oma masinatesse installida. Selle Scala õpetuse jaoks laadime alla IntelliJ IDEA.

Kui külastate allalaadimislinki, leiate kaks IntelliJ IDE versiooni.

Selle Scala õpetuse jaoks laadime alla Community Editioni, mis on tasuta ja sisaldab kõike, mida vajate Scala programmide kirjutamiseks.

Step 1) Valige kogukonna väljaanne
Klõpsake lehel kogukonna väljaande rippmenüül.

See annab meile võimaluse alla laadida IntelliJ IDE koos JBR-iga, mis sisaldab JDK rakendust (Java Arenduskomplekt) OpenJDK, mida Scala vajab koodi kompileerimiseks ja käivitamiseks.

Step 2) Käivitage installimine
Kui olete IntelliJ alla laadinud, topeltklõpsake seda installiviisardi käivitamiseks ja järgige dialoogi.

Step 3) Valige asukoht
Valige IDE installimise koht.

Kui te juhuslikult JDK-ga allalaadimist ei laadinud, kuvatakse ikkagi viip, kust saame selle allalaadimist kontrollida, märkides märkeruudu.

Step 4) Klõpsake järgmisel
Jätke muud vaikeseaded samaks ja klõpsake nuppu Edasi.

Step 5) Klõpsake käivitusikooni
Kui installimine on lõppenud, käivitage IntelliJ IDE, klõpsates käivitusmenüüs selle käivitusikooni nagu tavalisel rakendusel.

Peate siiski läbima täiendava sammu Scala pistikprogrammi lisamiseks IntelliJ-sse; selleks klõpsate ekraani paremas alanurgas asuvas konfigureerimismenüüs rippmenüül ja valite pistikprogrammi valiku.

Vahekaardil Marketplace kuvab Scala otsing pistikprogrammi esimese tulemusena märgendi Keeled all.

Step 6) Installige plugin
Klõpsake nuppu Install, mis käivitab pistikprogrammi allalaadimise.

Step 7) Taaskäivitage IDE
Kui allalaadimine on lõppenud, palutakse teil IDE taaskäivitada, et installitud pistikprogramm saaks tööle hakata.

Pärast taaskäivitamist leiate end samal lehelt, kus IDE käitasime, kuid seekord oleme juba installinud Scala pistikprogrammi.

Programm Scala Hello World

Step 1) Valige suvand Loo projekt, mis viib meid lehele, kus saame valida, millist keelt meie projekt kasutab.

Step 2) valige Scala, märkides Scala märkeruudu ja klõpsake nuppu Edasi.

Step 3) Valige meie projektifaili salvestamise koht ja andke projektile nimi.

Kui kataloogi pole, palub IntelliJ meilt kausta loomiseks luba küsida. Nõustu ja klõpsake nuppu Lõpeta. Teid suunatakse teie Scala projekti, millel pole praegu ühtegi Scala koodi.

Mõne indeksi laadimine võtab veidi aega, nii et ärge muretsege, kui te ei saa kohe midagi teha, kui teie IDE allosas on edenemisriba, see tähendab lihtsalt, et teie IDE laadib mõned failid, mis on vajalikud Scala käitamiseks ja abi IDE automaatse täitmisega.

Step 4) Järgmisena klõpsame IDE-st vasakul asuvat projektide vahekaarti ja laiendame seda, et näeksime oma projekti sisu.

Hetkel on projekt tühi ja sisaldab ainult IDE poolt genereeritud .idea kausta ja hello-world.iml faili. Meie huvipunkt on src kaust. Src on koht, kus salvestame oma projekti lähtekoodi. Siin loome oma esimese Scala faili.

Step 5) Uue Scala faili loomiseks menüü avamiseks paremklõpsake src-l.

Seejärel loome failile nime, selles Scala õpetuses kasutame tere ja seejärel valime rippmenüüst, mida lisada Scala faili sisuks. Valige "Objekt"

Kui oleme seda teinud, on meil Scala fail, millel on Singletoni objekt, mida kasutame oma koodi käitamiseks.

Nüüd, kui teil on Hello objektiga Scala fail. Kirjutate oma esimese programmi, laiendades rakenduse märksõna abil loodud objekti.

Meie objekti laiendamine rakendusega öelge kompilaatorile, millist koodi käivitada, kui see teie programmi käivitab. Kohe pärast rakenduse laiendamist kuvatakse vasakul küljel roheline nool, mis näitab, et saate nüüd oma programmi käivitada.

Hello objekti sisse kirjutame ühe funktsiooni println(), mida kasutatakse selle sees oleva teksti konsooli printimiseks. Käitame oma koodi, klõpsates rohelisel noolel.

Noolele klõpsates avaneb suvand Käivita, tere, sellel klõpsamisel hakkab meie kood kompileerima ja mõne sekundi pärast näeme oma programmi tulemusi prindituna IntelliJ IDE-sse sisseehitatud konsoolist.

Ja seal me oleme Scala edukalt installinud ja käivitanud oma esimese programmi.

Mida saate Scalaga teha

• Esikülje veebiarendus ScalaJS-iga
• Mobiiliarendus, mõlemad Android Arendus ja IOS – koos Scala Native'iga
• Serveripoolsed teegid nagu HTTP4S, Akka-Http, Play Framework
• Asjade Interneti kasutamine
• Mängu arendamine
• NLP – loomuliku keele töötlemine, kasutades ScalaNLP-teekide komplekti
• Täiustatud programmeerimistehnikate testimine, nagu funktsionaalne programmeerimine ja objektorienteeritud programmeerimine
• Ehitage näitlejate abil väga samaaegne suhtlusrakendus JVM-i jaoks Erlangist inspireeritud raamatukogu
• Kasutage seda masinõppeks, kasutades selliseid teeke nagu Figaro, mis teeb tõenäosuslikku programmeerimist ja Apache Spark et

Anonüümsed funktsioonid

Scala keeles on anonüümsed funktsioonid, mida nimetatakse ka funktsiooniliteraalid. Kuna Scala on funktsionaalne keel, tähendab see sageli, et arendajad jagavad suured probleemid paljudeks väikesteks ülesanneteks ja loovad nende probleemide lahendamiseks palju funktsioone. Funktsioonide loomise hõlbustamiseks sisaldab Scala neid funktsioone, mis võivad olla instantseeritud ilma nimeta. Saame need määrata otse muutujatele või definitsioonidele "def", nagu on näidatud allolevas Scala näites:

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

Seejärel saame kasutada funktsioone tavapärasel viisil, edastades neile parameetrid järgmiselt.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Need meetodid on kasulikud, kui soovime saada puhast ja ülevaatlikku koodi. Anonüümseid funktsioone saame kasutada selliste meetodite määratlemisel, mis ei ole suured ja ei nõua oma kehas palju koodi. Need on väga lihtsad ega vaja nende loomiseks tseremooniat.

Need meetodid ei piirdu argumentidega funktsioonidega ja neid saab kasutada selliste meetodite loomiseks, mis argumente ei võta.

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

Enamikku neist anonüümsetest funktsioonidest kasutatakse meie koodi muudes osades, kus peame looma kiire funktsiooni.

Teine põhjus, miks neid funktsioone nimetatakse ka tekstisisesed funktsioonid. Anonüümsete funktsioonide kasutamine on levinud muster, mida kasutatakse kogude teegis laialdaselt koguga kiirete toimingute tegemiseks.

Näiteks on meil filtermeetod, mis kasutab sisemist funktsiooni/anonüümset funktsiooni, et luua uus kogu, milles on ainult elemente, mis vastavad meie anonüümses funktsioonis määratletud kriteeriumidele.

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)

Anonüümsete funktsioonidena kasutatavad meetodid on need, mis kontrollivad, kas loendist saadav väärtus on paaritu ja paaritu, ning tagastavad üksuse.

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

Scalas on võimalik kasutada metamärke ka siis, kui meie anonüümse funktsiooni parameetrit ei nimetata. Näiteks

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Selle stsenaariumi korral me ei nimeta parameetrit, mida me edastame. Ainus asi, mida me kasutame selle tähistamiseks alakriipsu.

Laisk hindamine

Enamik keeli hindab muutujaid ja funktsioonide parameetreid järjestikku üksteise järel. Scalas on meil märksõna nimega laisk, mis aitab käsitleda väärtusi, mida me ei soovi hinnata enne, kui neile viidatakse.

Laisaks märgitud muutujat ei hinnata seal, kus see on määratletud. Seda nimetatakse tavaliselt innukaks hindamiseks, seda hinnatakse ainult siis, kui sellele viidatakse mõnes koodi hilisemas osas.

See võib olla abiks siis, kui väärtuse hindamine võib olla kulukas arvutus. Kui see pole nii, et väärtust pole alati vaja, saame säästa end kalli arvutuse eest, mis võib meie tarkvara aeglustada, muutes muutuja laisaks.

lazy val myExpensiveValue = expensiveComputation

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

See pole laiskade muutujate ainus kasutusjuht. Need aitavad lahendada ka koodi tsirkulaarse sõltuvuse probleeme.

Kui sätted on valed, ei pruugi me vajada myExpensiveValue'i kasutamist, mis võib meid päästa kallite arvutuste tegemisest, mis aitab tagada, et kasutajad veedavad meie rakendust kasutades mõnusalt aega, kuna meie muud vajadused saab korralikult välja arvutada ilma ülekoormamata. RAM.

Kui sätted on valed, ei pruugi me vajada myExpensiveValue'i kasutamist, mis võib meid säästa kallite arvutuste tegemisest, mis aitab tagada, et kasutajad veedavad meie rakendust kasutades mõnusalt aega, kuna meie muud vajadused saab õigesti arvutada ilma ülekoormamata. RAM.

Laiskus aitab ka funktsiooni argumentide puhul, kus argumente kasutatakse ainult siis, kui neile funktsiooni sees viidatakse. Seda kontseptsiooni nimetatakse Call-by-name parameetriteks.

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

Paljudes keeltes kasutatakse argumentide hindamiseks kõne väärtuse järgi meetodit. Nime järgi läbitud parameetrit hinnatakse ainult siis, kui see on funktsiooni kehas vajalik, ja seda enne seda ei hinnata. Kui väärtus on hinnatud, salvestatakse see ja seda saab hiljem uuesti kasutada, ilma et peaks seda uuesti hindama. Mõiste, mida nimetatakse meeldejätmiseks.

Tüüp Järeldus

Scalas ei pea te iga loodud muutuja tüüpe deklareerima. Selle põhjuseks on asjaolu, et Scala kompilaator saab teha tüüpjäreldusi parempoolse külje hindamise põhjal. See võimaldab teie koodil olla kokkuvõtlikum – see vabastab meid kirjutamast katlakivi, kus eeldatav tüüp on ilmne

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

Kõrgema järgu funktsioon

Kõrgemat järku funktsioon on funktsioon, mis võib võtta funktsioone argumentidena ja tagastada funktsiooni tagastustüübina. Scalas peetakse funktsioone esmaklassilisteks kodanikeks. Nende funktsioonide kasutamine võimaldab meil olla väga paindlikud programmide osas, mida saame teha. Saame luua funktsioone dünaamiliselt ja toita funktsionaalsust dünaamiliselt teistele funktsioonidele.

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

Ülaltoodud funktsioonis edastame int ja funktsiooni, mis võtab int ja tagastab int. Võime selle allkirja mis tahes funktsiooni edasi anda. Allkirja all peame silmas funktsiooni sisendit ja väljundit. Signatuur Int=>Int tähendab, et funktsioon võtab sisendiks Int ja tagastab väljundina Int.

Signatuur ()=>Int tähendab, et funktsioon ei võta midagi sisendiks ja tagastab väljundina Int. Sellise funktsiooni näide on selline, mis genereerib meie jaoks juhusliku int.

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

Ülaltoodud funktsioonil on signatuur ()=>Int

Meil võib olla funktsioon, millel on signatuur scala ()=>Unit. See tähendab, et funktsioonid ei võta midagi sisse ega tagasta tüüpi. Funktsioon võib olla mingisuguse arvutuse tegemine, muutes midagi ettemääratud tegevuseks.

Seda tüüpi meetodeid ei soovitata siiski kasutada, kuna need näivad olevat must kast, mis võib süsteemi mingil teadmata viisil mõjutada. Need on ka testimatud. Selgesõnaliste sisend- ja väljundtüüpide olemasolu võimaldab meil mõelda, mida meie funktsioon teeb.

Kõrgemat järku funktsioon võib ka funktsiooni tagastada.

Näiteks võime luua meetodi, mis loob toitefunktsiooni, st võtab arvu ja rakendab sellele võimsust.

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

Ülaltoodud funktsioon võtab int. Meie tagastustüüp on anonüümne funktsioon, mis võtab Int x, * kasutame võimsusfunktsiooni argumendina int x.

Karrimine

Scalas saame teisendada funktsiooni, mis võtab kaks argumenti, üheks, mis võtab korraga ühe argumendi. Kui sisestame ühe argumendi, rakendame selle osaliselt ja saame funktsiooni, mis võtab funktsiooni täitmiseks ühe argumendi. Currying võimaldab meil luua funktsioone, lisades osaliselt mõned argumendid.

See võib olla kasulik funktsioonide dünaamiliseks loomiseks enne, kui meil on täielik argumentide komplekt

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

Kui meil on vaja luua funktsioon, mis korrutab mingi kindla arvuga, ei pea me looma teist korrutamismeetodit.

Saame lihtsalt kutsuda ülaltoodud funktsiooni .curried ja saada funktsiooni, mis võtab kõigepealt ühe argumendi ja tagastab osaliselt rakendatud funktsiooni

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Mustri sobitamine

Scalal on võimas sisseehitatud mehhanism, mis aitab meil kontrollida, kas muutuja vastab teatud kriteeriumidele, nagu me teeme seda lüliti avalduses Java või kui/muidu väidete seerias. Keeles on mustrite sobitamine, mille abil saame kontrollida, kas muutuja on teatud tüüpi. Mustri sobitamine Scalas on võimas ja seda saab kasutada nende komponentide struktureerimiseks, millel on unapply meetod, et saada meid huvitavad väljad otse sobitatavast muutujast.

Scala mustrite sobitamine pakub ka meeldivama süntaksi võrreldes lülitiga.

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

Võrdleme oma muutujat valikute komplektiga ja kui muutuja, mida me sobitame, vastab kriteeriumidele, hinnatakse paksu noole (=>) paremal küljel olevat avaldist ja see tagastatakse vaste tulemuseks.

Kasutame alljoont, et tabada juhtumeid, millel pole meie koodis vastet. See peegeldab vaikejuhtumi käitumist lülitilausete käsitlemisel.

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
}

Ülaltoodud koodist saate teada muutuja myItem tüübi ja selle põhjal hargneda mõnele konkreetsele koodile.

Mustri sobitamine kontrollib, kas muutuja sobib

Alakriips töötab kohatäidisena, mis vastab mis tahes muule tingimusele, mis ei vasta ülaltoodud juhtumilausete muudele üksustele. Võtame muutuja myItem ja kutsume vaste meetodi.

• kontrollime, kas myItem on tõene, kasutades paksu noole "=>" paremal küljel olevat loogikat.
• kasutame alljoont, et sobitada midagi, mis ei ühti ühegi koodis määratletud käändelausega.

Case klasside abil saame isegi kaugemale minna ja klassi hävitada, et saada väljad objekti sees.

Kasutades oma klasside määratlemiseks pitseeritud märksõna, saame kasu sellest, et kompilaator kontrollib ammendavalt juhtumeid, mida proovime vastendada, ja hoiatab meid, kui unustame mõne konkreetse käsitleda.

Muutmatus

Märksõna val abil on võimalik luua väärtusi, mida Scala teised funktsioonid muuta ei saa. See saavutatakse aastal Java kasutades viimast märksõna. Scalas kasutame seda muutuja loomisel märksõna val, selle asemel, et kasutada muutujat, mis on alternatiiv, mida kasutaksime muutuva muutuja loomiseks.

Märksõna val abil defineeritud muutuja on kirjutuskaitstud, samas kui muutujaga var määratletud muutuja saab lugeda ja seda saab muuta teiste funktsioonide või koodis oleva kasutaja poolt suvaliselt.

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

Kui proovite määrata väärtusele myNumber pärast seda, kui oleme selle deklareerinud väärtuseks, ilmneb kompileerimisaja tõrge või "ümbermääramine väärtusele".

Miks kasutada muutumatust?

Muutumatus aitab meil takistada koodil ja teistel programmeerijatel meie väärtusi ootamatult muutmast, mis tooks kaasa ootamatuid tulemusi, kui nad kavatsevad kasutada meie salvestatud väärtust, võivad nad sellest hoopis koopia teha. Nii hoitakse ära vead, mille võivad põhjustada sama muutuja muutmine mitmel osalejal.

Klassid ja objektid

Me kõik teame, et objektid on reaalse maailma üksused ja klass on mall, mis määratleb objekte. Klassides on nii olek kui ka käitumine. Olekud on kas väärtused või muutujad. Käitumine on Scala meetodid.

Vaatame, kuidas saate klassi määratleda, seda eksemplari luua ja Scala abil kasutada.

Siin on klass nimega Ristkülik, millel on kaks muutujat ja kaks funktsiooni. Parameetreid l ja b saab programmis kasutada ka otse väljadena. Teil on objekt, millel on põhimeetod ja mis on loonud klassi kahe väärtusega.

Näide:

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

Kõik väljad ja meetodid on Scalas vaikimisi avalikud. Alistamise kasutamine on hädavajalik, kuna Scalas on objekti jaoks määratletud meetod toString.

Pärisosa

Scalal on mitut tüüpi pärandit (nt ühe-, mitmetasandiline, mitmekordne, hierarhiline, hübriidne), millel on palju ühist traditsiooniliste pärandvormidega, mida leidub Java. Võite pärida nii klasside kui ka tunnuste järgi. Saate pärida ühe klassi liikmeid teise klassi kasutades märksõna "laiendab". See võimaldab korduvkasutamist.

Võimalik on pärida ühest klassist või mitmest klassist. Samuti on võimalik pärida alamklassidest, millel endal on oma ülemklassid, luues protsessi käigus pärimise hierarhia.

Allolevas Scala näites on baasklass Circle ja tuletatud klass on Sphere. Ringjoonel on väärtus nimega raadius, mis pärineb klassist Sphere. Meetod calcArea tühistatakse märksõna alistamise abil.

Näide:

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

Abstraktsioon

Scalas saame luua abstraktseid meetodeid ja liikmevälju, kasutades abstraktseid klasse ja tunnuseid. Abstraktsete klasside ja tunnuste sees saame määratleda abstraktseid välju ilma neid tingimata rakendamata.

Näide:

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

Neid välju rakendavad klassid, mis laiendavad tunnust või abstraktset klassi. Saate kasutada tunnuseid, et luua lepinguid selle kohta, mida meie rakendus peaks suutma teha, ja seejärel neid meetodeid hiljem rakendada.

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

Nii saame planeerida, kuidas meie rakendus välja näeb, rakendamata meetodeid, mis aitavad meil ette kujutada, kuidas erinevad meetodid välja näevad. See järgib abstraktsioonide programmeerimist, mitte tegelikku rakendamist.

Klass, mille eessõna on märksõna abstraktne, võib sisaldada nii abstraktseid kui ka mitteabstraktseid meetodeid. Kuid abstraktne klass ei toeta mitut pärandit. Seega saate laiendada maksimaalselt ühte abstraktset klassi.

Üksikud objektid

Singleton on klass, mis instantseeritakse programmis ainult üks kord. See pärineb populaarsest ja kasulikust programmeerimismustrist, mida tuntakse "üksiku mustrina". See on kasulik selliste eksemplaride loomisel, mis on mõeldud pika elueaga ja millele pääseb tavaliselt juurde kogu teie programmis, mille olek on süsteemi sündmuste koordineerimisel lahutamatu osa. Sellise klassi loomine Scalas on lihtne, kuna Scala pakub lihtsat vahendit üksiktoonide loomiseks objekti märksõna abil.

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

Seejärel saame sellele objektile kogu oma programmis viidata, tagades, et kõik meie programmi osad näevad samu andmeid, kuna seda on ainult üks eksemplar.

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

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

Staatiliste liikmete kontseptsiooni Scalas pole, seetõttu peate kasutama üksikuid objekte, mis toimivad nagu klassi staatilised liikmed.

Kaudsed klassid

Kaudsed klassid on uued funktsioonid, mis on lisatud pärast versiooni 2.1. Eelkõige selleks, et lisada suletud klassidesse uusi funktsioone.

Kaudne märksõna tuleks määratleda klassis, objektis või tunnuses. Implitsiitse klassi esmasel konstruktoril peaks oma esimeses parameetriloendis olema täpselt üks argument. See võib sisaldada ka täiendavat kaudsete parameetrite loendit.

Allolevas Scala näites on lisatud uus funktsioon stringi täishäälikute asendamiseks tähega *.

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

Peate importima klassis, kus seda kasutate.

import StringUtil.StringEnhancer

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

Objektorienteeritud programmeerimine (OOP) vs. funktsionaalne programmeerimine (FP)

OOP-is koostatakse programmid andmete ja nende andmetega töötavate funktsioonide rühmitamise teel tihedalt ühendatud üksusteks. Objektid kannavad oma andmeid väljadel ja meetoditel, mis neil toimivad. Selle programmeerimisstiili puhul on põhiliseks abstraktsiooniks andmed, kuna loodud meetodid on mõeldud andmetega töötamiseks.

Funktsionaalne programmeerimine, teisest küljest eraldab andmed ja andmetega töötavad funktsioonid. See võimaldab arendajatel käsitleda funktsioone programmide modelleerimisel abstraktsiooni ja edasiviiva jõuna.

Scala võimaldab funktsionaalset programmeerimist, omades funktsioone esmaklassiliste kodanikena, võimaldades neid väärtustena teistele funktsioonidele edasi anda ja ka väärtustena tagastada. Nende kahe paradigma kombinatsioon on muutnud Scala suurepäraseks valikuks keeruka tarkvara loomisel erinevates tööstusharudes, näiteks Data Science.

Scala olulised raamistikud

Siin on mõned Scala olulised raamistikud

• mängima on avatud lähtekoodiga veebirakenduste raamistik, mis kasutab MVC arhitektuur. 2007. aastal välja antud ja nüüd Apache all litsentsitud raamistik sai 2013. aastal GitHubi populaarseimaks raamistikuks. Seda raamistikku kasutavad sellised ettevõtted nagu LinkedIn, Walmart, Samsung, Eero.
• Tõstma on veel üks Scalas kirjutatud tasuta veebiraamistik, mis käivitati 2007. aastal. Foursquare kasutab tõsteraamistikku. See on suure jõudlusega, kiiremini ehitatav raamistik.
• Acre
• Kassid
• Spark

Samaaegsuse tugi

• Scala väärtused on vaikimisi muutumatud. See muudab selle samaaegse keskkonnaga väga kohanemisvõimeliseks.
• Scalas on palju funktsioone, mis muudavad selle samaaegsete rakenduste jaoks parimaks.
• Futuurid ja lubadused muudavad andmete asünkroonse töötlemise lihtsamaks, toetades sellega paralleelsust.
• Akka – tööriistakomplekt, mis kasutab näitlejate samaaegsusmudelit. On mitmeid näitlejaid, kes sõnumeid saades tegutsevad.
• Samaaegsus, kasutades lõime alates Java saab toetada ka Scalas.
• Voo töötlemine on veel üks suurepärane funktsioon, mis võimaldab andmete pidevat reaalajas töötlemist.

Scalal on mõned parimad samaaegsusteegid Java ökosüsteemi.

• Pärit Java niidid
• Kiud sellistest raamatukogudest nagu Vertex
• ZIO – raamatukogu, millel on primitiivid, mis aitavad meil toime tulla samaaegsuse ja asünkroonse arvutusega
• STM – Tehing
• Tulevik – sisseehitatud Scala keelde

Java vs Scala

Siin on peamine erinevus Java ja Scala.

Scala	Java
Kompaktsem ja ülevaatlikum	Suhteliselt suuremad kooditükid
Disainitud ja arendatud olema nii objekti- kui ka funktsionaalseks orienteeritud keeleks. Toetab mitmesuguseid funktsionaalseid programmeerimisfunktsioone, nagu samaaegsus, muutumatus.	Algselt töötati välja objektorienteeritud keelena ja hakkas viimastel päevadel toetama funktsionaalseid programmeerimisfunktsioone. Funktsionaalse programmeerimiskeelena pole see siiski tugev.
Kasutab samaaegsuse toetamiseks näitleja mudelit, mis on kaasaegne	Kasutab samaaegsuse jaoks tavapärast lõimepõhist mudelit.
Toetab raamistikke – Play, Lift	Toetab kevadet, Graali ja palju muud
Toetab laiska hindamist	Ei toeta laiska hindamist
Staatilisi liikmeid pole	Sisaldab staatilisi liikmeid
Toetab operaatori ülekoormust	Ei toeta operaatori ülekoormamist
Lähtekoodi koostamine on suhteliselt aeglane	Lähtekoodi koostamine on kiirem kui Scala
Omadused – käitu nagu Java 8 liidest	Java 8 liidest püüavad ületada lõhet klasside ja liideste vahel
Vaja on ümberkirjutamist	Ümberkirjutamine pole vajalik
Veavabade koodide osas pole kindlust	Väiksemate defektide täielik garantii
Toetab tagasiühilduvust.	Scala ei toeta tagasiühilduvust.
Operatoreid koheldakse erinevalt Java ja need ei ole meetodikutsed.	Kõik kirjete operaatorid on Scalas kutsutud meetodi kaudu.
Toetab mitut pärimist klasside, kuid mitte abstraktsete klasside abil	Ei toeta mitut pärimist klasside, vaid liideste abil
Kood on kirjutatud kompaktsel kujul.	Kood on kirjutatud pikal kujul.
Scala ei sisalda staatilist märksõna.	Java sisaldab staatilist märksõna.

kokkuvõte

Sellest õpetusest saate teada, kuidas Scala kasutamist alustada. Samuti olete õppinud funktsionaalseid ja objektorienteeritud funktsioone. Samuti olete avastanud sarnasused ja erinevused Java ja Scala. See õpetus oleks pidanud teid aitama paljude näidetega, mis on hästi demonstreeritud.