Scala opetusohjelma

Scala opetusohjelman yhteenveto

Tämä scala opetusohjelma kattaa kaikki scalan näkökohdat ja aiheet. Opit kaikki perusasiat tyhjästä, kuten mikä on scala, scalan asennusprosessi, Scala-ohjelmat, Scala-toiminnot, laiska arviointi, tyyppiliittymä, luokat ja objektit, perinnöllisyys, abstraktiot, Java ja skalaerot jne.

Scala on skaalautuva kieli, jota käytetään ohjelmistojen kirjoittamiseen useille alustoille. Tästä syystä se sai nimen "Scala". Tämä kieli on tarkoitettu ratkaisemaan ongelmia Java samalla kun se on ytimekkäämpi. Sen alun perin suunnitteli Martin Odersky, mutta se julkaistiin vuonna 2003.

Miksi oppia Scalaa

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

• Scala on helppo oppia olio-ohjelmoijille, Java kehittäjät. Siitä on tulossa 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 joustavia sanomapohjaisia. Se on yksi tämän vuosikymmenen vaativimmista kielistä.
• Se on ytimekäs, tehokas kieli ja voi nopeasti kasvaa käyttäjiensä kysynnän mukaan.
• Se on oliosuuntautunut ja siinä on paljon toiminnallisia ohjelmointiominaisuuksia, jotka tarjoavat kehittäjille paljon joustavuutta koodata haluamallaan tavalla.
• Scala tarjoaa monia ankkatyyppejä
• Siinä on vähemmän kattilalevyä, jos olet kotoisin Java
• Scalassa kirjoitetut Lift and Play -kehykset ovat kasvukäyrässä.

Kuinka asentaa Scala

Jotta voit aloittaa Scala-ohjelmien kirjoittamisen, sinun on oltava asennettuna tietokoneellesi. Jotta voit tehdä tämän, sinun tulee vierailla heidän sivustollaan https://www.scala-lang.org/download/ ladataksesi Scalan uusimman version.

Linkin jälkeen meidät johdetaan kahteen vaihtoehtoon, jotka voimme valita Scalan asentamiseksi koneillemme. Lataamme tätä Scala-opetusohjelmaa varten IntelliJ IDEA.

Kun vierailet latauslinkissä, löydät kaksi versiota IntelliJ IDE:stä.

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

Vaihe 1) Valitse Community Edition
Napsauta sivulla Community Editionin avattavaa valikkoa.

Se tarjoaa meille mahdollisuuden ladata IntelliJ IDE yhdessä JBR:n kanssa, joka sisältää JDK-toteutuksen (Java Development Kit) OpenJDK, jonka Scala tarvitsee kääntääkseen ja suorittaakseen koodin.

Vaihe 2) Suorita asennus
Kun olet ladannut IntelliJ:n, kaksoisnapsauta sitä käynnistääksesi ohjatun asennustoiminnon ja seuraamalla valintaikkunaa.

Vaihe 3) Valitse sijainti
Valitse IDE:n asennuspaikka.

Jos et vahingossa ladannut sitä JDK:n kanssa, saamme silti kehotteen, josta voimme tarkistaa sen lataamisen valitsemalla valintaruudun.

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

Vaihe 5) Napsauta käynnistyskuvaketta
Kun asennus on valmis, suorita IntelliJ IDE napsauttamalla sen käynnistyskuvaketta käynnistysvalikossa tavallisen sovelluksen tapaan.

Sinun on vielä lisättävä Scala-laajennus IntelliJ:hen. Voit tehdä sen napsauttamalla pudotusvalikkoa konfigurointivalikossa, joka sijaitsee näytön oikeassa alakulmassa ja valitsemalla laajennusvaihtoehdon.

Marketplace-välilehdellä Scala-haku näyttää laajennuksen ensimmäisenä tuloksena Languages-tunnisteen alla.

Vaihe 6) Asenna laajennus
Napsauta Asenna, jolloin laajennus aloittaa latauksen.

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

Uudelleenkäynnistyksen jälkeen löydät itsesi samalta sivulta kuin ennenkin, kun suoritimme IDE:tä, mutta tällä kertaa olemme jo asentaneet Scala-laajennuksen.

Scala Hello World -ohjelma

Vaihe 1) Valitse Luo projekti -vaihtoehto, joka johtaa meidät sivulle, jolla voimme valita kielen, jota projektimme käyttää.

Vaihe 2) valitse Scala valitsemalla Scala-valintaruutu ja napsauta Seuraava.

Vaihe 3) Valitse projektitiedoston tallennuspaikka ja anna projektille nimi.

Jos hakemistoa ei ole olemassa, IntelliJ pyytää meitä kysymään lupaa kansion luomiseen. Hyväksy ja napsauta lopeta. Sinut ohjataan Scala-projektiisi, jolla ei tällä hetkellä ole Scala-koodia.

Joidenkin indeksien lataaminen kestää jonkin aikaa, joten älä huoli, jos et voi tehdä heti mitään, kun IDE:n alaosassa on edistymispalkki, se tarkoittaa yksinkertaisesti sitä, että IDE lataa joitain tiedostoja, joita tarvitaan Scalan ja apua IDE:n automaattiseen täydennykseen.

Vaihe 4) Seuraavaksi napsautamme IDE:n vasemmalla puolella olevaa projektit-välilehteä ja laajennamme, jotta voimme nähdä projektimme sisällön.

Tällä hetkellä projekti on tyhjä ja sisältää vain IDE:n luoman .idea-kansion ja hello-world.iml-tiedoston. Mielenkiintopisteemme on src-kansio. Src on paikka, johon tallennamme projektimme lähdekoodin. Siellä luomme ensimmäisen Scala-tiedostomme.

Vaihe 5) Napsauta hiiren kakkospainikkeella src avataksesi valikon uuden Scala-tiedoston luomiseksi.

Luomme sitten tiedostolle nimen, tässä Scala-opetusohjelmassa käytämme helloa ja valitsemme sitten pudotusvalikosta, mitä laitamme Scala-tiedoston sisällöksi. Valitse "Objekti"

Kun teemme tämän, meillä on Scala-tiedosto, jossa on Singleton-objekti, jota käytämme koodimme suorittamiseen.

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

Laajennamme objektiamme sovelluksella, kerro kääntäjälle, mikä koodi ajetaan, kun se käynnistää ohjelman. Välittömästi sovelluksen laajentamisen jälkeen vasemmalla puolella näkyy vihreä nuoli, joka osoittaa, että voit nyt suorittaa ohjelman.

Hello-objektin sisään kirjoitetaan yksi funktio println(), jota käytetään sen sisällä olevan tekstin tulostamiseen konsoliin. Suoritamme koodimme napsauttamalla vihreää nuolta.

Napsauttamalla nuolta saamme vaihtoehdon Suorita, hei, sitä napsauttamalla koodimme alkaa kääntää ja muutaman sekunnin kuluttua näemme ohjelmamme tulokset tulostettuna IntelliJ IDE:n sisäänrakennetusta konsolista.

Ja siinä mennään, olemme asentaneet Scalan onnistuneesti ja suorittaneet ensimmäisen ohjelmamme.

Mitä voit tehdä Scalalla

• Etuliittymän verkkokehitys ScalaJS:llä
• Mobiilikehitys, molemmat Android Kehitys ja IOS – Scala Nativella
• Palvelinpuolen kirjastot, kuten HTTP4S, Akka-Http, Play Framework
• Käyttävien esineiden Internet
• Pelin kehitys
• NLP – Natural Language Processing käyttämällä ScalaNLP-kirjastoja
• Kehittyneiden ohjelmointitekniikoiden, kuten toiminnallisen ohjelmoinnin ja olioohjelmoinnin testaus
• Rakenna erittäin samanaikainen viestintäsovellus toimijoiden avulla Erlangin inspiroima JVM-kirjasto
• Käytä sitä koneoppimiseen käyttämällä kirjastoja, kuten Figaro, joka tekee todennäköisyyspohjaista ohjelmointia ja Apache Spark että

Anonyymit toiminnot

Scala-kielessä on anonyymejä toimintoja, joita kutsutaan myös nimellä funktioliteraaleja. Koska Scala on toiminnallinen kieli, kehittäjät hajottavat suuret ongelmat moniin pieniin tehtäviin ja luovat monia toimintoja näiden ongelmien ratkaisemiseksi. Toimintojen luomisen helpottamiseksi Scala sisältää nämä toiminnot, joita voi olla muotoiltu ilman nimeä. Voimme määrittää ne suoraan muuttujiin tai määritelmiin "def", kuten alla olevassa Scala-esimerkissä näkyy:

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

