Perguntas de Entrevista em Scala

Tutoriais
Scala

Antes de ler esta postagem, por favor, dê uma olhada na minha postagem anterior em “Scala Basic Interview Questions and Answers” para obter algum conhecimento básico sobre a Linguagem Scala. Nesta postagem, vamos discutir sobre algumas outras perguntas de entrevista Scala que são úteis para desenvolvedores Scala experientes. Nota:- Como esta lista já se tornou muito extensa, vou publicar outra postagem com as perguntas e respostas restantes. Por favor, consulte essa postagem em: “Scala Intermediate and Advanced Interview Questions and Answers”

Perguntas de Entrevista Scala

Nesta seção, vamos listar todas as perguntas de entrevista Scala intermediárias e na próxima seção discutiremos elas detalhadamente.

  1. O que é Construtor Primário? O que é Construtor Secundário ou Auxiliar em Scala?
  2. Qual é o uso de Construtores Auxiliares em Scala? Por favor, explique as regras a seguir na definição de Construtores Auxiliares em Scala?
  3. Quais são as diferenças entre Array e ArrayBuffer em Scala?
  4. O que é classe case? O que é objeto case? Quais são as vantagens da classe case?
  5. Qual é a diferença entre Case Object e Object (Objeto Normal)?
  6. Quais são as principais vantagens ou benefícios de uma Case-class em comparação com a Classe Normal?
  7. Qual é o uso dos métodos isInstanceOf e asInstanceOf em Scala? Existe algum conceito semelhante disponível em Java?
  8. Como você prova que por padrão, Case Object é Serializable e Normal Object não é?
  9. Qual a diferença entre Array e List em Scala?
  10. Qual é a diferença entre “val” e “lazy val” em Scala? O que é Avaliação Ávida? O que é Avaliação Preguiçosa?
  11. Qual é a relação entre o método equals e == em Scala? Diferencie o == de Scala do operador == de Java?
  12. Qual é a diferença entre a classe Interna de Scala e a classe Interna de Java?
  13. O que é o Problema do Diamante? Como o Scala resolve o Problema do Diamante?
  14. Por que o Scala NÃO tem a palavra-chave “static”? Qual é o principal motivo para essa decisão?
  15. Qual é o uso da palavra-chave “object” em Scala? Como criar objetos Singleton em Scala?
  16. Como definir métodos de fábrica usando a palavra-chave object em Scala? Qual é o uso de definir métodos de fábrica em object?
  17. O que é o método apply em Scala? O que é o método unapply em Scala? Qual é a diferença entre os métodos apply e unapply em Scala?
  18. Como funciona por baixo dos panos quando criamos uma instância de uma Classe sem usar a palavra-chave ‘new’ em Scala? Quando devemos usar essa abordagem?
  19. Como declaramos um Construtor Primário privado em Scala? Como fazemos uma chamada para um Construtor Primário privado em Scala?
  20. 1. **Companion Object Access in Scala:**
    O objeto Companion acessa membros privados de sua classe Companion em Scala?

  21. 2. **Design Decision on class and object in Scala:**
    Qual é a principal decisão de design sobre as duas palavras-chave separadas: class e object em Scala? Como definimos membros de instância e membros estáticos em Scala?

  22. 3. **Object in Scala:**
    O que é objeto em Scala? É um objeto singleton ou instância de uma classe?

  23. 4. **Companion Object and Class in Scala:**
    O que é um Companion Object em Scala? O que é uma Companion Class em Scala? Qual é o uso do Companion Object em Scala?

  24. 5. **Implementing Interfaces in Scala:**
    Como implementar interfaces em Scala?

  25. 6. **Range in Scala:**
    O que é Range em Scala? Como criar um Range em Scala?

  26. 7. **Values of Type Nothing in Scala:**
    Quantos valores do tipo Nothing existem em Scala?

  27. 8. **Values of Type Unit in Scala:**
    Quantos valores do tipo Unit existem em Scala?

  28. 9. **Range in Scala (Repetition):**
    O que é Range em Scala? Como criar um Range em Scala?

  29. 10. **Function vs Procedure in FP:**
    Em FP, qual é a diferença entre uma função e um procedimento?

  30. 11. **Scala’s Auxiliary Constructors vs Java’s Constructors:**
    Quais são as principais diferenças entre os construtores auxiliares em Scala e os construtores em Java?

  31. 12. **’yield’ Keyword in Scala’s For-Comprehension:**
    Qual é o uso da palavra-chave ‘yield’ na construção for-comprehension em Scala?

  32. 13. **Guard in Scala’s For-Comprehension:**
    O que é guard em Scala’s for-comprehension construct?

  33. 14. **Scala’s Inheritance Diamond Problem vs Java 8:**
    Como Scala resolve automaticamente e facilmente o Problema do Diamante de Herança em comparação com Java 8?

  34. 15. **Design Pattern in Scala Pattern Matching and Java ‘instanceof’:**
    Em Scala, o Pattern Matching segue qual padrão de design? Em Java, o operador ‘instanceof’ segue qual padrão de design?

