Scala Výukový program: Příklad programovacího jazyka Scala a kód

Shrnutí výukového programu Scala

Tento tutoriál scala pokrývá všechny aspekty a témata scaly. Naučíte se všechny základy od začátku, jako je Co je scala, instalační proces scala, programy Scala, funkce Scala, líné vyhodnocení, rozhraní typu, třídy a objekty, dědičnost, abstrakce, Java a rozdíly ve scal atd.

Scala je škálovatelný jazyk používaný k psaní softwaru pro více platforem. Proto dostal název „Scala“. Tento jazyk je určen k řešení problémů Java a zároveň být stručnější. Původně navržený Martinem Oderskym, byl vydán v roce 2003.

Proč se učit Scala

Zde jsou hlavní důvody, proč se učit programovací jazyk Scala:

• Scala se snadno učí pro objektově orientované programátory, Java vývojáři. V posledních letech se stává jedním z populárních jazyků.
• Scala nabízí uživatelům prvotřídní funkce
• Scala může být provedena na JVM, čímž se otevírá cesta pro interoperabilitu s jinými jazyky.
• Je navržen pro aplikace, které jsou řízeny souběžnými, distribuovanými a odolnými zprávami. Je to jeden z nejnáročnějších jazyků tohoto desetiletí.
• Je to stručný, výkonný jazyk a může rychle růst podle požadavků svých uživatelů.
• Je objektově orientovaný a má mnoho funkčních programovacích funkcí, které poskytují vývojářům velkou flexibilitu při kódování způsobem, který chtějí.
• Scala nabízí mnoho druhů kachen
• Pokud pocházíte, má méně vzoru Java
• Rámce Lift and Play napsané ve Scale jsou na křivce růstu.

Jak nainstalovat Scala

Chcete-li začít psát programy Scala, musíte je mít nainstalované v počítači. Chcete-li to provést, budete muset navštívit jejich stránky https://www.scala-lang.org/download/ abyste si mohli stáhnout nejnovější verzi Scala.

Po odkazu jsme vedeni ke dvěma možnostem, které si můžeme vybrat a nainstalovat Scala na naše stroje. Pro tento tutoriál Scala stáhneme soubor IntelliJ IDEA.

Jakmile navštívíte odkaz ke stažení, najdete dvě verze IntelliJ IDE.

Pro tento tutoriál Scala si stáhneme Community Edition, která je zdarma a obsahuje vše, co potřebujete k psaní programů Scala.

Krok 1) Vyberte Community Edition
Na stránce klikněte na rozbalovací nabídku Community Edition.

Představuje nám možnost stáhnout si IntelliJ IDE spolu s JBR, které obsahuje implementaci JDK (Java Development Kit) OpenJDK, který Scala potřebuje ke kompilaci a spuštění kódu.

Krok 2) Spusťte instalaci
Jakmile stáhnete IntelliJ, dvakrát na něj klikněte, aby se spustil průvodce instalací a postupujte podle dialogu.

Krok 3) Vyberte místo
Vyberte umístění pro instalaci IDE.

Pokud jste si náhodou nestáhli ten s JDK, stále se nám zobrazí výzva, kde jej můžeme zaškrtnout a stáhnout zaškrtnutím políčka.

Krok 4) Klikněte na další
Ostatní výchozí hodnoty ponechte tak, jak jsou, a klepněte na tlačítko Další.

Krok 5) Klikněte na ikonu spouštění
Po dokončení instalace spusťte IntelliJ IDE kliknutím na jeho spouštěcí ikonu ve spouštěcí nabídce jako běžnou aplikaci.

Stále musíte projít dalším krokem přidáním zásuvného modulu Scala do IntelliJ; učiníte tak kliknutím na rozevírací nabídku v nabídce konfigurace umístěné v pravé dolní části obrazovky a výběrem možnosti pluginu.

Na záložce Marketplace zobrazí vyhledávání Scala plugin jako první výsledek pod tagem Languages.

