Scala Tutorial

Rezumat Tutorial Scala

Acest tutorial scala acoperă toate aspectele și subiectele scala. Veți învăța toate elementele fundamentale de la zero, cum ar fi Ce este scala, procesul de instalare a scala, programele Scala, funcțiile Scala, evaluarea leneșă, interfața tip, clasele și obiectele, moștenirea, abstracțiile, Java și diferențe de scala etc.

Scala este un limbaj scalabil folosit pentru a scrie software pentru mai multe platforme. Prin urmare, a primit numele „Scala”. Acest limbaj este destinat să rezolve problemele Java fiind în același timp mai concis. Proiectat inițial de Martin Odersky, a fost lansat în 2003.

De ce să înveți Scala

Iată principalele motive pentru a învăța limbajul de programare Scala:

• Scala este ușor de învățat pentru programatorii orientați pe obiecte, Java dezvoltatori. Devine una dintre limbile populare în ultimii ani.
• Scala oferă utilizatorilor funcții de primă clasă
• Scala poate fi executat pe FMV, deschizând astfel calea pentru interoperabilitatea cu alte limbi.
• Este conceput pentru aplicații care sunt concurente, distribuite și rezistente bazate pe mesaje. Este una dintre cele mai solicitante limbi ale acestui deceniu.
• Este un limbaj concis, puternic și poate crește rapid în funcție de cererea utilizatorilor săi.
• Este orientat pe obiecte și are o mulțime de caracteristici funcționale de programare, oferind multă flexibilitate dezvoltatorilor de a codifica în modul dorit.
• Scala oferă multe tipuri de rață
• Are mai puțin boilerplate dacă vii din Java
• Cadrele Lift and Play scrise în Scala sunt în curba de creștere.

Cum se instalează Scala

Pentru a începe să scrieți programe Scala, trebuie să îl aveți instalat pe computer. Pentru a face acest lucru, va trebui să vizitați site-ul lor https://www.scala-lang.org/download/ pentru a descărca cea mai recentă versiune de Scala.

Urmând link-ul, suntem conduși la două opțiuni pe care le putem alege să instalăm Scala pe mașinile noastre. Pentru acest tutorial Scala, vom descărca IntelliJ IDEA.

Odată ce accesați linkul de descărcare, veți găsi două versiuni ale IntelliJ IDE.

Pentru acest tutorial Scala, vom descărca ediția comunitară, care este gratuită și vine cu tot ce aveți nevoie pentru a scrie programe Scala.

Pas 1) Selectați Community Edition
Pe pagină, faceți clic pe meniul drop-down din Community Edition.

Ne prezintă o opțiune de a descărca IDE-ul IntelliJ împreună cu JBR care conține o implementare JDK (Java Development Kit) OpenJDK de care Scala are nevoie pentru a compila și a rula codul.

Pas 2) Rulați instalarea
După ce descărcați IntelliJ, faceți dublu clic pe el pentru a rula asistentul de instalare și urmați dialogul.

Pas 3) Selectați o locație
Alegeți o locație pentru a instala IDE-ul.

Dacă din întâmplare nu l-ați descărcat pe cel cu JDK, primim totuși o solicitare în care putem verifica pentru a-l descărca bifând caseta de selectare.

Pas 4) Faceți clic pe următorul
Lăsați celelalte setări implicite așa cum sunt și faceți clic pe Următorul.

Pas 5) Faceți clic pe pictograma de pornire
După finalizarea instalării, rulați IntelliJ IDE făcând clic pe pictograma de pornire din meniul de pornire ca o aplicație obișnuită.

Încă trebuie să parcurgeți un pas suplimentar de adăugare a pluginului Scala la IntelliJ; faceți acest lucru făcând clic pe meniul derulant din meniul de configurare situat în partea dreaptă jos a ecranului și selectând opțiunea de plugin.

În fila Piață, o căutare pentru Scala va prezenta pluginul ca prim rezultat sub eticheta Limbi.