Perguntas e Respostas da Entrevista Scala

Nesta seção, vamos abordar cada pergunta da lista acima e discutir em detalhes com exemplos adequados (se necessário). Se você deseja entender esses conceitos em profundidade com exemplos, por favor, consulte minhas postagens anteriores na seção de Tutoriais Scala.

O que é Construtor Primário? O que é Construtor Secundário ou Auxiliar em Scala? Qual é o propósito do Construtor Auxiliar em Scala? É possível sobrecarregar construtores em Scala?

Scala possui dois tipos de construtores:

  • Construtor Primário
  • Construtor Auxiliar

Construtor Primário Em Scala, o Construtor Primário é um construtor que é definido juntamente com a definição da classe. Cada classe deve ter um Construtor Primário: seja um construtor com parâmetros ou um construtor sem parâmetros. Exemplo:-

class Person

A classe Pessoa acima tem um construtor primário de Zero parâmetros ou Sem Parâmetros ou Sem Parâmetros para criar instâncias desta classe.

class Person (firstName: String, lastName: String)

A classe Pessoa acima tem um construtor primário de dois parâmetros para criar instâncias desta classe. Construtor Auxiliar O Construtor Auxiliar também é conhecido como Construtor Secundário. Podemos declarar um Construtor Secundário usando as palavras-chave ‘def’ e ‘this’ como mostrado abaixo:

class Person (firstName: String, middleName:String, lastName: String){
  def this(firstName: String, lastName: String){
      this(firstName, "", lastName)
  }
}

Qual é o uso dos Construtores Auxiliares em Scala? Por favor, explique as regras a seguir na definição de Construtores Auxiliares em Scala?

No Scala, O principal propósito dos Construtores Auxiliares é sobrecarregar construtores. Assim como em Java, podemos fornecer vários tipos de construtores para que o usuário possa escolher o certo com base em sua necessidade. Regras dos Construtores Auxiliares:

  • Eles são como métodos apenas. Como métodos, devemos usar a palavra-chave ‘def’ para defini-los.
  • Devemos usar o mesmo nome ‘this’ para todos os Construtores Auxiliares.
  • Cada Construtor Auxiliar deve começar com uma chamada para outro Construtor Auxiliar previamente definido ou Construtor Primário. Caso contrário, erro de tempo de compilação.
  • Cada Construtor Auxiliar deve diferir em sua lista de parâmetros: pode ser por número ou tipos.
  • Os Construtores Auxiliares não podem chamar construtores de uma superclasse. Eles devem chamá-los apenas através do Construtor Primário.
  • Todos os Construtores Auxiliares chamam seu Construtor Primário, seja diretamente ou indiretamente através de outros Construtores Auxiliares.

NOTA:- Se você quiser aprender sobre os Construtores em Scala, consulte minhas postagens sobre Scala em: Construtor Primário e Construtor Auxiliar.

Quais são as diferenças entre Array e ArrayBuffer em Scala?

Diferenças entre Array e ArrayBuffer em Scala:

  • Array é um array de tamanho fixo. Não podemos alterar seu tamanho depois de criado.
  • ArrayBuffer é um array de tamanho variável. Ele pode aumentar ou diminuir seu tamanho dinamicamente.
  • Array é algo semelhante aos arrays primitivos de Java.
  • ArrayBuffer é algo semelhante ao ArrayList de Java.