Krok 6) Nainstalujte plugin
Klikněte na instalovat, čímž se plugin zahájí stahováním.

Krok 7) Restartujte IDE
Po dokončení stahování budete vyzváni k restartování IDE, aby nainstalovaný plugin mohl začít fungovat.

Po restartu se ocitnete na stejné stránce jako předtím, když jsme spustili IDE, ale tentokrát jsme již nainstalovali plugin Scala.

Program Scala Hello World

Krok 1) Vyberte možnost Vytvořit projekt, která nás zavede na stránku, kde můžeme vybrat druh jazyka, který bude náš projekt používat.

Krok 2) vyberte Scala zaškrtnutím políčka Scala a klikněte na Další.

Krok 3) Vyberte umístění pro uložení souboru našich projektů a pojmenujte náš projekt.

Pokud adresář neexistuje, IntelliJ nás vyzve, abychom nás požádali o povolení k vytvoření složky. Přijměte a klikněte na Dokončit. Budete přesměrováni do svého projektu Scala, který momentálně nemá žádný kód Scala.

Načtení některých indexů bude nějakou dobu trvat, takže se nebojte, pokud nemůžete okamžitě nic dělat, zatímco ve spodní části vašeho IDE je ukazatel průběhu, jednoduše to znamená, že vaše IDE načítá nějaké soubory potřebné ke spuštění Scala a pomoc s automatickým dokončováním IDE.

Krok 4) Dále klikneme na záložku projekty nalevo od IDE a rozbalíme, abychom viděli obsah našeho projektu.

V tuto chvíli je projekt prázdný a obsahuje pouze složku .idea a soubor hello-world.iml vygenerovaný IDE. Naším bodem zájmu je složka src. Src je místo, kde ukládáme zdrojový kód pro náš projekt. Zde vytvoříme náš první soubor Scala.

Krok 5) Kliknutím pravým tlačítkem na src otevřete nabídku pro vytvoření nového souboru Scala.

Poté vytvoříme název souboru, v tomto tutoriálu Scala použijeme hello a poté z rozevírací nabídky vybereme, co vložíme jako obsah souboru Scala. Vyberte "Objekt"

Jakmile to uděláme, budeme mít soubor Scala, který má objekt Singleton, který použijeme ke spuštění našeho kódu.

Nyní, když máte soubor Scala s objektem Hello. Svůj první program napíšete rozšířením objektu, který jste vytvořili, pomocí klíčového slova App.

Rozšířením našeho objektu pomocí App řeknete kompilátoru, který kód má spustit, když spustí váš program. Ihned po rozšíření aplikace se na levé straně zobrazí zelená šipka, která označuje, že nyní můžete spustit svůj program.

Uvnitř objektu Hello napíšeme jednu funkci println(), která se používá k vytištění textu uvnitř do konzole. Náš kód spustíme kliknutím na zelenou šipku.

Kliknutím na šipku se nám zobrazí možnost Spustit, ahoj, po kliknutí na ni se náš kód začne kompilovat a po několika sekundách uvidíme výsledky našeho programu vytištěné z konzole, která je vestavěná v IntelliJ IDE.

A je to, úspěšně jsme nainstalovali Scala a spustili náš první program.

Co můžete dělat se Scalou

• Frontend vývoj webu s ScalaJS
• Mobilní vývoj, obojí Android Vývoj a IOS – s Scala Native
• Knihovny na straně serveru jako HTTP4S, Akka-Http, Play Framework
• Internet věcí pomocí
• Vývoj hry
• NLP – Natural Language Processing pomocí sady knihoven ScalaNLP
• Testování pokročilých programovacích technik, jako je funkční programování a objektově orientované programování
• Sestavte vysoce souběžnou komunikační aplikaci pomocí herců a knihovny pro JVM inspirované Erlangem
• Použijte jej pro strojové učení pomocí knihoven jako Figaro, které dělá pravděpodobnostní programování, a Apache Spark že

