Скала — Обзор

Scala, сокращение от Scalable Language, является гибридным функциональным языком программирования. Он был создан Мартином Одерским. Scala плавно интегрирует функции объектно-ориентированных и функциональных языков. Scala скомпилирован для работы на виртуальной машине Java. Многие существующие компании, которые используют Java для критически важных бизнес-приложений, обращаются к Scala, чтобы повысить производительность своих разработок, масштабируемость приложений и общую надежность.

Здесь мы представили несколько моментов, которые делают Scala лучшим выбором для разработчиков приложений.

Scala является объектно-ориентированным

Scala — это чисто объектно-ориентированный язык в том смысле, что каждое значение является объектом. Типы и поведение объектов описываются классами и признаками, которые будут объяснены в последующих главах.

Классы расширяются подклассами и гибким механизмом композиции на основе миксинов в качестве чистой замены множественного наследования.

Скала функциональна

Scala также является функциональным языком в том смысле, что каждая функция является значением, а каждое значение является объектом, поэтому в конечном итоге каждая функция является объектом.

Scala предоставляет легкий синтаксис для определения анонимных функций , поддерживает функции высшего порядка , позволяет вкладывать функции и поддерживает каррирование . Эти понятия будут объяснены в последующих главах.

Скала имеет статическую типизацию

Scala, в отличие от некоторых других статически типизированных языков (C, Pascal, Rust и т. Д.), Не ожидает, что вы предоставите избыточную информацию о типах. Вам не нужно указывать тип в большинстве случаев, и вам, конечно, не нужно повторять его.

Scala работает на JVM

Scala компилируется в байт-код Java, который выполняется виртуальной машиной Java (JVM). Это означает, что Scala и Java имеют общую платформу времени выполнения. Вы можете легко перейти с Java на Scala.

Компилятор Scala компилирует ваш код Scala в байт-код Java, который затем может быть выполнен командой « scala ». Команда ‘ scala ‘ похожа на команду java в том, что она выполняет ваш скомпилированный код Scala.

Scala может выполнять код Java

Scala позволяет вам использовать все классы Java SDK, а также ваши собственные пользовательские классы Java или ваши любимые проекты с открытым исходным кодом Java.

Scala может выполнять параллельную и синхронизированную обработку

Scala позволяет эффективно выражать общие закономерности программирования. Это уменьшает количество строк и помогает программисту кодировать безопасным для типов способом. Это позволяет вам писать коды неизменным образом, что упрощает применение параллелизма и параллелизма (Synchronize).

Скала против Явы

Scala обладает набором функций, которые полностью отличаются от Java. Некоторые из них —

• Все типы являются объектами
• Тип вывода
• Вложенные функции
• Функции являются объектами
• Поддержка предметно-ориентированного языка (DSL)
• Черты
• Затворы
• Поддержка параллелизма, вдохновленная Erlang

Scala Web Framework

Scala используется везде и, что важно, в корпоративных веб-приложениях. Вы можете проверить некоторые из самых популярных веб-фреймворков Scala —

• Lift Framework

• The Play framework

• Рамки Боулера

Lift Framework

The Play framework

Рамки Боулера

Scala — Настройка среды

Scala может быть установлен на любой UNIX или Windows-системе. Перед тем, как начать установку Scala на свой компьютер, на вашем компьютере должна быть установлена ​​Java 1.8 или выше.

Следуйте инструкциям ниже, чтобы установить Scala.

Шаг 1: Проверьте вашу установку Java

Прежде всего, вам необходимо установить Java Software Development Kit (SDK) в вашей системе. Чтобы убедиться в этом, выполните любую из следующих двух команд в зависимости от платформы, на которой вы работаете.

Если установка Java была выполнена правильно, то на ней отобразится текущая версия и спецификация вашей установки Java. Пример вывода приведен в следующей таблице.

Откройте Командную консоль и введите —

\> Java-версия

Java версия «1.8.0_31»

Java (TM) SE Run Time

Окружающая среда (сборка 1.8.0_31-b31)

Java Hotspot (TM) 64-битный сервер

ВМ (сборка 25.31-b07, смешанный режим)

Откройте командный терминал и введите —

$ java – версия

Java версия «1.8.0_31»

Открытая среда выполнения JDK (rhel-2.8.10.4.el6_4-x86_64)

Откройте виртуальную машину 64-разрядного сервера JDK (сборка 25.31-b07, смешанный режим)

Мы предполагаем, что читатели этого руководства установили Java SDK версии 1.8.0_31 в своей системе.

Если у вас нет Java SDK, загрузите его текущую версию с http://www.oracle.com/technetwork/java/javase/downloads/index.html и установите его.

Шаг 2: Настройте свою среду Java

Установите переменную среды JAVA_HOME, чтобы она указывала на местоположение базовой директории, где установлена ​​Java на вашем компьютере. Например,

Windows

Установите JAVA_HOME в C: \ ProgramFiles \ java \ jdk1.7.0_60

Linux

Экспорт JAVA_HOME = / usr / local / java-current

Добавьте полный путь расположения компилятора Java к системному пути.

Windows

Добавьте строку «C: \ Program Files \ Java \ jdk1.7.0_60 \ bin» в конец системной переменной PATH.

Linux

Экспорт PATH = $ PATH: $ JAVA_HOME / bin /

Выполните команду java -version из командной строки, как описано выше.

Шаг 3: Установите Scala

Вы можете скачать Scala с http://www.scala-lang.org/downloads . На момент написания этого руководства я скачал ‘scala-2.11.5-installer.jar’. Убедитесь, что у вас есть права администратора для продолжения. Теперь выполните следующую команду в командной строке:

\> java –jar scala-2.11.5-installer.jar \>

Эта команда отобразит мастер установки, который поможет вам установить Scala на ваш компьютер с Windows. Во время установки он запросит лицензионное соглашение, просто примите его, а затем попросит указать путь для установки Scala. Я выбрал заданный по умолчанию путь «C: \ Program Files \ Scala», вы можете выбрать подходящий путь для вашего удобства.

Команда —

$ java –jar scala-2.9.0.1-installer.jar

Выход —

Добро пожаловать в установку Scala 2.9.0.1!

Домашняя страница по адресу — http://Scala-lang.org/

нажмите 1 для продолжения, 2 для выхода, 3 для повторного отображения

1 …………………………………………

[Начиная распаковывать]

[Обработка пакета: Установка программного пакета (1/1)]

[Распаковка закончена]

[Консольная установка сделана]

Во время установки он запросит лицензионное соглашение, примет тип 1 и попросит указать путь для установки Scala. Я ввел / usr / local / share, вы можете выбрать подходящий путь для вашего удобства.

Наконец, откройте новую командную строку, введите Scala -version и нажмите Enter. Вы должны увидеть следующее —

\> скала-версия

Scala code runner версия 2.11.5 — Copyright 2002-2013, LAMP / EPFL

$ scala -version

Scala код бегун версии 2.9.0.1 — Copyright 2002-2013, LAMP / EPFL

Scala — основной синтаксис

Если вы хорошо разбираетесь в Java, вам будет очень легко выучить Scala. Самая большая синтаксическая разница между Scala и Java заключается в том, что ‘;’ символ конца строки не является обязательным.

Когда мы рассматриваем программу Scala, она может быть определена как набор объектов, которые взаимодействуют посредством вызова методов друг друга. Давайте теперь кратко рассмотрим, что означают переменные класса, объекта, метода и экземпляра.

• Объект — объекты имеют состояния и поведение. Объект является экземпляром класса. Пример — у собаки есть состояния — цвет, имя, порода, а также поведение — вилять, лаять и есть.

• Класс — класс может быть определен как шаблон / план, который описывает поведение / состояния, связанные с классом.

• Методы . Метод — это в основном поведение. Класс может содержать много методов. Именно в методах пишутся логики, манипулируются данными и выполняются все действия.

• Поля — каждый объект имеет свой уникальный набор переменных экземпляра, которые называются полями. Состояние объекта создается значениями, присвоенными этим полям.

• Закрытие — Закрытие — это функция, возвращаемое значение которой зависит от значения одной или нескольких переменных, объявленных вне этой функции.

• Черты — Черта заключает в себе определения методов и полей, которые затем могут быть повторно использованы путем смешивания их в классы. Черты используются для определения типов объектов путем указания сигнатуры поддерживаемых методов.

Объект — объекты имеют состояния и поведение. Объект является экземпляром класса. Пример — у собаки есть состояния — цвет, имя, порода, а также поведение — вилять, лаять и есть.

Класс — класс может быть определен как шаблон / план, который описывает поведение / состояния, связанные с классом.

Методы . Метод — это в основном поведение. Класс может содержать много методов. Именно в методах пишутся логики, манипулируются данными и выполняются все действия.

Поля — каждый объект имеет свой уникальный набор переменных экземпляра, которые называются полями. Состояние объекта создается значениями, присвоенными этим полям.

Закрытие — Закрытие — это функция, возвращаемое значение которой зависит от значения одной или нескольких переменных, объявленных вне этой функции.

Черты — Черта заключает в себе определения методов и полей, которые затем могут быть повторно использованы путем смешивания их в классы. Черты используются для определения типов объектов путем указания сигнатуры поддерживаемых методов.

Первая программа Scala

Мы можем выполнить программу Scala в двух режимах: один в интерактивном режиме, а другой в режиме сценария .

Интерактивный режим

Откройте командную строку и используйте следующую команду, чтобы открыть Scala.

\>scala

Если в вашей системе установлена ​​Scala, будет отображен следующий вывод:

Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.

Введите следующий текст справа от приглашения Scala и нажмите клавишу Enter —

scala> println("Hello, Scala!");

