Diferença entre object e class em Scala

Eu estou apenas passando por alguns tutoriais Scala na Internet e notei em alguns exemplos que um object é declarado no início do exemplo.

Qual é a diferença entre class e object no Scala?

tl; dr

  • class C define uma class, assim como em Java ou C ++.
  • object O cria um object singleton O como instância de alguma class anônima; ele pode ser usado para manter membros estáticos que não estão associados a instâncias de alguma class.
  • object O extends T faz o object O uma instância de trait T ; você pode então passar O qualquer lugar, um T é esperado.
  • se houver uma class C , o object C será o object complementar da class C ; Observe que o object complementar não é automaticamente uma instância de C

Veja também a documentação do Scala para object e class .

Uso como host de membros estáticos

Na maioria das vezes, você precisa de um object para manter methods e valores / variables ​​que devem estar disponíveis sem ter que primeiro instanciar uma instância de alguma class. Este é o uso está intimamente relacionado a membros static em Java.

 object A { def twice(i: Int): Int = 2*i } 

Você pode então chamar o método acima usando A.twice(2) .

Se twice fosse membro de alguma class A , você precisaria criar uma instância primeiro:

 class A() { def twice(i: Int): Int = 2 * i } val a = new A() a.twice(2) 

Você pode ver como isso é redundante, pois twice não requer dados específicos da instância.

Uso como uma instância nomeada especial

Você também pode usar o próprio object como uma instância especial de uma class ou traço. Quando você faz isso, seu object precisa estender algum trait para se tornar uma instância de uma subclass dele.

Considere o seguinte código:

 object A extends B with C { ... } 

Essa declaração primeiro declara uma class anônima (inacessível) que estende B e C e instancia uma única instância dessa class chamada A

Isso significa que A pode ser passado para funções que esperam objects do tipo B ou C , ou B with C

Recursos adicionais do object

Existem também algumas características especiais de objects no Scala. Eu recomendo ler a documentação oficial .

  • def apply(...) permite a syntax usual do nome-menos método de A(...)
  • def unapply(...) permite criar extratores de correspondência de padrões personalizados
  • se acompanha uma class com o mesmo nome, o object assume uma function especial ao resolver parâmetros implícitos

Uma class é uma definição, uma descrição. Define um tipo em termos de methods e composição de outros tipos.

Um object é um singleton – uma instância de uma class que é garantida como única. Para cada object no código, uma class anônima é criada, que herda de qualquer class que você tenha declarado object para implementar. Esta class não pode ser vista no código-fonte do Scala – embora você possa obtê-lo através da reflection.

Existe uma relação entre object e class . Diz-se que um object é o object-companheiro de uma class se eles compartilham o mesmo nome. Quando isso acontece, cada um tem access a methods de visibilidade private no outro. Esses methods não são importados automaticamente, no entanto. Você precisa importá-los explicitamente ou prefixá-los com o nome da class / object.