O que é uma classe case? O que é um objeto case? Quais são as vantagens de uma classe case?

Uma classe case é uma classe definida com as palavras-chave “case class”. Um objeto case é um objeto definido com as palavras-chave “case object”. Devido a essa palavra-chave “case”, obtemos alguns benefícios para evitar códigos desnecessários. Podemos criar objetos de classes case sem usar a palavra-chave “new”. Por padrão, o compilador Scala adiciona “val” para todos os parâmetros do construtor. É por isso que, sem usar val ou var, os parâmetros do construtor de uma classe case se tornarão membros da classe, o que não é possível para classes normais. Vantagens de uma classe case:

  • O compilador Scala adiciona automaticamente os métodos toString, hashCode e equals. Podemos evitar escrever esse código desnecessário.
  • O compilador Scala adiciona automaticamente um objeto companheiro com métodos apply e unapply, portanto, não precisamos da palavra-chave “new” para criar instâncias de uma classe case.
  • O compilador Scala adiciona automaticamente o método copy.
  • Podemos usar classes case em correspondência de padrões.
  • Por padrão, classes case e objetos case são serializáveis.

Qual é a diferença entre Case Object e Object (Objeto Normal)?

  • Um objeto normal é criado usando a palavra-chave “object”. Por padrão, é um objeto singleton.
object MyNormalObject
  • Um Case Object é criado usando a palavra-chave “case object”. Por padrão, também é um objeto singleton
case object MyCaseObject
  • Por padrão, um Case Object obtém os métodos toString e hashCode, mas um objeto normal não.
  • Por padrão, um Case Object é serializável, mas um objeto normal não é.

Em comparação com uma Classe Normal, quais são as principais vantagens ou benefícios de uma Case Class?

As principais vantagens ou benefícios de uma Case Class sobre Classes Normais são:

  • Evita muitos códigos de boilerplate, adicionando automaticamente alguns métodos úteis.
  • Por padrão, suporta imutabilidade porque seus parâmetros são ‘val’.
  • Fácil de usar em Pattern Matching.
  • Não é necessário usar a palavra-chave ‘new’ para criar uma instância de Case Class.
  • Por padrão, suporta Serialização e Desserialização.

Qual é o uso dos métodos isInstanceOf e asInstanceOf em Scala? Existe algum conceito semelhante disponível em Java?

Ambos os métodos isInstanceOf e asInstanceOf são definidos na classe Any. Portanto, não é necessário importá-los para obter esses métodos em qualquer classe ou objeto. O método “isInstanceOf” é usado para testar se o objeto é de um determinado tipo ou não. Se sim, retorna true. Caso contrário, retorna false.

   scala> val str = "Hello"
   
   scala>str.isInstanceOf[String]
   res0: Boolean = false

O método “asInstanceOf” é usado para converter o objeto para o tipo fornecido. Se o objeto e o tipo fornecido forem do mesmo tipo, então ele é convertido para o tipo fornecido. Caso contrário, ele lança java.lang.ClassCastException.

 scala> val str = "Hello".asInstanceOf[String]
 str: String = Hello

No Java, a palavra-chave ‘instanceof’ é semelhante ao método ‘isInstanceOf’ do Scala. No Java, o seguinte tipo de conversão de tipo manual é semelhante ao método ‘asInstanceOf’ do Scala.

AccountService service = (AccountService)
 context.getBean("accountService");

Como você prova que por padrão, o Case Object é Serializable e o Object Normal não é?

Sim, por padrão, o objeto Case é serializável. Mas o objeto normal não é. Podemos comprovar isso usando o método `isInstanceOf` conforme mostrado abaixo:

scala> object MyNormalObject
defined object MyNormalObject

scala> MyNormalObject.isInstanceOf[Serializable]
res0: Boolean = false

scala> case object MyCaseObject
defined object MyCaseObject

scala> MyCaseObject.isInstanceOf[Serializable]
res1: Boolean = true