Voimme sitten käyttää funktioita normaalilla tavalla siirtämällä parametreja niille seuraavasti.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Nämä menetelmät ovat hyödyllisiä, kun haluamme puhtaan ja tiiviin koodin. Voimme käyttää anonyymejä funktioita määriteltäessä menetelmiä, jotka eivät ole suuria ja jotka eivät vaadi rungossaan paljon koodia. Ne ovat hyvin yksinkertaisia ​​eivätkä vaadi seremoniaa luodakseen.

Nämä menetelmät eivät rajoitu funktioihin, joissa on argumentteja, ja niitä voidaan käyttää sellaisten menetelmien ilmentämiseen, jotka eivät ota vastaan ​​argumentteja.

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

Useimpia näistä anonyymeistä funktioista käytetään muissa koodimme osissa, joissa meidän on luotava nopea funktio.

Toinen syy, miksi näitä toimintoja kutsutaan myös nimellä sisäisiä toimintoja. Nimettömien funktioiden käyttäminen on yleinen malli, jota käytetään laajasti kokoelmakirjastossa suorittamaan nopeita toimintoja kokoelmalle.

Meillä on esimerkiksi suodatusmenetelmä, joka käyttää sisäistä funktiota/anonyymiä funktiota luodakseen toisen kokoelman, jossa on vain elementtejä, jotka täyttävät nimettömässä funktiossa määrittämämme kriteerit.

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ä anonyymeinä funktioina käyttämämme menetelmät ovat niitä, jotka tarkistavat, onko luettelosta saamamme arvo pariton ja parillinen, ja palauttavat kohteen.

//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ä, joissa anonyymin funktiomme parametreja ei ole nimetty. Esimerkiksi

var timesTwo = (_:Int)*2

timesTwo(5)
//10

Tässä skenaariossa emme nimeä parametria, jota välitämme. Ainoa asia, jota käytämme alaviivaa edustamaan sitä.

Laiska arviointi

Useimmat kielet arvioivat muuttujia ja funktioparametreja peräkkäin peräkkäin. Scalassa meillä on avainsana nimeltä laiska, joka auttaa käsittelemään arvoja, joita emme halua arvioida ennen kuin niihin viitataan.

Laiskaksi merkittyä muuttujaa ei arvioida siellä, missä se on määritelty, eli innokas arviointi, se arvioidaan vain, kun siihen viitataan jossain myöhemmässä koodissa.

Tästä voi olla apua, kun arvon arvioiminen voi olla kallista laskentaa. Jos arvoa ei aina tarvita, voimme säästää itsemme kalliilta laskutoimituksilta, jotka voivat hidastaa ohjelmistojamme tekemällä muuttujamme laiskaksi.

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 pyöreän riippuvuuden ongelmia.

Jos asetukset ovat vääriä, meidän ei ehkä tarvitse käyttää myExpensiveValue-arvoa, mikä voi johtaa meidät säästämään kalliilta laskutoimituksilta, mikä auttaa varmistamaan, että käyttäjillä on mukavaa käyttää sovellusta, koska heidän muut tarpeemme voidaan laskea oikein ilman ylikuormitusta. RAM.

Jos asetukset ovat vääriä, meidän ei ehkä tarvitse käyttää myExpensiveValuetta, mikä voi saada meidät säästämään kalliilta laskelmalta, mikä auttaa varmistamaan, että käyttäjillä on mukavaa käyttää sovellusta, koska heidän muut tarpeensa voidaan laskea asianmukaisesti ilman ylikuormitusta. RAM.

Laiskuus auttaa myös funktion argumenteissa, joissa argumentteja käytetään vain, 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 arvokohtaista tapaa. Kutsutun nimen kautta välitetty parametri arvioidaan vain tarvittaessa funktion rungossa, eikä sitä arvioida ennen sitä. Kun arvo on arvioitu, se tallennetaan ja voidaan käyttää myöhemmin uudelleen ilman, että sitä tarvitsee arvioida uudelleen. Käsite, joka tunnetaan nimellä memoisointi.

Tyyppi johtopäätös

Scalassa sinun ei tarvitse ilmoittaa tyyppejä jokaiselle luomillesi muuttujille. Tämä johtuu siitä, että Scala-kääntäjä voi tehdä tyyppipäätelmiä tyypeistä oikean puolen arvioinnin perusteella. Näin koodisi on tiiviimpi – se vapauttaa meidät kirjoittamasta kattilaa, jossa odotettu tyyppi on ilmeinen

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

