Perguntas de Entrevista sobre Scala

Tutoriais
Scala

Antes de ler este post, por favor, revise meu post anterior em “Perguntas e Respostas Básicas sobre Scala” para obter algum conhecimento básico sobre a linguagem Scala. Neste post, vamos discutir algumas perguntas mais avançadas sobre Scala que são úteis para desenvolvedores Scala experientes. Nota:- Como esta lista já ficou muito grande, vou criar outro post com as perguntas e respostas restantes. Por favor, consulte esse post em: “Perguntas e Respostas Intermediárias e Avançadas sobre Scala“

Perguntas sobre Entrevista Scala

Nesta seção, vamos listar todas as perguntas intermediárias sobre Scala e na próxima seção, vamos discuti-las em detalhes.

  1. O que é o Construtor Primário? O que é o Construtor Secundário ou Auxiliar em Scala?
  2. Qual é o uso dos Construtores Auxiliares em Scala? Por favor, explique as regras a serem seguidas ao definir Construtores Auxiliares em Scala?
  3. Quais são as diferenças entre Array e ArrayBuffer em Scala?
  4. O que é uma classe case? O que é um objeto case? Quais são as vantagens de uma 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 uma Classe Normal?
  7. Qual é a utilização dos métodos isInstanceOf e asInstanceOf em Scala? Existe algum conceito semelhante disponível em Java?
  8. Como você prova que por padrão, um Case Object é Serializable e um Object Normal 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 Eager? O que é Avaliação Lazy?
  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 Inner de Scala e a classe Inner de Java?
  13. O que é o Problema do Diamante? Como Scala resolve o Problema do Diamante?
  14. Por que 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 internamente quando criamos uma instância de uma Classe sem usar a palavra-chave ‘new’ em Scala? Quando optamos por 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. O objeto Companion acessa membros privados de sua classe Companion em Scala?
  21. Qual é a principal decisão de design em relação às duas palavras-chave separadas: class e object em Scala? Como definimos membros de instância e membros estáticos em Scala?
  22. O que é um objeto em Scala? É um objeto singleton ou uma instância de uma classe?
  23. O que é um Objeto Companion em Scala? O que é uma Classe Companion em Scala? Qual é o uso do Objeto Companion em Scala?
  24. Como implementar interfaces em Scala?
  25. O que é Range em Scala? Como criar um Range em Scala?
  26. Quantos valores do tipo Nothing existem em Scala?
  27. Quantos valores do tipo Unit existem em Scala?
  28. O que é Range em Scala? Como criar um Range em Scala?
  29. Em FP, qual é a diferença entre uma função e um procedimento?
  30. Quais são as principais diferenças entre os construtores auxiliares do Scala e os construtores do Java?
  31. Qual é o uso da palavra-chave ‘yield’ na construção for-comprehension do Scala?
  32. O que é um guard em uma construção for-comprehension do Scala?
  33. Como o Scala resolve automaticamente e facilmente o problema do Diamante de Herança em comparação com o Java 8?
  34. No Scala, o Pattern Matching segue qual padrão de design? No Java, o operador ‘instanceof’ segue qual padrão de design?

Perguntas e Respostas da Entrevista Scala

Nesta seção, iremos abordar cada pergunta da lista acima e discuti-la em detalhes com exemplos adequados (se necessário). Se você deseja entender esses conceitos detalhadamente 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 definido junto 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

class Person acima tem um construtor primário sem parâmetros ou sem parâmetro ou sem parâmetros para criar instâncias desta classe.

class Person (firstName: String, lastName: String)

A classe Person acima possui um construtor primário com 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’, conforme mostrado abaixo:

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