Diferença entre Array e List em Scala?

  • Arrays são sempre mutáveis, enquanto List é sempre imutável.
  • Uma vez criado, podemos alterar os valores do Array, enquanto não podemos alterar o objeto List.
  • Arrays são estruturas de dados de tamanho fixo, enquanto Listas são estruturas de dados de tamanho variável. O tamanho da Lista é automaticamente aumentado ou diminuído com base nas operações que realizamos nela.
  • Arrays são invariantes, enquanto Listas são covariantes.

NOTA: Se você não tem certeza sobre Invariante e Covariante, por favor, leia minha próxima postagem sobre Perguntas de Entrevista em Scala.

Qual é a diferença entre “val” e “lazy val” em Scala? O que é Avaliação Eager? O que é Avaliação Lazy?

Como discutimos nas minhas Perguntas Básicas de Entrevista em Scala, “val” significa valor ou constante, que é usado para definir variáveis imutáveis. Existem dois tipos de avaliações de programa:

  • Avaliação Ansiosa
  • Avaliação Preguiçosa

Avaliação Ansiosa significa avaliar o programa em tempo de compilação ou em tempo de implantação, independentemente de os clientes estarem usando esse programa ou não. Avaliação Preguiçosa significa avaliar o programa em tempo de execução sob demanda, ou seja, quando os clientes acessam o programa, ele é avaliado apenas naquele momento. A diferença entre “val” e “lazy val” é que “val” é usado para definir variáveis que são avaliadas ansiosamente e “lazy val” também é usada para definir variáveis, mas elas são avaliadas de forma preguiçosa.

Qual é a relação entre o método equals e == em Scala? Diferencie o == de Scala do operador == de Java?

No Scala, não precisamos chamar o método equals() para comparar duas instâncias ou objetos. Quando comparamos duas instâncias com ==, o Scala chama automaticamente o método equals() desse objeto. O operador == de Java é usado para verificar a igualdade de referências, ou seja, se duas referências estão apontando para o mesmo objeto ou não. O == de Scala é usado para verificar a igualdade de instâncias, ou seja, se duas instâncias são iguais ou não.

Diferença entre a classe interna do Scala e a classe interna do Java?

No Java, a classe interna está associada à classe externa, ou seja, a classe interna é um membro da classe externa. Ao contrário do Java, o Scala trata a relação entre a classe externa e a classe interna de forma diferente. A classe interna do Scala está associada ao objeto da classe externa.

O que é o Problema do Diamante? Como o Scala resolve o Problema do Diamante?

A Diamond Problem is a Multiple Inheritance problem. Some people calls this problem as Deadly Diamond Problem. In Scala, it occurs when a Class extends more than one Traits which have same method definition as shown below. Unlike Java 8, Scala solves this diamond problem automatically by following some rules defined in Language. Those rules are called “Class Linearization”. Example:-

trait A{   
  def display(){ println("From A.display")  }
}
trait B extends A{ 
  override def display() { println("From B.display") }
}
trait C extends A{ 
  override def display() { println("From C.display") }
}
class D extends B with C{ }

object ScalaDiamonProblemTest extends App {
    val d = new D
    d display
}

Aqui, a saída é “De C.display” do trait C. O compilador Scala lê “extends B with C” da direita para a esquerda e assume a definição do método “display” do trait mais à esquerda, que é C. NOTA:- Veja minha postagem sobre “Traços do Scala em Profundidade” para entender isso com uma explicação clara.

Por que o Scala NÃO tem a palavra-chave “static”? Qual é a principal razão para essa decisão?

Como sabemos, Scala NÃO tem a palavra-chave “static” de todo. Esta é uma decisão de design feita pela Equipe Scala. A principal razão para tomar essa decisão é tornar Scala uma Linguagem de Programação Orientada a Objetos Pura. A palavra-chave “static” significa que podemos acessar os membros da classe sem criar um objeto ou sem usar um objeto. Isso vai totalmente contra os princípios da POO. Se uma linguagem suporta a palavra-chave “static”, então essa linguagem não é uma Linguagem de Programação Orientada a Objetos Pura. Por exemplo, como o Java suporta a palavra-chave “static”, ele NÃO é uma Linguagem de Programação Orientada a Objetos Pura. Mas Scala é uma Linguagem de Programação Orientada a Objetos Pura.