Por exemplo:

 class X { // class X can see private members of object X // Prefix to call def m(x: Int) = Xf(x) // Import and use import X._ def n(x: Int) = f(x) private def o = 2 } object X { private def f(x: Int) = x * x // object X can see private members of class X def g(x: X) = { import x._ xo * o // fully specified and imported } } 

Um object tem exatamente uma instância (você não pode chamar new MyObject ). Você pode ter várias instâncias de uma class.

O object tem o mesmo propósito (e alguns adicionais) que os methods e campos estáticos em Java.

Como foi explicado por muitos, o object define uma instância singleton. A única coisa nas respostas aqui que eu acredito é deixada de fora é que o object serve a vários propósitos.

  • Pode ser o object companheiro de uma class / trait , contendo o que pode ser considerado methods estáticos ou methods de conveniência.

  • Ele pode agir de maneira muito semelhante a um módulo, contendo tipos e definições relacionados / subsidiários, etc.

  • Ele pode implementar uma interface estendendo uma class ou uma ou mais trait .

  • Pode representar um caso de um sealed trait que não contém dados. A esse respeito, muitas vezes é considerado mais correto do que uma case class sem parâmetros. O caso especial de um sealed trait com apenas implementadores de case object é mais ou menos a versão Scala de um enum.

  • Pode atuar como evidência para a lógica orientada implicit .

  • Introduz um tipo singleton.

É uma construção muito poderosa e geral. O que pode ser muito confuso para os iniciantes do Scala é que o mesmo construto pode ter usos muito diferentes. E um object pode servir muitos desses diferentes usos de uma só vez, o que pode ser ainda mais confuso.

Definir um object no Scala é como definir uma class em Java que tenha apenas methods estáticos. No entanto, no Scala, um object pode estender outra superclass, implementar interfaces e ser passado como se fosse uma instância de uma class. (Então, é como os methods estáticos em uma class, mas melhor).

A diferença formal –

  1. você não pode fornecer parâmetros de construtor
  2. não é um tipo – você não pode criar uma instância com um novo operador. Mas pode ter campos, methods, estender uma superclass e misturar traços.

A diferença de uso:

  • O Scala não possui methods ou campos estáticos. Em vez disso, você deve usar o object . Você pode usá-lo com ou sem class relacionada. No primeiro caso, é chamado de object complementar. Voce tem que:
    1. use o mesmo nome para class e object
    2. colocá-los no mesmo arquivo de origem.
  • Para criar um programa, você deve usar o método main no object , não na class .

     object Hello { def main(args: Array[String]) { println("Hello, World!") } } 
  • Você também pode usá-lo enquanto usa o object singleton em java.

A palavra-chave object cria um novo tipo singleton, que é como uma class que possui apenas uma única instância nomeada. Se você estiver familiarizado com o Java, declarar um object no Scala é muito parecido com a criação de uma nova instância de uma class anônima.

O Scala não tem equivalente à palavra-chave estática do Java, e um object é frequentemente usado no Scala, onde você pode usar uma class com membros estáticos em Java.

Objeto é uma class, mas já tem (é) uma instância, portanto, você não pode chamar new ObjectName . Por outro lado, Classe é apenas tipo e pode ser uma instância chamando new ClassName() .

Classe Scala igual à Classe Java, mas scala não fornece nenhum método de input na class, como o método main em java. O principal método associado à palavra-chave object. Você pode pensar na palavra-chave object como a criação de um object singleton de uma class definida implicitamente.

mais informações consulte esta class de artigo e palavra-chave object em programação scala

Em scala, não há conceito static . Então, o scala cria um object singleton para fornecer o ponto de input para a execução do seu programa. Se você não criar um object singleton, seu código será compilado com sucesso, mas não produzirá nenhuma saída. Os methods declarados no object Singleton são acessíveis globalmente. Um object singleton pode estender classs e características.

Exemplo de object Scala Singleton

 object Singleton{ def main(args:Array[String]){ SingletonObject.hello() // No need to create object. } } object SingletonObject{ def hello(){ println("Hello, This is Singleton Object") } } 

Saída:

 Hello, This is Singleton Object 

Em scala, quando você tem uma class com o mesmo nome do object singleton, ela é chamada de class complementar e o object singleton é chamado de object complementar.

A class complementar e seu object complementar devem ser definidos no mesmo arquivo de origem.

Exemplo de object complementar do Scala

 class ComapanionClass{ def hello(){ println("Hello, this is Companion Class.") } } object CompanoinObject{ def main(args:Array[String]){ new ComapanionClass().hello() println("And this is Companion Object.") } } 

Saída:

 Hello, this is Companion Class. And this is Companion Object. 

Em scala, uma class pode conter:

1. Membro de dados

2. Método de membro

3. Bloco Construtor

4. Classe aninhada

5. Super informações de class etc.

Você deve inicializar todas as variables ​​de instância na class. Não há escopo padrão. Se você não especificar o escopo de access, será público. Deve haver um object no qual o método principal é definido. Ele fornece o ponto de partida para o seu programa. Aqui, criamos um exemplo de class.

Exemplo de amostra Scala da class

 class Student{ var id:Int = 0; // All fields must be initialized var name:String = null; } object MainObject{ def main(args:Array[String]){ var s = new Student() // Creating an object println(s.id+" "+s.name); } } 

Desculpe, estou muito atrasado, mas espero que isso ajude você.

O object é igual à class estática em Java para algumas extensões, as características estáticas significam que a class estática não precisa criar um object ao colocar na JVM, ele pode ser usado pelo nome da class diretamente

Uma class é um modelo para objects. Depois de definir uma class, você pode criar objects a partir do blueprint da class com a palavra-chave new . Através do object, você pode usar todas as funcionalidades da class definida.

Diagrama para uma melhor explicação:

diagrama

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

Fonte

Classe e object: uma class é uma definição que descreve todos os atributos de entidade ou object. E object é uma instância de uma class.