Scala - Classes e objetos
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 DemoResultado
Point x location : 20
Point y location : 30Estendendo 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 DemoResultado
Point x location : 20
Point y location : 30
Point z location : 20Classes 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 DemoResultado
Hello
Hello
Hello
HelloNote -
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 DemoResultado
Point x location : 10
Point y location : 20