Scala - Guia Rápido

Scala, abreviação de Scalable Language, é uma linguagem de programação funcional híbrida. Foi criado por Martin Odersky. Scala integra suavemente os recursos das linguagens orientadas a objetos e funcionais. Scala é compilado para rodar na máquina virtual Java. Muitas empresas existentes, que dependem do Java para aplicativos críticos de negócios, estão recorrendo ao Scala para aumentar sua produtividade de desenvolvimento, escalabilidade de aplicativos e confiabilidade geral.

Apresentamos aqui alguns pontos que tornam o Scala a primeira escolha dos desenvolvedores de aplicativos.

Scala é orientado a objetos

Scala é uma linguagem puramente orientada a objetos, no sentido de que todo valor é um objeto. Tipos e comportamento de objetos são descritos por classes e características que serão explicadas nos capítulos subsequentes.

As aulas são estendidas por subclassing e um flexível mixin-based composition mecanismo como um substituto limpo para herança múltipla.

Scala é funcional

Scala também é uma linguagem funcional no sentido de que cada função é um valor e cada valor é um objeto, portanto, em última análise, cada função é um objeto.

Scala fornece uma sintaxe leve para definir anonymous functions, suporta higher-order functions, permite que as funções sejam nestede suporta currying. Esses conceitos serão explicados nos capítulos subsequentes.

Scala é digitado estaticamente

Scala, ao contrário de algumas das outras linguagens tipadas estaticamente (C, Pascal, Rust, etc.), não espera que você forneça informações de tipo redundantes. Você não precisa especificar um tipo na maioria dos casos e certamente não precisa repeti-lo.

Scala é executado no JVM

Scala é compilado em Java Byte Code que é executado pela Java Virtual Machine (JVM). Isso significa que Scala e Java têm uma plataforma de tempo de execução comum. Você pode facilmente mudar de Java para Scala.

O compilador Scala compila seu código Scala em Java Byte Code, que pode então ser executado pelo 'scala'comando. O 'scala'comando é semelhante ao java , no sentido de que executa seu código Scala compilado.

Scala pode executar código Java

Scala permite que você use todas as classes do Java SDK e também suas próprias classes Java personalizadas ou seus projetos de código aberto Java favoritos.

Scala pode fazer processamento simultâneo e sincronizado

Scala permite que você expresse padrões gerais de programação de uma maneira eficaz. Ele reduz o número de linhas e ajuda o programador a codificar de forma segura. Ele permite que você escreva códigos de maneira imutável, o que facilita a aplicação de simultaneidade e paralelismo (Sincronizar).

Scala vs Java

Scala possui um conjunto de recursos completamente diferente do Java. Alguns destes são -

• Todos os tipos são objetos
• Inferência de tipo
• Funções Aninhadas
• Funções são objetos
• Suporte a idioma específico de domínio (DSL)
• Traits
• Closures
• Suporte de simultaneidade inspirado em Erlang

Scala Web Frameworks

Scala está sendo usado em todos os lugares e de forma importante em aplicativos da Web corporativos. Você pode verificar algumas das estruturas da web Scala mais populares -

• The Lift Framework

• A estrutura do Play

• A estrutura Bowler

Scala pode ser instalado em qualquer sistema baseado em UNIX ou Windows. Antes de iniciar a instalação do Scala em sua máquina, você deve ter o Java 1.8 ou superior instalado em seu computador.

Siga as etapas abaixo para instalar o Scala.

Etapa 1: verifique sua instalação Java

Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, execute qualquer um dos dois comandos a seguir, dependendo da plataforma em que está trabalhando.

Se a instalação do Java foi feita corretamente, ele exibirá a versão atual e as especificações de sua instalação do Java. Um exemplo de saída é fornecido na tabela a seguir.

Presumimos que os leitores deste tutorial tenham o Java SDK versão 1.8.0_31 instalado em seus sistemas.

Caso você não tenha Java SDK, baixe sua versão atual em http://www.oracle.com/technetwork/java/javase/downloads/index.html e instale-o.

Etapa 2: definir seu ambiente Java

Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,

Anexe o caminho completo do local do compilador Java ao caminho do sistema.

Execute o comando java -version no prompt de comando, conforme explicado acima.

Etapa 3: Instale o Scala

Você pode baixar Scala de http://www.scala-lang.org/downloads. No momento em que escrevi este tutorial, eu baixei 'scala-2.11.5-installer.jar'. Certifique-se de ter privilégios de administrador para continuar. Agora, execute o seguinte comando no prompt de comando -

Por fim, abra um novo prompt de comando e digite Scala -versione pressione Enter. Você deve ver o seguinte -

Se você tiver um bom conhecimento de Java, será muito fácil aprender Scala. A maior diferença sintática entre Scala e Java é que o ';' o caractere de fim de linha é opcional.

Quando consideramos um programa Scala, ele pode ser definido como uma coleção de objetos que se comunicam por meio da invocação dos métodos uns dos outros. Vamos agora dar uma olhada rápida no que significam classes, objetos, métodos e variáveis ​​de instância.

• Object- Os objetos têm estados e comportamentos. Um objeto é uma instância de uma classe. Exemplo - Um cão tem estados - cor, nome, raça e também comportamentos - abanar, latir e comer.

• Class - Uma classe pode ser definida como um template / blueprint que descreve os comportamentos / estados relacionados à classe.

• Methods- Um método é basicamente um comportamento. Uma classe pode conter muitos métodos. É nos métodos onde as lógicas são escritas, os dados são manipulados e todas as ações são executadas.

• Fields- Cada objeto tem seu conjunto único de variáveis ​​de instância, que são chamadas de campos. O estado de um objeto é criado pelos valores atribuídos a esses campos.

• Closure - A closure é uma função, cujo valor de retorno depende do valor de uma ou mais variáveis ​​declaradas fora desta função.

• Traits- Uma característica encapsula definições de método e campo, que podem ser reutilizadas misturando-as em classes. Traits são usados ​​para definir tipos de objetos especificando a assinatura dos métodos suportados.

Primeiro Programa Scala

Podemos executar um programa Scala em dois modos: um é interactive mode e outro é script mode.

Modo Interativo

Abra o prompt de comando e use o seguinte comando para abrir o Scala.

\>scala

Se Scala estiver instalado em seu sistema, a seguinte saída será exibida -

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

Digite o seguinte texto à direita do prompt do Scala e pressione a tecla Enter -

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

Isso produzirá o seguinte resultado -

Hello, Scala!

Modo Script

Use as instruções a seguir para escrever um programa Scala no modo de script. Abra o bloco de notas e adicione o seguinte código a ele.

Exemplo

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

Salve o arquivo como - HelloWorld.scala.

Abra a janela do prompt de comando e vá para o diretório onde o arquivo do programa foi salvo. O 'scalac'comando é usado para compilar o programa Scala e irá gerar alguns arquivos de classe no diretório atual. Um deles será chamadoHelloWorld.class. Este é um bytecode que será executado na Java Virtual Machine (JVM) usando 'scala'comando.

Use o seguinte comando para compilar e executar seu programa Scala.

\> scalac HelloWorld.scala
\> scala HelloWorld

Resultado

Hello, World!

Sintaxe Básica

