English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
A classe é a abstração do objeto, e o objeto é o exemplo específico da classe. A classe é abstrata, não ocupa memória, enquanto o objeto é específico, ocupa espaço de armazenamento. A classe é o esboço usado para criar objetos, é um modelo de software que define métodos e variáveis incluídos em um tipo específico de objeto.
Podemos usar a palavra-chave new para criar objetos da classe, exemplo a seguir:}}
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("Coordenadas do ponto x: " + x);
println("Coordenadas do ponto y: " + y);
}
}As classes no Scala não são declaradas como public, um arquivo-fonte Scala pode conter várias classes.
A definição da classe do exemplo acima define duas variáveis x e y Método:moveMétodos não têm valor de retorno.
A definição de classe do Scala pode ter parâmetros, chamados de parâmetros de classe, como xc, yc acima, os parâmetros de classe podem ser acessados em todo o escopo da classe.
A seguir, podemos usar new para instanciar a classe e acessar os métodos e variáveis da classe:
import java.io._
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("Coordenadas do ponto x: " + x);
println("Coordenadas do ponto y: " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// mover-se para uma nova posição
pt.move(10, 10);
}
}Execute o código acima e o resultado será:
$ scalac Test.scala $ scala Test Coordenadas do ponto x: 20 Coordenadas do ponto y: 30
A herança do Scala é semelhante ao Java, mas precisamos prestar atenção aos seguintes pontos:
1Para sobrescrever um método não abstrato, é necessário usar o modificador override.
2Apenas o construtor principal pode passar parâmetros para o construtor da classe pai.
3Na subclasse, ao sobrescrever o método abstrato da superclasse, você não precisa usar a palavra-chave override.
Vamos ver um exemplo a seguir:
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("Coordenadas do ponto x: " + x);
println("Coordenadas do ponto y: " + 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("Ponto de coordenada x: "); + x);
println("Ponto de coordenada y: "); + y);
println("Coordenadas do ponto z : " + z);
}
}O Scala usa a palavra-chave extends para herdar uma classe. No exemplo, a classe Location herda a classe Point. Point é chamada de classe pai (classe base), Location é chamada de subclasse.
override val xc Para sobrescrever os campos da classe pai.
A herança herda todas as propriedades e métodos da classe pai, o Scala permite apenas a herança de uma classe pai.
Exemplo a seguir:
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("Ponto de coordenada x: "); + x);
println("Ponto de coordenada y: "); + 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("Ponto de coordenada x: "); + x);
println("Ponto de coordenada y: "); + y);
println("Coordenadas do ponto z : " + z);
}
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// mover-se para uma nova posição
loc.move(10, 10, 5);
}
}Execute o código acima e o resultado será:
$ scalac Test.scala $ scala Test Ponto de coordenada x: 20 Ponto de coordenada y: 30 Coordenadas do ponto z : 20
O Scala reescreve um método não abstrato, deve usar o modificador override.
class Person {
var name = ""
override def toString = getClass.getName + "[name=" + name + "]"
}
class Employee extends Person {
var salary = 0.0
override def toString = super.toString + "[salary=" + salary + "]"
}
object Test extends App {
val fred = new Employee
fred.name = "Fred"
fred.salary = 50000
println(fred)
}Execute o código acima e o resultado será:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
No Scala, não há essa coisa chamada static, mas também fornece um método de implementação do padrão singleton, que é o uso da palavra-chave object.
No Scala, ao usar o padrão singleton, além da classe definida, também é necessário definir um objeto object com o mesmo nome, a diferença é que o objeto object não pode ter parâmetros.
Quando um objeto singleton compartilha o mesmo nome com uma classe, ele é chamado de objeto anexado dessa classe: object companion. Você deve definir a classe e seu objeto anexado no mesmo arquivo de origem. A classe é chamada de classe companion do objeto singleton: class companion. A classe e seu objeto anexado podem acessar os membros privados um do outro.
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 Test {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println("Ponto de coordenada x: "); + point.x);
println("Ponto de coordenada y: "); + point.y);
}
}
}Execute o código acima e o resultado será:
$ scalac Test.scala $ scala Test Ponto de coordenada x: 10 Ponto de coordenada y: 20
/* Nome do arquivo: Marker.scala
* autor: Site deTutorial Básico
* url:pt.oldtoolbag.com
*/
// Construtor privado
class Marker private(val color: String) {}}
println("Criar" + this)
override def toString(): String = "Marcador de Cor:"+ color
}
// Objeto anexado, com o mesmo nome da classe, pode acessar propriedades e métodos privados da classe
object Marker{
private val markers: Map[String, Marker] = Map(
"red" -> new Marker("red"),
"blue" -> new Marker("blue"),
"green" -> new Marker("green")
)
def apply(color: String) = {
if(markers.contains(color)) markers(color) else null
}
def getMarker(color: String) = {
if(markers.contains(color)) markers(color) else null
}
def main(args: Array[String]) {
println(Marker("red"))
// Chamada de função singleton, omitindo o símbolo (ponto) .
println(Marker getMarker "blue")
}
}Execute o código acima e o resultado será:
$ scalac Marker.scala $ scala Marker Criar Marcador de Cor: vermelho Criar Marcador de Cor: azul Criar Marcador de Cor: verde Marcador de Cor: vermelho Marcador de Cor: azul