Qual é o uso da palavra-chave “object” em Scala? Como criar objetos Singleton em Scala?

No Scala, a palavra-chave object é usada para os seguintes propósitos:

  • É usada para criar um objeto singleton em Scala.
object MySingletonObject

Aqui, MeuObjetoSingleton se torna automaticamente um objeto singleton.- A palavra-chave object é usada para definir Aplicações Scala que são programas executáveis Scala.

object MyScalaExecutableProgram{   
   def main(args: Array[String]){
       println("Hello World")
   }
}

Quando definimos o método main em object como mostrado acima (é o mesmo que o método main() em Java), ele se torna automaticamente um programa Scala executável.- É usada para definir membros estáticos como variáveis estáticas e métodos estáticos sem usar a palavra-chave “static”.

object MyScalaStaticMembers{ 
  val PI: Double = 3.1414  
  def add(a: Int, b: Int) = a + b
}

A variável def PI e os métodos add se tornarão membros estáticos. Isso significa que podemos chamá-los sem criar um objeto separado, como MyScalaStaticMembers.add(10,20).- É usado para definir métodos de fábrica. Por favor, veja minha próxima pergunta sobre isso.

Como definir métodos de fábrica usando a palavra-chave object em Scala? Qual é o uso de definir métodos de fábrica em um objeto?

No Scala, usamos a palavra-chave ‘object’ para definir métodos de fábrica. O objetivo principal desses métodos de fábrica em Scala é evitar o uso da palavra-chave ‘new’. Sem usar a palavra-chave ‘new’, podemos criar objetos. Para definir métodos de fábrica: Podemos usar o método apply para definir métodos de fábrica em Scala. Se tivermos um construtor primário e vários construtores auxiliares, então precisamos definir vários métodos apply como mostrado abaixo.

class Person(val firstName: String, val middleName: String, val lastName: String){
  def this(firstName: String, lastName: String){
    this(firstName,"",lastName)
  }
}
object Person{
  def apply(val firstName: String, val middleName: String, val lastName: String) 
        = new Person(firstName,middleName,lastName)

  def apply(val firstName: String, val lastName: String) 
        = new Person(firstName, lastName)
}

Agora podemos criar objetos Person sem usar a palavra-chave new ou com a palavra-chave new, conforme sua preferência.

val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")

O que é o método apply em Scala? O que é o método unapply em Scala? Qual é a diferença entre os métodos apply e unapply em Scala?

No Scala, os métodos apply e unapply desempenham um papel muito importante. Eles também são muito úteis no Play Framework para mapear e desmapear dados entre dados de formulário e dados de modelo. Em termos simples,

  • método apply: Para compor ou montar um objeto a partir de seus componentes.
  • método unapply: Para decompor ou desmontar um objeto em seus componentes.

O método apply do Scala: É usado para compor um objeto usando seus componentes. Suponha que queremos criar um objeto Pessoa, então usamos os dois componentes firstName e lastName e compomos o objeto Pessoa conforme mostrado abaixo.

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)
}

O método unapply do Scala: É usado para decompor um objeto em seus componentes. Ele segue o processo reverso do método apply. Suponha que tenhamos um objeto Pessoa, então podemos decompor esse objeto em seus dois componentes: firstName e lastName, como mostrado abaixo.

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)

    def unapply(p: Person): (String,String) 
        = (p.firstName, p.lastName)
}

Como funciona internamente quando criamos uma instância de uma Classe sem usar a palavra-chave ‘new’ em Scala? Quando optamos por essa abordagem? Como declarar construtores privados em Scala?

Em Scala, quando criamos uma instância de uma Classe sem usar a palavra-chave ‘new’, internamente é feita uma chamada ao método apply apropriado disponível no objeto Companion. Aqui, método apply apropriado significa aquele que corresponde aos parâmetros. Quando escolhemos esta opção: Quando precisamos fornecer um construtor privado e queremos evitar o uso da palavra-chave ‘new’, podemos implementar apenas o método apply com o mesmo conjunto de parâmetros e permitir que os usuários de nossa classe o criem sem a palavra-chave new.