Anonymní funkce

Jazyk Scala má anonymní funkce, které se také nazývají funkční literály. Scala jako funkční jazyk často znamená, že vývojáři rozdělují velké problémy na mnoho malých úkolů a vytvářejí mnoho funkcí k řešení těchto problémů. Aby bylo vytváření funkcí snadné, Scala obsahuje tyto funkce, které mohou být vytvořené beze jména. Můžeme je přiřadit přímo k proměnným nebo definicím 'def', jak ukazuje níže uvedený příklad Scala:

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

Potom můžeme použít normální způsob, jakým používáme funkce, a to tak, že jim předáme parametry.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Tyto metody se hodí, když chceme mít čistý a stručný kód. Anonymní funkce můžeme použít při definování metod, které nejsou velké a nevyžadují ve svém těle mnoho kódu. Jsou velmi jednoduché a k vytvoření nepotřebují obřad.

Tyto metody nejsou omezeny na funkce s argumenty a lze je použít k vytvoření instancí metod, které nepřijímají žádné argumenty.

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

Většina těchto anonymních funkcí se používá v jiných částech našeho kódu, kde potřebujeme vytvořit rychlou funkci.

Dalším důvodem, proč jsou tyto funkce také označovány jako inline funkce. Používání anonymních funkcí je běžný vzor, ​​který se všudypřítomně používá v knihovně kolekcí k provádění rychlých akcí nad kolekcí.

Máme například metodu filtrování, která využívá inline funkci/anonymní funkci k vytvoření další kolekce pouze s prvky, které splňují kritéria, která definujeme v anonymní funkci.

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)

Zde metody, které máme jako anonymní funkce, jsou ty, které kontrolují, zda hodnota, kterou získáváme ze seznamu, je lichá a sudá a vrací položku.

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

Ve Scale je také možné použít zástupné znaky tam, kde není pojmenován parametr naší anonymní funkce. Například

var timesTwo = (_:Int)*2

timesTwo(5)
//10

V tomto scénáři nepojmenováváme parametr, který předáváme. Jediná věc, kterou k reprezentaci používáme, používáme podtržítko.

Líné hodnocení

Většina jazyků postupně vyhodnocuje proměnné a parametry funkcí, jednu po druhé. Ve Scale máme klíčové slovo nazvané lazy, které pomáhá při práci s hodnotami, které nechceme hodnotit, dokud se na ně neodkážeme.

Proměnná označená jako líná nebude vyhodnocena tam, kde je definována, což je běžně známé jako dychtivé vyhodnocení, bude vyhodnocena pouze tehdy, když je na ni odkazováno později v kódu.

To může být užitečné, když vyhodnocení hodnoty může být nákladný výpočet, pokud tomu tak není, že hodnota je vždy potřeba, můžeme se ušetřit spuštěním drahého výpočtu, který může zpomalit náš software tím, že naše proměnná bude líná.

lazy val myExpensiveValue = expensiveComputation

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

Toto není jediný případ použití pro líné proměnné. Pomáhají také řešit problémy s cyklickou závislostí v kódu.

V případě, že je nastavení nepravdivé, možná nebudeme muset použít myExpensiveValue, což nás může vést k tomu, že nás ušetříte před prováděním drahých výpočtů, což pomáhá zajistit, aby se uživatelé dobře bavili při používání naší aplikace, protože jejich další potřeby mohou být správně spočítány bez přetěžování. RAM.

V případě, že je nastavení nepravdivé, možná nebudeme muset použít myExpensiveValue, což nás může vést k tomu, že nás ušetříte od provádění drahých výpočtů, což pomáhá zajistit, aby se uživatelé dobře bavili při používání naší aplikace, protože jejich další potřeby lze vypočítat správně, aniž by to zahlcovalo. RAM.

Lenost také pomáhá s argumenty funkcí, kde se argumenty používají pouze tehdy, když se na ně odkazuje uvnitř funkce. Tento koncept se nazývá parametry Call-by-name.

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

Mnoho jazyků používá k vyhodnocování argumentů způsob call-by-value. Parametr předaný přes call-by-name bude vyhodnocen pouze v případě potřeby v těle funkce a nebude vyhodnocen dříve. Jakmile je hodnota vyhodnocena, je uložena a lze ji později znovu použít, aniž by bylo nutné ji znovu vyhodnocovat. Koncept, který je známý jako memoizace.

Typ Inference

Ve Scale nemusíte deklarovat typy pro každou proměnnou, kterou vytvoříte. Je to proto, že kompilátor Scala může provádět typové odvození typů na základě vyhodnocení pravé strany. To umožňuje, aby byl váš kód stručnější – osvobozuje nás to od psaní standardního textu, kde je očekávaný typ zřejmý

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

Funkce vyššího řádu

Funkce vyššího řádu je funkce, která může mít funkce jako argumenty a může vrátit funkci jako návratový typ. Ve Scale jsou funkce považovány za prvotřídní občany. Použití těchto funkcí nám umožňuje být velmi flexibilní, pokud jde o druhy programů, které můžeme vytvářet. Můžeme dynamicky vytvářet funkce a dynamicky doplňovat funkce do jiných funkcí.

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

Ve výše uvedené funkci předáme int a funkci, která vezme int a vrátí int. Můžeme předat jakoukoli funkci tohoto podpisu. Podpisem rozumíme vstup a výstup funkce. Signatura Int=>Int znamená, že funkce bere Int jako vstup a vrací Int jako svůj výstup.

Podpis ()=>Int znamená, že funkce nebere nic jako svůj vstup a vrací Int jako svůj výstup. Příkladem takové funkce by byla funkce, která nám generuje náhodné int.

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

Výše uvedená funkce má podpis ()=>Int

Můžeme mít funkci, která má signaturu scala ()=>Unit. To znamená, že funkce nic nepřijímají a nevrací typ. Funkce by mohla provádět nějaký druh výpočtu změnou něčeho na něco předem určeného.

Tyto druhy metod však nejsou podporovány, protože se zdají být černou skříňkou, která může nějakým neznámým způsobem ovlivnit systém. Jsou také netestovatelné. Explicitní vstupní a výstupní typy nám umožňují uvažovat o tom, co naše funkce dělá.

Funkce vyššího řádu může také vrátit funkci.

Mohli bychom například vytvořit metodu, která vytvoří funkci napájení, tj. vezme číslo a použije na něj sílu.

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

Výše uvedená funkce trvá int. Náš návratový typ je anonymní funkce, která přebírá Int x, * používáme int x jako argument pro mocninnou funkci.

Kari

Ve Scale můžeme převést funkci, která přebírá dva argumenty, na jednu, která přebírá jeden argument najednou. Když předáme jeden argument, částečně ho použijeme a skončíme s funkcí, která potřebuje jeden argument k dokončení funkce. Currying nám umožňuje vytvářet funkce částečným přidáním některých argumentů.

To může být užitečné pro dynamické vytváření funkcí, než budeme mít kompletní sadu argumentů

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

Pokud potřebujeme vytvořit funkci, která se násobí nějakým konkrétním číslem, nemusíme vytvářet další metodu násobení.

Můžeme jednoduše zavolat .curried na naší funkci výše a získat funkci, která nejprve vezme jeden argument a vrátí částečně použitou funkci

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

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

Shoda vzorů

Scala má výkonný vestavěný mechanismus, který nám pomáhá kontrolovat, zda proměnná odpovídá určitým kritériím, podobně jako bychom to dělali v příkazu switch v Java nebo v řadě příkazů if/else. Jazyk má porovnávání vzorů, které můžeme použít ke kontrole, zda je proměnná určitého typu. Porovnávání vzorů ve Scale je výkonné a lze jej použít k destrukci komponent, které mají metodu unapply, a získat tak pole, která nás zajímají, přímo z proměnné, kterou porovnáváme.