Это даст следующий результат —

Hello, Scala!

Режим сценария

Используйте следующие инструкции, чтобы написать программу Scala в режиме сценария. Откройте блокнот и добавьте в него следующий код.

пример

object HelloWorld {
   /* This is my first java program.  
   * This will print 'Hello World' as the output
   */
   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World
   }
}

Сохраните файл как — HelloWorld.scala .

Откройте окно командной строки и перейдите в каталог, в котором сохранен файл программы. Команда « scalac » используется для компиляции программы Scala, и она генерирует несколько файлов классов в текущем каталоге. Один из них будет называться HelloWorld.class . Это байт-код, который будет работать на виртуальной машине Java (JVM) с помощью команды « scala ».

Используйте следующую команду, чтобы скомпилировать и выполнить вашу программу Scala.

\> scalac HelloWorld.scala
\> scala HelloWorld

Выход

Hello, World!

Основной синтаксис

Ниже приведены основные синтаксисы и соглашения о кодировании в Scala-программировании.

• Чувствительность к регистру — Scala чувствительна к регистру, что означает, что идентификатор Hello и hello будут иметь различное значение в Scala.

• Имена классов — для всех имен классов первая буква должна быть в верхнем регистре. Если несколько слов используются для формирования имени класса, первая буква каждого внутреннего слова должна быть в верхнем регистре.

  Пример — класс MyFirstScalaClass.

• Имена методов — все имена методов должны начинаться с буквы нижнего регистра. Если для формирования имени метода используются несколько слов, то первая буква каждого внутреннего слова должна быть в верхнем регистре.

  Пример — def myMethodName ()

• Имя файла программы — имя файла программы должно точно соответствовать имени объекта. При сохранении файла вы должны сохранить его, используя имя объекта (помните, что в Scala учитывается регистр ) и добавьте « .scala » в конец имени. (Если имя файла и имя объекта не совпадают, ваша программа не будет компилироваться).

  Пример. Предположим, что HelloWorld является именем объекта. Затем файл должен быть сохранен как «HelloWorld.scala».

• def main (args: Array [String]) — обработка программы Scala начинается с метода main (), который является обязательной частью каждой программы Scala.

Чувствительность к регистру — Scala чувствительна к регистру, что означает, что идентификатор Hello и hello будут иметь различное значение в Scala.

Имена классов — для всех имен классов первая буква должна быть в верхнем регистре. Если несколько слов используются для формирования имени класса, первая буква каждого внутреннего слова должна быть в верхнем регистре.

Пример — класс MyFirstScalaClass.

Имена методов — все имена методов должны начинаться с буквы нижнего регистра. Если для формирования имени метода используются несколько слов, то первая буква каждого внутреннего слова должна быть в верхнем регистре.

Пример — def myMethodName ()

Имя файла программы — имя файла программы должно точно соответствовать имени объекта. При сохранении файла вы должны сохранить его, используя имя объекта (помните, что в Scala учитывается регистр ) и добавьте « .scala » в конец имени. (Если имя файла и имя объекта не совпадают, ваша программа не будет компилироваться).

Пример. Предположим, что HelloWorld является именем объекта. Затем файл должен быть сохранен как «HelloWorld.scala».

def main (args: Array [String]) — обработка программы Scala начинается с метода main (), который является обязательной частью каждой программы Scala.

Скала Идентификаторы

Все компоненты Scala требуют имен. Имена, используемые для объектов, классов, переменных и методов, называются идентификаторами. Ключевое слово не может использоваться в качестве идентификатора, а идентификаторы чувствительны к регистру. Scala поддерживает четыре типа идентификаторов.

Буквенно-цифровые идентификаторы

Буквенно-цифровой идентификатор начинается с буквы или символа подчеркивания, за которым могут следовать дополнительные буквы, цифры или символы подчеркивания. Символ ‘$’ является зарезервированным ключевым словом в Scala и не должен использоваться в идентификаторах.

Ниже приведены допустимые буквенно-цифровые идентификаторы.

age, salary, _value,  __1_value

Ниже приведены незаконные идентификаторы —

$salary, 123abc, -salary

Идентификаторы оператора

Идентификатор оператора состоит из одного или нескольких символов оператора. Символы оператора являются печатными символами ASCII, такими как +,:,?, ~ Или #.

Ниже приведены юридические идентификаторы операторов —

+ ++ ::: <?> :>

Компилятор Scala внутренне «искажает» идентификаторы операторов, чтобы превратить их в допустимые идентификаторы Java со встроенными символами $. Например, идентификатор: -> будет представлен внутри как $ colon $ минус $ больше.

Смешанные идентификаторы

Смешанный идентификатор состоит из буквенно-цифрового идентификатора, за которым следует подчеркивание и идентификатор оператора.

Ниже приведены допустимые смешанные идентификаторы.

unary_+,  myvar_=

Здесь unary_ +, ​​используемый в качестве имени метода, определяет унарный оператор +, а myvar_ =, используемый в качестве имени метода, определяет оператор присваивания (перегрузка оператора).

Литеральные идентификаторы

Литеральный идентификатор — это произвольная строка, заключенная в обратные галочки (`…`).

Ниже приведены юридические буквенные идентификаторы —

`x` `<clinit>` `yield`

Scala Ключевые слова

Следующий список показывает зарезервированные слова в Scala. Эти зарезервированные слова не могут использоваться как константы или переменные или любые другие имена идентификаторов.

Комментарии в Scala

Scala поддерживает однострочные и многострочные комментарии, очень похожие на Java. Многострочные комментарии могут быть вложенными, но должны быть правильно вложенными. Все символы, доступные внутри любого комментария, игнорируются компилятором Scala.

object HelloWorld {
   /* This is my first java program.  
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */
   def main(args: Array[String]) {
      // Prints Hello World
      // This is also an example of single line comment.
      println("Hello, world!") 
   }
}

Пустые строки и пробелы

Строка, содержащая только пробел, возможно с комментарием, называется пустой строкой, и Scala полностью игнорирует ее. Токены могут быть разделены пробельными символами и / или комментариями.

Символы новой строки

Scala — это линейно-ориентированный язык, где операторы могут заканчиваться точкой с запятой (;) или символом новой строки. Точка с запятой в конце оператора обычно необязательна. Вы можете набрать один, если хотите, но не обязаны, если оператор появляется в одной строке. С другой стороны, точка с запятой требуется, если вы пишете несколько операторов в одной строке. Ниже синтаксис использования нескольких операторов.

val s = "hello"; println(s)

Скала Пакеты

Пакет — это именованный модуль кода. Например, служебный пакет Lift — это net.liftweb.util. Объявление пакета является первой строкой без комментариев в исходном файле следующим образом:

package com.liftcode.stuff

Пакеты Scala можно импортировать, чтобы на них можно было ссылаться в текущей области компиляции. Следующая инструкция импортирует содержимое пакета scala.xml —

import scala.xml._

Вы можете импортировать один класс и объект, например, HashMap из пакета scala.collection.mutable —

import scala.collection.mutable.HashMap

Вы можете импортировать несколько классов или объектов из одного пакета, например TreeMap и TreeSet из пакета scala.collection.immutable —

import scala.collection.immutable.{TreeMap, TreeSet}

Применить динамический

Черта маркера, которая позволяет динамические вызовы. Экземпляры x этой черты допускают вызовы методов x.meth (args) для произвольных имен методов meta и списков аргументов args, а также доступ к полю x.field для произвольного поля имен полей. Эта функция представлена ​​в Scala-2.10.

Если вызов изначально не поддерживается х (то есть, если проверка типа не удалась), он переписывается в соответствии со следующими правилами:

foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)

Scala — Типы данных

Scala имеет все те же типы данных, что и Java, с тем же объемом памяти и точностью. Ниже приведена таблица с подробной информацией обо всех типах данных, доступных в Scala.

Байт

8-битное значение со знаком. Диапазон от -128 до 127

короткий

16-битное значение со знаком. Диапазон от -32768 до 32767

Int

32-битное значение со знаком. Диапазон от -2147483648 до 2147483647

Долго

64-битное значение со знаком. От -9223372036854775808 до 9223372036854775807

терка

32-разрядный IEEE 754 с плавающей точкой одинарной точности

двойной

64-разрядный IEEE 754 с двойной точностью

голец

16-битный символ Unicode без знака. Диапазон от U + 0000 до U + FFFF

строка

Последовательность символов

логический

Либо буквальная правда, либо буквальная ложь

Единица измерения

Не соответствует никакой ценности

Ноль

пустая или пустая ссылка

Ничего такого

Подтип любого другого типа; не содержит значений

любой

Супертип любого типа; любой объект имеет тип Any

AnyRef

Супертип любого ссылочного типа

Все перечисленные выше типы данных являются объектами. Там нет примитивных типов, как в Java. Это означает, что вы можете вызывать методы для Int, Long и т. Д.

Скала Основные литералы

Правила, которые Scala использует для литералов, просты и интуитивно понятны. В этом разделе описаны все основные литералы Scala.

Интегральные литералы

Целочисленные литералы обычно имеют тип Int или тип Long, за которым следует суффикс L или l. Вот некоторые целочисленные литералы —

0
035
21 
0xFFFFFFFF 
0777L

Литерал с плавающей точкой

Литералы с плавающей запятой имеют тип Float, если за ними следует суффикс типа F или f с плавающей запятой, в противном случае они имеют тип Double. Вот некоторые литералы с плавающей точкой —

0.0 
1e30f 
3.14159f 
1.0e100
.1

Логические литералы

Булевы литералы true и false являются членами типа Boolean.

Символьные литералы