A seguir estão as sintaxes básicas e convenções de codificação na programação Scala.

• Case Sensitivity - Scala diferencia maiúsculas de minúsculas, o que significa identificador Hello e hello teria um significado diferente em Scala.

• Class Names- Para todos os nomes de turmas, a primeira letra deve estar em maiúsculas. Se várias palavras forem usadas para formar o nome da classe, a primeira letra de cada palavra interna deve estar em maiúsculas.

  Example - classe MyFirstScalaClass.

• Method Names- Todos os nomes de métodos devem começar com uma letra minúscula. Se várias palavras forem usadas para formar o nome do método, a primeira letra de cada palavra interna deve estar em maiúsculas.

  Example - def myMethodName ()

• Program File Name- O nome do arquivo do programa deve corresponder exatamente ao nome do objeto. Ao salvar o arquivo, você deve salvá-lo usando o nome do objeto (Lembre-se de que Scala diferencia maiúsculas de minúsculas) e acrescente '.scala'ao final do nome. (Se o nome do arquivo e o nome do objeto não corresponderem, seu programa não será compilado).

  Example- Suponha que 'HelloWorld' seja o nome do objeto. Em seguida, o arquivo deve ser salvo como 'HelloWorld.scala'.

• def main(args: Array[String]) - O processamento do programa Scala começa a partir do método main (), que é uma parte obrigatória de todo Programa Scala.

Identificadores Scala

Todos os componentes do Scala requerem nomes. Os nomes usados ​​para objetos, classes, variáveis ​​e métodos são chamados de identificadores. Uma palavra-chave não pode ser usada como identificador e os identificadores diferenciam maiúsculas de minúsculas. Scala oferece suporte a quatro tipos de identificadores.

Identificadores Alfanuméricos

Um identificador alfanumérico começa com uma letra ou sublinhado, que pode ser seguido por outras letras, dígitos ou sublinhados. O caractere '$' é uma palavra-chave reservada no Scala e não deve ser usado em identificadores.

A seguir estão legal alphanumeric identifiers -

age, salary, _value,  __1_value

A seguir estão illegal identifiers -

$salary, 123abc, -salary

Identificadores de operador

Um identificador de operador consiste em um ou mais caracteres de operador. Os caracteres do operador são caracteres ASCII imprimíveis, como +,:,?, ~ Ou #.

A seguir estão os identificadores legais de operador -

+ ++ ::: <?> :>

O compilador Scala internamente "mutilará" identificadores de operador para transformá-los em identificadores Java legais com $ caracteres incorporados. Por exemplo, o identificador: -> seria representado internamente como$colon$menos $ maior.

Identificadores mistos

Um identificador misto consiste em um identificador alfanumérico, que é seguido por um sublinhado e um identificador de operador.

A seguir estão os identificadores mistos legais -

unary_+,  myvar_=

Aqui, unário_ + usado como um nome de método define um operador unário + e myvar_ = usado como nome de método define um operador de atribuição (sobrecarga de operador).

Identificadores literais

Um identificador literal é uma string arbitrária encerrada em marcas de retorno (`...`).

A seguir estão os identificadores literais legais -

`x` `<clinit>` `yield`

Palavras-chave Scala

A lista a seguir mostra as palavras reservadas em Scala. Essas palavras reservadas não podem ser usadas como constantes ou variáveis ​​ou quaisquer outros nomes de identificador.

Comentários no Scala

Scala oferece suporte a comentários de uma e de várias linhas muito semelhantes ao Java. Os comentários de várias linhas podem ser aninhados, mas devem ser aninhados corretamente. Todos os caracteres disponíveis em qualquer comentário são ignorados pelo compilador 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!") 
   }
}

Linhas em branco e espaços em branco

Uma linha contendo apenas espaços em branco, possivelmente com um comentário, é conhecida como linha em branco e o Scala a ignora totalmente. Os tokens podem ser separados por caracteres de espaço em branco e / ou comentários.

Caracteres de Newline

Scala é uma linguagem orientada por linha em que as instruções podem ser encerradas por ponto-e-vírgula (;) ou novas linhas. Um ponto-e-vírgula no final de uma instrução geralmente é opcional. Você pode digitar um se quiser, mas não precisa se a instrução aparecer sozinha em uma única linha. Por outro lado, um ponto-e-vírgula é necessário se você escrever várias instruções em uma única linha. A sintaxe abaixo é o uso de várias instruções.

val s = "hello"; println(s)

Pacotes Scala

Um pacote é um módulo de código nomeado. Por exemplo, o pacote do utilitário Lift é net.liftweb.util. A declaração do pacote é a primeira linha sem comentários no arquivo de origem da seguinte forma -

package com.liftcode.stuff

Os pacotes Scala podem ser importados para que possam ser referenciados no escopo de compilação atual. A instrução a seguir importa o conteúdo do pacote scala.xml -

import scala.xml._

Você pode importar uma única classe e objeto, por exemplo, HashMap do pacote scala.collection.mutable -

import scala.collection.mutable.HashMap

Você pode importar mais de uma classe ou objeto de um único pacote, por exemplo, TreeMap e TreeSet do pacote scala.collection.immutable -

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

Aplicar Dinâmica

Um traço de marcador que permite invocações dinâmicas. As instâncias x desta característica permitem invocações de método x.meth (args) para nomes de métodos arbitrários meth e args de listas de argumentos, bem como acessos a campos x.field para campos de nomes de campos arbitrários. Este recurso é apresentado no Scala-2.10.

Se uma chamada não for nativamente suportada por x (ou seja, se a verificação de tipo falhar), ela será reescrita de acordo com as seguintes regras -

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 tem todos os mesmos tipos de dados que Java, com a mesma pegada de memória e precisão. A seguir está a tabela com detalhes sobre todos os tipos de dados disponíveis no Scala -

Todos os tipos de dados listados acima são objetos. Não existem tipos primitivos como em Java. Isso significa que você pode chamar métodos em um Int, Long, etc.

Literais básicos de Scala

As regras que Scala usa para literais são simples e intuitivas. Esta seção explica todos os literais básicos do Scala.

Literais Integrais

Literais inteiros são geralmente do tipo Int ou do tipo Long quando seguidos por um sufixo L ou l. Aqui estão alguns literais inteiros -

0
035
21 
0xFFFFFFFF 
0777L

Literal de ponto flutuante

Literais de ponto flutuante são do tipo Float quando seguidos por um sufixo de tipo de ponto flutuante F ou f, e são do tipo Double, caso contrário. Aqui estão alguns literais de ponto flutuante -

0.0 
1e30f 
3.14159f 
1.0e100
.1

Literais booleanos

Os literais booleanos true e false são membros do tipo Boolean.

Literais de símbolo

Um símbolo literal 'x é uma abreviatura para a expressão scala.Symbol("x"). Symbol é uma classe de caso, definida da seguinte maneira.

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

Literais de caracteres

Um literal de caractere é um único caractere entre aspas. O caractere é um caractere Unicode imprimível ou é descrito por uma seqüência de escape. Aqui estão alguns literais de caracteres -

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

Literais de string

Um literal de string é uma sequência de caracteres entre aspas duplas. Os caracteres são caracteres Unicode imprimíveis ou são descritos por sequências de escape. Aqui estão alguns literais de string -

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