Porovnání vzorů Scala také poskytuje příjemnější syntaxi ve srovnání s příkazem switch.

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

Porovnáme naši proměnnou se sadou možností, a když proměnná, kterou porovnáváme, splňuje kritéria, vyhodnotí se výraz na pravé straně tlusté šipky (=>) a vrátí se jako výsledek shody.

K zachycení případů, které v našem kódu nemají obdoby, používáme podtržítko. Odráží chování výchozího případu při práci s příkazy 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
}

Ve výše uvedeném kódu jste schopni zjistit typ proměnné myItem a na základě toho se rozvětvit na nějaký konkrétní kód.

Porovnávání vzorů kontroluje, zda se proměnná shoduje

Podtržítko funguje jako zástupný symbol, který odpovídá jakékoli jiné podmínce, která neodpovídá ostatním položkám ve výše uvedených případech. Vezmeme proměnnou myItem a zavoláme metodu match.

• zkontrolujeme, zda je myItem pravdivé pomocí a uděláme nějakou logiku na pravé straně tlusté šipky "=>."
• používáme podtržítko, abychom odpovídali čemukoli, co se neshoduje s žádným z výrazů případu, které jsme definovali v kódu.

S třídami Case můžeme jít ještě dále a destruovat třídu, abychom dostali pole uvnitř objektu.

Použitím klíčového slova sealed k definování našich tříd získáme výhodu, že kompilátor důkladně zkontroluje případy, se kterými se snažíme porovnat, a varuje nás, pokud zapomeneme zpracovat konkrétní.

Nezměnitelnost

Je možné vytvořit hodnoty, které nelze změnit jinými funkcemi ve Scale pomocí klíčového slova val. Toho je dosaženo v Java pomocí posledního klíčového slova. Ve Scale to děláme tak, že při vytváření proměnné použijeme klíčové slovo val namísto použití var, což je alternativa, kterou bychom použili k vytvoření proměnné proměnné.

Proměnná definovaná pomocí klíčového slova val je pouze pro čtení, zatímco proměnná definovaná pomocí var lze číst a měnit jinými funkcemi nebo libovolně uživatelem v kódu.

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

Pokus o přiřazení hodnoty k myNumber poté, co jsme jej deklarovali jako val, způsobí chybu při kompilaci nebo „přeřazení na val“.

Proč používat Immutability?

Neměnnost nám pomáhá předcházet tomu, aby kód a další programátoři nečekaně měnili naše hodnoty, což by vedlo k neočekávaným výsledkům, pokud jsou zamýšleni k použití hodnoty, kterou ukládáme, mohou místo toho vytvořit její kopii. Tímto způsobem je zabráněno chybám, které mohou být způsobeny více aktéry měnícími stejnou proměnnou.

Třídy a objekty

Všichni víme, že objekty jsou entity reálného světa a třída je šablona, ​​která objekty definuje. Třídy mají jak stav, tak chování. Stavy jsou buď hodnoty, nebo proměnné. Chování jsou metody ve Scale.

Pojďme se podívat na to, jak můžete definovat třídu, instanciovat ji a používat ji pomocí Scala.

Zde je třída nazvaná Rectangle, která má dvě proměnné a dvě funkce. Parametry l a b můžete také použít přímo jako pole v programu. Máte objekt, který má hlavní metodu a vytvořil instanci třídy se dvěma hodnotami.

Příklad:

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

Všechna pole a metoda jsou ve Scale standardně veřejné. Je nezbytné použít přepsání, protože metoda toString je definována pro Object v Scala.

Dědictví

Scala má několik typů dědičnosti (jako je jednoduchá, víceúrovňová, vícenásobná, hierarchická, hybridní), které sdílejí mnoho společného s tradičními formami nalezenými v Java. Můžete dědit po třídách i vlastnostech. Členy jedné třídy můžete zdědit do jiné třídy pomocí klíčového slova „extends“. To umožňuje opětovné použití.