Korkeamman asteen toiminto

Korkeamman asteen funktio on funktio, joka voi ottaa funktioita argumentteina ja palauttaa funktion palautustyyppinä. Scalassa toimintoja pidetään ensiluokkaisina kansalaisina. Käyttämällä näitä toimintoja tällä tavalla voimme olla erittäin joustavia siinä, millaisia ​​ohjelmia voimme tehdä. Pystymme luomaan toimintoja dynaamisesti ja syöttämään toimintoja dynaamisesti muihin toimintoihin.

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

Yllä olevassa funktiossa välitetään int ja funktio, joka ottaa int:n ja palauttaa int:n. Voimme siirtää minkä tahansa allekirjoituksen toiminnon. Allekirjoituksella tarkoitamme funktion tuloa ja lähtöä. Allekirjoitus Int=>Int tarkoittaa, että funktio ottaa Int:n syötteenä ja palauttaa Int:n ulostulokseen.

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

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

Yllä olevalla funktiolla on allekirjoitus ()=>Int

Meillä voi olla funktio, jolla on allekirjoitus scala ()=>Yksikkö. Tämä tarkoittaa, että funktiot eivät ota mitään vastaan ​​eivätkä palauta tyyppiä. Funktio voisi tehdä jonkinlaisen laskennan muuttamalla jotain tekemällä jotain ennalta määrättyä.

Tällaisia ​​menetelmiä ei kuitenkaan suositella, koska ne näyttävät olevan musta laatikko, joka voi vaikuttaa järjestelmään jollain tuntemattomalla tavalla. Ne ovat myös testaamattomia. Eksplisiittiset tulo- ja lähtötyypit antavat meille mahdollisuuden päätellä, mitä funktiomme tekee.

Korkeamman asteen funktio voi myös palauttaa funktion.

Voisimme esimerkiksi luoda menetelmän, joka luo tehofunktion, eli ottaa luvun ja käyttää siihen tehoa.

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

Yllä oleva funktio ottaa int. Palautustyyppimme on anonyymi funktio, joka ottaa Int x:n, * käytämme int x:ää tehofunktion argumenttina.

Curry

Scalassa voimme muuntaa kaksi argumenttia käyttävän funktion funktioksi, joka ottaa yhden argumentin kerrallaan. Kun välitämme yhden argumentin, käytämme sitä osittain ja päädymme funktioon, joka vie yhden argumentin funktion suorittamiseen. Curryingin avulla voimme luoda funktioita lisäämällä osittain joitain argumentteja.

Tämä voi olla hyödyllistä luotaessa funktioita dynaamisesti ennen kuin meillä on täydellinen sarja argumentteja

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

Jos meidän on luotava funktio, joka kertoo tietyllä luvulla, meidän ei tarvitse luoda toista kertolaskutapaa.

Voimme yksinkertaisesti kutsua yllä olevan funktiomme .curryed ja saada funktion, joka ottaa ensin yhden argumentin ja palauttaa osittain käytetyn funktion

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Kuvion sovitus

Scalassa on tehokas sisäänrakennettu mekanismi, joka auttaa meitä tarkistamaan, vastaako muuttuja tiettyjä ehtoja, aivan kuten tekisimme kytkinlauseessa Java tai sarjassa if/else-lauseita. Kielessä on mallisovitus, jonka avulla voimme tarkistaa, onko muuttuja tiettyä tyyppiä. Scalan kuvioiden täsmäytys on tehokas, ja sitä voidaan käyttää tuhoamaan komponentit, joissa on unapply-metodi, saadakseen meitä kiinnostavat kentät suoraan täsmäämästämme muuttujasta.

Scalan mallinsovitus tarjoaa myös miellyttävämmän syntaksin kuin switch-lause.

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

Vertaamme muuttujaamme vaihtoehtoihin, ja kun vertailemamme muuttuja täyttää kriteerit, paksun nuolen (=>) oikealla puolella oleva lauseke arvioi ja palautetaan osuman tuloksena.

Käytämme alaviivaa havaitaksemme tapaukset, jotka ovat vertaansa vailla koodissamme. Se heijastaa oletustapauksen käyttäytymistä kytkinlauseita käsiteltäessä.

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
}

Yllä olevasta koodista voit selvittää myItem-muuttujan tyypin ja haarautua sen perusteella johonkin tiettyyn koodiin.