Символьный литерал ‘x является сокращением для выражения scala.Symbol («x») . Символ представляет собой класс case, который определяется следующим образом.

package scala
final case class Symbol private (name: String) {
   override def toString: String = "'" + name
}

Символьные литералы

Символьный литерал — это отдельный символ, заключенный в кавычки. Символ является либо печатным символом Unicode, либо описан escape-последовательностью. Вот некоторые литералы символов —

'a' 
'\u0041'
'\n'
'\t'

Строковые литералы

Строковый литерал — это последовательность символов в двойных кавычках. Символы являются либо печатными символами Unicode, либо описываются escape-последовательностями. Вот некоторые строковые литералы —

"Hello,\nWorld!"
"This string contains a \" character."

Многострочные строки

Многострочный строковый литерал — это последовательность символов, заключенная в тройные кавычки «» «…» «». Последовательность символов произвольна, за исключением того, что она может содержать три или более последовательных символа кавычки только в самом конце.

Символы не обязательно должны быть напечатаны; переводы строки и другие управляющие символы также разрешены. Вот многострочный строковый литерал —

"""the present string
spans three
lines."""

Нулевые значения

Нулевое значение имеет тип scala.Null и поэтому совместимо с каждым ссылочным типом. Он обозначает ссылочное значение, которое ссылается на специальный «нулевой» объект.

Побег последовательности

Следующие escape-последовательности распознаются в символьных и строковых литералах.

Символ с Unicode от 0 до 255 также может быть представлен восьмеричным экранированием, то есть обратной косой чертой ‘\’, за которой следует последовательность до трех восьмеричных символов. Ниже приведен пример, показывающий несколько символов escape-последовательности:

пример

object Test {
   def main(args: Array[String]) {
      println("Hello\tWorld\n\n" );
   }
} 

Когда приведенный выше код компилируется и выполняется, он дает следующий результат —

Выход

Hello   World

Scala — переменные

Переменные — это не что иное, как зарезервированные области памяти для хранения значений. Это означает, что когда вы создаете переменную, вы резервируете некоторое пространство в памяти.

На основе типа данных переменной компилятор выделяет память и решает, что можно сохранить в зарезервированной памяти. Поэтому, назначая переменным разные типы данных, вы можете хранить целые, десятичные или символы в этих переменных.

Объявление переменной

Scala имеет другой синтаксис для объявления переменных. Их можно определить как значение, т. Е. Постоянное или переменное. Здесь myVar объявлен с использованием ключевого слова var. Это переменная, которая может изменить значение, и это называется изменяемой переменной . Ниже приведен синтаксис для определения переменной с помощью ключевого слова var.

Синтаксис

var myVar : String = "Foo"

Здесь myVal объявлен с использованием ключевого слова val. Это означает, что это переменная, которая не может быть изменена, и это называется неизменяемой переменной . Ниже приведен синтаксис для определения переменной с помощью ключевого слова val —

Синтаксис

val myVal : String = "Foo"

Типы переменных данных

Тип переменной указывается после имени переменной и перед знаком равенства. Вы можете определить любой тип переменной Scala, упомянув ее тип данных следующим образом:

Синтаксис

val or val VariableName : DataType = [Initial Value]

Если вы не присваиваете какое-либо начальное значение переменной, тогда оно действует следующим образом:

Синтаксис

var myVar :Int;
val myVal :String;

Вывод типа переменной

Когда вы присваиваете начальное значение переменной, компилятор Scala может определить тип переменной на основе присвоенного ей значения. Это называется выводом типа переменной. Следовательно, вы можете написать эти объявления переменных следующим образом:

Синтаксис

var myVar = 10;
val myVal = "Hello, Scala!";

Здесь по умолчанию myVar будет иметь тип Int, а myVal станет переменной типа String.

Несколько назначений

Scala поддерживает несколько заданий. Если блок кода или метод возвращает Tuple ( Tuple — содержит коллекцию объектов разных типов), Tuple может быть назначен переменной val. [ Примечание. Мы будем изучать кортежи в следующих главах.]

Синтаксис

val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

И вывод типа делает это правильно —

Синтаксис

val (myVar1, myVar2) = Pair(40, "Foo")

Пример программы

Ниже приведен пример программы, объясняющей процесс объявления переменных в Scala. Эта программа объявляет четыре переменные — две переменные определены с объявлением типа, а остальные две без объявления типа.

пример

object Demo {
   def main(args: Array[String]) {
      var myVar :Int = 10;
      val myVal :String = "Hello Scala with datatype declaration.";
      var myVar1 = 20;
      val myVal1 = "Hello Scala new without datatype declaration.";
      
      println(myVar); println(myVal); println(myVar1); 
      println(myVal1);
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

10
Hello Scala with datatype declaration.
20
Hello Scala without datatype declaration.

Переменная сфера

Переменные в Scala могут иметь три разные области видимости в зависимости от места их использования. Они могут существовать в виде полей, параметров метода и локальных переменных. Ниже приведены подробные сведения о каждом типе области.

поля

Поля — это переменные, которые принадлежат объекту. Поля доступны изнутри каждого метода в объекте. Поля также могут быть доступны вне объекта в зависимости от того, с какими модификаторами доступа объявлено поле. Поля объекта могут быть как изменяемыми, так и неизменяемыми типами и могут быть определены с использованием var или val .

Параметры метода

Параметры метода — это переменные, которые используются для передачи значения внутри метода при вызове метода. Параметры метода доступны только изнутри метода, но переданные объекты могут быть доступны извне, если у вас есть ссылка на объект извне метода. Параметры метода всегда неизменны и определяются ключевым словом val .

Локальные переменные

Локальные переменные — это переменные, объявленные внутри метода. Локальные переменные доступны только внутри метода, но созданные вами объекты могут покинуть метод, если вы вернете их из метода. Локальные переменные могут быть как изменчивыми, так и неизменяемыми типами и могут быть определены с использованием var или val .

Scala — Классы и Объекты

В этой главе рассказывается, как использовать классы и объекты в программировании Scala. Класс — это план для объектов. Определив класс, вы можете создавать объекты из чертежа класса с ключевым словом new . Через объект вы можете использовать все функциональные возможности определенного класса.

Следующая диаграмма демонстрирует класс и объект на примере ученика класса, который содержит переменные-члены (name и roll no) и методы-члены (setName () и setRollNo ()). Наконец все являются членами класса. Класс — это синяя печать, а объекты здесь реальны. На следующей диаграмме ученик — это класс, а Харини, Джон и Мария — объекты ученического класса, у которых есть имя и номер броска.

Базовый класс

Ниже приведен простой синтаксис для определения базового класса в Scala. Этот класс определяет две переменные x и y и метод: move , который не возвращает значение. Переменные класса называются, поля класса и методы называются методами класса.

Имя класса работает как конструктор класса, который может принимать несколько параметров. Приведенный выше код определяет два аргумента конструктора, xc и yc ; они оба видны во всем теле класса.

Синтаксис

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
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

Как упоминалось ранее в этой главе, вы можете создавать объекты, используя ключевое слово new, а затем вы можете получить доступ к полям и методам класса, как показано ниже в примере:

пример

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Point x location : 20
Point y location : 30

Расширение класса

Вы можете расширить базовый класс Scala и создать унаследованный класс так же, как вы делаете это в Java (используйте ключевое слово extends ), но есть два ограничения: переопределение метода требует ключевого слова override , и только первичный конструктор может передать параметры для базового конструктора. Давайте расширим наш класс и добавим еще один метод класса.

пример

Давайте возьмем пример из двух классов. Класс Point (такой же пример, как и выше) и класс Location наследуются классом с использованием ключевого слова extends. Такое предложение extends имеет два эффекта: оно делает класс Location наследующим все не приватные члены класса Point и делает тип Location подтипом класса Point . Так что здесь класс Point называется суперклассом, а класс Location называется подклассом . Расширение класса и наследование всех функций родительского класса называется наследованием, но Scala позволяет наследовать только от одного класса.

Примечание. Методы метода move () в классе Point и метода move () в классе Location не переопределяют соответствующие определения move, поскольку они являются разными определениями (например, первые принимают два аргумента, а последние принимают три аргумента).

Попробуйте следующий пример программы для реализации наследования.

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Point x location : " + x);
      println ("Point y location : " + y);
      println ("Point z location : " + z);
   }
}