Je možné dědit z jedné třídy nebo z více tříd. Je také možné dědit z podtříd, které samy mají své nadtřídy, čímž se v procesu vytvoří hierarchie dědičnosti.

V níže uvedeném příkladu Scala je základní třída Circle a odvozená třída je Sphere. Kruh má hodnotu zvanou poloměr, která se dědí ve třídě Sphere. Metoda calcArea je přepsána pomocí klíčového slova override.

Příklad:

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

Abstrakce

Ve Scale můžeme vytvářet abstraktní metody a členská pole pomocí abstraktních tříd a vlastností. Uvnitř abstraktních tříd a vlastností můžeme definovat abstraktní pole, aniž bychom je nutně implementovali.

Příklad:

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

Tato pole jsou implementována třídami, které rozšiřují třídu vlastností nebo abstraktní třídu. Pomocí vlastností můžete vytvářet smlouvy o tom, co by naše aplikace měla umět, a tyto metody pak implementovat později.

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

Tímto způsobem můžeme naplánovat, jak bude naše aplikace vypadat, aniž bychom implementovali metody, které nám pomohou představit si, jak budou různé metody vypadat. Postupuje podle vzoru známého jako programování až po abstrakci, a nikoli skutečnou implementaci.

Třída, které předchází klíčové slovo abstrakt, může obsahovat jak abstraktní, tak neabstraktní metody. Vícenásobná dědičnost však není v abstraktní třídě podporována. Můžete tedy rozšířit maximálně jednu abstraktní třídu.

Singletonové objekty

Singleton je třída, která je v programu vytvořena pouze jednou. Je to z populárního a užitečného programovacího vzoru známého jako „singleton pattern“. Je užitečný při vytváření instancí, které mají být dlouhotrvající a budou běžně přístupné v celém vašem programu, jehož stav je nedílnou součástí koordinace událostí systému. Vytvoření takové třídy ve Scale je snadné, protože Scala nám poskytuje jednoduché prostředky k vytváření singletonů pomocí klíčového slova object.

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

Na tento objekt pak můžeme odkazovat v celém našem programu se zárukou, že všechny části našeho programu uvidí stejná data, protože existuje pouze jedna jeho instance.

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

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

Koncept statických členů ve Scale není, proto musíte použít singletonové objekty, které se chovají jako statické členy třídy.

Implicitní třídy

Implicitní třídy jsou nové funkce přidané po verzi 2.1. Jde především o přidání nových funkcí do uzavřených tříd.

Implicitní klíčové slovo by mělo být definováno ve třídě, objektu nebo vlastnosti. Primární konstruktor implicitní třídy by měl mít ve svém prvním seznamu parametrů přesně jeden argument. Může také obsahovat další implicitní seznam parametrů.

V níže uvedeném příkladu Scala je přidána nová funkce pro nahrazení samohlásek řetězce *.

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

Musíte importovat do třídy, kde jej používáte.

import StringUtil.StringEnhancer

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

Objektově orientované programování (OOP) vs. Funkční programování (FP)

V OOP jsou programy konstruovány seskupením dat a funkcí, které s těmito daty pracují, do vysoce propojených jednotek. Objekty nesou svá data v polích a metodách, které na nich působí. V tomto stylu programování jsou hlavní abstrakcí data, protože metody, které jsou vytvořeny, mají pracovat s daty.

Funkcionální programování, na druhé straně odděluje data a funkce, které s daty pracují. To umožňuje vývojářům považovat funkce za abstrakci a hnací sílu při modelování programů.

Scala umožňuje funkční programování tím, že má funkce jako prvotřídní občané, umožňuje je předávat jako hodnoty jiným funkcím a také je vracet jako hodnoty. Díky kombinaci těchto dvou paradigmat je Scala skvělou volbou při vytváření komplexního softwaru v různých odvětvích, jako je Data Science.

Důležité rámce na Scale