Pattern matching tarkistaa, täsmääkö muuttuja

Alaviiva toimii paikkamerkkinä, joka vastaa mitä tahansa muuta ehtoa, jota muut yllä olevien tapauslausekkeiden kohteet eivät vastaa. Otamme muuttujan myItem ja kutsumme hakumenetelmää.

• tarkistamme, onko myItem tosi, ja teemme logiikkaa rasvan nuolen oikealla puolella "=>".
• käytämme alaviivaa vastaamaan kaikkeen, joka ei vastaa mitään koodissa määrittämiämme tapauslausekkeita.

Case-luokkien avulla voimme jopa mennä pidemmälle ja tuhota luokan saadaksemme kenttiä objektin sisään.

Käyttämällä sinetöityä avainsanaa luokkiemme määrittelemiseen, saamme sen hyödyn, että kääntäjä tarkistaa perusteellisesti tapaukset, joita yritämme sopia, ja varoittaa meitä, jos unohdamme käsitellä tiettyä tapausta.

muuttumattomuudesta

On mahdollista luoda arvoja, joita muut Scalan toiminnot eivät voi muuttaa käyttämällä avainsanaa val. Tämä saavutetaan vuonna Java käyttämällä viimeistä avainsanaa. Scalassa teemme sen käyttämällä muuttujaa luotaessa avainsanaa val sen sijaan, että käytämme var, jota käyttäisimme vaihtuvan muuttujan luomiseen.

Val-avainsanalla määritetty muuttuja on vain luku, kun taas muuttuja, joka on määritetty var:lla, voidaan lukea ja muuttaa muilla funktioilla tai mielivaltaisesti koodissa olevan käyttäjän toimesta.

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

Yritetään määrittää arvo myNumberille sen jälkeen, kun olemme ilmoittaneet sen arvoksi val, aiheuttaa käännösaikavirheen tai "uudelleenmäärityksen arvoksi".

Miksi käyttää muuttumattomuutta?

Muuttumattomuus auttaa meitä estämään koodia ja muita ohjelmoijia muuttamasta arvojamme odottamatta, mikä johtaisi odottamattomiin tuloksiin, jos heidän on tarkoitus käyttää tallennettua arvoa, he voivat sen sijaan kopioida siitä. Tällä tavalla estetään virheet, jotka voivat aiheutua siitä, että useat toimijat muuttavat samaa muuttujaa.

Luokat ja esineet

Me kaikki tiedämme, että objektit ovat reaalimaailman kokonaisuuksia, ja luokka on malli, joka määrittelee objektit. Luokilla on sekä tila että käyttäytyminen. Tilat ovat joko arvoja tai muuttujia. Käyttäytyminen on Scalan menetelmiä.

Katsotaanpa, kuinka voit määrittää luokan, luoda sen ja käyttää sitä Scalan avulla.

Tässä luokka nimeltään Suorakulmio, jossa on kaksi muuttujaa ja kaksi funktiota. Voit myös käyttää parametreja l ja b suoraan ohjelman kenttinä. Sinulla on objekti, jolla on päämenetelmä ja joka on instantoinut luokan 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 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)    
  }
}

Kaikki kentät ja menetelmä ovat oletuksena julkisia Scalassa. On välttämätöntä käyttää ohitusta, koska toString-menetelmä on määritetty Objectille Scalassa.

Perintö

Scalalla on useita perintötyyppejä (kuten yksi, monitasoinen, monikerroksinen, hierarkkinen, hybridi), joilla on paljon yhteistä perinteisten muotojen kanssa. Java. Voit periä sekä luokista että ominaisuuksista. Voit periä yhden luokan jäsenet toiseen luokkaan käyttämällä avainsanaa "laajentuu". Tämä mahdollistaa uudelleenkäytettävyyden.

On mahdollista periä yhdestä luokasta tai useista luokista. On myös mahdollista periä alaluokista, joilla itsellään on yliluokat, mikä luo prosessissa periytymishierarkian.

Alla olevassa Scala-esimerkissä perusluokka on Ympyrä ja johdettu luokka on Sphere. Ympyrällä on arvo nimeltä säde, joka periytyy Sphere-luokassa. Menetelmä calcArea ohitetaan käyttämällä avainsanan ohitusta.

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

Abstraktio