object Demo {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Point x location : 20
Point y location : 30
Point z location : 20

Неявные классы

Неявные классы позволяют неявные разговоры с основным конструктором класса, когда класс находится в области видимости. Неявный класс — это класс, помеченный ключевым словом «неявный». Эта функция представлена ​​в Scala 2.10.

Синтаксис . Ниже приводится синтаксис неявных классов. Здесь неявный класс всегда находится в области объекта, где разрешены все определения методов, потому что неявный класс не может быть классом верхнего уровня.

Синтаксис

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

пример

Давайте возьмем пример неявного класса с именем IntTimes с помощью метода times (). Это означает, что times () содержит транзакцию цикла, которая будет выполнять данный оператор столько раз, сколько мы даем. Предположим, что данный оператор «4 раза println (« Hello »)» означает, что оператор println («Hello») будет выполнен 4 раза.

Ниже приведена программа для данного примера. В этом примере используются два класса объектов (Run и Demo), поэтому мы должны сохранить эти два класса в разных файлах с соответствующими именами, как показано ниже.

Run.scala — сохраните следующую программу в Run.scala.

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =
         
         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala — Сохраните следующую программу в Demo.scala.

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

Следующие команды используются для компиляции и выполнения этих двух программ.

команда

\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo

Выход

Hello
Hello
Hello
Hello

Примечание —

• Неявные классы должны быть определены внутри другого класса / объекта / признака (не на верхнем уровне).

• Неявные классы могут принимать только один неявный аргумент в своем конструкторе.

• Неявные классы не могут быть любым методом, членом или объектом в области с тем же именем, что и неявный класс.

Неявные классы должны быть определены внутри другого класса / объекта / признака (не на верхнем уровне).

Неявные классы могут принимать только один неявный аргумент в своем конструкторе.

Неявные классы не могут быть любым методом, членом или объектом в области с тем же именем, что и неявный класс.

Одиночные объекты

Scala более объектно-ориентирован, чем Java, потому что в Scala у нас не может быть статических членов. Вместо этого в Scala есть одноэлементные объекты . Singleton — это класс, который может иметь только один экземпляр, т.е. Object. Вы создаете синглтон, используя ключевое слово object вместо ключевого слова class. Поскольку вы не можете создать экземпляр одноэлементного объекта, вы не можете передать параметры первичному конструктору. Вы уже видели все примеры с использованием одноэлементных объектов, где вы вызывали основной метод Scala.

Ниже приведен тот же пример программы для реализации синглтона.

пример

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Point x location : 10
Point y location : 20

Scala — Модификаторы доступа

В этой главе рассказывается о модификаторах доступа Scala. Члены пакетов, классов или объектов могут быть помечены как закрытые и защищенные модификаторы доступа, и если мы не используем ни одно из этих двух ключевых слов, доступ будет считаться общедоступным. Эти модификаторы ограничивают доступ членов к определенным областям кода. Чтобы использовать модификатор доступа, вы включаете его ключевое слово в определение членов пакета, класса или объекта, как мы увидим в следующем разделе.

Частные Члены

Закрытый член виден только внутри класса или объекта, который содержит определение члена.

Ниже приведен пример фрагмента кода для объяснения частного участника:

пример

class Outer {
   class Inner {
      private def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // Error: f is not accessible
}

В Scala доступ (новый Inner). f () недопустимо, потому что f объявлен как private во Inner, и доступ не изнутри класса Inner. Напротив, первый доступ к f в классе Innermost в порядке, потому что этот доступ содержится в теле класса Inner. Java разрешает оба доступа, потому что позволяет внешнему классу обращаться к закрытым членам своих внутренних классов.

Защищенные участники

Защищенный член доступен только из подклассов класса, в котором этот член определен.

Ниже приведен пример фрагмента кода для объяснения защищенного члена:

пример

package p {
   class Super {
      protected def f() { println("f") }
   }
   
   class Sub extends Super {
      f()
   }
   
   class Other {
      (new Super).f() // Error: f is not accessible
   }
}

Доступ к f в классе Sub в порядке, потому что f объявлен защищенным в классе ‘Super’, а класс ‘Sub’ является подклассом Super. В отличие от этого, доступ к f в классе «Other» не разрешен, поскольку класс «Other» не наследуется от класса «Super». В Java последний доступ будет по-прежнему разрешен, поскольку класс «Other» находится в том же пакете, что и класс «Sub».

Публичные участники

В отличие от закрытых и защищенных членов, не требуется указывать ключевое слово Public для открытых членов. Не существует явного модификатора для открытых участников. К таким членам можно получить доступ откуда угодно.

Ниже приведен пример фрагмента кода для объяснения открытого участника:

пример

class Outer {
   class Inner {
      def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // OK because now f() is public
}

Степень защиты

Модификаторы доступа в Scala могут быть дополнены классификаторами. Модификатор формы private [X] или protected [X] означает, что доступ является частным или защищенным «до» X, где X обозначает некоторый включающий пакет, класс или одноэлементный объект.

Рассмотрим следующий пример —

пример

package society {
   package professional {
      class Executive {
         private[professional] var workDetails = null
         private[society] var friends = null
         private[this] var secrets = null

         def help(another : Executive) {
            println(another.workDetails)
            println(another.secrets) //ERROR
         }
      }
   }
}

Примечание — следующие пункты из приведенного выше примера —

• Переменная workDetails будет доступна для любого класса в рамках пакета специалистов.

• Переменные друзья будут доступны для любого класса в рамках общества пакета.

• Секреты переменных будут доступны только для неявного объекта в методах экземпляра (this).

Переменная workDetails будет доступна для любого класса в рамках пакета специалистов.

Переменные друзья будут доступны для любого класса в рамках общества пакета.

Секреты переменных будут доступны только для неявного объекта в методах экземпляра (this).

Скала — Операторы

Оператор — это символ, который указывает компилятору выполнять определенные математические или логические манипуляции. Scala богата встроенными операторами и предоставляет следующие типы операторов —

• Арифметические Операторы
• Операторы отношений
• Логические Операторы
• Битовые операторы
• Операторы присваивания

В этой главе рассматриваются один за другим арифметические, реляционные, логические, побитовые, присваивания и другие операторы.

Арифметические Операторы

Следующие арифметические операторы поддерживаются языком Scala. Например, предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —

Показать примеры

Операторы отношений

Следующие реляционные операторы поддерживаются языком Scala. Например, предположим, что переменная A содержит 10, а переменная B содержит 20, тогда —

Показать примеры

Логические Операторы

Следующие логические операторы поддерживаются языком Scala. Например, предположим, что переменная A содержит 1, а переменная B содержит 0, тогда —

Показать примеры

Битовые операторы

Побитовый оператор работает с битами и выполняет побитовую операцию. Таблицы истинности для &, | и ^ следующие:

Предположим, если А = 60; и B = 13; теперь в двоичном формате они будут выглядеть следующим образом —

A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

Побитовые операторы, поддерживаемые языком Scala, перечислены в следующей таблице. Предположим, что переменная A содержит 60, а переменная B содержит 13, тогда —

Показать примеры

Операторы присваивания

В языке Scala поддерживаются следующие операторы присваивания:

Показать примеры

Приоритет операторов в Scala

Приоритет оператора определяет группировку терминов в выражении. Это влияет на то, как оценивается выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например, оператор умножения имеет более высокий приоритет, чем оператор сложения —

Например, х = 7 + 3 * 2; здесь x назначено 13, а не 20, потому что оператор * имеет более высокий приоритет, чем +, поэтому он сначала умножается на 3 * 2, а затем прибавляется к 7.

Посмотрите на следующую таблицу. Операторы с наивысшим приоритетом отображаются вверху таблицы, а операторы с наименьшим приоритетом — внизу. Внутри выражения операторы с более высоким приоритетом будут оцениваться первыми.

Scala — IF ELSE Заявления

В этой главе рассказывается об условных конструкциях в Scala-программировании. Ниже приводится общая форма типичной структуры принятия решений IF … ELSE, встречающейся в большинстве языков программирования.

Блок-схема

Ниже приведена блок-схема условного оператора.

если заявление

оператор if состоит из логического выражения, за которым следует одно или несколько операторов.

Синтаксис

Синтаксис оператора if следующий.

if(Boolean_expression) {
   // Statements will execute if the Boolean expression is true
}

Если логическое выражение имеет значение true, тогда будет выполнен блок кода внутри выражения if. Если нет, то будет выполнен первый набор кода после конца выражения if (после закрывающей фигурной скобки).

Попробуйте следующий пример программы, чтобы понять условные выражения (если выражение) на языке программирования Scala.

пример

object Demo {
   def main(args: Array[String]) {
      var x = 10;

      if( x < 20 ){
         println("This is if statement");
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

This is if statement

If-else Заявление

За оператором if может следовать необязательный оператор else , который выполняется, когда логическое выражение имеет значение false.

Синтаксис

Синтаксис if … else —

if(Boolean_expression){
   //Executes when the Boolean expression is true
} else{
   //Executes when the Boolean expression is false
}

Попробуйте следующий пример программы, чтобы понять условные операторы (оператор if-else) на языке программирования Scala.

пример

object Demo {
   def main(args: Array[String]) {
      var x = 30;

      if( x < 20 ){
         println("This is if statement");
      } else {
         println("This is else statement");
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

This is else statement

Оператор if-else-if-else

За оператором ‘if’ может следовать необязательный оператор ‘ else if … else ‘, который очень полезен для проверки различных условий с использованием одиночного оператора if … else if.

При использовании операторов if, else if, else необходимо учитывать несколько моментов.

• «Если» может иметь ноль или еще одно, и оно должно идти после любого другого «если».

• «Если» может иметь ноль для многих других «если», и они должны предшествовать другому.

• Один раз, если это удастся, ни один из оставшихся, если он или еще, не будет проверен.

«Если» может иметь ноль или еще одно, и оно должно идти после любого другого «если».

«Если» может иметь ноль для многих других «если», и они должны предшествовать другому.

Один раз, если это удастся, ни один из оставшихся, если он или еще, не будет проверен.

Синтаксис

Ниже приводится синтаксис выражения «если … еще, если … еще»:

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
   //Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
   //Executes when the Boolean expression 3 is true
} else {
   //Executes when the none of the above condition is true.
}

Попробуйте следующий пример программы, чтобы понять условные операторы (оператор if-else-if-else) на языке программирования Scala.

пример

object Demo {
   def main(args: Array[String]) {
      var x = 30;

      if( x == 10 ){
         println("Value of X is 10");
      } else if( x == 20 ){
         println("Value of X is 20");
      } else if( x == 30 ){
         println("Value of X is 30");
      } else{
         println("This is else statement");
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Value of X is 30

Вложенный оператор if-else

Всегда допустимо вкладывать операторы if-else , что означает, что вы можете использовать один оператор if или else-if внутри другого оператора if или else-if .

Синтаксис

Синтаксис для вложенного if-else следующий:

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
   
   if(Boolean_expression 2){
      //Executes when the Boolean expression 2 is true
   }
}

Попробуйте следующий пример программы, чтобы понять условные операторы (оператор nested-if) на языке программирования Scala.

пример

object Demo {
   def main(args: Array[String]) {
      var x = 30;
      var y = 10;
      
      if( x == 30 ){
         if( y == 10 ){
            println("X = 30 and Y = 10");
         }
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

X = 30 and Y = 10

Scala — Loop Заявления

В этой главе описываются структуры управления циклами в языках программирования Scala.

Может возникнуть ситуация, когда вам нужно выполнить блок кода несколько раз. В общем случае операторы выполняются последовательно: первый оператор в функции выполняется первым, затем второй и так далее.

Языки программирования предоставляют различные управляющие структуры, которые допускают более сложные пути выполнения.

Оператор цикла позволяет нам выполнять оператор или группу операторов несколько раз, и в большинстве языков программирования ниже приводится общая форма инструкции цикла.

Блок-схема

Язык программирования Scala предоставляет следующие типы циклов для обработки требований циклов. Нажмите на следующие ссылки в таблице, чтобы проверить их детали.

в то время как цикл

Повторяет оператор или группу операторов, пока данное условие выполняется. Он проверяет условие перед выполнением тела цикла.

цикл действия

Как оператор while, за исключением того, что он проверяет условие в конце тела цикла.

для цикла

Выполняет последовательность операторов несколько раз и сокращает код, который управляет переменной цикла.

Заявления о контроле цикла

Операторы управления циклом изменяют выполнение от его нормальной последовательности. Когда выполнение покидает область действия, все автоматические объекты, созданные в этой области, уничтожаются. Так как Scala не поддерживает операторы break или continue, как в Java, но начиная с Scala версии 2.8, существует способ разбивать циклы. Нажмите на следующие ссылки, чтобы проверить детали.

заявление о нарушении

Завершает оператор цикла и передает выполнение в оператор, следующий сразу за циклом.

Бесконечный цикл

Цикл становится бесконечным, если условие никогда не становится ложным. Если вы используете Scala, цикл while — лучший способ реализовать бесконечный цикл.

Следующая программа реализует бесконечный цикл.

пример

object Demo {
   def main(args: Array[String]) {
      var a = 10;
      
      // An infinite loop.
      while( true ){
         println( "Value of a: " + a );
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Если вы выполните приведенный выше код, он будет идти в бесконечном цикле, который вы можете завершить нажатием клавиш Ctrl + C.

Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
…………….

Scala — Функции

Функция — это группа операторов, которые выполняют задачу. Вы можете разделить ваш код на отдельные функции. То, как вы делите свой код между различными функциями, зависит от вас, но логически разделение обычно таково, что каждая функция выполняет определенную задачу.

В Scala есть как функции, так и методы, и мы используем термины «метод» и «функции» взаимозаменяемо с небольшим отличием. Метод Scala — это часть класса, которая имеет имя, сигнатуру, необязательно несколько аннотаций и некоторый байт-код, где в качестве функции в Scala это полный объект, который может быть назначен переменной. Другими словами, функция, которая определяется как член какого-либо объекта, называется методом.

Определение функции может появиться в любом месте исходного файла, и Scala допускает определения вложенных функций, то есть определения функций внутри других определений функций. Наиболее важным моментом, который следует отметить, является то, что имя функции Scala может содержать такие символы, как +, ++, ~, &, -, -, \, /,: и т. Д.

Объявления функций

Объявление функции Scala имеет следующую форму —

def functionName ([list of parameters]) : [return type]

Методы неявно объявляются абстрактными, если вы не используете знак равенства и тело метода.

Определения функций

Определение функции Scala имеет следующую форму —

Синтаксис

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

Здесь тип возвращаемого значения может быть любым допустимым типом данных Scala, а список параметров будет списком переменных, разделенных запятой, а список параметров и тип возвращаемого значения являются необязательными. Очень похоже на Java, оператор return может использоваться вместе с выражением, если функция возвращает значение. Ниже приведена функция, которая добавляет два целых числа и возвращает их сумму:

Синтаксис

object add {
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

Функция, которая ничего не возвращает, может вернуть модуль , эквивалентный void в Java, и указывает, что функция ничего не возвращает. Функции, которые ничего не возвращают в Scala, они называются процедурами.

Синтаксис

Вот синтаксис —

object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

Функции вызова

Scala предоставляет ряд синтаксических вариантов для вызова методов. Ниже приведен стандартный способ вызова метода:

functionName( list of parameters )

Если функция вызывается с использованием экземпляра объекта, то мы будем использовать точечную нотацию, аналогичную Java, следующим образом:

[instance.]functionName( list of parameters )

Попробуйте следующий пример программы, чтобы определить и затем вызвать ту же функцию.

пример

object Demo {
   def main(args: Array[String]) {
      println( "Returned Value : " + addInt(5,7) );
   }
   
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Returned Value : 12

Функции Scala являются сердцем программирования Scala, поэтому Scala считается функциональным языком программирования. Ниже приводится несколько важных понятий, связанных с функциями Scala, которые должен понимать программист Scala.

Скала — Закрытие

Замыкание — это функция, возвращаемое значение которой зависит от значения одной или нескольких переменных, объявленных вне этой функции.

Следующий кусок кода с анонимной функцией.

val multiplier = (i:Int) => i * 10

Здесь единственная переменная, используемая в теле функции, i * 10, это i, которая определяется как параметр функции. Попробуйте следующий код —

val multiplier = (i:Int) => i * factor

В множителе есть две свободные переменные: i и factor . Один из них, i, является формальным параметром функции. Следовательно, он связан с новым значением каждый раз, когда вызывается множитель. Однако фактор не является формальным параметром, тогда что это? Давайте добавим еще одну строку кода.

var factor = 3
val multiplier = (i:Int) => i * factor

Теперь фактор имеет ссылку на переменную вне функции, но во вложенной области видимости. Функция ссылается на множитель и каждый раз считывает его текущее значение. Если функция не имеет внешних ссылок, она тривиально замкнута над собой. Внешний контекст не требуется.

Попробуйте следующий пример программы.

пример

object Demo {
   def main(args: Array[String]) {
      println( "multiplier(1) value = " +  multiplier(1) )
      println( "multiplier(2) value = " +  multiplier(2) )
   }
   var factor = 3
   val multiplier = (i:Int) => i * factor
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

multiplier(1) value = 3
multiplier(2) value = 6

Скала — Струны

В этой главе рассказывается о Scala. В Scala, как и в Java, строка является неизменным объектом, то есть объектом, который нельзя изменить. С другой стороны, объекты, которые могут быть изменены, например, массивы, называются изменяемыми объектами. Строки являются очень полезными объектами, в оставшейся части этого раздела мы представляем важные методы класса java.lang.String .

Создание строки

Следующий код может быть использован для создания строки —

var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

Всякий раз, когда компилятор встречает строковый литерал в коде, он создает объект String со своим значением, в данном случае «Hello world!». Строковое ключевое слово также может быть указано в альтернативном объявлении, как показано выше.

Попробуйте следующий пример программы.

пример

object Demo {
   val greeting: String = "Hello, world!"

   def main(args: Array[String]) {
      println( greeting )
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Hello, world!

Как упоминалось ранее, класс String является неизменным. Созданный строковый объект не может быть изменен. Если необходимо внести множество изменений в строки символов, используйте класс String Builder, доступный в Scala !.

Длина строки

Методы, используемые для получения информации об объекте, называются методами доступа. Одним из методов доступа, который можно использовать со строками, является метод length (), который возвращает количество символов, содержащихся в строковом объекте.

Используйте следующий сегмент кода, чтобы найти длину строки —

пример

object Demo {
   def main(args: Array[String]) {
      var palindrome = "Dot saw I was Tod";
      var len = palindrome.length();
      
      println( "String Length is : " + len );
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

String Length is : 17

Конкатенация строк

Класс String включает метод для объединения двух строк:

string1.concat(string2);

Это возвращает новую строку, которая является строкой1 с добавленной строкой2 в конце. Вы также можете использовать метод concat () со строковыми литералами, как в —

"My name is ".concat("Zara");

Строки чаще объединяются с помощью оператора +, как в —

"Hello," + " world" + "!"

Что приводит к —

"Hello, world!"

Следующие строки кода, чтобы найти длину строки.

пример

object Demo {
   def main(args: Array[String]) {
      var str1 = "Dot saw I was ";
      var str2 =  "Tod";
      
      println("Dot " + str1 + str2);
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Dot Dot saw I was Tod

Создание форматных строк

У вас есть методы printf () и format () для печати вывода с отформатированными числами. Класс String имеет эквивалентный метод класса format (), который возвращает объект String, а не объект PrintStream.

Попробуйте следующий пример программы, которая использует метод printf () —

пример

object Demo {
   def main(args: Array[String]) {
      var floatVar = 12.456
      var intVar = 2000
      var stringVar = "Hello, Scala!"
      
      var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
      
      println(fs)
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

The value of the float variable is 12.456000, 
while the value of the integer variable is 2000, 
and the string is Hello, Scala!()

Строковая интерполяция

Интерполяция строк — это новый способ создания строк на языке программирования Scala. Эта функция поддерживает версии Scala-2.10 и выше. Строковая интерполяция: механизм для встраивания ссылок на переменные непосредственно в строковый литерал процесса.

В String Interpolation есть три типа (интерполяторы) реализаций.

Строковый интерполятор

Литерал ‘s’ позволяет использовать переменную непосредственно при обработке строки, когда вы добавляете ‘s’ к ней. Любая строковая переменная в области видимости, которая может быть использована в строковой переменной. Ниже приведены различные варианты использования строкового интерполятора.

В следующем примере фрагмента кода для реализации интерполятора ‘s’ при добавлении переменной String ($ name) к обычной строке (Hello) в операторе println.

val name = “James”
println(s “Hello, $name”) //output: Hello, James

Строковый интерполятор также может обрабатывать произвольные выражения. Следующий фрагмент кода для обработки строки (1 + 1) с произвольным выражением ($ {1 + 1}) с использованием интерполятора строки ‘s’. Любое произвольное выражение может быть встроено в ‘$ {}’.

println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2

Попробуйте следующий пример программы реализации интерполятора ‘s’.

пример

object Demo {
   def main(args: Array[String]) {
      val name = "James"
      
      println(s"Hello, $name")
      println(s"1 + 1 = ${1 + 1}")
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Hello, James
1 + 1 = 2

Интерполятор ‘f’

Буквенный интерполятор ‘f’ позволяет создавать форматированную строку, аналогичную printf на языке Си. При использовании интерполятора ‘f’ все ссылки на переменные должны сопровождаться спецификаторами формата стиля printf , такими как% d,% i,% f и т. Д.

Давайте рассмотрим пример добавления значения с плавающей запятой (высота = 1,9d) и строковой переменной (имя = «Джеймс») с нормальной строкой. Следующий фрагмент кода реализации интерполятора ‘f’. Здесь $ name% s для печати (строковая переменная) James и $ height% 2.2f для печати (значение с плавающей запятой) 1.90.

val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall

Это безопасный тип (то есть) ссылка на переменную, и следующий спецификатор формата должен совпадать, иначе это показывает ошибку. Интерполятор ‘f’ использует утилиты формата String (спецификаторы формата), доступные в Java. По умолчанию означает, что после ссылки на переменную нет символа%. Предполагается, что% s (String).

«сырой» интерполятор

«Необработанный» интерполятор похож на «s» -интерполятор за исключением того, что он не выполняет экранирование литералов внутри строки. Следующие фрагменты кода в таблице будут отличаться использованием интерполяторов ‘s’ и ‘raw’. В выходных данных ‘s’ использование ‘\ n’ влияет как новая строка, а в выходных данных ‘raw’ использование ‘\ n’ не будет действовать. Он напечатает всю строку с escape-буквами.

object Demo {
   def main(args: Array[String]) {
      println(s"Result = \n a \n b")
   }
}

object Demo {
   def main(args: Array[String]) {
      println(raw"Result = \n a \n b")
   }
}

Result =
a
b

Result = \n a \n b

Программа —

Программа —

Выход —

Выход —

Строковые Методы

Ниже приведен список методов, определенных классом java.lang.String, которые можно использовать непосредственно в ваших программах Scala.

char charAt (int index)

Возвращает символ по указанному индексу.

int CompareTo (Объект o)

Сравнивает эту строку с другим объектом.

int compareTo (String anotherString)

Сравнивает две строки лексикографически.

int compareToIgnoreCase (String str)

Сравнивает две строки лексикографически, игнорируя различия в регистре.

Строка Конкат (String str)

Объединяет указанную строку до конца этой строки.

логическое contentEquals (StringBuffer sb)

Возвращает true тогда и только тогда, когда эта String представляет ту же последовательность символов, что и указанный StringBuffer.

static String copyValueOf (char [] data)

Возвращает строку, представляющую последовательность символов в указанном массиве.

static String copyValueOf (данные char [], смещение int, число int)

Возвращает строку, представляющую последовательность символов в указанном массиве.

логическое заканчивается с (суффикс строки)

Проверяет, заканчивается ли эта строка указанным суффиксом.

логическое равенство (Object anObject)

Сравнивает эту строку с указанным объектом.

логическое equalsIgnoreCase (String anotherString)

Сравнивает эту строку с другой строкой, игнорируя соображения регистра.

byte getBytes ()

Кодирует эту строку в последовательность байтов, используя кодировку платформы по умолчанию, сохраняя результат в новом байтовом массиве.

byte [] getBytes (String charsetName)

Кодирует эту строку в последовательность байтов, используя именованную кодировку, сохраняя результат в новом байтовом массиве.

void getChars (int srcBegin, int srcEnd, char [] dst, int dstBegin)

Копирует символы из этой строки в массив символов назначения.

int hashCode ()

Возвращает хеш-код для этой строки.

int indexOf (int ch)

Возвращает индекс в этой строке первого вхождения указанного символа.

int indexOf (int ch, int fromIndex)

Возвращает индекс в этой строке первого вхождения указанного символа, начиная поиск по указанному индексу.

int indexOf (String str)

Возвращает индекс в этой строке первого вхождения указанной подстроки.

int indexOf (String str, int fromIndex)

Возвращает индекс в этой строке первого вхождения указанной подстроки, начиная с указанного индекса.

Строка интерна ()

Возвращает каноническое представление для строкового объекта.

int lastIndexOf (int ch)

Возвращает индекс в этой строке последнего вхождения указанного символа.

int lastIndexOf (int ch, int fromIndex)

Возвращает индекс в этой строке последнего вхождения указанного символа с поиском в обратном направлении, начиная с указанного индекса.

int lastIndexOf (String str)

Возвращает индекс в этой строке самого правого вхождения указанной подстроки.

int lastIndexOf (String str, int fromIndex)

Возвращает индекс в этой строке последнего вхождения указанной подстроки с обратным поиском, начиная с указанного индекса.

int length ()

Возвращает длину этой строки.

булевы совпадения (строковое регулярное выражение)

Сообщает, соответствует ли эта строка заданному регулярному выражению.

логическое regionMatches (логическое ignoreCase, int toffset, String other, int offset, int len)

Проверяет, равны ли две строковые области.

логическое regionMatches (int toffset, String other, int offset, int len)

Проверяет, равны ли две строковые области.

Замена строки (char oldChar , char newChar)

Возвращает новую строку, полученную в результате замены всех вхождений oldChar в этой строке на newChar.

String replaceAll (регулярное выражение строки, замена строки

Заменяет каждую подстроку этой строки, которая соответствует данному регулярному выражению с данной заменой.

String replaceFirst (регулярное выражение строки, замена строки)

Заменяет первую подстроку этой строки, которая соответствует заданному регулярному выражению с заданной заменой.

String [] split (регулярное выражение строки)

Разбивает эту строку вокруг совпадений заданного регулярного выражения.

String [] split (регулярное выражение String, ограничение int)

Разбивает эту строку вокруг совпадений заданного регулярного выражения.

логическое начальное с (строковый префикс)

Проверяет, начинается ли эта строка с указанного префикса.

логическое начальное с (строковый префикс, int toffset)

Проверяет, начинается ли эта строка с указанного префикса, начиная с указанного индекса.

Подпоследовательность CharSequence (int beginIndex, int endIndex)

Возвращает новую последовательность символов, которая является подпоследовательностью этой последовательности.

Строковая подстрока (int beginIndex)

Возвращает новую строку, которая является подстрокой этой строки.

Строковая подстрока (int beginIndex, int endIndex)

Возвращает новую строку, которая является подстрокой этой строки.

char [] toCharArray ()

Преобразует эту строку в новый массив символов.

Строка toLowerCase ()

Преобразует все символы в этой строке в нижний регистр, используя правила локали по умолчанию.

String toLowerCase (языковой стандарт)

Преобразует все символы в этой строке в нижний регистр, используя правила данной локали.

Строка toString ()

Этот объект (который уже является строкой!) Сам по себе возвращается.

Строка toUpperCase ()

Преобразует все символы в этой строке в верхний регистр, используя правила локали по умолчанию.

String toUpperCase (языковой стандарт)

Преобразует все символы в этой строке в верхний регистр, используя правила данной локали.

Струнная отделка ()

Возвращает копию строки, пропуская начальные и конечные пробелы.

static String valueOf (примитивный тип данных x)

Возвращает строковое представление переданного аргумента типа данных.

Скала — Массивы

Scala предоставляет структуру данных, массив , в котором хранится последовательная коллекция фиксированного размера элементов одного типа. Массив используется для хранения коллекции данных, но часто более полезно думать о массиве как о коллекции переменных одного типа.

Вместо того, чтобы объявлять отдельные переменные, такие как number0, number1, … и number99, вы объявляете одну переменную массива, такую ​​как числа, и используете числа [0], числа [1] и …, числа [99] для представления отдельные переменные. В этом руководстве рассказывается, как объявлять переменные массива, создавать массивы и обрабатывать массивы с использованием индексированных переменных. Индекс первого элемента массива — это число ноль, а индекс последнего элемента — это общее количество элементов минус один.

Объявление переменных массива

Чтобы использовать массив в программе, вы должны объявить переменную для ссылки на массив и указать тип массива, на который может ссылаться переменная.

Ниже приведен синтаксис объявления переменной массива.

Синтаксис

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

Здесь z объявлен как массив строк, который может содержать до трех элементов. Значения могут быть назначены отдельным элементам или получить доступ к отдельным элементам, это можно сделать с помощью команд, подобных следующим:

команда

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Здесь последний пример показывает, что в общем случае индексом может быть любое выражение, которое выдает целое число. Есть еще один способ определения массива —

var z = Array("Zara", "Nuha", "Ayan")

Следующая картинка представляет массив myList . Здесь myList содержит десять двойных значений и индексы от 0 до 9.

Обработка массивов

При обработке элементов массива мы часто используем структуры управления циклами, потому что все элементы в массиве имеют одинаковый тип, а размер массива известен.

Ниже приведен пример программы, показывающей, как создавать, инициализировать и обрабатывать массивы.

пример

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }

      // Summing all elements
      var total = 0.0;
      
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      // Finding the largest element
      var max = myList(0);
      
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      
      println("Max is " + max);
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala не поддерживает напрямую различные операции с массивами и предоставляет различные методы для обработки массивов в любом измерении. Если вы хотите использовать разные методы, то вам необходимо импортировать пакет Array._ .

Многомерные массивы

Существует много ситуаций, когда вам необходимо определить и использовать многомерные массивы (т. Е. Массивы, элементы которых являются массивами). Например, матрицы и таблицы являются примерами структур, которые могут быть реализованы в виде двумерных массивов.

Ниже приведен пример определения двумерного массива:

var myMatrix = ofDim[Int](3,3)

Это массив, который имеет три элемента, каждый из которых является массивом целых чисел, который имеет три элемента.

Попробуйте следующий пример программы для обработки многомерного массива —

пример

import Array._

object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

0 1 2
0 1 2
0 1 2

Конкатенированные массивы

Попробуйте следующий пример, который использует метод concat () для объединения двух массивов. Вы можете передать более одного массива в качестве аргументов метода concat ().

пример

import Array._

object Demo {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)
      
      // Print all the array elements
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Создать массив с диапазоном

Использование метода range () для генерации массива, содержащего последовательность возрастающих целых чисел в заданном диапазоне. Вы можете использовать последний аргумент как шаг для создания последовательности; если вы не используете последний аргумент, тогда шаг будет принят за 1.

Давайте возьмем пример создания массива диапазона (10, 20, 2): это означает создание массива с элементами между 10 и 20 и разностью диапазона 2. Элементами в массиве являются 10, 12, 14, 16 и 18. ,

Другой пример: диапазон (10, 20). Здесь разница в диапазоне не указана, поэтому по умолчанию используется 1 элемент. Он создает массив с элементами от 10 до 20 с разницей в диапазоне 1. Элементами массива являются 10, 11, 12, 13,… и 19.

В следующем примере программы показано, как создать массив с диапазонами.

пример

import Array._

object Demo {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Scala Array Методы

Ниже приведены важные методы, которые вы можете использовать при игре с массивом. Как показано выше, вам придется импортировать пакет Array._ перед использованием любого из упомянутых методов. Для полного списка доступных методов, пожалуйста, проверьте официальную документацию Scala.

def apply (x: T, xs: T *): массив [T]

Создает массив из T объектов, где T может быть Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean.

def concat [T] (xss: массив [T] *): массив [T]

Объединяет все массивы в один массив.

def copy (src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, длина: Int): единица измерения

Скопируйте один массив в другой. Эквивалент Java System.arraycopy (src, srcPos, dest, destPos, length).

def empty [T]: Array [T]

Возвращает массив длины 0

def iterate [T] (начало: T, len: Int) (f: (T) => T): массив [T]

Возвращает массив, содержащий повторные применения функции к начальному значению.

def fill [T] (n: Int) (elem: => T): Array [T]

Возвращает массив, который содержит результаты вычисления некоторого элемента несколько раз.

def fill [T] (n1: Int, n2: Int) (elem: => T): Array [Array [T]]

Возвращает двумерный массив, который содержит результаты вычисления некоторого элемента несколько раз.

def iterate [T] (начало: T, len: Int) (f: (T) => T): массив [T]

Возвращает массив, содержащий повторные применения функции к начальному значению.

def ofDim [T] (n1: Int): массив [T]

Создает массив с заданными размерами.

def ofDim [T] (n1: Int, n2: Int): Array [Array [T]]

Создает 2-мерный массив

def ofDim [T] (n1: Int, n2: Int, n3: Int): Array [Array [Array [T]]]

Создает 3-мерный массив

диапазон определения (начало: Int, конец: Int, шаг: Int): Array [Int]

Возвращает массив, содержащий одинаково расположенные значения в некотором целочисленном интервале.

диапазон определения (начало: Int, конец: Int): Array [Int]

Возвращает массив, содержащий последовательность увеличивающихся целых чисел в диапазоне.

def tabulate [T] (n: Int) (f: (Int) => T): Array [T]

Возвращает массив, содержащий значения данной функции в диапазоне целочисленных значений, начиная с 0.

def tabulate [T] (n1: Int, n2: Int) (f: (Int, Int) => T): Array [Array [T]]

Возвращает двумерный массив, содержащий значения данной функции в диапазонах целочисленных значений, начиная с 0.

Scala — Коллекции

Scala имеет богатый набор коллекционных библиотек. Коллекции являются контейнерами вещей. Эти контейнеры могут быть последовательными, линейными наборами элементов, такими как List, Tuple, Option, Map и т. Д. Коллекции могут иметь произвольное количество элементов или быть ограничены нулем или одним элементом (например, Option).

Коллекции могут быть строгими или ленивыми . Ленивые коллекции имеют элементы, которые могут не потреблять память до тех пор, пока к ним не будет получен доступ, например, диапазоны . Кроме того, коллекции могут быть изменяемыми (содержимое ссылки может изменяться) или неизменными (вещь, на которую ссылается ссылка, никогда не изменяется). Обратите внимание, что неизменяемые коллекции могут содержать изменяемые элементы.

Для некоторых задач изменяемые коллекции работают лучше, а для других неизменные коллекции работают лучше. В случае сомнений лучше начать с неизменяемой коллекции и изменить ее позже, если вам нужны изменяемые.

Эта глава проливает свет на наиболее часто используемые типы коллекций и наиболее часто используемые операции над этими коллекциями.

Scala Lists

Scala’s List [T] — это связанный список типа T.

Наборы Скала

Набор представляет собой набор попарно различных элементов одного типа.

Scala Maps

Карта — это набор пар ключ / значение. Любое значение может быть получено на основе его ключа.

Скала Кортежи

В отличие от массива или списка, кортеж может содержать объекты разных типов.

Опции Scala

Опция [T] предоставляет контейнер для нуля или одного элемента данного типа.

Scala Iterators

Итератор — это не коллекция, а способ доступа к элементам коллекции один за другим.

Скала — Черты

Черта инкапсулирует определения методов и полей, которые затем могут быть повторно использованы путем смешивания их в классы. В отличие от наследования классов, в котором каждый класс должен наследовать только от одного суперкласса, класс может смешиваться в любом количестве признаков.

Черты используются для определения типов объектов путем указания сигнатуры поддерживаемых методов. Scala также позволяет частично реализовывать черты, но черты могут не иметь параметров конструктора.

Определение черты выглядит точно так же, как определение класса, за исключением того, что оно использует черту ключевого слова. Ниже приведен базовый пример синтаксиса черты.

Синтаксис

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

Эта черта состоит из двух методов isEqual и isNotEqual . Здесь мы не дали никакой реализации для isEqual, где другой метод имеет свою реализацию. Дочерние классы, расширяющие черту, могут дать реализацию для не реализованных методов. Таким образом, черта очень похожа на то, что у нас есть абстрактные классы в Java.

Предположим, что пример признака Equal содержит два метода isEqual () и isNotEqual () . Признак Equal содержит один реализованный метод isEqual (), поэтому, когда пользовательский класс Point расширяет признак Equal , должна быть обеспечена реализация метода isEqual () в классе Point .

Здесь необходимо знать два важных метода Scala, которые используются в следующем примере.

• obj.isInstanceOf [Point] Для проверки Тип obj и Point одинаковы не являются.

• obj.asInstanceOf [Point] означает точное приведение типа объекта obj и возвращает тот же объект, что и тип Point.

obj.isInstanceOf [Point] Для проверки Тип obj и Point одинаковы не являются.

obj.asInstanceOf [Point] означает точное приведение типа объекта obj и возвращает тот же объект, что и тип Point.

Попробуйте следующий пример программы для реализации черт.

пример

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
   var x: Int = xc
   var y: Int = yc
   
   def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}

object Demo {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

true
false
true

Классы ценности и универсальные черты

Классы значений — это новый механизм в Scala, позволяющий избежать выделения объектов времени выполнения. Он содержит основной конструктор с ровно одним параметром val . Он содержит только методы (def), недопустимые var, val, вложенные классы, признаки или объекты. Значение класса не может быть расширен другим классом. Это может быть возможно путем расширения вашего класса значений с AnyVal. Безопасность типов пользовательских типов данных без затрат времени выполнения.

Давайте рассмотрим примеры классов значений «Вес», «Рост», «Электронная почта», «Возраст» и т. Д. Для всех этих примеров не требуется выделять память в приложении.

Класс значения не может расширять черты. Чтобы позволить классам значений расширять черты, вводятся универсальные черты , которые распространяются на Any .

пример

trait Printable extends Any {
   def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable

object Demo {
   def main(args: Array[String]) {
      val w = new Wrapper(3)
      w.print() // actually requires instantiating a Wrapper instance
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Это даст вам хэш-код класса Wrapper.

Wrapper@13

Когда использовать черты?

Не существует твердого правила, но вот несколько рекомендаций для рассмотрения —

• Если поведение не будет использоваться повторно, сделайте его конкретным классом. Это не многоразовое поведение в конце концов.

• Если это может быть повторно использовано в нескольких, не связанных между собой классах, сделайте это признаком. Только черты могут быть смешаны в разных частях иерархии классов.

• Если вы хотите наследовать от него в коде Java, используйте абстрактный класс.

• Если вы планируете распространять его в скомпилированной форме и ожидаете, что внешние группы будут писать классы, унаследованные от него, вы можете склоняться к использованию абстрактного класса.

• Если эффективность очень важна, склоняйтесь к использованию класса.

Если поведение не будет использоваться повторно, сделайте его конкретным классом. Это не многоразовое поведение в конце концов.

Если это может быть повторно использовано в нескольких, не связанных между собой классах, сделайте это признаком. Только черты могут быть смешаны в разных частях иерархии классов.

Если вы хотите наследовать от него в коде Java, используйте абстрактный класс.

Если вы планируете распространять его в скомпилированной форме и ожидаете, что внешние группы будут писать классы, унаследованные от него, вы можете склоняться к использованию абстрактного класса.

Если эффективность очень важна, склоняйтесь к использованию класса.

Scala — Pattern Matching

Сопоставление с образцом является второй наиболее широко используемой функцией Scala после значений функций и замыканий. Scala обеспечивает отличную поддержку сопоставления с образцом при обработке сообщений.

Сопоставление с шаблоном включает последовательность альтернатив, каждая из которых начинается с ключевого слова case . Каждая альтернатива включает в себя шаблон и одно или несколько выражений , которые будут оцениваться, если шаблон соответствует. Символ стрелки => отделяет шаблон от выражений.

Попробуйте следующий пример программы, которая показывает, как сопоставить целочисленное значение.

пример

object Demo {
   def main(args: Array[String]) {
      println(matchTest(3))
   }
   
   def matchTest(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

many

Блок с инструкциями case определяет функцию, которая отображает целые числа в строки. Ключевое слово match обеспечивает удобный способ применения функции (например, функции сопоставления с шаблоном выше) к объекту.

Попробуйте следующий пример программы, которая сопоставляет значение с шаблонами разных типов.

пример

object Demo {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
   }
   
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

2
many
one

Сопоставление с использованием Case Class

Классы case — это специальные классы, которые используются при сопоставлении с образцами выражений. Синтаксически это стандартные классы со специальным модификатором: case .

Попробуйте следующее: это простой пример сопоставления с шаблоном, использующий класс case.

пример

object Demo {
   def main(args: Array[String]) {
      val alice = new Person("Alice", 25)
      val bob = new Person("Bob", 32)
      val charlie = new Person("Charlie", 32)
   
      for (person <- List(alice, bob, charlie)) {
         person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) => println(
               "Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   case class Person(name: String, age: Int)
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?

Добавление ключевого слова case приводит к тому, что компилятор автоматически добавляет ряд полезных функций. Ключевое слово предполагает связь с выражениями регистра при сопоставлении с образцом.

Во-первых, компилятор автоматически преобразует аргументы конструктора в неизменяемые поля (vals). Ключевое слово val необязательно. Если вам нужны изменяемые поля, используйте ключевое слово var. Итак, наши списки аргументов конструктора теперь короче.

Во-вторых, компилятор автоматически реализует методы equals, hashCode и toString для класса, которые используют поля, указанные в качестве аргументов конструктора. Таким образом, нам больше не нужны наши собственные методы toString ().

Наконец, также тело класса Person становится пустым, потому что нет методов, которые нам нужно определить!

Scala — регулярные выражения

В этой главе объясняется, как Scala поддерживает регулярные выражения через класс Regex, доступный в пакете scala.util.matching.

Попробуйте следующий пример программы, где мы попытаемся найти слово Scala из оператора.

пример

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = "Scala".r
      val str = "Scala is Scalable and cool"
      
      println(pattern findFirstIn str)
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Some(Scala)

Мы создаем String и вызываем метод r () . Scala неявно преобразует String в RichString и вызывает этот метод для получения экземпляра Regex. Чтобы найти первое совпадение регулярного выражения, просто вызовите метод findFirstIn () . Если вместо того, чтобы найти только первое вхождение, мы хотели бы найти все вхождения соответствующего слова, мы можем использовать метод findAllIn (), и в случае, если в целевой строке доступно несколько слов Scala, это вернет коллекцию всех соответствующих слова.

Вы можете использовать метод mkString () для объединения результирующего списка, и вы можете использовать конвейер (|) для поиска в маленьком и заглавном регистре Scala, а вместо этого вы можете использовать конструктор Regex или метод r () для создания шаблона.

Попробуйте следующий пример программы.

пример

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("(S|s)cala")
      val str = "Scala is scalable and cool"
      
      println((pattern findAllIn str).mkString(","))
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Scala,scala

Если вы хотите заменить соответствующий текст, мы можем использовать replaceFirstIn (), чтобы заменить первое совпадение, или replaceAllIn (), чтобы заменить все вхождения.

пример

object Demo {
   def main(args: Array[String]) {
      val pattern = "(S|s)cala".r
      val str = "Scala is scalable and cool"
      
      println(pattern replaceFirstIn(str, "Java"))
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Java is scalable and cool

Формирование регулярных выражений

Scala наследует свой синтаксис регулярных выражений от Java, который, в свою очередь, наследует большинство функций Perl. Вот лишь несколько примеров, которых должно быть достаточно для повышения квалификации —

Ниже приведена таблица со списком всех синтаксисов метасимволов регулярных выражений, доступных в Java.

Примеры регулярных выражений

Обратите внимание — каждая обратная косая черта появляется дважды в строке выше. Это связано с тем, что в Java и Scala одиночная обратная косая черта является escape-символом в строковом литерале, а не обычным символом, который отображается в строке. Поэтому вместо ‘\’ вам нужно написать ‘\\’, чтобы получить один обратный слеш в строке.

Попробуйте следующий пример программы.

пример

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("abl[ae]\\d+")
      val str = "ablaw is able1 and cool"
      
      println((pattern findAllIn str).mkString(","))
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

able1

Scala — обработка исключений

Исключения в Scala работают как исключения во многих других языках, таких как Java. Вместо того, чтобы возвращать значение обычным способом, метод может завершиться с помощью исключения. Однако на самом деле Scala не имеет проверенных исключений.

Когда вы хотите обработать исключения, вы используете блок try {…} catch {…}, как в Java, за исключением того, что блок catch использует сопоставление для идентификации и обработки исключений.

Бросать исключения

Бросок исключения выглядит так же, как в Java. Вы создаете объект исключения и затем бросаете его с помощью ключевого слова throw следующим образом.

throw new IllegalArgumentException

Ловить исключения

Scala позволяет вам попробовать / перехватить любое исключение в одном блоке, а затем выполнить сопоставление с ним с помощью блоков case . Попробуйте следующий пример программы для обработки исключений.

пример

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Missing file exception

Поведение этого выражения try-catch такое же, как и в других языках, за исключением. Тело выполняется, и если оно выдает исключение, каждое предложение catch проверяется по очереди.

Окончательный пункт

Вы можете заключить выражение в предложение finally , если хотите, чтобы какой-либо код выполнялся независимо от завершения выражения. Попробуйте следующую программу.

пример

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Missing file exception
Exiting finally...

Скала — экстракторы

Экстрактор в Scala — это объект, у которого в качестве одного из членов есть метод unapply . Цель этого неприменимого метода — сопоставить значение и разобрать его. Часто объект экстрактора также определяет двойной метод, применяемый для создания значений, но это не обязательно.

пример

Давайте возьмем пример того, как объект определяет методы apply и unapply . Метод apply имеет то же значение, что и всегда: он превращает Test в объект, который можно применять к аргументам в скобках так же, как применяется метод. Таким образом, вы можете написать Test («Zara», «gmail.com»), чтобы создать строку «Zara@gmail.com».

Метод unapply — это то, что превращает класс Test в экстрактор и обращает процесс создания применения . Если apply принимает две строки и формирует из них строку адреса электронной почты, unapply принимает адрес электронной почты и возвращает потенциально две строки: пользователя и домен адреса.

Отмена также должна обрабатывать случай, когда данная строка не является адресом электронной почты. Вот почему unapply возвращает тип Option для пар строк. Его результатом является либо Some (пользователь, домен), если строка str является адресом электронной почты с указанными частями пользователя и домена, либо None, если str не является адресом электронной почты. Вот несколько примеров следующим образом.

Синтаксис

unapply("Zara@gmail.com") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None

В следующем примере программа показывает объект экстрактора для адресов электронной почты.

пример

object Demo {
   def main(args: Array[String]) {
      println ("Apply method : " + apply("Zara", "gmail.com"));
      println ("Unapply method : " + unapply("Zara@gmail.com"));
      println ("Unapply method : " + unapply("Zara Ali"));
   }
   
   // The injection method (optional)
   def apply(user: String, domain: String) = {
      user +"@"+ domain
   }

   // The extraction method (mandatory)
   def unapply(str: String): Option[(String, String)] = {
      val parts = str split "@"
      
      if (parts.length == 2){
         Some(parts(0), parts(1)) 
      } else {
         None
      }
   }
}

Сохраните вышеуказанную программу в Demo.scala . Следующие команды используются для компиляции и выполнения этой программы.

команда

\>scalac Demo.scala
\>scala Demo

Выход

Apply method : Zara@gmail.com
Unapply method : Some((Zara,gmail.com))
Unapply method : None

Сравнение шаблонов с экстракторами

Когда за экземпляром класса следуют круглые скобки со списком из нуля или более параметров, компилятор вызывает метод apply для этого экземпляра. Мы можем определить применение как в объектах, так и в классах.

Как упомянуто выше, цель метода unapply состоит в том, чтобы извлечь конкретное значение, которое мы ищем. Это делает противоположную операцию применяется делает. При сравнении объекта экстрактора с использованием оператора match автоматически будет выполнен метод неприменить .

Попробуйте следующий пример программы.

пример

object Demo {
   def main(args: Array[String]) {
      val x = Demo(5)
      println(x)

      x match {
         case Demo(num) => println(x+" is bigger two times than "+num)
         
         //unapply is invoked
         case _ => println("i cannot calculate")
      }
   }
   def apply(x: Int) = x*2
   def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}