Pas 6) Instalați pluginul
Faceți clic pe instalare, ceea ce va conduce pluginul la începutul descărcarii.

Pas 7) Reporniți IDE-ul
După finalizarea descărcării, vi se va solicita să reporniți IDE-ul, astfel încât pluginul instalat să poată începe să funcționeze.

După repornire, vă veți găsi pe aceeași pagină ca înainte când am rulat IDE-ul, dar de data aceasta am instalat deja pluginul Scala.

Programul Scala Hello World

Pas 1) Selectați opțiunea Creare proiect, care ne va conduce la o pagină în care putem selecta tipul de limbă pe care o va folosi proiectul nostru.

Pas 2) alegeți Scala bifând caseta de selectare Scala și faceți clic pe următorul.

Pas 3) Selectați o locație pentru a salva fișierul proiectelor noastre și dați un nume proiectului nostru.

Dacă directorul nu există, IntelliJ ne va cere să ne cerem permisiunea de a crea folderul. Acceptați și faceți clic pe Terminare. Veți fi dus la proiectul dvs. Scala, care în prezent nu are niciun cod Scala.

Va dura ceva timp pentru a încărca niște indexuri, așa că nu vă faceți griji dacă nu puteți face imediat nimic în timp ce există o bară de progres în partea de jos a IDE-ului dvs., înseamnă pur și simplu IDE-ul dvs. încarcă unele fișiere necesare pentru a rula Scala și ajutor cu completarea automată IDE.

Pas 4) Apoi, vom face clic pe fila proiecte din stânga IDE-ului și vom extinde astfel încât să putem vedea conținutul proiectului nostru.

Momentan proiectul este gol și conține doar un folder .idea și un fișier hello-world.iml generat de IDE. Punctul nostru de interes este folderul src. Src este locul în care stocăm codul sursă pentru proiectul nostru. Aici vom crea primul nostru fișier Scala.

Pas 5) Faceți clic dreapta pe src pentru a deschide un meniu pentru a crea un nou fișier Scala.

Vom crea apoi un nume pentru fișier, în acest tutorial Scala vom folosi salut și apoi vom alege dintr-un meniu derulant ce să punem ca conținut al fișierului Scala. Selectați „Obiect”

Odată ce facem acest lucru, vom avea un fișier Scala care are un obiect Singleton pe care îl vom folosi pentru a rula codul nostru.

Acum că aveți un fișier Scala cu un obiect Hello. Veți scrie primul program extinzând obiectul pe care l-ați creat folosind cuvântul cheie App.

Extinderea obiectului nostru cu App spuneți compilatorului ce cod să ruleze atunci când pornește programul. Imediat după extinderea aplicației, în partea stângă apare o săgeată verde, indicând că acum puteți rula programul.

În interiorul obiectului Hello, scriem o funcție println() care este folosită pentru a tipări textul din interiorul acestuia pe consolă. Vom rula codul făcând clic pe săgeata verde.

Făcând clic pe săgeată, ne prezintă opțiunea Run, hello, după ce facem clic pe ea, codul nostru va începe compilarea și după câteva secunde vom vedea rezultatele programului nostru tipărite din consola care este încorporată în IntelliJ IDE.

Și iată-ne, am instalat cu succes Scala și am rulat primul nostru program.

Ce poți face cu Scala

• Dezvoltare web front-end cu ScalaJS
• Dezvoltare mobilă, ambele Android Dezvoltare și IOS – cu Scala Native
• Biblioteci de pe partea serverului, cum ar fi HTTP4S, Akka-Http, Play Framework
• Utilizarea internetului lucrurilor
• Dezvoltarea jocului
• NLP – Procesarea limbajului natural folosind o suită de biblioteci ScalaNLP
• Testarea tehnicilor avansate de programare, cum ar fi programarea funcțională și programarea orientată pe obiecte
• Construiți aplicații de comunicare extrem de concurente folosind actori o bibliotecă pentru JVM inspirată de Erlang
• Folosiți-l pentru învățarea automată folosind biblioteci precum Figaro care face programare probabilistică și Apache Spark acea

Funcții anonime

Limbajul Scala are funcții anonime, care sunt și numite literali de funcție. Scala fiind un limbaj funcțional înseamnă adesea că dezvoltatorii descompun problemele mari în multe sarcini mici și creează multe funcții pentru a rezolva aceste probleme. Pentru a facilita crearea de funcții, Scala conține aceste funcții care pot fi instanțiat fără nume. Le putem atribui direct variabilelor sau definițiilor „def”, așa cum se arată în exemplul Scala de mai jos:

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

Apoi putem folosi modul normal în care folosim funcțiile, pasând parametrii acestora.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Aceste metode sunt utile atunci când dorim să avem un cod curat și concis. Putem folosi funcții anonime atunci când definim metode care nu sunt mari și nu necesită mult cod în corpul lor. Sunt foarte simple și nu au nevoie de o ceremonie pentru a le crea.

Aceste metode nu se limitează la funcții cu argumente și pot fi folosite pentru a instanția metode care nu preiau niciun argument.

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

Cele mai multe dintre aceste funcții anonime sunt utilizate în alte părți ale codului nostru, unde trebuie să creăm o funcție rapidă.

Un alt motiv pentru care aceste funcții sunt denumite și ca funcții inline. Utilizarea funcțiilor anonime este un model obișnuit care este utilizat în mod general în biblioteca colecțiilor pentru a efectua acțiuni rapide asupra unei colecții.

De exemplu, avem metoda de filtru care necesită o funcție inline/funcție anonimă pentru a crea o altă colecție cu doar elemente care îndeplinesc criteriile pe care le definim în funcția anonimă.

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)

Aici metodele pe care le avem ca funcții anonime sunt cele care verifică dacă valoarea pe care o primim din listă este pară și impară și returnează elementul.

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

În Scala, este, de asemenea, posibil să folosiți metacaracterele unde parametrul funcției noastre anonime nu este denumit. De exemplu

var timesTwo = (_:Int)*2

timesTwo(5)
//10

În acest scenariu, nu denumim parametrul pe care îl transmitem. Singurul lucru pe care îl folosim un caracter de subliniere pentru a-l reprezenta.

Evaluare leneșă

Majoritatea limbilor evaluează secvenţial variabilele şi parametrii funcţiei, unul după altul. În Scala, avem un cuvânt cheie numit lazy, care ajută la tratarea valorilor pe care nu dorim să fie evaluate până când nu sunt referite.

O variabilă marcată ca leneș nu va fi evaluată acolo unde este definită, care este cunoscută în mod obișnuit ca evaluare dornică, va fi evaluată doar atunci când este referită mai târziu în cod.

Acest lucru poate fi util atunci când evaluarea unei valori ar putea fi un calcul costisitor, dacă nu este cazul în care valoarea este întotdeauna necesară, ne putem salva de a rula un calcul costisitor care poate încetini software-ul nostru făcând variabila leneșă.

lazy val myExpensiveValue = expensiveComputation

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

Acesta nu este singurul caz de utilizare pentru variabilele leneșe. De asemenea, ajută la rezolvarea problemelor legate de dependența circulară în cod.

În cazul în care setările sunt false, s-ar putea să nu fie nevoie să folosim myExpensiveValue, ceea ce ne poate determina să ne salvăm de la efectuarea unui calcul costisitor care ne ajută să ne asigurăm că utilizatorii se distrează bine folosind aplicația noastră, deoarece celelalte nevoi ale lor pot fi calculate corect, fără a fi copleșite. Berbecul.

În cazul în care setările sunt false, s-ar putea să nu fie nevoie să folosim myExpensiveValue, ceea ce ne poate determina să ne salvăm de la efectuarea unui calcul costisitor, ceea ce ne ajută să ne asigurăm că utilizatorii se simt bine folosind aplicația noastră, deoarece celelalte nevoi ale lor pot fi calculate în mod corespunzător, fără a fi copleșite. Berbecul.