Multi-Line Strings

Um literal de string de várias linhas é uma sequência de caracteres colocados entre aspas triplas "" "..." "". A sequência de caracteres é arbitrária, exceto que pode conter três ou mais aspas consecutivas apenas no final.

Os caracteres não devem ser necessariamente imprimíveis; novas linhas ou outros caracteres de controle também são permitidos. Aqui está um literal de string de várias linhas -

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

Valores Nulos

O valor nulo é do tipo scala.Nulle, portanto, é compatível com todos os tipos de referência. Ele denota um valor de referência que se refere a um objeto especial "nulo".

Sequências de Escape

As seguintes sequências de escape são reconhecidas em literais de caracteres e strings.

Um caractere com Unicode entre 0 e 255 também pode ser representado por um escape octal, ou seja, uma barra invertida '\' seguida por uma sequência de até três caracteres octais. A seguir está o exemplo para mostrar alguns caracteres de sequência de escape -

Exemplo

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

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Resultado

Hello   World

As variáveis ​​nada mais são do que locais de memória reservados para armazenar valores. Isso significa que, ao criar uma variável, você reserva algum espaço na memória.

Com base no tipo de dados de uma variável, o compilador aloca memória e decide o que pode ser armazenado na memória reservada. Portanto, ao atribuir diferentes tipos de dados a variáveis, você pode armazenar números inteiros, decimais ou caracteres nessas variáveis.

Declaração de Variável

Scala tem uma sintaxe diferente para declarar variáveis. Eles podem ser definidos como um valor, ou seja, uma constante ou uma variável. Aqui, myVar é declarado usando a palavra-chave var. É uma variável que pode mudar de valor e é chamadamutable variable. A seguir está a sintaxe para definir uma variável usandovar palavra-chave -

Sintaxe

var myVar : String = "Foo"

Aqui, myVal é declarado usando a palavra-chave val. Isso significa que é uma variável que não pode ser alterada e é chamadaimmutable variable. A seguir está a sintaxe para definir uma variável usando a palavra-chave val -

Sintaxe

val myVal : String = "Foo"

Tipos de dados variáveis

O tipo de uma variável é especificado após o nome da variável e antes do sinal de igual. Você pode definir qualquer tipo de variável Scala mencionando seu tipo de dados da seguinte forma -

Sintaxe

val or val VariableName : DataType = [Initial Value]

Se você não atribuir nenhum valor inicial a uma variável, ele é válido da seguinte forma -

Sintaxe

var myVar :Int;
val myVal :String;

Inferência de tipo de variável

Quando você atribui um valor inicial a uma variável, o compilador Scala pode descobrir o tipo da variável com base no valor atribuído a ela. Isso é chamado de inferência de tipo de variável. Portanto, você pode escrever essas declarações de variáveis ​​assim -

Sintaxe

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

Aqui, por padrão, myVar será do tipo Int e myVal se tornará a variável do tipo String.

Múltiplas atribuições

Scala oferece suporte a várias atribuições. Se um bloco de código ou método retornar uma Tupla (Tuple- Contém coleção de objetos de diferentes tipos), a tupla pode ser atribuída a uma variável val. [Note - Estudaremos tuplas nos capítulos subsequentes.]

Sintaxe

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

E a inferência de tipo acerta -

Sintaxe

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

Programa Exemplo

A seguir está um programa de exemplo que explica o processo de declaração de variável no Scala. Este programa declara quatro variáveis ​​- duas variáveis ​​são definidas com a declaração de tipo e as duas restantes sem declaração de tipo.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Escopo Variável

As variáveis ​​no Scala podem ter três escopos diferentes, dependendo do local onde estão sendo usadas. Eles podem existir como campos, como parâmetros de método e como variáveis ​​locais. Abaixo estão os detalhes sobre cada tipo de escopo.

Campos

Os campos são variáveis ​​que pertencem a um objeto. Os campos são acessíveis de dentro de todos os métodos do objeto. Os campos também podem ser acessíveis fora do objeto, dependendo de quais modificadores de acesso o campo é declarado. Os campos de objeto podem ser tipos mutáveis ​​e imutáveis ​​e podem ser definidos usando qualquervar ou val.

Parâmetros do Método

Os parâmetros do método são variáveis, usadas para passar o valor dentro de um método, quando o método é chamado. Os parâmetros do método são acessíveis apenas de dentro do método, mas os objetos passados ​​podem ser acessíveis de fora, se você tiver uma referência ao objeto de fora do método. Os parâmetros do método são sempre imutáveis, definidos porval palavra-chave.

Variáveis ​​Locais

Variáveis ​​locais são variáveis ​​declaradas dentro de um método. Variáveis ​​locais são acessíveis apenas de dentro do método, mas os objetos que você cria podem escapar do método se você retorná-los do método. Variáveis ​​locais podem ser tipos mutáveis ​​e imutáveis ​​e podem ser definidas usando qualquervar ou val.

Este capítulo mostra como usar classes e objetos na programação Scala. Uma classe é um projeto para objetos. Depois de definir uma classe, você pode criar objetos a partir do blueprint da classe com a palavra-chavenew. Através do objeto você pode utilizar todas as funcionalidades da classe definida.

O diagrama a seguir demonstra a classe e o objeto tomando um exemplo de classe aluno, que contém as variáveis ​​de membro (nome e número de rolagem) e métodos de membro (setName () e setRollNo ()). Finalmente, todos são membros da classe. A classe é uma planta e os objetos são reais aqui. No diagrama a seguir, Aluno é uma classe e Harini, John e Maria são os objetos da classe Aluno, que têm nome e número de rolagem.

Aula Básica

A seguir está uma sintaxe simples para definir uma classe básica em Scala. Esta classe define duas variáveisx e y e um método: move, que não retorna um valor. Variáveis ​​de classe são chamadas, campos da classe e métodos são chamados métodos de classe.

O nome da classe funciona como um construtor de classe que pode receber vários parâmetros. O código acima define dois argumentos do construtor,xc e yc; ambos são visíveis em todo o corpo da classe.

Sintaxe

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

Conforme mencionado anteriormente neste capítulo, você pode criar objetos usando uma palavra-chave new e então você pode acessar os campos de classe e métodos como mostrado abaixo no exemplo -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Point x location : 20
Point y location : 30

Estendendo uma aula

Você pode estender uma classe base Scala e projetar uma classe herdada da mesma maneira que você faz em Java (use extends palavra-chave), mas há duas restrições: a substituição do método requer o override palavra-chave, e apenas a primaryO construtor pode passar parâmetros para o construtor base. Vamos estender nossa classe acima e adicionar mais um método de classe.

Exemplo

Vamos dar um exemplo de duas classes classe Point (como o mesmo exemplo acima) e a classe Location é uma classe herdada usando a palavra-chave extends. Tal um 'extendsA cláusula 'tem dois efeitos: faz com que a classe Location herde todos os membros não privados da classe Point e torna o tipo Location um subtipo da classe Point de tipo . Então aqui a classe Point é chamadasuperclasse a classe Location é chamadasubclass. Estender uma classe e herdar todos os recursos de uma classe pai é chamadoinheritance mas Scala permite a herança de apenas uma classe apenas.