Zde jsou některé důležité rámce Scala

• Hrát je open-source webový aplikační rámec, který používá architektura MVC. Vydáno v roce 2007 a nyní licencováno pod Apache, stalo se nejoblíbenějším frameworkem na GitHubu v roce 2013. Společnosti jako LinkedIn, Walmart, Samsung, Eero tento framework používají.
• Výtah je další bezplatný webový rámec napsaný ve Scale spuštěný v roce 2007. Foursquare používá rámec Lift. Je vysoce výkonný, rychleji se staví framework.
• Tak jako
• Kočky
• Spark

Podpora souběžnosti

• Hodnoty v Scala jsou ve výchozím nastavení neměnné. Díky tomu se velmi přizpůsobí souběžnému prostředí.
• Scala má mnoho funkcí, díky kterým je nejlepší pro souběžné aplikace.
• Futures and Promises usnadňují zpracování dat asynchronně, čímž podporují paralelismus.
• Akka – sada nástrojů, která využívá model souběžnosti Actor. Existuje řada herců, kteří jednají, když dostávají zprávy.
• Souběžnost pomocí vláken z Java může být také podporována v Scala.
• Zpracování datových proudů je další skvělá funkce, která umožňuje kontinuální zpracování dat v reálném čase.

Scala má některé z nejlepších souběžných knihoven v Java Ekosystému.

• Domácí Java nitě
• Vlákna z knihoven jako Vertex
• ZIO – knihovna, která má primitiva, která nám pomáhají vypořádat se se souběžným a asynchronním výpočtem
• STM – Transaction
• Budoucnost – vestavěná v jazyce Scala

Java vs. Scala

Zde jsou hlavní rozdíl mezi Java a Scala.

Scala	Java
Kompaktnější a stručnější	Poměrně větší kusy kódu
Navržen a vyvinut tak, aby byl objektově i funkcionálně orientovaný jazyk. Podporuje širokou škálu funkčních programovacích funkcí, jako je souběžnost, neměnnost.	Původně vyvinutý jako objektově orientovaný jazyk a v posledních dnech začal podporovat funkce funkčního programování. Stále není silný jako funkční programovací jazyk.
Používá model aktéra pro podporu souběžnosti, což je moderní	Používá konvenční model založený na vláknech pro souběžnost.
Podporuje frameworky – Play, Lift	Podporuje jaro, grály, mnohem více
Podporuje líné hodnocení	Nepodporuje líné hodnocení
Žádné statické členy	Obsahuje statické členy
Podporuje přetížení operátora	Nepodporuje přetížení operátora
Kompilace zdrojového kódu je poměrně pomalá	Kompilace zdrojového kódu je rychlejší než Scala
Vlastnosti – chovejte se jako Java 8 rozhraní	Java 8 rozhraní se snaží překlenout mezeru mezi třídami a rozhraními
Je potřeba přepisování	Přepisování není nutné
Žádná záruka ohledně kódů bez chyb	Kompletní zajištění menších vad
Podporuje zpětnou kompatibilitu.	Scala nepodporuje zpětnou kompatibilitu.
Operas tory se zachází odlišně v Java a nejsou volání metod.	Všechny operátory na položkách jsou pomocí metody volané v Scala.
Podporuje vícenásobnou dědičnost pomocí tříd, ale ne pomocí abstraktních tříd	Nepodporuje vícenásobnou dědičnost pomocí tříd, ale podle rozhraní
Kód je napsán v kompaktní formě.	Kód je napsán v dlouhém tvaru.
Scala neobsahuje klíčové slovo static.	Java obsahuje klíčové slovo static.

Shrnutí

V tomto tutoriálu jste se naučili, jak začít se Scalou. Naučili jste se také funkční a objektově orientované funkce. Také jste objevili podobnosti a rozdíly mezi nimi Java a Scala. Tento tutoriál vám měl pomoci se širokou škálou příkladů, které jsou dobře demonstrovány.