|
| 1 | +--- |
| 2 | +layout: tutorial |
| 3 | +title: Objetos Singleton |
| 4 | + |
| 5 | +disqus: true |
| 6 | + |
| 7 | +tutorial: scala-tour |
| 8 | +num: 12 |
| 9 | + |
| 10 | +tutorial-next: xml-processing |
| 11 | +tutorial-previous: pattern-matching |
| 12 | +language: pt-br |
| 13 | +--- |
| 14 | + |
| 15 | +Métodos e valores que não são associados com instâncias individuais de uma [classe](classes.html) são considerados *objetos singleton*, denotados através da palavra-chave `object` ao invés de `class`. |
| 16 | + |
| 17 | +``` |
| 18 | +package test |
| 19 | +
|
| 20 | +object Blah { |
| 21 | + def sum(l: List[Int]): Int = l.sum |
| 22 | +} |
| 23 | +``` |
| 24 | + |
| 25 | +O método `sum` é disponível globalmente, e pode ser referenciado ou importado como `test.Blah.sum`. |
| 26 | + |
| 27 | +Objetos Singleton são um tipo de mescla e abreviação para definir uma classe de uso único, a qual não pode ser diretamente instanciada, e um membro `val` durante a definição do `object`. De fato, como `val`, objetos singleton podem ser definidos como membros de uma [trait](traits.html) ou [classe](classes.html), porém isso não é comum. |
| 28 | + |
| 29 | +Um objeto singleton pode estender classes e traits. Já uma [classe clase](case-classes.html) sem [parâmetros com tipo](generic-classes.html) por padrão irá criar um objeto singleton como o mesmo nome e com uma [`Função*`](http://www.scala-lang.org/api/current/scala/Function1.html) trait implementada. |
| 30 | + |
| 31 | +## Acompanhantes ## |
| 32 | + |
| 33 | +A maioria dos objetos singleton não estão sozinhos, mas sim associados com uma classe de mesmo nome. O “objeto singleton de mesmo nome” que uma classe case, acima mencionado, é um exemplo disso. Quando isso acontece, o objeto singleton é chamado de *objeto acompanhante* de uma classe e, a classe é chamada de *classe acompanhante* de um objeto. |
| 34 | + |
| 35 | +[Scaladoc](https://wiki.scala-lang.org/display/SW/Introduction) possui um um recurso espacial para navegar entre classes e seus acompanhantes: se o grande círculo contendo “C” ou “O” possui sua extremidade superior dobrada para baixo, você pode clicar no círculo para acessar o acompanhante. |
| 36 | + |
| 37 | +Se houver um objeto acompanhante para uma classe, ambos devem ser definidos no mesmo aquivo fonte. Por exemplo: |
| 38 | + |
| 39 | +```tut |
| 40 | +class IntPair(val x: Int, val y: Int) |
| 41 | +
|
| 42 | +object IntPair { |
| 43 | + import math.Ordering |
| 44 | +
|
| 45 | + implicit def ipord: Ordering[IntPair] = |
| 46 | + Ordering.by(ip => (ip.x, ip.y)) |
| 47 | +} |
| 48 | +``` |
| 49 | + |
| 50 | +É comum ver instâncias de classes de tipo como [valores implicit](implicit-parameters.html), como `ipord` acima, definido no objeto acompanhante quando se segue o padrão da classe de tipo. Isso ocorre porque os membros do objeto acompanhante são incluídos por padrão na busca de valores implicitos. |
| 51 | + |
| 52 | +## Nota para programadores Java ## |
| 53 | + |
| 54 | +`static` não é uma palavra-chava em Scala. Ao invés disso, todos os membros que devem ser estáticos, incluindo classes, devem ser declarados no objeto singleton. Eles podem ser referenciados com a mesma sintaxe, They can be referred to with the same syntax, importados gradativamente ou como um grupo, e assim por diante. |
| 55 | + |
| 56 | +Frequentemente, os programadores Java definem membros estáticos, talvez `private`, como auxiliares de implementação para seus membros de instância. Estes são movidos para o acompanhante também; Um padrão comum é importar os membros do objeto acompanhante na classe, da seguinte forma: |
| 57 | +``` |
| 58 | +class X { |
| 59 | + import X._ |
| 60 | +
|
| 61 | + def blah = foo |
| 62 | +} |
| 63 | +
|
| 64 | +object X { |
| 65 | + private def foo = 42 |
| 66 | +} |
| 67 | +``` |
| 68 | + |
| 69 | +Isso demonstra outra característica: no contexto `private`, as classes e seus acompanhantes são amigos. `object X` pode acessar membro privados da `class X`, e vice versa. Para fazer com que um membro seja *realmente* para um ou outro, utilize `private[this]`. |
| 70 | + |
| 71 | +Para conveniência Java, métodos, incluindo `var`s e `val`s, definidos diretamente em um objeto singleton também têm um método estático definido na classe acompanhante, chamado *encaminhadores estáticos*. Outros membros são acessíveis por meio de campos estáticos `X$.MODULE$` para o `object X`. |
| 72 | + |
| 73 | +Se você mover tudo para um objeto acompanhante e descobrir que tudo o que resta é uma classe que você não deseja que seja instanciada, exclua simplesmente a classe. Encaminhadores estáticos ainda serão criados. |
0 commit comments