Lenea ajută și cu argumentele funcției, unde argumentele sunt folosite doar atunci când sunt referite în interiorul funcției. Acest concept se numește parametri de apelare după nume.

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

Multe limbi folosesc modul apel-după-valoare de a evalua argumentele. Parametrul trecut prin call-by-name va fi evaluat numai atunci când este necesar în corpul funcției și nu va fi evaluat înainte. Odată evaluată valoarea, aceasta este stocată și poate fi reutilizată ulterior fără a fi necesară reevaluarea. Un concept cunoscut sub numele de memorare.

Tip Inferență

În Scala, nu trebuie să declarați tipuri pentru fiecare variabilă pe care o creați. Acest lucru se datorează faptului că compilatorul Scala poate face inferențe de tip pe tipuri pe baza evaluării părții din dreapta. Acest lucru permite codului dvs. să fie mai concis - ne eliberează de la scrierea de tip boilerplate unde tipul așteptat este evident

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

Funcție de ordin superior

O funcție de ordin superior este o funcție care poate lua funcții ca argumente și poate returna o funcție ca tip de returnare. La Scala, funcțiile sunt considerate cetățeni de primă clasă. Folosirea acestor funcții în acest fel ne permite să fim foarte flexibili în ceea ce privește tipurile de programe pe care le putem realiza. Putem crea funcții în mod dinamic și putem alimenta funcționalități în mod dinamic altor funcții.

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

În funcția de mai sus, trecem un int și o funcție care ia un int și returnează un int. Putem trece în orice funcție a acelei semnături. Prin semnătură, înțelegem intrarea și ieșirea unei funcții. O semnătură a lui Int=>Int înseamnă că o funcție ia un Int ca intrare și returnează un Int ca ieșire.

O semnătură de ()=>Int înseamnă că o funcție nu ia nimic ca intrare și returnează un Int ca ieșire. Un exemplu de funcție ca acesta ar fi unul care generează un int aleatoriu pentru noi.

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

Funcția de mai sus are o semnătură () => Int

Putem avea o funcție care are o semnătură scala ()=>Unit. Aceasta înseamnă că funcțiile nu preiau nimic și nu returnează un tip. Funcția ar putea face un fel de calcul schimbând ceva în a face ceva predeterminat.

Cu toate acestea, aceste tipuri de metode nu sunt încurajate, deoarece par a fi o cutie neagră care poate afecta un sistem în anumite moduri necunoscute. Sunt, de asemenea, netestabile. Având tipuri explicite de intrare și ieșire, ne permite să raționăm cu privire la ceea ce face funcția noastră.

O funcție de ordin superior poate returna și o funcție.

De exemplu, am putea crea o metodă care va crea o funcție de alimentare, adică ia un număr și îi aplică putere.

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

Funcția de mai sus ia un int. Tipul nostru returnat este o funcție anonimă care ia un Int x, * folosim int x ca argument pentru funcția de putere.

curry

În Scala, putem converti o funcție care ia două argumente într-una care ia câte un argument la un moment dat. Când introducem un argument, îl aplicăm parțial și ajungem la o funcție care ia un argument pentru a finaliza funcția. Currying ne permite să creăm funcții prin adăugarea parțială a unor argumente.

Acest lucru poate fi util pentru a crea funcții în mod dinamic înainte de a avea un set complet de argumente

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

Dacă trebuie să creăm o funcție care se înmulțește cu un anumit număr, nu trebuie să creăm o altă metodă de înmulțire.

Putem apela pur și simplu .curried pe funcția noastră de mai sus și obținem o funcție care ia mai întâi un argument și returnează o funcție aplicată parțial

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Potrivire de model

Scala are un mecanism puternic încorporat pentru a ne ajuta să verificăm dacă o variabilă se potrivește cu anumite criterii, la fel cum am face într-o declarație switch în Java sau într-o serie de afirmații if/else. Limbajul are potrivire de tipare pe care o putem folosi pentru a verifica dacă o variabilă este de un anumit tip. Potrivirea modelelor în Scala este puternică și poate fi folosită pentru a destructura componentele care au o metodă neaplicată pentru a obține câmpurile care ne interesează direct din variabila pe care o potrivim.