Qual é a utilidade dos Construtores Auxiliares em Scala? Por favor, explique as regras a serem seguidas ao definir 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 adequado com base em sua necessidade. Regras do Construtor Auxiliar:

  • Eles são como métodos. 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 um Construtor Primário. Caso contrário, erro de compilação.
  • Cada Construtor Auxiliar deve diferir com sua lista de parâmetros: pode ser por número ou tipos.
  • Construtores Auxiliares não podem chamar construtores de superclasses. Eles devem chamá-los apenas através do Construtor Primário.
  • Todos os Construtores Auxiliares chamam seu Construtor Primário diretamente ou indiretamente através de outros Construtores Auxiliares.

NOTA:- Se você deseja aprender sobre 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:

  • O Array é um array de tamanho fixo. Não podemos alterar seu tamanho depois de criado.
  • O ArrayBuffer é um array de tamanho variável. Ele pode aumentar ou diminuir seu tamanho dinamicamente.
  • O Array é algo semelhante aos arrays primitivos do Java.
  • O ArrayBuffer é algo semelhante ao ArrayList do 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 redundantes. Podemos criar objetos de classe case sem usar a palavra-chave “new”. Por padrão, o compilador Scala adiciona “val” para todos os parâmetros do construtor. Por isso, sem usar val ou var, os parâmetros do construtor da classe case se tornarão membros da classe, o que não é possível para classes normais. Vantagens de uma classe case:

  • Por padrão, o compilador Scala adiciona os métodos toString, hashCode e equals. Podemos evitar escrever esse código redundante.
  • Por padrão, o compilador Scala adiciona um objeto companheiro com métodos apply e unapply, por isso não precisamos da palavra-chave “new” para criar instâncias de uma classe case.
  • Por padrão, o compilador Scala adiciona o método copy também.
  • 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
  • O Case Object é criado usando a expressão “case object”. Por padrão, também é um objeto singleton. Além disso, por padrão, o Case Object possui os métodos toString e hashCode, o que um objeto normal não possui.
case object MyCaseObject
  • Por padrão, o Case Object é serializável, enquanto 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 as classes normais são as seguintes:

  • A Case Class evita muitos códigos boilerplate, adicionando automaticamente alguns métodos úteis.
  • Por padrão, suporta imutabilidade, pois seus parâmetros são declarados como ‘val’.
  • Fácil de usar em correspondência de padrões.
  • Não é necessário usar a palavra-chave ‘new’ para criar uma instância da Case Class.
  • Por padrão, oferece suporte à Serialização e Deserialização.

Qual é a utilidade 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 é do tipo fornecido ou não. Se sim, retorna verdadeiro. Caso contrário, retorna falso.

   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 fornecido e o tipo forem do mesmo tipo, ele é convertido para o tipo fornecido. Caso contrário, 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 manual é semelhante ao método ‘asInstanceOf’ do Scala.

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

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

Sim, por padrão, o objeto Case é serializável. Mas o objeto normal não é. Podemos provar 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 Lista 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 List é uma estrutura de dados de tamanho variável. O tamanho da Lista é automaticamente aumentado ou diminuído com base nas operações que realizamos sobre ela.
  • Arrays são invariantes, enquanto Listas são covariantes.

NOTA: Se você não tem certeza sobre o que são invariantes e covariantes, por favor, leia meu próximo post sobre Perguntas de Entrevista em Scala.

Qual é a diferença entre “val” e “lazy val” em Scala? O que é Avaliação Ansiosa? O que é Avaliação Preguiçosa?

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 programas:

  • Avaliação Ávida
  • Avaliação Preguiçosa

Avaliação Ávida significa avaliar o programa em tempo de compilação ou 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, apenas quando os clientes acessam o programa é que ele é avaliado. A diferença entre “val” e “lazy val” é que “val” é usado para definir variáveis que são avaliadas ávidamente, e “lazy val” também é usado para definir variáveis, mas elas são avaliadas preguiçosamente.

