Підручник Scala
⚡ Розумний підсумок
У посібнику зі Scala представлена статично типізована мова програмування на основі JVM, яка поєднує об'єктно-орієнтоване та функціональне програмування. Посібник охоплює встановлення, синтаксис, основні функції та фреймворки, що роблять Scala ідеальною для створення паралельних, масштабованих та лаконічних сучасних застосунків.

Що таке Scala?
масштаб — це статично типізована мова програмування, яка поєднує об'єктно-орієнтоване та функціональне програмування для покращення масштабованості застосунків. Scala працює переважно на платформі JVM, і розробники також можуть використовувати її для написання програмного забезпечення для нативних платформ через Scala-Native або для браузера через ScalaJs та... JavaScript час виконання.
Scala — це масштабована мова програмування, яка використовується для створення програмного забезпечення для різних платформ, саме тому вона й отримала свою назву. Мова була розроблена для вирішення кількох проблем із багатослівністю, що виникають у Java залишаючись лаконічним. Мартін Одерскі розробив Scala, а перший публічний реліз з'явився у 2004 році.
Навіщо вивчати Scala
Ось основні причини для вивчення мови програмування Scala:
- Scala легко вивчається об'єктно-орієнтованими програмістами та Java розробників, і вона стала однією з популярних мов за останні роки.
- Scala пропонує користувачам першокласні функції.
- Scala може бути виконана на JVM, що відкриває шлях для сумісності з іншими мовами.
- Він розроблений для паралельних, розподілених та стійких додатків, що працюють на основі повідомлень, що робить його однією з найбільш затребуваних мов цього десятиліття.
- Це лаконічна, потужна мова, яка може швидко розвиватися відповідно до потреб своїх користувачів.
- Він об'єктно-орієнтований і включає багато функцій функціонального програмування, що надає розробникам значну гнучкість у написанні коду.
- Scala пропонує Duck Typing через структурні типи.
- Він має менше шаблонних шаблонів, ніж Java.
- Фреймворки Lift та Play, написані на Scala, продовжують розвиватися та набирати популярності.
Як встановити Scala
Щоб почати писати програми на Scala, вам потрібно встановити його на вашому комп'ютері. Для цього відвідайте офіційний сайт за адресою https://www.scala-lang.org/download/ щоб завантажити останню версію Scala.
Перейшовши за посиланням, вам буде запропоновано два варіанти встановлення Scala. У цьому посібнику зі Scala ми використовуватимемо IntelliJ IDEA, що забезпечує чудову підтримку Scala одразу після встановлення.
Після переходу за посиланням для завантаження ви знайдете дві версії IntelliJ IDE.
Для цього посібника зі Scala ми завантажимо Community Edition, яка є безкоштовною та містить усе необхідне для написання програм Scala.
Крок 1) Виберіть «Видання для спільноти».
На сторінці натисніть спадне меню «Версія для спільноти».
Він пропонує можливість завантажити IntelliJ IDE разом з JBR, який містить реалізацію JDK (Java Комплект розробки), такий як OpenJDK, який Scala потребує для компіляції та запуску коду.
Крок 2) Запустіть інсталяцію.
Після завантаження IntelliJ двічі клацніть інсталятор і дотримуйтесь інструкцій на екрані майстра.
Крок 3) Виберіть місцезнаходження.
Виберіть місце для встановлення IDE.
Якщо ви не завантажили пакет разом з JDK, інсталятор все одно запропонує вам додати JDK за допомогою прапорця під час налаштування.
Крок 4) Натисніть кнопку Далі.
Залиште інші значення за замовчуванням як є, та натисніть кнопку «Далі».
Програма Scala Hello World
Крок 5) Натисніть значок запуску.
Після завершення встановлення запустіть середовище розробки IntelliJ IDE, клацнувши його значок запуску в меню «Пуск», як звичайну програму.
Вам все ще потрібно додати плагін Scala до IntelliJ. Клацніть випадаюче меню в меню налаштування в правому нижньому куті екрана та виберіть опцію Плагіни.
На вкладці «Маркетплейс» знайдіть Scala. Плагін відображається як перший результат під тегом «Мови».
Крок 6) Встановіть плагін.
Натисніть кнопку «Встановити», щоб розпочати завантаження плагіна Scala.
Крок 7) Перезапустіть середовище розробки (IDE).
Після завершення завантаження вам буде запропоновано перезапустити IDE, щоб встановлений плагін міг почати працювати.
Після перезапуску ви повернетеся на ту саму сторінку, що й раніше, але тепер плагін Scala встановлено та готовий до роботи.
Крок 8) Виберіть «Створити проєкт», що переведе на сторінку, де можна вибрати мову для проєкту.
Крок 9) Виберіть Scala, встановивши прапорець Scala, і натисніть кнопку Далі.
Крок 10) Виберіть місце для збереження файлу проєкту та дайте проєкту назву.
Якщо каталог не існує, IntelliJ запитує дозвіл на створення папки. Погодьтеся та натисніть кнопку «Готово». Після цього ви перейдете до свого проекту Scala, який наразі не містить жодного коду Scala.
Завантаження індексів займає деякий час, тому не хвилюйтеся, якщо ви не можете взаємодіяти з IDE, поки внизу відображається індикатор виконання. IDE завантажує файли, необхідні для роботи Scala та забезпечення автодоповнення.
Крок 11) Клацніть вкладку «Проект» ліворуч від IDE та розгорніть її, щоб побачити вміст проекту.
На цьому етапі проєкт порожній і містить лише папку .idea та файл hello-world.iml, згенерований IDE. Цікавою є папка src, яка містить вихідний код проєкту. Тут ви створюєте свій перший файл Scala.
Крок 12) Клацніть правою кнопкою миші на src, щоб відкрити меню та створити новий файл Scala.
Виберіть назву для файлу. Для цього посібника зі Scala використовуйте привіт, а потім виберіть Об’єкт зі спадного списку для типу вмісту файлу Scala.
Після цього у вас буде файл Scala, який містить об'єкт-синглтон, який ви використовуватимете для запуску коду.
Тепер, коли у вас є файл Scala з об'єктом Hello, напишіть свою першу програму, розширивши створений вами об'єкт за допомогою ключового слова App.
Розширення об'єкта за допомогою App вказує компілятору, який код виконувати під час запуску програми. Відразу після розширення App ліворуч з'являється зелена стрілка, яка вказує на те, що програма тепер придатна для виконання.
Всередині об'єкта Hello напишіть функцію println() для виведення тексту в консоль. Запустіть програму, натиснувши зелену стрілку.
Клацання стрілки відкриває опцію «Виконати Hello». Її вибір компілює код, і через кілька секунд вивід програми з'являється в консолі IntelliJ.
Ви успішно встановили Scala та запустили свою першу програму.
Що ви можете зробити зі Scala
Scala широко використовується в багатьох сферах завдяки своїй гнучкості та сумісності з JVM. Загальні випадки використання включають:
- Розробка фронтенд-сайтів на ScalaJS.
- Мобільна розробка для Android та iOS зі Scala Native.
- Серверні бібліотеки, такі як HTTP4S, Akka-Http та Play Framework.
- Програми Інтернету речей (IoT).
- Розробка гри.
- Обробка природної мови з використанням набору бібліотек ScalaNLP.
- Спільне використання передових методів, таких як функціональне програмування та об'єктно-орієнтоване програмування.
- Високопаралельні комунікаційні програми, що використовують актори, бібліотеку для JVM, натхненну Erlang.
- Машинне навчання з бібліотеками, такими як Figaro для ймовірнісного програмування та Apache Spark для обробки великомасштабних даних.
Анонімні функції
Мова Scala підтримує анонімні функції, які також називаються функціональні літералиОскільки Scala є функціональною мовою, розробники часто розбивають великі проблеми на безліч дрібних завдань і створюють безліч функцій. Щоб це було легко, Scala дозволяє створювати функції. екземпляр без іменіВи можете призначити їх безпосередньо змінним або визначенням за допомогою def, як показано в наступному прикладі Scala:
val multiplyByTwo = (n:Int) => n * 2 def multiplyByThree = (n:Int) => n * 3
Потім ви можете використовувати їх як звичайні функції, передаючи параметри:
multiplyByTwo(3) //6 multiplyByThree(4) //12
Ці методи стають у пригоді, коли вам потрібен чистий та лаконічний код. Анонімні функції корисні для визначення невеликих методів, які не потребують багато коду в своєму тілі. Вони дуже прості та не потребують жодних церемоній для створення.
Ці методи не обмежуються функціями з аргументами та можуть бути використані для створення екземплярів методів, які не приймають аргументів.
val sayHello = () => { println("hello") }
Більшість цих анонімних функцій використовуються в інших частинах коду, де потрібна швидка функція. З цієї причини їх також називають вбудовані функціїВикористання анонімних функцій – це поширений шаблон, який зустрічається в бібліотеці колекцій для виконання швидких дій над колекцією.
Наприклад, метод filter приймає вбудовану функцію для створення іншої колекції лише з елементами, що відповідають критеріям, визначеним в анонімній функції.
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)
Тут анонімні функції перевіряють, чи є значення зі списку парним чи непарним, і повертають відповідний елемент.
//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
У Scala також можна використовувати шаблони підстановки там, де параметр анонімної функції не вказано. Наприклад:
var timesTwo = (_:Int) * 2 timesTwo(5) //10
У цьому сценарії ви не називаєте параметр. Для його представлення використовується символ підкреслення.
Ледача оцінка
Більшість мов послідовно обчислюють змінні та параметри функцій, один за одним. У Scala ключове слово lazy допомагає працювати зі значеннями, які не потрібно оцінювати, доки на них не буде посилання.
Змінна, позначена як lazy, не обчислюється там, де вона визначена, що зазвичай відоме як нетерпляча обчислення. Вона обчислюється лише тоді, коли на неї посилаються пізніше в коді.
Це може бути корисним, коли обчислення значення є дорогим. Якщо значення не завжди потрібне, ви позбавляєте себе необхідності виконувати дороге обчислення, яке може уповільнити роботу програми, зробивши змінну лінивою.
lazy val myExpensiveValue = expensiveComputation def runMethod() = { if(settings == true) { use(myExpensiveValue) } else { use(otherValue) } }
Це не єдиний випадок використання лінивих змінних. Вони також допомагають впоратися з циклічними залежностями в коді.
Якщо прапорець налаштувань має значення «false», вам не потрібно використовувати myExpensiveValue, що позбавляє вас від витратних обчислень. Це допомагає забезпечити безперебійну роботу користувачів, оскільки ресурси не витрачаються на значення, які ніколи не зчитуються.
Лінь також допомагає з аргументами функцій, де аргументи використовуються лише тоді, коли на них посилаються всередині функції. Ця концепція називається параметрами виклику за іменем.
def sometimesUsedString(someValue:String, defaultValue: => String) = { if(someValue != null) { use(defaultValue) } else { use(someValue) } }
Багато мов програмування використовують підхід виклику за значенням для оцінки аргументів. Параметр, переданий через виклик за іменем, оцінюється лише тоді, коли це потрібно всередині тіла функції. Після оцінки значення воно зберігається та може бути використане повторно пізніше без повторної оцінки, ця концепція відома як мемоізація.
Типовий висновок
У Scala вам не потрібно оголошувати типи для кожної змінної, яку ви створюєте, оскільки компілятор Scala може виводити типи з правої частини виразу. Це дозволяє вашому коду бути більш лаконічним і звільняє вас від написання шаблонного коду, де очікуваний тип очевидний.
var first:String = "Hello, " var second:String = "World" var third = first + second //the compiler infers that third is of type String
Функція вищого порядку
Функція вищого порядку — це функція, яка може приймати функції як аргументи та повертати функцію як тип, що повертається. У Scala функції вважаються повноцінними. Використання функцій таким чином дозволяє вам бути дуже гнучкими у типах програм, які ви можете створювати. Ви можете створювати функції динамічно та динамічно передавати функціональність іншим функціям.
def doMathToInt(n:Int, myMathFunction:Int=>Int): Int = { myMathFunction(n) }
У наведеній вище функції ви передаєте Int і функція, яка приймає Int і повертає IntВи можете передати будь-яку функцію з цим підписом. Під підписом ми маємо на увазі вхідні та вихідні дані функції. Підпис Int => Int означає, що функція приймає ціле число (Int) на вхід і повертає ціле число (Int) на вихід.
Підпис () => Int означає, що функція нічого не приймає на вхідні дані та повертає ціле число на вихід. Прикладом такої функції є функція, яка генерує випадкове ціле число.
def generateRandomInt() = { return scala.util.Random.nextInt() }
Вищевказана функція має сигнатуру () => Int.
Функція також може мати сигнатуру () => UnitЦе означає, що функція нічого не приймає та не повертає тип. Натомість функція може змінити певний стан або виконати заздалегідь визначену дію.
Такі методи не рекомендуються, оскільки вони можуть діяти як чорна скринька, яка впливає на систему невідомим чином. Їх також важче тестувати. Наявність чітких типів вхідних і вихідних даних дозволяє вам міркувати про те, що робить ваша функція.
Функція вищого порядку також може повертати функцію. Наприклад, ви можете створити метод, який повертає функцію піднесення до степеня, тобто таку, що приймає число та застосовує до нього степінь.
def powerByFunction(n:Int): Int=>Int = { return (x:Int) => scala.math.pow(x,n).toInt }
Функція вище приймає ціле число. Тип повернення – це анонімна функція, яка приймає ціле число. x і використовує його як аргумент для степеневої функції.
Заготівля
У Scala ви можете перетворити функцію, яка приймає два аргументи, на одну, яка приймає один аргумент за раз. Коли ви передаєте один аргумент, ви частково застосовуєте його та отримуєте функцію, яка приймає решту аргументу для завершення виклику. Каррування дозволяє створювати функції, частково додаючи деякі аргументи.
Це корисно для динамічного створення функцій, перш ніж у вас буде повний набір аргументів.
def multiplyTwoNumbers(n:Int)(m:Int): Int = { return n * m }
Якщо вам потрібна функція, яка множить на певне число, вам не потрібно створювати ще один метод множення. Ви можете застосувати один аргумент до каррірованої функції та повторно використати результат:
def multiplyTwoNumbers(n:Int)(m:Int): Int = { return n * m } var multiplyByFive = multiplyTwoNumbers(5) _ multiplyByFive(4) //returns 20
Збірка візерунків
Scala має потужний вбудований механізм, який допомагає перевірити, чи відповідає змінна певним критеріям, подібно до оператора switch у Java або ланцюжок операторів if/else. Мова підтримує зіставлення зі зразком, яке можна використовувати для перевірки, чи належить змінна до певного типу. Зіставлення зі зразком у Scala є потужним інструментом і може деструктуризувати компоненти, які мають unapply метод для отримання потрібних вам полів безпосередньо зі змінної, що зіставляється.
Зіставлення зі зразком Scala також забезпечує приємніший синтаксис, ніж оператор switch.
myItem match { case true => //do something case false => //do something else case _ => //if none of the above do this by default }
Ви порівнюєте змінну з набором опцій. Коли змінна відповідає критеріям, вираз праворуч від жирної стрілки (=>) обчислюється та повертає значення як результат збігу.
Підкреслення перехоплює випадки, які не збігаються в коді, відображаючи поведінку випадку за замовчуванням в операторі 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 _ => //unknown type, do something else }
У наведеному вище коді ви можете визначити тип myItem змінну та, виходячи з цього, перейти до конкретного коду.
Зіставлення зі зразком перевіряє, чи відповідає змінна кожному випадку по порядку.
Підкреслення працює як заповнювач, який відповідає будь-якій умові, якій не відповідають інші оператори case. Ви берете змінну myItem і зателефонуйте match метод.
- Перевірте, чи
myItemistrueта запустіть логіку праворуч від жирної стрілки “=>”. - Використовуйте символ підкреслення для зіставлення будь-чого, що не відповідає жодному з операторів case, визначених у коді.
За допомогою класів case ви можете деструктуризувати клас до extract полів всередині об'єкта.
Використовуючи sealed ключове слово для визначення класів, ви отримуєте перевагу в тому, що компілятор вичерпно перевіряє випадки, які ви намагаєтеся зіставити, і попереджає вас, якщо ви забудете обробити один із них.
Незмінюваність
У Scala можна створювати значення, які не можуть бути змінені іншими функціями, використовуючи val ключове слово. Це досягається в Java за допомогою final ключове слово. У Scala ви використовуєте val під час створення змінної замість var, що є альтернативою для змінних, що змінюються.
Змінна, визначена за допомогою val ключове слово доступне лише для читання, тоді як ключове слово, визначене за допомогою var можуть бути прочитані та змінені пізніше іншими функціями або користувачем у коді.
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
Спроба присвоїти значення myNumber після оголошення його як val викидає помилку під час компіляції: «перепризначення значення».
Навіщо використовувати незмінність?
Незмінність допомагає запобігти непередбачуваній зміні значень кодом та іншими програмістами, що може призвести до непередбачуваних результатів. Якщо споживачам значення потрібно його змінити, вони можуть натомість зробити копію. Таким чином, запобігається помилкам, спричиненим зміною однієї й тієї ж змінної кількома учасниками.
Класи та об'єкти
Об'єкти – це сутності реального світу, а клас – це шаблон, який визначає об'єкти. Класи мають як стан, так і поведінку. Станами є або значення, або змінні. Поведінкою в Scala є методи.
У наступному розділі показано, як визначити клас, створити його екземпляр та використовувати його в Scala.
Ось клас під назвою Rectangle, який має два значення та дві функції. Ви також можете використовувати параметри l та b безпосередньо як поля в програмі. У вас є об'єкт, який має метод main та створює екземпляр класу з двома значеннями.
приклад:
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) } }
Усі поля та методи в Scala за замовчуванням є публічними. Важливо використовувати override оскільки toString вже визначено для кожного об'єкта в Scala.
Спадкування
Scala має кілька типів успадкування (одинарне, багаторівневе, множинне, ієрархічне та гібридне), які мають багато спільного з традиційними формами, що зустрічаються в JavaВи можете успадковувати як від класів, так і від рис. Ви успадковуєте членів одного класу в інший за допомогою ключового слова extendsЦе забезпечує можливість повторного використання.
Можна успадковувати від одного класу або кількох класів. Також можливо успадковувати від підкласів, які самі мають власні суперкласи, створюючи при цьому ієрархію успадкування.
У наведеному нижче прикладі Scala базовим класом є Circle, а похідний клас — SphereКоло має значення, яке називається радіусом, що успадковується в класі Sphere. Метод calcArea перевизначається ключовим словом override.
приклад:
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ції
У Scala ви можете створювати пресtract-методи та поля-члени з використанням abstract-класи та риси. Внутрішній пресtract класи та риси, ви можете визначити абсtract полів без їх реалізації.
приклад:
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" } }
Ці поля реалізуються класами, що розширюють трейт або абс.tract-клас. Ви можете використовувати риси для створення конtracts для того, що має робити програма, а потім реалізувати ці методи пізніше.
trait DatabaseService { def addItemName(itemName:String) def removeItem(itemId:Int) def updateItem(itemId:Int, newItemName:String) }
Таким чином, ви можете спланувати, як виглядатиме застосунок, не реалізуючи методи, helping ви уявляєте, як виглядатимуть різні методи. Це відповідає схемі, відомій як програмування м'язів пресуtracцій, а не до фактичного впровадження.
Клас, що передує abstract Ключове слово може містити обидва абсtracт та не абсtract методи. Однак, множинне успадкування не підтримується в abstract заняття, тому ви можете розтягувати лише один пресtracт-клас.
Об'єкти Singleton
Синглтон – це клас, екземпляр якого створюється лише один раз у програмі. Він походить від популярного та корисного шаблону програмування, відомого як «шаблон синглтона». Він корисний для створення екземплярів, які призначені для тривалого існування та загального доступу протягом усієї програми, де стан є невід'ємною частиною координації подій у системі. Створення такого класу в Scala просте, оскільки Scala надає простий спосіб створення синглтонів за допомогою… object keyword.
object UserProfile { var userName = "" var isLoggedIn:Boolean = false }
Потім ви можете посилатися на цей об'єкт протягом усієї програми з гарантією того, що всі частини програми бачать одні й ті самі дані, оскільки існує лише один його екземпляр.
def getLoggedInStatus():Boolean = { return UserProfile.isLoggedIn } def changeLoggedInStatus():Boolean = { UserProfile.isLoggedIn = !UserProfile.isLoggedIn return UserProfile.isLoggedIn }
Концепція статичних членів у Scala відсутня, тому ви використовуєте об'єкти-синглтони, які діють як статичні члени класу.
Неявні класи
Неявні класи – це функція, додана у версії 2.10, і вони використовуються переважно для додавання нової функціональності до існуючих закритих класів.
Команда implicit Ключове слово має бути визначено в класі, об'єкті або трейті. Первинний конструктор неявного класу повинен мати рівно один аргумент у своєму першому списку параметрів. Він також може включати додатковий неявний список параметрів.
У наведеному нижче прикладі Scala додано нову функціональність для заміни голосних у рядку на *.
object StringUtil { implicit class StringEnhancer(str: String) { def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*") } }
Вам потрібно імпортувати неявний клас у клас, де ви його використовуєте.
import StringUtil.StringEnhancer object ImplicitEx extends App { val msg = "This is Guru99!" println(msg.replaceVowelWithStar) }
Об'єктно-орієнтоване програмування (ООП) проти функціонального програмування (ФП)
В ООП програми створюються груповим методом.ping дані та функції, що працюють з цими даними, у тісно пов'язані одиниці. Об'єкти несуть свої дані в полях, а методи працюють з ними. У цьому стилі програмування основні абсtracцією є дані, оскільки створені методи призначені для роботи з даними.
Функціональне програмування, з іншого боку, розділяє дані та функції, які з ними працюють. Це дозволяє розробникам розглядати функції як абсtracція та рушійна сила під час моделювання програм.
Scala дозволяє функціональне програмування, розглядаючи функції як повноцінних користувачів, дозволяючи передавати їх як значення іншим функціям та повертати їх також як значення. Поєднання цих двох парадигм зробило Scala чудовим вибором для створення складного програмного забезпечення в таких галузях, як наука про дані.
Важливі фреймворки на Scala
Ось деякі важливі фреймворки для Scala:
- Play це фреймворк веб-програми з відкритим кодом, який використовує Архітектура MVCВипущений у 2007 році та тепер ліцензований під Apache, він став одним із найпопулярніших фреймворків на GitHub до 2013 року. Такі компанії, як LinkedIn, Walmart, Samsung та Eero використовують цей фреймворк.
- ліфт — це ще один безкоштовний веб-фреймворк, написаний на Scala, запущений у 2007 році. Foursquare використовує фреймворк Lift. Це високопродуктивний фреймворк, за допомогою якого швидко створювати.
- Акка надає інструментарій для створення високопаралельних, розподілених та стійких програм, керованих повідомленнями, на JVM.
- коти це бібліотека, яка надає пресtracції для функціонального програмування.
- Spark — це уніфікований аналітичний механізм для обробки великомасштабних даних, що широко використовується в робочих процесах великих даних та машинного навчання.
Підтримка паралелізму
- Значення в Scala за замовчуванням незмінні, що робить його дуже адаптивним до паралельних середовищ.
- Scala має багато функцій, які роблять її ідеальною для паралельних застосунків.
- Futures і Promises полегшують асинхронну обробку даних, таким чином підтримуючи паралелізм.
- Akka — це інструментарій, який використовує модель паралельного використання акторів. Актори діють, коли отримують повідомлення.
- Паралелізм із використанням потоків із Java також підтримується в Scala.
- Потокова обробка – це ще одна чудова функція, яка дозволяє безперервно обробляти дані в режимі реального часу.
Scala має одні з найкращих бібліотек паралелізму Java екосистема:
- рідний Java нитки.
- Волокна з бібліотек, таких як Vertx.
- ZIO, бібліотека, яка містить примітиви для допомоги в управлінні паралельними та асинхронними обчисленнями.
- Програмна транзакційна пам'ять (STM) для транзакцій.
- Future, вбудований у мову Scala.
Java проти Scala
Ось основні відмінності між Java і Scala.
| масштаб | Java |
|---|---|
| Більш компактний та лаконічний. | Порівняно більші фрагменти коду. |
| Розроблено та створено як об'єктно-орієнтований та функціональний варіант. Підтримує широкий спектр функцій функціонального програмування, таких як паралельність та незмінність. | Спочатку розроблена як об'єктно-орієнтована мова програмування, а в останніх версіях почала підтримувати функції функціонального програмування. Вона все ще не така сильна, як Scala для функціонального програмування. |
| Використовує акторну модель для підтримки паралельності. | Використовує звичайну модель на основі потоків для паралелізму. |
| Підтримує такі фреймворки, як Play та Lift. | Підтримує Spring, Grails та багато інших. |
| Підтримує ліниву оцінку. | Не підтримує лінивий процес обчислення (lazy evaluation) власноруч. |
| Без статичних членів. | Містить статичні члени. |
| Підтримує перевантаження операторів. | Не підтримує перевантаження операторів. |
| Компіляція вихідного коду відбувається порівняно повільно. | Компіляція вихідного коду швидша, ніж у Scala. |
| Риси діють як Java 8 інтерфейсів. | Java 8 інтерфейсів намагаються подолати розрив між класами та інтерфейсами. |
| Переписування іноді потрібне під час оновлення версій. | Переписування між версіями зазвичай не потрібне. |
| Безпека типів забезпечує високу надійність коду, але не гарантує абсолютної відсутності помилок. | Сильний статичний зарядping допомагає зменшити багато дефектів під час виконання. |
| Має деякі обмеження зворотної сумісності між основними версіями. | Сильна довгострокова зворотна сумісність. |
| OperaВиклики обробляються як виклики методів. | OperaВиклики методів мають спеціальний синтаксис і не є викликами методів. |
| Підтримує множинне успадкування за допомогою ознак. | Не підтримує множинне успадкування за допомогою класів; натомість використовує інтерфейси. |
| Code записується у компактній формі. | Code написано у більш багатослівній формі. |
| Scala не містить ключового слова static. | Java містить ключове слово static. |






