Note - Métodos move () método na classe Point e move() method in Location class não substitua as definições correspondentes de movimento, uma vez que são definições diferentes (por exemplo, a primeira leva dois argumentos, enquanto a última leva três argumentos).

Experimente o programa de exemplo a seguir para implementar a herança.

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Classes implícitas

As classes implícitas permitem conversas implícitas com o construtor primário da classe quando a classe está no escopo. Classe implícita é uma classe marcada com a palavra-chave 'implícita'. Este recurso foi introduzido no Scala 2.10.

Syntax- A seguir está a sintaxe para classes implícitas. Aqui, a classe implícita está sempre no escopo do objeto, onde todas as definições de método são permitidas porque a classe implícita não pode ser uma classe de nível superior.

Sintaxe

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

Exemplo

Vamos dar um exemplo de uma classe implícita chamada IntTimescom o método times (). Significa que times () contém uma transação de loop que irá executar a instrução dada no número de vezes que damos. Vamos supor que a instrução fornecida seja “4 vezes println (“ Hello ”)” significa que a instrução println (“” Hello ”) será executada 4 vezes.

A seguir está o programa para o exemplo fornecido. Neste exemplo, duas classes de objetos são usadas (Run e Demo) para que tenhamos que salvar essas duas classes em arquivos diferentes com seus respectivos nomes, como segue.

Run.scala - Salve o seguinte programa em 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 - Salve o seguinte programa em Demo.scala.

import Run._

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

Os comandos a seguir são usados ​​para compilar e executar esses dois programas.

Comando

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

Resultado

Hello
Hello
Hello
Hello

Note -

• As classes implícitas devem ser definidas dentro de outra classe / objeto / característica (não no nível superior).

• Classes implícitas podem ter apenas um argumento não-implícito em seu construtor.

• As classes implícitas não podem ser nenhum método, membro ou objeto no escopo com o mesmo nome da classe implícita.

Objetos Singleton

Scala é mais orientado a objetos do que Java porque em Scala não podemos ter membros estáticos. Em vez disso, Scala temsingleton objects. Um singleton é uma classe que pode ter apenas uma instância, ou seja, Object. Você cria singleton usando a palavra-chaveobjectem vez da palavra-chave class. Como você não pode instanciar um objeto singleton, não pode passar parâmetros para o construtor primário. Você já viu todos os exemplos de objetos singleton nos quais chamou o método principal do Scala.

A seguir está o mesmo programa de exemplo para implementar o singleton.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Point x location : 10
Point y location : 20

Este capítulo o conduz pelos modificadores de acesso Scala. Membros de pacotes, classes ou objetos podem ser rotulados com os modificadores de acesso private e protected, e se não estivermos usando nenhuma dessas duas palavras-chave, então access será assumido como public. Esses modificadores restringem o acesso aos membros a certas regiões do código. Para usar um modificador de acesso, você inclui sua palavra-chave na definição de membros de pacote, classe ou objeto, como veremos na seção seguinte.

Membros privados

Um membro privado é visível apenas dentro da classe ou objeto que contém a definição do membro.

A seguir está o snippet de código de exemplo para explicar o membro privado -

Exemplo

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

No Scala, o acesso (novo Inner). f () é ilegal porque f é declarado privado no Inner e o acesso não é de dentro da classe Inner. Em contraste, o primeiro acesso a f na classe Innermost está OK, porque esse acesso está contido no corpo da classe Inner. Java permitiria ambos os acessos porque permite que uma classe externa acesse membros privados de suas classes internas.

Membros protegidos

Um membro protegido só pode ser acessado por subclasses da classe na qual o membro está definido.

A seguir está o exemplo de snippet de código para explicar o membro protegido -

Exemplo

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

O acesso a f na classe Sub está OK porque f é declarado protegido na classe 'Super' e a classe 'Sub' é uma subclasse de Super. Em contraste, o acesso a f na classe 'Outro' não é permitido, porque a classe 'Outro' não herda da classe 'Super'. Em Java, o último acesso ainda seria permitido porque a classe 'Other' está no mesmo pacote da classe 'Sub'.

Membros Públicos

Ao contrário dos membros privados e protegidos, não é necessário especificar a palavra-chave pública para membros públicos. Não há modificador explícito para membros públicos. Esses membros podem ser acessados ​​de qualquer lugar.

A seguir está o exemplo de snippet de código para explicar o membro público -

Exemplo

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

Escopo de proteção

Modificadores de acesso em Scala podem ser aumentados com qualificadores. Um modificador da forma privado [X] ou protegido [X] significa que o acesso é privado ou protegido "até" X, onde X designa algum pacote, classe ou objeto singleton.

Considere o seguinte exemplo -

Exemplo

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

Note - os seguintes pontos do exemplo acima -

• WorkDetails variáveis ​​estarão acessíveis a qualquer classe dentro do pacote profissional.

• Os amigos variáveis ​​estarão acessíveis a qualquer classe dentro da sociedade de pacotes incluídos.

• Segredos de variáveis ​​estarão acessíveis apenas no objeto implícito dentro dos métodos de instância (this).

Um operador é um símbolo que informa ao compilador para executar manipulações matemáticas ou lógicas específicas. Scala é rico em operadores integrados e fornece os seguintes tipos de operadores -

• Operadores aritméticos
• Operadores Relacionais
• Operadores lógicos
• Operadores bit a bit
• Operadores de atribuição

Este capítulo examinará os operadores aritméticos, relacionais, lógicos, de atribuição de bits e outros, um por um.

Operadores aritméticos

Os seguintes operadores aritméticos são suportados pela linguagem Scala. Por exemplo, vamos supor que a variável A contém 10 e a variável B contém 20, então -

Mostrar exemplos

Operadores Relacionais

Os seguintes operadores relacionais são suportados pela linguagem Scala. Por exemplo, vamos supor que a variável A contém 10 e a variável B contém 20, então -

Mostrar exemplos

Operadores lógicos

Os seguintes operadores lógicos são suportados pela linguagem Scala. Por exemplo, suponha que a variável A detém 1 e a variável B detém 0, então -

Mostrar exemplos

Operadores bit a bit

O operador bit a bit funciona em bits e executa a operação bit a bit. As tabelas de verdade para &, | e ^ são as seguintes -

Suponha que A = 60; e B = 13; agora em formato binário serão os seguintes -

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

Os operadores bit a bit suportados pela linguagem Scala estão listados na tabela a seguir. Suponha que a variável A tenha 60 e a variável B tenha 13, então -

Mostrar exemplos

Operadores de atribuição

Existem os seguintes operadores de atribuição suportados pela linguagem Scala -

Mostrar exemplos

Precedência de operadores em Scala

A precedência do operador determina o agrupamento de termos em uma expressão. Isso afeta como uma expressão é avaliada. Certos operadores têm precedência mais alta do que outros; por exemplo, o operador de multiplicação tem precedência mais alta do que o operador de adição -

Por exemplo, x = 7 + 3 * 2; aqui, x é atribuído a 13, não 20, porque o operador * tem precedência mais alta do que +, portanto, primeiro é multiplicado por 3 * 2 e, em seguida, é adicionado a 7.

Dê uma olhada na tabela a seguir. Os operadores com a precedência mais alta aparecem na parte superior da tabela e aqueles com a precedência mais baixa aparecem na parte inferior. Em uma expressão, os operadores de precedência superior serão avaliados primeiro.

Este capítulo o conduz pelas instruções de construção condicional na programação Scala. A seguir está a forma geral de uma estrutura IF ... ELSE típica de tomada de decisão encontrada na maioria das linguagens de programação.

Fluxograma

A seguir está um diagrama de fluxo para declaração condicional.

declaração if

A instrução 'if' consiste em uma expressão booleana seguida por uma ou mais instruções.

Sintaxe

A sintaxe de uma instrução 'if' é a seguinte.

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

Se a expressão booleana for avaliada como verdadeira, o bloco de código dentro da expressão 'if' será executado. Caso contrário, o primeiro conjunto de código após o final da expressão 'if' (após a chave de fechamento) será executado.

Experimente o programa de exemplo a seguir para entender as expressões condicionais (se expressão) na linguagem de programação Scala.

Exemplo

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

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

This is if statement

Declaração If-else

Uma instrução 'if' pode ser seguida por uma instrução else opcional , que é executada quando a expressão booleana é falsa.

Sintaxe

A sintaxe de um if ... else is -

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

Experimente o programa de exemplo a seguir para entender as instruções condicionais (instrução if-else) na linguagem de programação Scala.

Exemplo

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

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

This is else statement

Instrução If-else-if-else

Uma instrução 'if' pode ser seguida por uma instrução opcional ' else if ... else ', que é muito útil para testar várias condições usando uma instrução if ... else if única.

Ao usar as instruções if, else if, else, há alguns pontos a serem considerados.

• Um 'se' pode ter zero ou mais um e deve vir depois de qualquer outro se.

• Um 'se' pode ter zero a muitos outros if's e eles devem vir antes do else.

• Depois que um else for bem-sucedido, nenhum dos outros if's ou else's serão testados.

Sintaxe

A seguir está a sintaxe de um 'if ... else if ... else' é a seguinte -

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

Experimente o programa de exemplo a seguir para entender as instruções condicionais (instrução if-else-if-else) na linguagem de programação Scala.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Value of X is 30

Instrução if-else aninhada

É sempre legal aninhar if-else declarações, o que significa que você pode usar uma if ou else-if declaração dentro de outra if ou else-if declaração.

Sintaxe

A sintaxe para um if-else aninhado é a seguinte -

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

Experimente o programa de exemplo a seguir para entender as instruções condicionais (instrução aninhada-if) na linguagem de programação Scala.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

X = 30 and Y = 10

Este capítulo o conduz pelas estruturas de controle de loop nas linguagens de programação Scala.

Pode haver uma situação em que você precise executar um bloco de código várias vezes. Em geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes e a seguir está a forma geral de uma instrução de loop na maioria das linguagens de programação -

Fluxograma

A linguagem de programação Scala fornece os seguintes tipos de loops para lidar com os requisitos de loop. Clique nos links a seguir na tabela para verificar seus detalhes.

Declarações de controle de loop

As instruções de controle de loop alteram a execução de sua sequência normal. Quando a execução deixa um escopo, todos os objetos automáticos que foram criados nesse escopo são destruídos. Como tal, Scala não suportabreak ou continuecomo o Java faz, mas a partir do Scala versão 2.8, há uma maneira de quebrar os loops. Clique nos links a seguir para verificar os detalhes.

O loop infinito

Um loop se torna um loop infinito se uma condição nunca se torna falsa. Se você estiver usando Scala, owhile loop é a melhor maneira de implementar loop infinito.

O programa a seguir implementa um loop infinito.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Se você executar o código acima, ele entrará em um loop infinito que pode ser encerrado pressionando as teclas Ctrl + C.

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

Uma função é um grupo de instruções que executam uma tarefa. Você pode dividir seu código em funções separadas. Como você divide seu código entre as diferentes funções é com você, mas logicamente, a divisão geralmente é para que cada função execute uma tarefa específica.

Scala tem funções e métodos e usamos os termos método e função alternadamente, com uma pequena diferença. Um método Scala é uma parte de uma classe que possui um nome, uma assinatura, opcionalmente algumas anotações e algum bytecode onde uma função em Scala é um objeto completo que pode ser atribuído a uma variável. Em outras palavras, uma função, que é definida como membro de algum objeto, é chamada de método.

Uma definição de função pode aparecer em qualquer lugar em um arquivo de origem e Scala permite definições de função aninhadas, ou seja, definições de função dentro de outras definições de função. O ponto mais importante a se notar é que o nome da função Scala pode ter caracteres como +, ++, ~, &, -, -, \, /,:, etc.

Declarações de função

Uma declaração de função Scala tem o seguinte formato -

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

Os métodos são declarados implicitamente abstratos se você não usar o sinal de igual e o corpo do método.

Definições de função

Uma definição de função Scala tem a seguinte forma -

Sintaxe

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

Aqui, return type pode ser qualquer tipo de dados Scala válido e list of parametersserá uma lista de variáveis ​​separadas por vírgula e a lista de parâmetros e o tipo de retorno são opcionais. Muito semelhante ao Java, umreturndeclaração pode ser usada junto com uma expressão caso a função retorne um valor. A seguir está a função que adicionará dois inteiros e retornará sua soma -

Sintaxe

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

Uma função que não retorna nada pode retornar um Unit isso é equivalente a voidem Java e indica que a função não retorna nada. As funções que não retornam nada no Scala, são chamadas de procedimentos.

Sintaxe

Aqui está a sintaxe -

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

Funções de chamada

Scala fornece uma série de variações sintáticas para invocar métodos. A seguir está a maneira padrão de chamar um método -

functionName( list of parameters )

Se uma função está sendo chamada usando uma instância do objeto, então usaríamos notação de ponto semelhante a Java da seguinte maneira -

[instance.]functionName( list of parameters )

Experimente o programa de exemplo a seguir para definir e chamar a mesma função.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Returned Value : 12

As funções do Scala são o coração da programação do Scala e é por isso que o Scala é considerado uma linguagem de programação funcional. A seguir estão alguns conceitos importantes relacionados às funções Scala que devem ser compreendidos por um programador Scala.

UMA closure é uma função, cujo valor de retorno depende do valor de uma ou mais variáveis ​​declaradas fora desta função.

O seguinte trecho de código com função anônima.

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

Aqui, a única variável usada no corpo da função, i * 10, é i, que é definido como um parâmetro para a função. Experimente o seguinte código -

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

Existem duas variáveis ​​livres no multiplicador: i e factor. Um deles, i, é um parâmetro formal para a função. Conseqüentemente, ele é vinculado a um novo valor cada vez que o multiplicador é chamado. Contudo,factornão é um parâmetro formal, então o que é isso? Vamos adicionar mais uma linha de código.

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

Agora factortem uma referência a uma variável fora da função, mas no escopo envolvente. As referências de funçãofactore lê seu valor atual a cada vez. Se uma função não tem referências externas, ela é trivialmente fechada sobre si mesma. Nenhum contexto externo é necessário.

Experimente o seguinte programa de exemplo.

Exemplo

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
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Este capítulo o conduz pelas Strings do Scala. Em Scala, como em Java, uma string é um objeto imutável, ou seja, um objeto que não pode ser modificado. Por outro lado, objetos que podem ser modificados, como arrays, são chamados de objetos mutáveis. Strings são objetos muito úteis, no restante desta seção, apresentamos métodos importantes dejava.lang.String classe.

Criando uma String

O código a seguir pode ser usado para criar uma String -

var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

Sempre que o compilador encontra um literal de string no código, ele cria um objeto String com seu valor, neste caso, “Hello world!”. A palavra-chave string também pode ser fornecida em declaração alternativa, conforme mostrado acima.

Experimente o seguinte programa de exemplo.

Exemplo

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

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Hello, world!

Conforme mencionado anteriormente, a classe String é imutável. O objeto String, uma vez criado, não pode ser alterado. Se houver necessidade de fazer muitas modificações nas strings de caracteres, use a classe String Builder disponível em Scala !.

Comprimento da corda

Os métodos usados ​​para obter informações sobre um objeto são conhecidos como métodos de acesso. Um método de acesso que pode ser usado com strings é o método length (), que retorna o número de caracteres contidos no objeto string.

Use o seguinte segmento de código para encontrar o comprimento de uma string -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

String Length is : 17

Strings de concatenação

A classe String inclui um método para concatenar duas strings -

string1.concat(string2);

Isso retorna uma nova string que é string1 com string2 adicionada a ela no final. Você também pode usar o método concat () com literais de string, como em -

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

Strings são mais comumente concatenadas com o operador +, como em -

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

O que resulta em -

"Hello, world!"

As seguintes linhas de código para encontrar o comprimento da string.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Dot Dot saw I was Tod

Criação de strings de formato

Você tem os métodos printf () e format () para imprimir a saída com números formatados. A classe String tem um método de classe equivalente, format (), que retorna um objeto String em vez de um objeto PrintStream.

Tente o seguinte programa de exemplo, que usa o método printf () -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Interpolação de String

String Interpolation é a nova maneira de criar Strings na linguagem de programação Scala. Este recurso é compatível com as versões do Scala-2.10 e posteriores. Interpolação de string: o mecanismo para incorporar referências de variáveis ​​diretamente no literal de string do processo.

Existem três tipos (interpoladores) de implementações em String Interpolation.

O 's' String Interpolator

O literal 's' permite o uso de variável diretamente no processamento de uma string, quando você adiciona 's' a ela. Qualquer variável String em um escopo que pode ser usada em uma String. A seguir estão os diferentes usos do interpolador String de 's'.

O exemplo de trecho de código a seguir para a implementação do interpolador 's' ao anexar a variável String ($ name) a uma String normal (Hello) na instrução println.

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

O interpolador de strings também pode processar expressões arbitrárias. O seguinte trecho de código para Processar uma String (1 + 1) com expressão arbitrária ($ {1 + 1}) usando o interpolador String 's'. Qualquer expressão arbitrária pode ser incorporada em '$ {}'.

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

Experimente o seguinte programa de exemplo de implementação do interpolador 's'.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Hello, James
1 + 1 = 2

O 'f' Interpolator

O interpolador literal 'f' permite criar uma String formatada, semelhante a printf em linguagem C. Ao usar o interpolador 'f', todas as referências de variáveis ​​devem ser seguidas peloprintf especificadores de formato de estilo, como% d,% i,% f, etc.

Tomemos um exemplo de valor de ponto flutuante acrescentado (altura = 1,9d) e variável String (nome = “James”) com string normal. O seguinte trecho de código de implementação do Interpolador 'f'. Aqui$name%s to print (String variable) James and $altura% 2.2f para imprimir (valor de ponto flutuante) 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

É um tipo seguro (ou seja) a referência de variável e o especificador de formato seguinte devem corresponder, caso contrário, ele está mostrando erro. O interpolador 'f' faz uso dos utilitários de formato String (especificadores de formato) disponíveis em Java. Por padrão, não há caractere% após a referência de variável. Ele assumirá como% s (String).

Interpolador 'bruto'

O interpolador 'bruto' é semelhante ao interpolador 's', exceto que ele não executa nenhum escape de literais dentro de uma string. Os trechos de código a seguir em uma tabela irão diferir o uso de interpoladores 's' e 'brutos'. Em saídas de 's' uso '\ n' efeitos como nova linha e na saída de uso 'bruto' o '\ n' não terá efeito. Ele imprimirá a string completa com letras de 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

Métodos de String

A seguir está a lista de métodos definidos por java.lang.String classe e pode ser usado diretamente em seus programas Scala -

Scala fornece uma estrutura de dados, o array, que armazena uma coleção sequencial de tamanho fixo de elementos do mesmo tipo. Uma matriz é usada para armazenar uma coleção de dados, mas geralmente é mais útil pensar em uma matriz como uma coleção de variáveis ​​do mesmo tipo.

Em vez de declarar variáveis ​​individuais, como número0, número1, ... e número99, você declara uma variável de matriz, como números e usa números [0], números [1] e ..., números [99] para representar variáveis ​​individuais. Este tutorial apresenta como declarar variáveis ​​de array, criar arrays e processar arrays usando variáveis ​​indexadas. O índice do primeiro elemento de uma matriz é o número zero e o índice do último elemento é o número total de elementos menos um.

Declarando Variáveis ​​de Matriz

Para usar uma matriz em um programa, você deve declarar uma variável para fazer referência à matriz e deve especificar o tipo de matriz que a variável pode fazer referência.

A seguir está a sintaxe para declarar uma variável de matriz.

Sintaxe

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

or

var z = new Array[String](3)

Aqui, z é declarado como uma matriz de Strings que pode conter até três elementos. Os valores podem ser atribuídos a elementos individuais ou obter acesso a elementos individuais, isso pode ser feito usando comandos como o seguinte -

Comando

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

Aqui, o último exemplo mostra que, em geral, o índice pode ser qualquer expressão que produza um número inteiro. Existe mais uma maneira de definir uma matriz -

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

A imagem a seguir representa uma matriz myList. Aqui,myList possui dez valores duplos e os índices vão de 0 a 9.

Processando matrizes

Ao processar elementos de array, frequentemente usamos estruturas de controle de loop porque todos os elementos em um array são do mesmo tipo e o tamanho do array é conhecido.

Abaixo está um programa de exemplo mostrando como criar, inicializar e processar matrizes -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala não suporta diretamente várias operações de array e fornece vários métodos para processar arrays em qualquer dimensão. Se você quiser usar os diferentes métodos, é necessário importarArray._ pacote.

Matrizes multidimensionais

Existem muitas situações em que você precisaria definir e usar arrays multidimensionais (ou seja, arrays cujos elementos são arrays). Por exemplo, matrizes e tabelas são exemplos de estruturas que podem ser realizadas como matrizes bidimensionais.

A seguir está o exemplo de definição de uma matriz bidimensional -

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

Este é um array com três elementos, cada um sendo um array de inteiros com três elementos.

Experimente o programa de exemplo a seguir para processar uma matriz multidimensional -

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

0 1 2
0 1 2
0 1 2

Arrays concatenados

Tente o exemplo a seguir, que usa o método concat () para concatenar dois arrays. Você pode passar mais de um array como argumentos para o método concat ().

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Criar matriz com intervalo

Uso do método range () para gerar uma matriz contendo uma sequência de números inteiros crescentes em um determinado intervalo. Você pode usar o argumento final como etapa para criar a sequência; se você não usar o argumento final, o passo será assumido como 1.

Vejamos um exemplo de criação de uma matriz de intervalo (10, 20, 2): Significa criar uma matriz com elementos entre 10 e 20 e diferença de intervalo 2. Os elementos da matriz são 10, 12, 14, 16 e 18 .

Outro exemplo: intervalo (10, 20). Aqui a diferença de intervalo não é fornecida, por padrão, assume 1 elemento. Ele cria uma matriz com os elementos entre 10 e 20 com diferença de intervalo 1. Os elementos da matriz são 10, 11, 12, 13, ... e 19.

O programa de exemplo a seguir mostra como criar uma matriz com intervalos.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Métodos Scala Array

A seguir estão os métodos importantes, que você pode usar enquanto brinca com array. Conforme mostrado acima, você teria que importarArray._pacote antes de usar qualquer um dos métodos mencionados. Para uma lista completa dos métodos disponíveis, verifique a documentação oficial do Scala.

Scala tem um rico conjunto de biblioteca de coleção. Coleções são contêineres de coisas. Esses recipientes podem ser sequenciados, conjuntos lineares de itens como Lista, Tupla, Opção, Mapa, etc. As coleções podem ter um número arbitrário de elementos ou ser limitadas a zero ou um elemento (por exemplo, Opção).

As coleções podem ser strict ou lazy. As coleções lentas têm elementos que podem não consumir memória até que sejam acessadas, comoRanges. Além disso, as coleções podem sermutable (o conteúdo da referência pode mudar) ou immutable(aquilo a que uma referência se refere nunca é alterado). Observe que as coleções imutáveis ​​podem conter itens mutáveis.

Para alguns problemas, as coleções mutáveis ​​funcionam melhor e, para outros, as coleções imutáveis ​​funcionam melhor. Em caso de dúvida, é melhor começar com uma coleção imutável e alterá-la mais tarde se precisar de uma coleção mutável.

Este capítulo lança luz sobre os tipos de coleção mais comumente usados ​​e as operações mais frequentemente usadas sobre essas coleções.

Uma característica encapsula definições de método e campo, que podem ser reutilizadas misturando-as em classes. Ao contrário da herança de classe, na qual cada classe deve herdar de apenas uma superclasse, uma classe pode misturar qualquer número de características.

Traits são usados ​​para definir tipos de objetos especificando a assinatura dos métodos suportados. Scala também permite que as características sejam parcialmente implementadas, mas as características podem não ter parâmetros de construtor.

Uma definição de característica se parece com uma definição de classe, exceto que usa a palavra-chave trait. A seguir está o exemplo básico de sintaxe de trait.

Sintaxe

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

Esta característica consiste em dois métodos isEqual e isNotEqual. Aqui, não fornecemos nenhuma implementação para isEqual onde outro método tem sua implementação. As classes filhas que estendem uma característica podem fornecer implementação para os métodos não implementados. Portanto, um traço é muito semelhante ao que temosabstract classes em Java.

Vamos supor um exemplo de traço Equal contém dois métodos isEqual() e isNotEqual(). O traçoEqual contém um método implementado que é isEqual() então, quando a classe definida pelo usuário Point estende o traço Equal, implementação para isEqual() método em Point classe deve ser fornecida.

Aqui é necessário conhecer dois métodos importantes de Scala, que são usados ​​no exemplo a seguir.

• obj.isInstanceOf [Point] Para verificar o tipo de obj e o ponto são iguais, não.

• obj.asInstanceOf [Point] significa moldagem exata, pegando o tipo de objeto de objeto e retorna o mesmo tipo de objeto de ponto.

Experimente o programa de exemplo a seguir para implementar características.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

true
false
true

Classes de valor e traços universais

As classes de valor são um novo mecanismo no Scala para evitar a alocação de objetos de tempo de execução. Ele contém um construtor primário com exatamente umvalparâmetro. Ele contém apenas métodos (def) não permitidos, var, val, classes aninhadas, características ou objetos. A classe de valor não pode ser estendida por outra classe. Isso pode ser possível estendendo sua classe de valor com AnyVal. A segurança de tipos de tipos de dados personalizados sem a sobrecarga do tempo de execução.

Vamos dar exemplos de classes de valor Peso, Altura, Email, Idade, etc. Para todos esses exemplos, não é necessário alocar memória no aplicativo.

Uma classe de valor não tem permissão para estender características. Para permitir que as classes de valor estendam as características,universal traits são introduzidos que se estendem por Any.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Ele fornecerá o código hash da classe Wrapper.

Wrapper@13

Quando usar características?

Não existe uma regra firme, mas aqui estão algumas diretrizes a serem consideradas -

• Se o comportamento não for reutilizado, torne-o uma classe concreta. Afinal, não é um comportamento reutilizável.

• Se puder ser reutilizado em várias classes não relacionadas, torne-o uma característica. Apenas características podem ser misturadas em diferentes partes da hierarquia de classes.

• Se você quiser inherit a partir dele no código Java, use uma classe abstrata.

• Se você planeja distribuí-lo em forma compilada e espera que grupos externos escrevam classes herdadas dele, você pode se inclinar a usar uma classe abstrata.

• Se a eficiência é muito importante, tente usar uma classe.

A correspondência de padrões é o segundo recurso mais amplamente usado do Scala, depois dos valores de função e fechamentos. Scala fornece um ótimo suporte para correspondência de padrões no processamento de mensagens.

Uma correspondência de padrão inclui uma sequência de alternativas, cada uma começando com a palavra-chave case. Cada alternativa inclui umpattern e um ou mais expressions, que será avaliado se o padrão corresponder. Um símbolo de seta => separa o padrão das expressões.

Experimente o programa de exemplo a seguir, que mostra como comparar com um valor inteiro.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

many

O bloco com as instruções case define uma função, que mapeia inteiros para strings. A palavra-chave match fornece uma maneira conveniente de aplicar uma função (como a função de correspondência de padrões acima) a um objeto.

Experimente o programa de exemplo a seguir, que compara um valor com padrões de diferentes tipos.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

2
many
one

Matching using Case Classes

o case classessão classes especiais usadas na correspondência de padrões com expressões de caso. Sintaticamente, essas são classes padrão com um modificador especial:case.

Tente o seguinte, é um exemplo simples de correspondência de padrões usando a classe de caso.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

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

Adicionar a palavra-chave case faz com que o compilador adicione vários recursos úteis automaticamente. A palavra-chave sugere uma associação com expressões de caso na correspondência de padrões.

Primeiro, o compilador converte automaticamente os argumentos do construtor em campos imutáveis ​​(vals). A palavra-chave val é opcional. Se você quiser campos mutáveis, use a palavra-chave var. Portanto, nossas listas de argumentos do construtor são mais curtas.

Em segundo lugar, o compilador implementa automaticamente equals, hashCode, e toStringmétodos para a classe, que usam os campos especificados como argumentos do construtor. Portanto, não precisamos mais de nossos próprios métodos toString ().

Finalmente, também, o corpo de Person a classe fica vazia porque não há métodos que precisemos definir!