Como declaramos um Construtor Primário privado em Scala? Como fazemos uma chamada para um Construtor Primário privado em Scala?

Em Scala, podemos declarar um Construtor Primário privado muito facilmente. Basta definir um Construtor Primário como é e adicionar ‘private’ logo após o nome da classe e antes da lista de parâmetros, conforme mostrado abaixo:

class Person private (name: String)
object Person{
 def apply(name: String) = new Person(name)
}

Como é um construtor privado, não podemos chamá-lo de fora. Devemos fornecer um método de fábrica (que é o método apply) como mostrado acima e usar esse construtor indiretamente.

Um objeto Companion acessa membros privados de sua classe Companion em Scala?

Geralmente, membros privados significam acessíveis apenas dentro daquela classe. No entanto, a classe Companion e o Objeto Companion do Scala forneceram outro recurso. Em Scala, um objeto Companion pode acessar membros privados de sua classe Companion e a classe Companion pode acessar membros privados de seu objeto Companion.

Qual é a decisão de design principal sobre duas palavras-chave separadas: class e object em Scala? Como definimos membros de instância e membros estáticos em Scala?

No Scala, usamos a palavra-chave class para definir membros de instância e a palavra-chave object para definir membros estáticos. Scala não possui a palavra-chave static, mas ainda podemos defini-los usando a palavra-chave object. A decisão de design principal sobre isso é a clara separação entre membros de instância e estáticos. Desacoplamento entre eles de forma flexível. E outra razão importante é evitar a palavra-chave static para que o Scala se torne uma Linguagem de Programação Orientada a Objetos Pura.

O que é object em Scala? É um objeto singleton ou uma instância de uma classe?

Ao contrário do Java, o Scala tem dois significados para ‘object’. Não se confunda com isso, vou explicar claramente. No Java, temos apenas um significado para objeto, que é “Uma instância de uma classe”.

  • Assim como no Java, o primeiro significado de object é “Uma instância de uma classe”.
val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")
  • Segundo significado é que objeto é uma palavra-chave em Scala. É usada para definir programas executáveis em Scala, objetos companheiros, objetos singleton, etc.

O que é um Objeto Companheiro em Scala? O que é uma Classe Companheira em Scala? Qual é o uso do Objeto Companheiro em Scala?

Em palavras simples, se uma classe e um objeto Scala compartilham o mesmo nome e são definidos no mesmo arquivo de origem, então essa classe é conhecida como “Classe Companheira” e esse objeto é conhecido como “Objeto Companheiro”. Quando criamos uma classe usando a palavra-chave “class” em Scala e um objeto usando a palavra-chave “object” em Scala com o mesmo nome e no mesmo arquivo de origem, então essa classe é conhecida como “Classe Companheira” e esse objeto é conhecido como “Objeto Companheiro”. Exemplo: Employee.scala

class Employee{ }
object Employee{ }

No Scala, o principal propósito do Objeto Companheiro é definir métodos apply e evitar o uso da palavra-chave new na criação de uma instância desse objeto da classe companheira.

Como implementar interfaces em Scala?

Como sabemos do background do Java, usamos interface para definir um contrato. No entanto, não há o conceito de interface em Scala. Mesmo, Scala não possui a palavra-chave interface. Scala possui um conceito mais poderoso e flexível, ou seja, trait para esse fim.

O que é Range em Scala? Como criar um Range em Scala?

Range é uma Coleção Preguiçosa em Scala. Range é uma classe disponível no pacote ‘scala’ como ‘scala.Range’. É usada para representar uma sequência de valores inteiros. É uma sequência ordenada de inteiros. Exemplo:-

scala> 1 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 until 10
res1: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

Quantos valores do tipo Nothing existem em Scala?

Em Scala, o tipo Nothing não possui valores, ou seja, zero. Não possui nenhum valor. É um subtipo de todas as classes de Valor e classes de Referência.

Quantos valores do tipo Unit existem em Scala?

No Scala, Unit é algo semelhante à palavra-chave void do Java. É usado para representar “Nenhum valor existe”. Ele tem um e apenas um valor que é ().

O que é uma função pura?

A pure function is a function without any observable side-effects. That means it returns always same results irrespective how many times we call it with same inputs. A pure function always gives same output for the same inputs. For Example:-

scala> 10 + 20
res0: Int = 30
scala>
scala> 10 + 20
res0: Int = 30

Aqui, “+” é uma função pura disponível na classe Int. Ela fornece o mesmo resultado, 30, para as mesmas entradas 10 e 30, independentemente de quantas vezes a chamamos.

No paradigma de programação funcional, qual é a diferença entre uma função e um procedimento?

Ambos são usados para realizar computações, no entanto, têm uma diferença fundamental no mundo da Programação Funcional. Uma função é uma unidade de computação sem efeitos colaterais, enquanto um procedimento é também uma unidade de computação com efeitos colaterais.

Quais são as principais diferenças entre os construtores auxiliares do Scala e os construtores do Java?

O construtor auxiliar do Scala é quase semelhante ao construtor do Java, com algumas diferenças. Em comparação com os construtores do Java, os construtores auxiliares têm as seguintes poucas diferenças:

  • Os construtores auxiliares são chamados usando a palavra-chave “this”.
  • Todos os construtores auxiliares são definidos com o mesmo nome, ou seja, “this”. No Java, usamos o nome da classe para definir construtores.
  • Cada construtor auxiliar deve começar com uma chamada a um construtor auxiliar previamente definido ou ao construtor primário.
  • Usamos a palavra-chave ‘def’ para definir construtores auxiliares, semelhante à definição de métodos/funções. No Java, a definição de construtor e a definição de método são diferentes.

Qual é o uso da palavra-chave ‘yield’ na construção de for-comprehension do Scala?

Podemos usar a palavra-chave ‘yield’ na construção de for-comprehension do Scala. ‘for/yield’ é usado para iterar uma coleção de elementos e gerar uma nova coleção do mesmo tipo. Não altera a coleção original, gerando uma nova coleção do mesmo tipo que o tipo da coleção original. Por exemplo, se usarmos a construção ‘for/yield’ para iterar uma Lista, ela gerará apenas uma nova Lista.

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)

scala> for(l <- list) yield l*2
res0: List[Int] = List(2, 4, 6, 8, 10)

O que é guard no construtor for-comprehension do Scala?

No Scala, o construtor for-comprehension possui uma cláusula if que é usada para escrever uma condição para filtrar alguns elementos e gerar uma nova coleção. Essa cláusula if também é conhecida como “guarda”. Se essa guarda for verdadeira, então o elemento é adicionado à nova coleção. Caso contrário, o elemento não é adicionado à coleção original. Exemplo:- Guarda for-comprehension para gerar apenas números pares em uma nova coleção.

scala> val list = List(1,2,3,4,5,6,7,8,9,10)
list: List[Int] = List(1, 2, 3, 4, 5 , 6 , 7 , 8 , 9 , 10)

scala> for(l <- list if l % 2 =0 ) yield l
res0: List[Int] = List(2, 4, 6, 8, 10)

Como o Scala resolve o Problema do Diamante de Herança automaticamente e facilmente do que o Java 8?

Se usarmos métodos padrão de Interface do Java 8, enfrentaremos o Problema do Diamante de Herança. O desenvolvedor precisa resolvê-lo manualmente no Java 8. Ele não fornece resolução padrão ou automática para esse problema. No Scala, enfrentaremos o mesmo problema com Traits, mas o Scala é muito inteligente e resolve o Problema do Diamante de Herança automaticamente usando o conceito de Linearização de Classe.

Em Scala, o Pattern Matching segue qual padrão de design? Em Java, o operador ‘instanceof’ segue qual padrão de design?

Em Scala, o Pattern Matching segue o padrão de design Visitor. Da mesma forma, o operador ‘instanceof’ em Java também segue o padrão de design Visitor. Isso é tudo sobre “Perguntas e Respostas Intermediárias de Scala”. Vamos discutir algumas Perguntas e Respostas Avançadas de Scala em minhas próximas postagens. Por favor, deixe um comentário se você gostou da minha postagem ou tem alguma questão/sugestão.

Source:
https://www.digitalocean.com/community/tutorials/scala-interview-questions