Scalassa voimme luoda abstrakteja menetelmiä ja jäsenkenttiä käyttämällä abstrakteja luokkia ja piirteitä. Abstraktien luokkien ja piirteiden sisällä voimme määritellä abstrakteja kenttiä ilman, että niitä välttämättä toteutetaan.

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 abstraktia luokkaa. Ominaisuuksien avulla voit luoda sopimuksia siitä, mitä sovelluksemme pitäisi pystyä tekemään, ja sitten ottaa nämä menetelmät käyttöön myöhemmin.

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

Näin voimme suunnitella, miltä sovelluksemme tulee näyttämään ilman menetelmiä, jotka voivat auttaa meitä näkemään, miltä eri menetelmät näyttävät. Se seuraa ohjelmointia abstrakteihin eikä varsinaiseen toteutukseen.

Luokka, jonka alussa on avainsana abstrakti, voi sisältää sekä abstrakteja että ei-abstrakteja menetelmiä. Useita perintöjä ei kuitenkaan tueta abstraktissa luokassa. Voit siis laajentaa enintään yhtä abstraktia luokkaa.

Yksittäisiä esineitä

Singleton on luokka, joka instantoidaan vain kerran ohjelmassa. Se on suositusta ja hyödyllisestä ohjelmointikuviosta, joka tunnetaan nimellä "singleton pattern". Se on hyödyllinen luotaessa ilmentymiä, jotka on tarkoitettu pitkäikäisiksi ja joita käytetään yleisesti koko ohjelmassa, jonka tila on olennainen järjestelmän tapahtumien koordinoinnissa. Tällaisen luokan luominen Scalassa on helppoa, koska Scala tarjoaa meille yksinkertaisen tavan luoda singletoneja käyttämällä objektiavainsanaa.

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

Voimme sitten viitata tähän objektiin koko ohjelmassamme takaamalla, että kaikki ohjelmamme osat näkevät samat tiedot, koska sitä on vain yksi esiintymä.

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

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

Staattisten jäsenten käsitettä ei ole Scalassa, siksi sinun on käytettävä singleton-objekteja, jotka toimivat kuin luokan staattiset jäsenet.

Implisiittiset luokat

Implisiittiset luokat ovat uusia toimintoja, jotka on lisätty version 2.1 jälkeen. Sen tarkoituksena on ensisijaisesti lisätä uusia toimintoja suljettuihin luokkiin.

Implisiittinen avainsana tulee määritellä luokassa, objektissa tai ominaisuudessa. Implisiittisen luokan ensisijaisella rakentajalla tulee olla täsmälleen yksi argumentti ensimmäisessä parametriluettelossaan. Se voi myös sisältää ylimääräisen implisiittisen parametriluettelon.

Alla olevassa Scala-esimerkissä on lisätty uusi toiminto merkkijonon vokaalien korvaamiseksi *:lla.

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

Sinun on tuotava luokassa, jossa käytät sitä.

import StringUtil.StringEnhancer

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

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

OOP:ssa ohjelmat rakennetaan ryhmittelemällä tiedot ja niillä toimivat toiminnot pitkälle kytketyiksi yksiköiksi. Objektit kuljettavat tietojaan niillä toimivilla aloilla ja menetelmillä. Tässä ohjelmointityylissä tärkein abstraktio on data, koska luotujen menetelmien on tarkoitus toimia datalla.

Toiminnallinen ohjelmointi, toisaalta erottaa tiedot ja datalla toimivat toiminnot. Tämä antaa kehittäjille mahdollisuuden käsitellä toimintoja abstraktiona ja liikkeellepanevana voimana ohjelmia mallintaessaan.

Scala mahdollistaa toiminnallisen ohjelmoinnin, koska sillä on funktioita ensiluokkaisina kansalaisina, jolloin ne voidaan välittää arvoina muille funktioille ja palauttaa arvoina. Näiden kahden paradigman yhdistelmä on tehnyt Scalasta erinomaisen valinnan monimutkaisten ohjelmistojen rakentamiseen eri aloilla, kuten Data Science -teollisuudessa.

Tärkeitä puitteita Scalassa

Tässä on joitain tärkeitä Scalan puitteita

