aulas Scala e objetos
Classe é um objeto abstrato, e o objeto é uma instância específica de uma classe. Classe é abstrato e não ocupa memória, e o objeto é de concreto, ocupam espaço de armazenamento. Classe é um modelo para a criação de um objeto, ele é um modelos definidos pelo software incluem métodos e variáveis em tipos específicos de objetos no.
Podemos usar a nova palavra-chave para criar objetos da classe, os exemplos são os seguintes:
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 ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
Scala na classe não são declarados como público, um arquivo de origem Scala pode ter várias classes.
Exemplos da classe acima define duas variáveisx e y,UmMétodo:movimento, o método não tem valor de retorno.
definição de classe Scala podem ter parâmetros, chamados parâmetros de classe, como a xc acima, yc, parâmetros de classe em toda a classe pode acessar.
Então, podemos usar de novo para instanciar os métodos e variáveis de classe de classe e de acesso:
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 ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Scala herdam
Scala herdar uma classe base com o Java é muito semelhante, mas precisamos prestar atenção aos seguintes pontos:
- 1, reescrever um método não-resumo deve usar o modificador override.
- 2, está disponível no apenas o principal construtor dos parâmetros construtor de gravação de classe base do passado.
- 3. Quando substituído em uma subclasse da superclasse abstrata, você não precisa usar a palavra-chave override.
Vejamos um exemplo:
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 ("x 的坐标点: " + x);
println ("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 ("x 的坐标点 : " + x);
println ("y 的坐标点 : " + y);
println ("z 的坐标点 : " + z);
}
}
Scala uso palavra-chave extends para herdar uma classe. Instâncias Localização classe herda da classe Point. Ponto chamado a classe pai (classe base), Localização é chamado de uma subclasse.
substituir val xc reescrever o campo classe pai.
Todas as propriedades e métodos de herdar herdará a classe pai, Scala só permite herdar uma classe pai.
Exemplos são os seguintes:
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 ("x 的坐标点 : " + x);
println ("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 ("x 的坐标点 : " + x);
println ("y 的坐标点 : " + y);
println ("z 的坐标点 : " + z);
}
}
object Test {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// 移到一个新的位置
loc.move(10, 10, 5);
}
}
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala reescrever um método não-abstrata deve substituir modificador.
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)
}
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala objeto singleton
Em Scala, essa coisa não é estática, mas também nos fornece um método para obter o padrão Singleton, e que está a usar a palavra objeto.
Scala quando utilizado em modelo de caso simples, em adição à definição de classe, mas também a definição de um objecto-alvo com o mesmo nome, é a diferença entre este e a classe, objecto objecto não pode receber parâmetros.
Quando os objetos Singleton compartilham o mesmo nome com uma classe, ele é chamado de objetos companheiro desta classe: objeto companheiro. Você deve definir a classe e seus objetos associados no mesmo arquivo de origem. Essa classe é chamada de classe de acompanhamento objeto singleton: class companheiro. Classe e seu objeto companheiro pode acessar um ao outro seus membros privados.
instâncias de objetos Singleton
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 ("x 的坐标点 : " + point.x);
println ("y 的坐标点 : " + point.y);
}
}
}
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
ocorrência de objeto associado
/* 文件名：Marker.scala
* author:本教程
* url:www.w3big.com
*/
// 私有构造方法
class Marker private(val color:String) {
println("创建" + this)
override def toString(): String = "颜色标记："+ color
}
// 伴生对象，与类共享名字，可以访问类的私有属性和方法
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"))
// 单例函数调用，省略了.(点)符号
println(Marker getMarker "blue")
}
}
Implementação do código acima, a saída é:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue