classes et objets Scala
La classe est un objet abstrait, et l'objet est une instance spécifique d'une classe. La classe est abstraite et ne prend pas la mémoire, et l'objet est concret, prendre l'espace de stockage. La classe est un modèle pour la création d'un objet, il est un des modèles définis par logiciel comprennent des méthodes et variables dans des types spécifiques d'objets dans le.
Nous pouvons utiliser le nouveau mot-clé pour créer des objets de la classe, les exemples sont les suivants:
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 dans la classe ne sont pas déclarés comme public, un fichier source Scala peut avoir plusieurs classes.
Des exemples de la classe ci - dessus définit deux variablesx et y,uneméthode:déplacer, la méthode n'a pas de valeur de retour.
définition de la classe Scala peut avoir des paramètres, paramètres appelés de classe, tels que le xc ci-dessus, yc, paramètres de classe dans l'ensemble de la classe peuvent accéder.
Ensuite, nous pouvons utiliser les nouvelles pour instancier les méthodes et les variables de classe de classe et d'accès:
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);
}
}
Mise en œuvre du code ci-dessus, la sortie est:
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Scala inherit
Scala hérite d'une classe de base avec Java est très similaire, mais nous devons prêter attention aux points suivants:
- 1, réécrire une méthode non abstraite doit utiliser le modificateur override.
- 2, est disponible dans le passé que le constructeur principal des paramètres constructeur d'écriture de la classe de base.
- 3. En cas de substitution dans une sous-classe de la superclasse abstraite, vous ne devez utiliser le mot-clé override.
Regardons un exemple:
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);
}
}
utilisation Scala mot-clé extends pour hériter d'une classe. Instances Emplacement classe hérite classe Point. Le point appelé la classe parent (classe de base), l'emplacement est appelé une sous-classe.
remplacer val xc réécrire le champ de la classe parent.
Toutes les propriétés et les méthodes héritent hériteront de la classe parente, Scala permet seulement hériter d'une classe parente.
Des exemples sont les suivants:
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);
}
}
Mise en œuvre du code ci-dessus, la sortie est:
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala réécrire une méthode non abstraite doit remplacer le modificateur.
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)
}
Mise en œuvre du code ci-dessus, la sortie est:
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Scala objet singleton
En Scala, cette chose est pas statique, mais il nous fournit également une méthode pour atteindre modèle Singleton, et qui est d'utiliser l'objet de mot-clé.
Scala lorsqu'il est utilisé dans un modèle unique cas, en plus de la définition de la classe, mais aussi la définition d'un objet cible avec le même nom, est la différence entre elle et la classe, l'objet de l'objet ne peut pas prendre des paramètres.
Lorsque les objets Singleton partagent le même nom avec une classe, il est appelé objets compagnon de cette classe: objet compagnon. Vous devez définir la classe et ses objets associés dans le même fichier source. Cette classe est appelée l'objet classe d'accompagnement singleton: classe compagnon. Classe et son objet compagnon peuvent accéder à l'autre de leurs membres privés.
instances d'objets 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);
}
}
}
Mise en œuvre du code ci-dessus, la sortie est:
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
instance d'objet associé
/* 文件名：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")
}
}
Mise en œuvre du code ci-dessus, la sortie est:
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue