Scala opetusohjelma

Mikä on Scala?

Scala on staattisesti tyypitetty ohjelmointikieli, joka yhdistää olio-ohjelmoinnin ja funktionaalisen ohjelmoinnin sovellusten skaalautuvuuden parantamiseksi. Scala toimii pääasiassa JVM-alustalla, ja kehittäjät voivat käyttää sitä myös ohjelmistojen kirjoittamiseen natiivialustoille Scala-Nativen avulla tai selaimelle ScalaJ:n avulla. JavaKäsikirjoitus ajonaikainen.

Scala on skaalautuva kieli, jota käytetään ohjelmistojen kehittämiseen useille alustoille, ja juuri siitä se sai nimensä. Kieli suunniteltiin ratkaisemaan useita sanasto-ongelmia, joita esiintyy Java pysyen kuitenkin ytimekkäänä. Martin Odersky suunnitteli Scalan, ja ensimmäinen julkinen julkaisu ilmestyi vuonna 2004.

Miksi oppia Scalaa

Tässä ovat tärkeimmät syyt Scala-ohjelmointikielen oppimiseen:

• Scala on helppo oppia olio-ohjelmoijille ja Java kehittäjille, ja siitä on tullut yksi suosituimmista kielistä viime vuosina.
• Scala tarjoaa käyttäjille ensiluokkaisia ​​toimintoja.
• Scala voidaan suorittaa JVM, mikä tasoittaa tietä yhteentoimivuudelle muiden kielten kanssa.
• Se on suunniteltu sovelluksille, jotka ovat samanaikaisia, hajautettuja ja vikasietoisia viestipohjaisia, mikä tekee siitä yhden tämän vuosikymmenen kysytyimmistä kielistä.
• Se on ytimekäs ja tehokas kieli, joka voi nopeasti kasvaa käyttäjiensä kysynnän mukaan.
• Se on oliopohjainen ja sisältää monia toiminnallisia ohjelmointiominaisuuksia, mikä antaa kehittäjille paljon joustavuutta koodin kirjoittamisessa.
• Scala tarjoaa Duck Ty -pelinping rakennetyyppien kautta.
• Siinä on vähemmän vakiomallia kuin Java.
• Scalassa kirjoitetut Lift and Play -kehykset kypsyvät ja kasvattavat suosiotaan jatkuvasti.

Kuinka asentaa Scala

Aloittaaksesi Scala-ohjelmien kirjoittamisen, sinun on asennettava se tietokoneellesi. Voit tehdä tämän käymällä virallisella sivustolla osoitteessa https://www.scala-lang.org/download/ ladataksesi Scalan uusimman version.

Linkin jälkeen sinulle esitetään kaksi vaihtoehtoa Scalan asentamiseen. Tässä Scala-tutoriaalissa käytämme seuraavaa IntelliJ IDEA, joka tarjoaa erinomaisen Scala-tuen heti käyttövalmiina.

Kun olet vieraillut latauslinkissä, löydät kaksi IntelliJ IDE:n versiota.

Tätä Scala-opetusohjelmaa varten lataamme Community Editionin, joka on ilmainen ja sisältää kaiken tarvittavan Scala-ohjelmien kirjoittamiseen.

Vaihe 1) Valitse Yhteisöversio.
Napsauta sivulla Yhteisöversion avattavaa valikkoa.

Se tarjoaa mahdollisuuden ladata IntelliJ IDE:n yhdessä JBR:n kanssa, joka sisältää JDK-toteutuksen (Java Development Kit), kuten OpenJDK, jota Scalan on käännettävä ja suoritettava koodi.

Vaihe 2) Suorita asennus.
Kun olet ladannut IntelliJ:n, kaksoisnapsauta asennusohjelmaa ja seuraa näytön ohjeita.

Vaihe 3) Valitse sijainti.
Valitse IDE:n asennuspaikka.

Jos et ladannut JDK:n mukana tulevaa pakettia, asennusohjelma kehottaa sinua silti lisäämään JDK:n valintaruudun kautta asennuksen aikana.

Vaihe 4) Napsauta Seuraava.
Jätä muut oletusasetukset ennalleen ja napsauta Seuraava.

Scala Hello World -ohjelma

Vaihe 5) Napsauta käynnistyskuvaketta.
Kun asennus on valmis, suorita IntelliJ IDE napsauttamalla sen käynnistyskuvaketta Käynnistä-valikossa kuten tavallista sovellusta.

Sinun on vielä lisättävä Scala-laajennus IntelliJ:hen. Napsauta näytön oikeassa alakulmassa olevan määritysvalikon avattavaa valikkoa ja valitse Lisäosat-vaihtoehto.

Hae Marketplace-välilehdellä Scalaa. Lisäosa näkyy ensimmäisenä tuloksena Kielet-tunnisteen alla.

Vaihe 6) Asenna laajennus.
Aloita Scala-laajennuksen lataus napsauttamalla Asenna.

Vaihe 7) Käynnistä IDE uudelleen.
Kun lataus on valmis, sinua pyydetään käynnistämään IDE uudelleen, jotta asennettu laajennus voi alkaa toimia.

Uudelleenkäynnistyksen jälkeen palaat samalle sivulle kuin aiemmin, mutta nyt Scala-laajennus on asennettu ja käyttövalmis.

Vaihe 8) Valitse Luo projekti, joka johtaa sivulle, jolla voit valita projektin kielen.

Vaihe 9) Valitse Scala valitsemalla Scala-valintaruutu ja napsauttamalla Seuraava.

Vaihe 10) Valitse projektitiedoston tallennussijainti ja anna projektille nimi.

Jos hakemistoa ei ole olemassa, IntelliJ pyytää lupaa luoda kansio. Hyväksy ja napsauta Valmis. Sinut ohjataan sitten Scala-projektiisi, joka ei tällä hetkellä sisällä Scala-koodia.

Indeksien lataaminen vie jonkin aikaa, joten älä huoli, jos et voi olla vuorovaikutuksessa IDE:n kanssa, vaikka et näe edistymispalkkia alareunassa. IDE lataa tiedostoja, joita tarvitaan Scalan suorittamiseen ja automaattisen täydennyksen tarjoamiseen.

Vaihe 11) Napsauta IDE:n vasemmalla puolella olevaa Projekti-välilehteä ja laajenna se nähdäksesi projektin sisällön.

Tässä vaiheessa projekti on tyhjä ja sisältää vain .idea-kansion ja IDE:n luoman hello-world.iml-tiedoston. Kiinnostava kohde on src-kansio, joka sisältää projektin lähdekoodin. Täällä luot ensimmäisen Scala-tiedostosi.

Vaihe 12) Napsauta hiiren kakkospainikkeella src-tiedostoa avataksesi valikon ja luodaksesi uuden Scala-tiedoston.

Valitse tiedostolle nimi. Käytä tässä Scala-tutoriaalissa heija valitse sitten Objekti avattavasta valikosta Scala-tiedoston sisältötyypille.

Kun teet tämän, sinulla on Scala-tiedosto, joka sisältää singleton-objektin, jota käytät koodin suorittamiseen.

Nyt kun sinulla on Scala-tiedosto, jossa on Hello-objekti, kirjoita ensimmäinen ohjelmasi laajentamalla luomaasi objektia App-avainsanalla.

Objektin laajentaminen App-osituksella kertoo kääntäjälle, mitä koodia suoritetaan ohjelman käynnistyessä. Heti App-ositteen laajentamisen jälkeen vasemmalle puolelle ilmestyy vihreä nuoli, joka osoittaa, että ohjelma on nyt suoritettavissa.

Kirjoita Hello-objektin sisälle funktio println() tulostaaksesi tekstin konsoliin. Suorita ohjelma napsauttamalla vihreää nuolta.

Nuolta napsauttamalla avautuu vaihtoehto Run Hello. Sen valitseminen kääntää koodin, ja muutaman sekunnin kuluttua ohjelman tuloste näkyy IntelliJ-konsolissa.

Olet nyt asentanut Scalan onnistuneesti ja suorittanut ensimmäisen ohjelmasi.

Mitä voit tehdä Scalalla

Scalaa käytetään laajalti monilla aloilla sen joustavuuden ja JVM-yhteentoimivuuden ansiosta. Yleisiä käyttötapauksia ovat:

• Frontend-verkkokehitystä ScalaJS:llä.
• Mobiilikehitys Android ja iOS Scala Nativella.
• Palvelinpuolen kirjastot, kuten HTTP4S, Akka-Http ja Play Framework.
• Esineiden internetin (IoT) sovellukset.
• Pelin kehitys.
• Luonnollisen kielen käsittely ScalaNLP-kirjastopaketin avulla.
• Harjoitellaan yhdessä edistyneitä tekniikoita, kuten funktionaalista ohjelmointia ja olio-ohjelmointia.
• Erittäin samanaikaiset toimijoita käyttävät viestintäsovellukset, Erlangista inspiroitunut JVM-kirjasto.
• Koneoppiminen kirjastojen, kuten Figaron, avulla todennäköisyysohjelmointiin ja Apachen avulla Spark laajamittaiseen tiedonkäsittelyyn.

Anonyymit toiminnot

Scala-kieli tukee anonyymejä funktioita, joita kutsutaan myös nimellä funktioliteraalejaKoska Scala on toiminnallinen kieli, kehittäjät usein jakavat suuret ongelmat moniin pienempiin tehtäviin ja luovat useita funktioita. Tämän helpottamiseksi Scala sallii funktioiden muotoiltu ilman nimeäVoit liittää ne suoraan muuttujiin tai määritelmiin käyttämällä def, kuten seuraavassa Scala-esimerkissä on esitetty:

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

Voit sitten käyttää niitä tavallisten funktioiden tavoin antamalla parametrit:

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Nämä metodit ovat käteviä, kun haluat selkeää ja ytimekästä koodia. Anonyymit funktiot ovat hyödyllisiä määriteltäessä pieniä metodeja, jotka eivät vaadi paljon koodia rungossaan. Ne ovat hyvin yksinkertaisia ​​eivätkä vaadi luomiseen mitään seremoniaa.

Nämä metodit eivät rajoitu argumentteja sisältäviin funktioihin, ja niitä voidaan käyttää sellaisten metodien instanssien luomiseen, jotka eivät ota vastaan ​​argumentteja.

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

Useimpia näistä anonyymejä funktioita käytetään koodin muissa osissa, joissa tarvitaan nopeaa funktiota. Tästä syystä niitä kutsutaan myös nimellä sisäisiä toimintojaAnonyymien funktioiden käyttö on yleinen kaava, joka esiintyy koko kokoelmakirjastossa pikatoimintojen suorittamiseksi kokoelmalle.

Esimerkiksi filter-metodi käyttää inline-funktiota luodakseen toisen kokoelman, joka sisältää vain anonyymissa funktiossa määritellyt kriteerit täyttävät elementit.

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)

Tässä anonyymit funktiot tarkistavat, onko listan arvo pariton vai parillinen, ja palauttavat vastaavan alkion.

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

Scalassa on myös mahdollista käyttää jokerimerkkejä, jos anonyymin funktion parametria ei ole nimetty. Esimerkiksi:

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

Tässä skenaariossa parametria ei nimetä. Sen esittämiseen käytetään alaviivaa.

Laiska arviointi

Useimmat kielet arvioivat muuttujia ja funktion parametreja peräkkäin. Scalassa avainsana lazy auttaa käsittelemään arvoja, joita et halua arvioida ennen kuin niihin viitataan.

Lazyksi merkittyä muuttujaa ei evaluoida siinä kohdassa, missä se on määritelty, tätä kutsutaan yleisesti innokkaaksi evaluoinniksi. Se evaluoidaan vasta, kun siihen viitataan myöhemmin koodissa.

Tästä voi olla hyötyä, kun arvon laskeminen olisi kallis laskentatoimenpide. Jos arvoa ei aina tarvita, säästyt kalliilta laskennalta, joka voi hidastaa ohjelmistoa tekemällä muuttujasta laiskan.

lazy val myExpensiveValue = expensiveComputation

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

Tämä ei ole ainoa laiskojen muuttujien käyttötapaus. Ne auttavat myös käsittelemään koodin kehämäisiä riippuvuuksia.

Jos asetuslippu on epätosi, sinun ei tarvitse käyttää myExpensiveValue-ominaisuutta, mikä säästää sinut kalliilta laskelmilta. Tämä auttaa varmistamaan sujuvan käyttökokemuksen, koska resursseja ei tuhlata arvoihin, joita ei koskaan lueta.

Laiskuus auttaa myös funktion argumenttien kanssa, sillä argumentteja käytetään vain silloin, kun niihin viitataan funktion sisällä. Tätä käsitettä kutsutaan nimellä "Call-by-name" -parametreiksi.

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

Monet kielet käyttävät argumenttien arviointiin arvon perusteella tapahtuvaa kutsumista. Nimikutsulla välitetty parametri arvioidaan vain tarvittaessa funktion rungon sisällä. Kun arvo on arvioitu, se tallennetaan ja sitä voidaan käyttää uudelleen myöhemmin ilman uudelleenarviointia. Tätä käsitettä kutsutaan muistiin tallentamiseksi.

Tyyppi johtopäätös

Scalassa sinun ei tarvitse määrittää tyyppiä jokaiselle luomallesi muuttujalle, koska Scalan kääntäjä voi päätellä tyypit lausekkeen oikealta puolelta. Tämä tekee koodistasi ytimekkäämmän ja vapauttaa sinut kirjoittamasta vakiomuotoisia koodeja, joissa odotettu tyyppi on ilmeinen.

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

Korkeamman asteen funktio

Ylemmän asteen funktio on funktio, joka voi ottaa funktioita argumentteina ja palauttaa funktion paluutyyppinä. Scalassa funktioita pidetään ensiluokkaisina kansalaisina. Funktioiden käyttö tällä tavalla mahdollistaa erittäin joustavan ohjelmien rakentamisen. Voit luoda funktioita dynaamisesti ja syöttää toiminnallisuutta dynaamisesti muille funktioille.

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

Yllä olevassa funktiossa välität Int ja funktio, joka ottaa Int ja palauttaa IntVoit välittää minkä tahansa funktion, jolla on kyseinen allekirjoitus. Allekirjoituksella tarkoitamme funktion syötettä ja tulostusta. Allekirjoitus Int => Int tarkoittaa, että funktio ottaa syötteeksi kokonaisluvun (Int) ja palauttaa tulosteeksi kokonaisluvun (Int).

Allekirjoitus () => Int tarkoittaa, että funktio ei ota syötteeksi mitään ja palauttaa tulosteeksi kokonaisluvun (Int). Esimerkki tällaisesta funktiosta on sellainen, joka luo satunnaisen kokonaisluvun (int).

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

Yllä olevalla funktiolla on allekirjoitus () => Int.

Funktiolla voi olla myös allekirjoitus () => UnitTämä tarkoittaa, että funktio ei ota mitään vastaan ​​eikä palauta tyyppiä. Funktio voi sen sijaan muuttaa jonkin tilan tai suorittaa ennalta määrätyn toiminnon.

Tällaisia ​​metodeja ei suositella, koska ne voivat toimia kuin musta laatikko, joka vaikuttaa järjestelmään tuntemattomilla tavoilla. Niitä on myös vaikeampi testata. Eksplisiittisten syöte- ja tulostyyppien avulla voit päätellä, mitä funktiosi tekee.

Korkeamman asteen funktio voi myös palauttaa funktion. Voit esimerkiksi luoda metodin, joka palauttaa potenssifunktion, joka ottaa luvun ja soveltaa siihen potenssia.

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

Yllä oleva funktio ottaa arvon Int. Sen paluutyyppi on anonyymi funktio, joka ottaa arvon Int. x ja käyttää sitä potenssifunktion argumenttina.

Curry

Scalassa voit muuntaa kaksi argumenttia vastaanottavan funktion yhdeksi funktioksi, joka vastaanottaa vain yhden argumentin kerrallaan. Kun annat yhden argumentin sisään, käytät sitä osittain ja saat funktion, joka käyttää jäljellä olevaa argumenttia kutsun loppuun saattamiseksi. Curryingin avulla voit rakentaa funktioita lisäämällä vain joitakin argumentteja.

Tämä on hyödyllistä funktioiden luomiseen dynaamisesti ennen kuin sinulla on täydellinen argumenttijoukko.

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

Jos tarvitset funktion, joka kertoo tietyllä luvulla, sinun ei tarvitse luoda toista kertolaskumenetelmää. Voit käyttää yhtä argumenttia curry-funktioon ja käyttää tulosta uudelleen:

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

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Kuvion sovitus

Scalassa on tehokas sisäänrakennettu mekanismi, joka auttaa tarkistamaan, täyttääkö muuttuja tiettyjä kriteerejä, aivan kuten switch-lauseke Java tai if/else-lausekkeiden ketju. Kieli tukee kuvioiden yhteensovittamista, jonka avulla voit tarkistaa, onko muuttuja tiettyä tyyppiä. Kuvioiden yhteensovittaminen Scalassa on tehokasta ja voi purkaa komponentteja, joilla on unapply menetelmä, jolla saat haluamasi kentät suoraan vastaavasta muuttujasta.

Scalan hahmontunnistus tarjoaa myös miellyttävämmän syntaksin kuin switch-lauseke.

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

Vertaat muuttujaa joukkoon vaihtoehtoja. Kun muuttuja täyttää kriteerit, paksun nuolen (=>) oikealla puolella oleva lauseke evaluoituu ja palauttaa osuman tuloksena.

Alaviiva havaitsee tapaukset, joita koodissa ei löydy, peilaten oletusarvoisen tapauksen toimintaa switch-lausekkeessa.

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
}

Yllä olevasta koodista voit havaita tyypin myItem muuttuja ja sen perusteella haarautuu tiettyyn koodiin.

Kuvioiden yhteensovitus tarkistaa, vastaako muuttuja kutakin tapausta järjestyksessä.

Alaviiva toimii paikkamerkkinä, joka vastaa mitä tahansa ehtoa, jota muut case-lausekkeet eivät täytä. Otat muuttujan myItem ja soita match menetelmällä.

• Tarkista onko myItem is true ja suorita logiikka paksun nuolen “=>” oikealla puolella.
• Käytä alaviivaa löytääksesi vastauksia mihin tahansa, joka ei vastaa koodissa määriteltyjä tapauskohtaisia ​​lausekkeita.

Case-luokkien avulla voit purkaa luokan esim. muotoontract-kentät objektin sisällä.

Käyttämällä sealed avainsanaa luokkien määrittelemiseen, saat edun siitä, että kääntäjä tarkistaa perusteellisesti kaikki tapaukset, joita yrität sovittaa yhteen, ja varoittaa sinua, jos unohdat käsitellä jonkin tapauksen.

muuttumattomuudesta

Scalan muilla funktioilla ei voida muuttaa arvoja käyttämällä val avainsana. Tämä saavutetaan Java käyttämällä final avainsana. Scalassa käytät val kun luot muuttujan sen sijaan, että var, joka on vaihtoehto muuttuville muuttujille.

Muuttuja, joka on määritelty käyttämällä val avainsana on vain luku -tilassa, kun taas avainsanalla määritelty var voidaan lukea ja muuttaa myöhemmin muilla funktioilla tai käyttäjän toimesta koodissa.

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

Yritetään antaa arvoa myNumber sen jälkeen, kun se oli julistettu val heittää käännösaikaisen virheen: “uudelleensijoitus arvoon arvo.”

Miksi käyttää muuttumattomuutta?

Muuttumattomuus auttaa estämään koodia ja muita ohjelmoijia muuttamasta arvoja odottamatta, mikä johtaisi arvaamattomiin tuloksiin. Jos arvon käyttäjien on muutettava sitä, he voivat sen sijaan tehdä kopion. Tällä tavoin estetään virheet, jotka johtuvat useiden toimijoiden saman muuttujan muuttamisesta.

Luokat ja esineet

Objektit ovat reaalimaailman olioita, ja luokka on malline, joka määrittelee objektit. Luokilla on sekä tila että käyttäytymismalleja. Tilat ovat joko arvoja tai muuttujia. Käyttäytymiset ovat Scalan metodeja.

Seuraavassa osiossa näytetään, miten luokka määritellään, luodaan siitä instanssi ja miten sitä käytetään Scalassa.

Tässä on luokka nimeltä Rectangle, jolla on kaksi arvoa ja kaksi funktiota. Voit käyttää myös parametreja l ja b suoraan kenttinä ohjelmassa. Sinulla on objekti, jolla on main-metodi ja joka luo luokan instanssin kahdella arvolla.

Esimerkiksi:

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

Kaikki kentät ja metodit ovat Scalassa oletusarvoisesti julkisia. On tärkeää käyttää override koska toString on jo määritelty jokaiselle Scalan objektille.

Perintö

Scalassa on useita periytymistyyppejä (yksitasoinen, monitasoinen, monitasoinen, hierarkkinen ja hybridi), joilla on paljon yhteistä perinteisten muotojen kanssa, joita löytyy mm. JavaVoit periä sekä luokista että ominaisuuksista. Voit periä yhden luokan jäsenet toiseen luokkaan käyttämällä avainsanaa extendsTämä mahdollistaa uudelleenkäytettävyyden.

On mahdollista periä yhdestä tai useammasta luokasta. On myös mahdollista periä alaluokista, joilla itsellään on omat yliluokkansa, jolloin prosessissa luodaan periytymishierarkia.

Alla olevassa Scala-esimerkissä perusluokka on Circle, ja johdettu luokka on SphereYmpyrällä on arvo nimeltä säde, joka periytyy Sphere-luokasta. Metodi calcArea ohitetaan avainsanalla override.

Esimerkiksi:

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

AbstracTUKSEN

Scalassa voit luoda vatsalihaksiatract-metodit ja jäsenkentät abs-funktion avullatract-luokat ja ominaisuudet. Vatsalihasten sisäpuolitract-luokat ja -ominaisuudet, voit määritellä vatsalihaksettract-kentät ilman niiden toteuttamista.

Esimerkiksi:

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

Nämä kentät toteuttavat luokat, jotka laajentavat ominaisuutta tai abs-arvoa.tract-luokka. Voit käyttää piirteitä luodaksesi contracts sille, mitä sovelluksen tulisi tehdä, ja sitten toteuttaa nämä metodit myöhemmin.

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

Tällä tavoin voit suunnitella sovelluksen ulkoasun toteuttamatta metodeja, kutenping kuvittelet, miltä erilaiset menetelmät näyttävät. Se noudattaa vatsalihasten ohjelmointina tunnettua kaavaatracpikemminkin kuin varsinaiseen toteutukseen.

Luokka, jonka alussa on abstract avainsana voi sisältää sekä abs- että abs-arvoja.tract ja ei-vatsalihaksettract-metodit. Useita periytymismalleja ei kuitenkaan tueta abs-metodeissa.tract-luokat, joten voit venytellä vain yhtä vatsalihastatract-luokka.

Yksittäisiä esineitä

Singleton on luokka, joka luodaan ohjelmassa vain kerran. Se on peräisin suositusta ja hyödyllisestä ohjelmointimallista, joka tunnetaan nimellä "singleton-malli". Se on hyödyllinen sellaisten instanssien luomiseen, joiden on tarkoitus olla pitkäikäisiä ja joihin pääsee yleisesti käsiksi koko ohjelman ajan, ja joissa tila on olennainen osa järjestelmän tapahtumien koordinointia. Tällaisen luokan luominen Scalassa on helppoa, koska Scala tarjoaa yksinkertaisen tavan luoda singletoneja käyttämällä object avainsana.

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

Voit sitten viitata tähän objektiin koko ohjelman ajan ja taata, että kaikki ohjelman osat näkevät saman datan, koska siitä on vain yksi instanssi.

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

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

Staattisten jäsenten käsitettä ei ole Scalassa, minkä vuoksi käytetään singleton-objekteja, jotka toimivat luokan staattisina jäseninä.

Implisiittiset luokat

Implisiittiset luokat ovat versiossa 2.10 lisätty ominaisuus, ja niitä käytetään ensisijaisesti uusien toimintojen lisäämiseen olemassa oleviin suljettuihin luokkiin.

implicit Avainsana tulee määritellä luokassa, objektissa tai ominaisuudessa. Implisiittisen luokan ensisijaisella konstruktorilla on oltava täsmälleen yksi argumentti ensimmäisessä parametriluettelossaan. Se voi sisältää myös toisen implisiittisen parametriluettelon.

Alla olevassa Scala-esimerkissä on lisätty uusi toiminto, jolla merkkijonon vokaalit voidaan korvata tähdellä (*).

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

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

Sinun täytyy tuoda implisiittinen luokka luokkaan, jossa käytät sitä.

import StringUtil.StringEnhancer

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

Olio-ohjelmointi (OOP) vs. funktionaalinen ohjelmointi (FP)

OOP:ssa ohjelmat rakennetaan ryhmittäinping data ja funktiot, jotka käsittelevät dataa, ovat erittäin yhteydessä toisiinsa. Objektit kuljettavat dataansa kentissä ja metodit käsittelevät niitä. Tässä ohjelmointityylissä pääabstraktitraction on data, koska luodut metodit on tarkoitettu toimimaan datan parissa.

Toiminnallinen ohjelmointitoisaalta erottaa datan ja sitä käyttävät funktiot. Tämä antaa kehittäjille mahdollisuuden käsitellä funktioita abs-tiedostona.tracja liikkeellepaneva voima ohjelmien mallintamisessa.

Scala mahdollistaa funktionaalisen ohjelmoinnin käsittelemällä funktioita ensiluokkaisina yksilöinä, jolloin ne voidaan välittää arvoina muille funktioille ja palauttaa myös arvoina. Näiden kahden paradigman yhdistelmä on tehnyt Scalasta loistavan vaihtoehdon monimutkaisten ohjelmistojen rakentamiseen esimerkiksi datatieteen kaltaisilla aloilla.

Tärkeitä puitteita Scalassa

Tässä on joitakin tärkeitä Scalan viitekehyksiä:

• Pelaa on avoimen lähdekoodin verkkosovelluskehys, joka käyttää MVC-arkkitehtuuriVuonna 2007 julkaistu ja nyt Apachen lisensoima, siitä tuli yksi GitHubin suosituimmista kehyksistä vuoteen 2013 mennessä. Yritykset, kuten LinkedIn, WalmartSamsung ja Eero käyttävät tätä viitekehystä.
• Nostaa on toinen ilmainen, Scalassa kirjoitettu verkkokehys, joka julkaistiin vuonna 2007. Foursquare käyttää Lift-kehystä. Se on tehokas kehys, jolla on nopea rakentaa.
• Kuten tarjoaa työkalupakin erittäin samanaikaisten, hajautettujen ja vikasietoisten viestipohjaisten sovellusten rakentamiseen JVM:lle.
• Kissat on kirjasto, joka tarjoaa vatsalihasliikkeitätracfunktionaalisen ohjelmoinnin periaatteet.
• Spark on yhtenäinen analytiikkamoottori laajamittaiseen datan käsittelyyn, jota käytetään laajalti big datan ja koneoppimisen työnkuluissa.

Samanaikaisuuden tuki

• Scalan arvot ovat oletusarvoisesti muuttumattomia, mikä tekee siitä erittäin mukautuvan samanaikaisiin ympäristöihin.
• Scalassa on monia ominaisuuksia, jotka tekevät siitä ihanteellisen rinnakkaisille sovelluksille.
• Futuurit ja lupaukset helpottavat tietojen asynkronista käsittelyä, mikä tukee rinnakkaisuutta.
• Akka on työkalupakki, joka käyttää toimijoiden samanaikaisuusmallia. Toimijat toimivat, kun ne vastaanottavat viestejä.
• Samanaikaisuus käyttämällä säikeitä kohteesta Java on tuettu myös Scalassa.
• Virtaprosessointi on toinen erinomainen ominaisuus, joka mahdollistaa jatkuvan, reaaliaikaisen datan käsittelyn.

Scalalla on joitain parhaista samanaikaisuuskirjastoista Java ekosysteemi:

• Syntyperäinen Java kierteet.
• Kuidut kirjastoista, kuten Vertx.
• ZIO, kirjasto, jossa on primitiivit samanaikaisuuden ja asynkronisen laskennan käsittelemiseksi.
• Ohjelmiston transaktiomuisti (STM) transaktioita varten.
• Future, joka on sisäänrakennettu Scala-kieleen.

Java vs. Scala

Tässä ovat tärkeimmät erot Java ja Scala.

UKK