• Pelaa on avoimen lähdekoodin verkkosovelluskehys, joka käyttää MVC-arkkitehtuuri. Julkaistu vuonna 2007 ja nyt lisensoitu Apachella, siitä tuli suosituin kehys GitHubissa vuonna 2013. Yritykset, kuten LinkedIn, Walmart, Samsung ja Eero, käyttävät tätä kehystä.
• Nostaa on toinen ilmainen verkkokehys, joka on kirjoitettu Scalassa vuonna 2007. Foursquare käyttää Lift-kehystä. Se on tehokas, nopeampi rakentaa runko.
• Kuten
• Kissat
• Spark

Samanaikaisuuden tuki

• Scalan arvot ovat oletuksena muuttumattomia. Tämä tekee siitä erittäin mukautuvan samanaikaiseen ympäristöön.
• Scalassa on monia ominaisuuksia, jotka tekevät siitä parhaan samanaikaisiin sovelluksiin.
• Futuurit ja lupaukset helpottavat tietojen asynkronista käsittelyä, mikä tukee rinnakkaisuutta.
• Akka – Actorin rinnakkaisuusmallia käyttävä työkalupakki. On olemassa joukko näyttelijöitä, jotka toimivat, kun he saavat viestejä.
• Samanaikaisuus käyttämällä säikeitä kohteesta Java voidaan tukea myös Scalassa.
• Stream-käsittely on toinen hieno ominaisuus, joka mahdollistaa jatkuvan, reaaliaikaisen tietojenkäsittelyn.

Scalalla on joitain parhaista samanaikaisuuskirjastoista Java ekosysteemin.

• Syntyperäinen Java kierteet
• Kuituja kirjastoista, kuten Vertex
• ZIO – kirjasto, jonka primitiivit auttavat meitä käsittelemään samanaikaisuutta ja asynkronista laskentaa
• STM – Transaction
• Tulevaisuus – sisäänrakennettu Scala-kielellä

Java vs. Scala

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

Scala	Java
Kompaktimpi ja tiiviimpi	Suhteellisen suurempia koodipaloja
Suunniteltu ja kehitetty sekä objekti- että toiminnalliseksi suuntautuneeksi kieleksi. Tukee laajaa valikoimaa toiminnallisia ohjelmointiominaisuuksia, kuten samanaikaisuutta, muuttumattomuutta.	Alun perin kehitetty olio-kieleksi ja se on viime päivinä alkanut tukea toiminnallisia ohjelmointiominaisuuksia. Ei silti ole vahva toiminnallisena ohjelmointikielenä.
Käyttää näyttelijämallia rinnakkaisuuden tukemiseen, joka on moderni	Käyttää tavanomaista säiepohjaista mallia samanaikaisuuteen.
Tukee kehyksiä – Play, Lift	Tukee Spring, Grails, paljon muuta
Tukee laiska arviointi	Ei tue laiska arviointia
Ei staattisia jäseniä	Sisältää staattisia jäseniä
Tukee käyttäjän ylikuormitusta	Ei tue käyttäjän ylikuormitusta
Lähdekoodin kääntäminen on suhteellisen hidasta	Lähdekoodin kääntäminen on nopeampaa kuin Scala
Ominaisuudet – toimi kuten Java 8 liitäntää	Java 8 rajapintaa pyrkii kuromaan siltaa luokkien ja rajapintojen välillä
Uudelleenkirjoitusta tarvitaan	Uudelleenkirjoitusta ei vaadita
Ei varmuutta bugittomista koodeista	Täydellinen vakuutus pienistä vioista
Tukee taaksepäin yhteensopivuutta.	Scala ei tue taaksepäin yhteensopivuutta.
Operatoreita kohdellaan eri tavalla Java eivätkä ne ole menetelmäkutsuja.	Kaikki merkintöjen operaattorit ovat Scalassa kutsutun menetelmän kautta.
Tukee useita perintöjä luokkien avulla, mutta ei abstrakteja luokkia	Ei tue useita perintöjä luokkien avulla, vaan rajapintojen mukaan
Koodi on kirjoitettu kompaktissa muodossa.	Koodi kirjoitetaan pitkässä muodossa.
Scala ei sisällä staattista avainsanaa.	Java sisältää staattisen avainsanan.

Yhteenveto

Tässä opetusohjelmassa olet oppinut aloittamaan Scalan käytön. Olet myös oppinut toiminnalliset ja olio-ominaisuudet. Olet myös löytänyt yhtäläisyyksiä ja eroja Java ja Scala. Tämän opetusohjelman olisi pitänyt auttaa sinua monien esimerkkien kanssa, jotka ovat hyvin esiteltyjä.