Este capítulo explica como Scala oferece suporte a expressões regulares por meio de Regex classe disponível no pacote scala.util.matching.

Experimente o programa de exemplo a seguir, onde tentaremos encontrar palavras Scala de uma declaração.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Some(Scala)

Criamos um String e chamamos o r( )método sobre ele. Scala converte implicitamente a String em RichString e invoca esse método para obter uma instância de Regex. Para encontrar uma primeira correspondência da expressão regular, basta chamar ofindFirstIn()método. Se, em vez de encontrar apenas a primeira ocorrência, quisermos encontrar todas as ocorrências da palavra correspondente, podemos usar ofindAllIn( ) e no caso de haver várias palavras Scala disponíveis na string de destino, isso retornará uma coleção de todas as palavras correspondentes.

Você pode usar o método mkString () para concatenar a lista resultante e você pode usar uma barra vertical (|) para pesquisar maiúsculas e minúsculas de Scala e você pode usar Regex construtor em vez ou r() método para criar um padrão.

Experimente o seguinte programa de exemplo.

Exemplo

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(","))
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Scala,scala

Se você quiser substituir o texto correspondente, podemos usar replaceFirstIn( ) para substituir a primeira correspondência ou replaceAllIn( ) para substituir todas as ocorrências.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Java is scalable and cool

Formando Expressões Regulares

Scala herda sua sintaxe de expressão regular de Java, que por sua vez herda a maioria dos recursos do Perl. Aqui estão apenas alguns exemplos que devem ser suficientes para atualizar -

A seguir está a tabela que lista toda a sintaxe de metacaracteres de expressões regulares disponíveis em Java.

Exemplos de expressões regulares

Note- que cada barra invertida aparece duas vezes na string acima. Isso ocorre porque em Java e Scala uma única barra invertida é um caractere de escape em um literal de string, não um caractere regular que aparece na string. Portanto, em vez de '\', você precisa escrever '\\' para obter uma única barra invertida na string.

Experimente o seguinte programa de exemplo.

Exemplo

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(","))
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

able1

As exceções do Scala funcionam como exceções em muitas outras linguagens como Java. Em vez de retornar um valor da maneira normal, um método pode terminar lançando uma exceção. No entanto, o Scala não tem exceções verificadas.

Quando você deseja manipular exceções, você usa um bloco try {...} catch {...} como faria em Java, exceto que o bloco catch usa correspondência para identificar e manipular as exceções.

Lançamento de exceções

Lançar uma exceção tem a mesma aparência que em Java. Você cria um objeto de exceção e o lança com othrow palavra-chave da seguinte forma.

throw new IllegalArgumentException

Captura de exceções

Scala permite que você try/catch qualquer exceção em um único bloco e, em seguida, execute a correspondência de padrões contra ele usando caseblocos. Experimente o programa de exemplo a seguir para lidar com a exceção.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Missing file exception

O comportamento deste try-catchexpressão é a mesma que em outras línguas, com exceções. O corpo é executado, e se lançar uma exceção, cadacatch cláusula é tentada por sua vez.

A cláusula final

Você pode envolver uma expressão com um finallycláusula se você quiser fazer com que algum código seja executado, independentemente de como a expressão termina. Experimente o seguinte programa.

Exemplo

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

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Missing file exception
Exiting finally...

Um extrator em Scala é um objeto que possui um método chamado unapplycomo um de seus membros. O objetivo desse método de não aplicação é combinar um valor e desmontá-lo. Freqüentemente, o objeto extrator também define um método duploapply para construir valores, mas isso não é necessário.

Exemplo

Vamos dar um exemplo de objeto que define ambos apply e unapplymétodos. O método apply tem o mesmo significado de sempre: ele transforma Test em um objeto que pode ser aplicado a argumentos entre parênteses da mesma forma que um método é aplicado. Portanto, você pode escrever Test ("Zara", "gmail.com") para construir a string "[email protected]".

o unapply método é o que transforma a classe de teste em um extractor e reverte o processo de construção de apply. Onde apply pega duas strings e forma uma string de endereço de e-mail, unapply pega um endereço de e-mail e retorna potencialmente duas strings: ouser e a domain do endereço.

o unapplytambém deve lidar com o caso em que a string fornecida não é um endereço de e-mail. É por isso que unapply retorna um tipo de opção sobre pares de strings. Seu resultado éSome (user, domain)se a string str for um endereço de e-mail com as partes de usuário e domínio fornecidas, ou Nenhum, se str não for um endereço de e-mail. Aqui estão alguns exemplos a seguir.

Sintaxe

unapply("[email protected]") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None

O programa de exemplo a seguir mostra um objeto extrator para endereços de e-mail.

Exemplo

object Demo {
   def main(args: Array[String]) {
      println ("Apply method : " + apply("Zara", "gmail.com"));
      println ("Unapply method : " + unapply("[email protected]"));
      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
      }
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Apply method : [email protected]
Unapply method : Some((Zara,gmail.com))
Unapply method : None

Correspondência de padrões com extratores

Quando uma instância de uma classe é seguida por parênteses com uma lista de zero ou mais parâmetros, o compilador invoca o applymétodo nessa instância. Podemos definir a aplicação tanto em objetos quanto em classes.

Como mencionado acima, o objetivo do unapplymétodo é extrair um valor específico que estamos procurando. Ele faz a operação opostaapplyfaz. Ao comparar um objeto extrator usando omatch declaração o unapply método será executado automaticamente.

Experimente o seguinte programa de exemplo.

Exemplo

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
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

10
10 is bigger two times than 5

Scala está aberto para fazer uso de qualquer objeto Java e java.io.File é um dos objetos que podem ser usados ​​na programação Scala para ler e escrever arquivos.

A seguir está um programa de exemplo para gravar em um arquivo.

Exemplo

import java.io._

object Demo {
   def main(args: Array[String]) {
      val writer = new PrintWriter(new File("test.txt" ))

      writer.write("Hello Scala")
      writer.close()
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Irá criar um arquivo chamado Demo.txtno diretório atual, onde o programa está colocado. A seguir está o conteúdo desse arquivo.

Resultado

Hello Scala

Lendo uma linha da linha de comando

Às vezes, você precisa ler a entrada do usuário na tela e, em seguida, prosseguir para algum processamento posterior. O programa de exemplo a seguir mostra como ler a entrada da linha de comando.

Exemplo

object Demo {
   def main(args: Array[String]) {
      print("Please enter your input : " )
      val line = Console.readLine
      
      println("Thanks, you just typed: " + line)
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Please enter your input : Scala is great
Thanks, you just typed: Scala is great

Ler o conteúdo do arquivo

Ler arquivos é muito simples. Você pode usar o ScalaSourceclasse e seu objeto companheiro para ler arquivos. A seguir está o exemplo que mostra como ler de"Demo.txt" arquivo que criamos anteriormente.

Exemplo

import scala.io.Source

object Demo {
   def main(args: Array[String]) {
      println("Following is the content read:" )

      Source.fromFile("Demo.txt" ).foreach { 
         print 
      }
   }
}

Salve o programa acima em Demo.scala. Os seguintes comandos são usados ​​para compilar e executar este programa.

Comando

\>scalac Demo.scala
\>scala Demo

Resultado

Following is the content read:
Hello Scala