Potrivirea modelului Scala oferă, de asemenea, o sintaxă mai plăcută în comparație cu declarația switch.

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

Ne comparăm variabila cu un set de opțiuni, iar când variabila pe care o potrivim îndeplinește criteriile, expresia din partea dreaptă a săgeții grase (=>) evaluează și este returnată ca rezultat al potrivirii.

Folosim un caracter de subliniere pentru a identifica cazurile care nu sunt egalate în codul nostru. Oglindește comportamentul cazului implicit atunci când se ocupă de instrucțiunile switch.

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
}

În codul de mai sus, puteți afla tipul variabilei myItem și, pe baza acelui cod, puteți găsi un anumit cod.

Potrivirea modelului verifică dacă variabila se potrivește

Sublinierea funcționează ca un substituent care se potrivește cu orice altă condiție care nu este potrivită de celelalte elemente din declarațiile de mai sus. Luăm o variabilă myItem și apelăm metoda potrivirii.

• verificăm dacă myItem este adevărat folosind și facem ceva logic în partea dreaptă a săgeții grase „=>.”
• folosim caracterul de subliniere pentru a se potrivi cu orice nu se potrivește cu oricare dintre declarațiile case pe care le-am definit în cod.

Cu clasele Case, putem chiar să mergem mai departe și să destructuram clasa pentru a obține câmpuri în interiorul obiectului.

Folosind cuvântul cheie sigilat pentru a ne defini clasele, obținem beneficiul de a avea compilatorul să verifice în mod exhaustiv cazurile cu care încercăm să le potrivim și să ne avertizeze dacă uităm să ne ocupăm de unul anume.

Imuabilitate

Este posibil să creați valori care nu pot fi modificate de alte funcții în Scala folosind cuvântul cheie val. Acest lucru se realizează în Java prin utilizarea cuvântului cheie final. În Scala, facem acest lucru folosind un cuvânt cheie val atunci când creăm o variabilă în loc de a folosi var, care este alternativa pe care am folosi-o pentru a crea o variabilă mutabilă.

O variabilă definită folosind cuvântul cheie val este doar pentru citire, în timp ce una definită cu var poate fi citită și modificată de alte funcții sau în mod arbitrar de către utilizator în cod.

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

Încercarea de a atribui o valoare lui Numărul meu după ce am declarat-o ca val, generează o eroare de compilare sau „reatribuire la val”.

De ce să folosiți Imutabilitatea?

Imuabilitatea ne ajută să împiedicăm codul și alți programatori să ne schimbe valorile în mod neașteptat, ceea ce ar duce la rezultate neașteptate, dacă ar trebui să utilizeze valoarea pe care o stocăm, o pot face în schimb o copie a acesteia. În acest fel, sunt prevenite erorile care pot fi cauzate de mai mulți actori care modifică aceeași variabilă.

Clase și obiecte

Știm cu toții că obiectele sunt entitățile din lumea reală, iar clasa este un șablon care definește obiectele. Clasele au atât stare, cât și comportamente. Stările sunt fie valori, fie variabile. Comportamentele sunt metodele din Scala.

Să ne uităm la modul în care poți defini o clasă, să o instanțiezi și să o folosești folosind Scala.

Aici, clasa numită Rectangle, care are două variabile și două funcții. De asemenea, puteți utiliza parametrii l și b direct ca câmpuri în program. Aveți un obiect care are o metodă principală și a instanțiat clasa cu două valori.

Exemplu:

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

Toate câmpurile și metoda sunt în mod implicit publice în Scala. Este esențial să utilizați override deoarece metoda toString este definită pentru Object în Scala.

Moştenire

Scala are mai multe tipuri de moștenire (cum ar fi un singur, multi-nivel, multiplu, ierarhic, hibrid) care au multe în comun cu formele tradiționale găsite în Java. Puteți moșteni atât din clase, cât și din trăsături. Puteți moșteni membrii unei clase într-o altă clasă folosind cuvântul cheie „extinde”. Acest lucru permite reutilizarea.

