A Scala programozási nyelv 2016. október 13-14. Szováta A Scala programozási nyelv IV. Székelyföldi IT&C és Innovációs Konferencia

Ki vagyok? Kolcza Győző Senior Java és Scala fejlesztő a Mortoff Kft-nél kolczagy2 gy.kolcza@mortoff.hu

Miről lesz szó? Funkcionális nyelvek Scala mint funkcionális nyelv Magasabb rendű függvények Névtelen függvények Mintaillesztés Osztályok és objektumok Case osztályok Traits

A programozási nyelvek osztályozása Imperatív Eljárásorientált nyelvek (Neumann elvű nyelvek pl. C, Pascal) Objektumorientált nyelvek (C++, Java, Scala) Deklaratív Funkcionális nyelvek (Scala, SML) Logikai nyelvek (Prolog)

A programozási nyelvek osztályozása Típusos (Java, Scala) Gyengén típusos (Php, Javascript) Imperatív

Deklaratív programozási stílus Nem hogyan, hanem mit

Deklaratív programozási stílus Imperativ int fact(int n){ int f=1; while(n>1) f*=n--; return f; }

Deklaratív programozási stílus FP fact 0=1 fact n=n*fact n-1 Imperativ int fact(int n){ int f=1; while(n>1) f*=n--; return f; }

Funkcionális nyelv jellemzői Minden entitás függvény érték Nincs változó Nincs állapot Nincs memóriacímzés A program egy függvény Függvények tiszták, nincsenek mellékhatásaik

Funkcionális nyelv jellemzői Funkcionális nyelven írt programok rendkívül megbízhatóak (pl. a párizsi metró irányító rendszer)

Mi a Scala? Java nyelv jövője Teljesen objektum orientált Funkcionális nyelv Típusos Tömör JVM-en fut Egyszerre használható Scala és Java ugyanabban a projektben

Mi a Scala? 2001 - be kezdték el fejleszteni Az első releaset 2004-ben jelent meg Java és .NET platformon (Scala 1.0) A második releaset 2006-ba adták ki (Scala 2.0) 2012 - be a .NET support teljesen megszűnt Jelenlegi verzió Scala 2.11.8

Scalaban írt rendszerek Twitter LinkedIn Netflix Sony

Környezet telepítése JDK Scala IDE (Eclipse, IntelliJ, Netbeans) SBT (Scala Build Tool)

Minden objektum Ellentétben a Java-val, Scalaba minden objektum

Minden objektum Példa: 1 + 2 * 3 / x A fenti kifejezés függvényhívásokból áll, mely ekvivalens az alábbi kifejezéssel: (1).+(((2).*(3))./(x))

Operátorok definiálása Scala nem definiál kifejezett operátorokat Az operátorok felülírhatók

Operátorok definiálása Komplex számok összeadása class Complex(val re: Double, val im: Double) { def + (that: Complex) = new Complex(re + that.re, im + that.im) def - (that: Complex) = new Complex(re - that.re, im - that.im) override def toString = re + (if (im < 0) "-" + (-im) else "+" + im) + "*i„ } val x = new Complex(2, 1); var y = new Complex(1, 3) println(x + y); // 3.0+4.0*i

Magasabb rendű függvények másik függvényt kapnak paraméterül egy függvényt adnak vissza

Magasabb rendű függvények def sum(f: Int => Int, a: Int, b: Int) : Int = if (a > b) 0 else f(a) + sum(f, a + 1, b) def square(x: Int): Int = x * x sum(square, 2, 3)

Névtelen függvények Square függvényt csak egyvalamire használtuk, hogy paramétere legyen a sumnak Névtelen függvények, azaz a lambda kifejezések

Névtelen függvények def sumInts(a: Int, b: Int): Int = sum(x => x, a, b) def sumSquares(a: Int, b: Int): Int = sum(x => x * x, a, b)

Osztályok és objektumok class Point(xc: Int, yc: Int) { var x: Int = xc var y: Int = yc def move(dx: Int, dy: Int) { x = x + dx y = y + dy } override def toString(): String = "(" + x + ", " + y + ")"; val pt = new Point(1,2)

Osztályok és objektumok object Point extends App { var x: Int = 0; var y: Int = 0; def setXY(xp: Int, yp: Int) { x = xp; y = yp; } …...... Névtelen osztály Singleton Implicit jönnek létre

Osztályok és objektumok

Mintalillesztes Hasonló mint a switch-case Bármilyen típusú adatra használható Első találat szabály él

Mintalillesztes def matchTest(x: Any): Any = x match { case 1 => "one" case "two" => 2 case y: Int => "scala Int" case List(0, _*) => "list" case _ => "no matching" } println(matchTest("two"))

Case osztályok Olyan mint Java-ba a POJO Explicit léteznek Előnye, hogy minta illeszthetünk rajta

Case osztályok abstract class Tree case class Fork(left: Tree, right: Tree, weight: Int) extends Tree case class Leaf() extends Tree

Case osztályok def weight(tree: Tree): Int = { tree match { case Fork(_,_,w) => w case Leaf() => 0 } }

Traits //Hasonló a Java interfacehez trait Language { val name:String //De tartalmazhat implementációt is override def toString = name }

Traits trait A { override def toString = "A vagyok" } trait B { override def toString = "B vagyok" } trait C { override def toString = "C vagyok" }

Traits class Foo extends A with C with B{ } object Main extends App { val f = new Foo println(f.toString()) }

Példa def countChange(money: Int, coins: List[Int]):Int ={ if(money == 0) 1 else if(money > 0 && !coins.isEmpty) countChange(money - coins.head, coins) + countChange(money, coins.tail) else 0 }

Irodalomjegyzék http://www.scala-lang.org/ http://www.scala-lang.org/docu/files/ScalaByExample.pdf https://www.coursera.org/learn/progfun1 http://nyelvek.inf.elte.hu/leirasok/Scala/index.php

Q&A

Köszönöm a figyelmet!