Qual é a relação entre o método equals e == em Scala? Diferencie o == em Scala do operador == em 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 == do 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 == do 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 é “From C.display” do trait C. O compilador Scala lê “extends B with C” da direita para a esquerda e pega a definição do método “display” do trait mais à esquerda, ou seja, C. NOTA:- Veja minha postagem sobre “Traits 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 possui a palavra-chave “static” de forma alguma. Esta é uma decisão de design feita pela equipe do Scala. A principal razão para tomar essa decisão é tornar o 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 é completamente contrário aos princípios da OOP. 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 objetos 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 Scala executáveis.

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

Quando definimos o método main no objeto 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
}

Brazilian Portuguese Translation:
Ao definir a variável PI por meio de \texttt{def} e adicionar métodos, eles se tornarão membros estáticos. Isso significa que podemos chamá-los sem criar um objeto separado, como em \texttt{MyScalaStaticMembers.add(10, 20)}. É usado para definir métodos de fábrica. Consulte minha próxima pergunta sobre isso.

Como definir métodos de fábrica usando a palavra-chave \texttt{object} em Scala? Qual é a utilidade 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 principal objetivo 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 \texttt{apply} para definir métodos de fábrica em Scala. Se tivermos um construtor primário e vários construtores auxiliares, precisamos definir vários métodos \texttt{apply}, conforme 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 \texttt{new} ou com a palavra-chave \texttt{new} de acordo com 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 do modelo. Em palavras 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.

Método apply do Scala: Ele é usado para compor um objeto usando seus componentes. Suponha que desejamos criar um objeto Pessoa, então usamos os componentes nome e sobrenome 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)
}

Método unapply do Scala: Ele é usado para decompor um objeto em seus componentes. Segue o processo reverso do método apply. Suponha que tenhamos um objeto Pessoa, então podemos decompor esse objeto em seus dois componentes: nome e sobrenome, conforme 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 em Scala sem usar a palavra-chave ‘new’? 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, o método apply apropriado significa aquele que corresponde aos parâmetros. Quando escolhemos essa 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 da 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, como 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.

O 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 outra característica. 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?

Em 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 principal decisão de design sobre isso é a clara separação entre membros de instância e estáticos. O acoplamento frouxo entre eles. E outra razão importante é evitar a palavra-chave static para que Scala se torne uma Linguagem Puramente Orientada a Objetos.

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

Ao contrário do Java, Scala tem dois significados sobre ‘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”.

  • Como no Java, o primeiro significado de objeto é “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 únicos, etc.

O que é um Objeto Companheiro em Scala? O que é uma Classe Companheira em Scala? Qual é o uso de um 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” do Scala e um objeto usando a palavra-chave “object” do 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 objetivo principal 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 contexto Java, usamos a interface para definir contrato. No entanto, não há o conceito de interface em Scala. De fato, Scala não possui a palavra-chave interface. Em seu lugar, Scala possui um conceito mais poderoso e flexível, ou seja, o trait para esse propósito.

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, sendo 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?

No Scala, o tipo Nothing não possui valores, ou seja, zero valores. Ele não tem nenhum valor. É um subtipo de todas as classes de valores e classes de referência.

Quantos valores do tipo Unit existem em Scala?

Em 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. Ele dá o mesmo resultado 30 para as mesmas entradas 10 e 30, independentemente de quantas vezes o chamamos.

No FP, qual é a diferença entre uma função e um procedimento?

Ambos são usados para realizar cálculos, no entanto, eles têm uma grande diferença no mundo da Programação Funcional. Uma função é uma unidade de cálculo sem efeitos colaterais, enquanto um Procedimento também é uma unidade de cálculo 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, que é “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étodo/função. 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. Isso não altera a coleção original, gerando uma nova coleção do mesmo tipo que o tipo original da coleção. Por exemplo, se usarmos a construção ‘for/yield’ para iterar uma Lista, ela gera 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 de compreensão de for em Scala?

Em Scala, o construtor de compreensão de for tem 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:- Compreensão de For com guarda 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 mais facilmente do que o Java 8?

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

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

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

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