Este posibil să moșteniți dintr-o clasă sau mai multe clase. De asemenea, este posibil să se moștenească din subclase care au ele însele superclasele, creând o ierarhie de moștenire în acest proces.

În exemplul Scala de mai jos, clasa de bază este Cerc, iar clasa derivată este Sferă. Un cerc are o valoare numită rază, care este moștenită în clasa Sphere. Metoda calcArea este suprascrisă folosind cuvântul cheie override.

Exemplu:

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

abstracțiune

În Scala, putem crea metode abstracte și câmpuri membre folosind clase și trăsături abstracte. În interiorul claselor și trăsăturilor abstracte, putem defini câmpuri abstracte fără a le implementa neapărat.

Exemplu:

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

Aceste câmpuri sunt implementate de clasele care extind trăsătura sau clasa abstractă. Puteți folosi trăsături pentru a crea contracte cu privire la ceea ce aplicația noastră ar trebui să poată face și apoi implementați acele metode mai târziu.

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

În acest fel, putem planifica cum va arăta aplicația noastră fără a implementa metodele care ne pot ajuta să ne imaginăm cum vor arăta diferite metode. Urmează de-a lungul unui model cunoscut ca programare la abstracții și nu implementarea propriu-zisă.

Clasa care este prefațată cu cuvântul cheie abstract poate conține atât metode abstracte, cât și non-abstracte. Dar, moștenirile multiple nu sunt acceptate în clasa abstractă. Deci, puteți extinde cel mult o clasă abstractă.

Obiecte Singleton

Un Singleton este o clasă care este instanțiată o singură dată într-un program. Este dintr-un model de programare popular și util cunoscut sub numele de „model singleton”. Este util în crearea instanțelor care sunt menite să aibă o viață lungă și care vor fi accesate în mod obișnuit în programul dvs. a căror stare este parte integrantă în coordonarea evenimentelor unui sistem. Crearea unei astfel de clase în Scala este ușoară, deoarece Scala ne oferă un mijloc simplu de a crea singletonuri folosind cuvântul cheie obiect.

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

Apoi putem face referire la acest obiect în programul nostru, cu garanția că toate părțile programului nostru vor vedea aceleași date, deoarece există o singură instanță a acestuia.

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

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

Conceptul de membri statici nu există în Scala, acesta este motivul pentru care trebuie să utilizați obiecte singleton, care acționează ca membri statici ai unei clase.

Clasele implicite

Clasele implicite sunt noua funcționalitate adăugată după versiunea 2.1. Este în primul rând pentru a adăuga noi funcționalități la clasele închise.

Cuvântul cheie implicit ar trebui definit într-o clasă, obiect sau trăsătură. Constructorul primar al unei clase implicite ar trebui să aibă exact un argument în prima sa listă de parametri. Poate include, de asemenea, o listă suplimentară de parametri impliciti.

În exemplul Scala de mai jos, se adaugă o nouă funcționalitate pentru a înlocui vocalele unui șir cu *.

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

Trebuie să importați în clasa în care îl utilizați.

import StringUtil.StringEnhancer

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

Programare orientată pe obiecte (OOP) vs. Programare funcțională (FP)

În OOP, programele sunt construite prin gruparea datelor și a funcțiilor care operează pe acele date în unități puternic conectate. Obiectele își poartă datele în câmpurile și metodele care operează asupra lor. În acest stil de programare, principala abstractizare sunt datele, deoarece metodele care sunt create sunt menite să opereze asupra datelor.

Programare funcțională, pe de altă parte, separă datele și funcțiile care operează asupra datelor. Acest lucru le permite dezvoltatorilor să trateze funcțiile ca forță de abstractizare și forță motrice atunci când modelează programe.

Scala permite programarea funcțională având funcții ca cetățeni de primă clasă, permițându-le să fie transmise ca valori către alte funcții și returnate, de asemenea, ca valori. Combinația acestor două paradigme a făcut din Scala o alegere excelentă în construirea de software complex în diverse industrii, cum ar fi Data Science.

Cadre importante pe Scala

Iată câteva cadre importante ale Scala

• Joaca este un cadru de aplicații web open-source care utilizează Arhitectura MVC. Lansat în 2007 și acum licențiat sub Apache, A devenit cel mai popular cadru de pe GitHub în 2013. Companii precum LinkedIn, Walmart, Samsung, Eero folosesc acest cadru.
• Ridicare este un alt framework web gratuit scris în Scala lansat în 2007. Foursquare folosește framework-ul Lift. Este un cadru performant, mai rapid de construit.
• Acru
• Pisici
• Spark

Suport simultan

• Valorile din Scala sunt implicit imuabile. Acest lucru îl face foarte adaptabil la mediul concurent.
• Există o mulțime de caracteristici în Scala care îl fac cel mai bun pentru aplicațiile concurente.
• Futures and Promises facilitează procesarea asincronă a datelor, susținând astfel paralelismul.
• Akka – set de instrumente care utilizează modelul de concurență Actor. Există o serie de Actori care acționează atunci când primesc mesaje.
• Concurență folosind fire din Java poate fi suportat și în Scala.
• Procesarea fluxului este o altă caracteristică excelentă care permite procesarea continuă, în timp real, a datelor.

Scala are unele dintre cele mai bune biblioteci de concurență din Java ecosistem.

• Nativ Java fire
• Fibre din biblioteci precum Vertex
• ZIO – o bibliotecă care are primitive pentru a ne ajuta să ne ocupăm de concurența și calculul asincron
• STM – Tranzacție
• Viitorul – încorporat în limbajul Scala

Java vs Scala

Iată care sunt principalele diferență între Java și Scala.

Scala	Java
Mai compact și mai concis	Bucăți de cod relativ mai mari
Proiectat și dezvoltat pentru a fi atât limbaj orientat pe obiect, cât și funcțional. Acceptă o mare varietate de caracteristici funcționale de programare, cum ar fi concurența, Imuabilitatea.	S-a dezvoltat inițial ca un limbaj orientat pe obiecte și a început să accepte funcții de programare funcționale în ultimele zile. Încă nu este puternic ca limbaj de programare funcțional.
Utilizează modelul de actor pentru a susține concurența, care este modern	Utilizează modelul convențional bazat pe fire pentru concurență.
Acceptă cadre – Play, Lift	Suporta Spring, Grails, multe altele
Sprijină evaluarea leneșă	Nu acceptă evaluarea leneșă
Fără membri statici	Conține membri statici
Acceptă supraîncărcarea operatorului	Nu acceptă supraîncărcarea operatorului
Compilarea codului sursă este relativ lentă	Compilarea codului sursă este mai rapidă decât Scala
Trăsături – acționează ca Java 8 interfețe	Java 8 interfețe încearcă să reducă decalajul dintre clase și interfețe
Este nevoie de rescriere	Rescrierea nu este necesară
Nicio asigurare cu privire la codurile fără erori	Asigurarea completă a defectelor mai mici
Suportă compatibilitate inversă.	Scala nu acceptă compatibilitatea inversă.
Operatorii sunt tratați diferit în Java și nu sunt apeluri de metodă.	Toți operatorii de pe intrări sunt printr-o metodă numită în Scala.
Suportă moșteniri multiple folosind clase, dar nu prin clase abstracte	Nu acceptă moșteniri multiple folosind clase, ci prin interfețe
Codul este scris într-o formă compactă.	Codul este scris în formă lungă.
Scala nu conține cuvântul cheie static.	Java conține cuvântul cheie static.

Rezumat

În acest tutorial, ați învățat cum să începeți cu Scala. Ați învățat și caracteristicile funcționale și orientate pe obiecte. De asemenea, ați descoperit asemănările și diferențele dintre Java și Scala. Acest tutorial ar fi trebuit să vă ajute cu o mare varietate de exemple care sunt bine demonstrate.