Classes et objets Scala
Une classe est une abstraction d'un objet, et un objet est une instance concrète d'une classe. Les classes sont abstraites et n'occupent pas de mémoire, tandis que les objets sont concrets et occupent de l'espace de stockage. Une classe est un modèle de création d'objets, un modèle logiciel qui définit les méthodes et les variables incluses dans un objet d'un type spécifique.
Nous pouvons utiliser le mot-clé new pour créer un objet d'une classe. L'exemple est le suivant :
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);
}
}Les classes dans Scala ne sont pas déclarées comme publiques et il peut y avoir plusieurs classes en une seule. Fichier source Scala.
La classe de l'exemple ci-dessus définit deux variables x et y, et une méthode : move, la méthode n'a pas de valeur de retour.
La définition de classe de Scala peut avoir des paramètres, appelés paramètres de classe, tels que xc, yc ci-dessus, accessibles dans toute la classe.
Ensuite, nous pouvons utiliser new pour instancier la classe et accéder aux méthodes et variables de la 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 ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}Exécutez le code ci-dessus, le résultat de sortie est :
$ scalac Test.scala $ scala Test x 的坐标点: 20 y 的坐标点: 30
Héritage Scala
Scala héritant d'une classe de base est très similaire à Java, mais nous devons faire attention à quelques points :
1. une méthode abstraite doit être utilisée pour modifier son symbole.
2. Seul le constructeur principal peut écrire des paramètres dans le constructeur de la classe de base.
3. Lors de la substitution d'une méthode abstraite d'une superclasse dans une sous-classe, vous n'avez pas besoin d'utiliser le mot-clé override.
Regardons ensuite 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);
}
}Scala utilise le mot-clé extends pour hériter d'une classe. Dans l'exemple, la classe Location hérite de la classe Point. Point est appelé la classe parent (classe de base) et Location est appelé la sous-classe.
override val xc remplace les champs de la classe parent.
L'héritage héritera de toutes les propriétés et méthodes de la classe parent. Scala n'autorise l'héritage que d'une seule classe parent.
L'exemple est le suivant :
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);
}
}Exécutez le code ci-dessus, le résultat de sortie est :
$ scalac Test.scala $ scala Test x 的坐标点 : 20 y 的坐标点 : 30 z 的坐标点 : 20
Scala réécrit une méthode non abstraite et doit utiliser le modificateur 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)
}Exécutez le code ci-dessus, le résultat de sortie est :
$ scalac Test.scala $ scala Test Employee[name=Fred][salary=50000.0]
Objet singleton Scala
Dans Scala, il n'y a pas de statique, mais c'est le cas Nous fournissons également une méthode pour implémenter le modèle singleton, qui consiste à utiliser l'objet mot-clé.
Lors de l'utilisation du mode singleton dans Scala, en plus de la classe définie, un objet objet du même nom doit également être défini. La différence entre celui-ci et une classe est que l'objet objet ne peut pas prendre de paramètres.
Lorsqu'un objet singleton partage le même nom avec une classe, il est appelé objet compagnon de cette classe : objet compagnon. Vous devez définir la classe et ses objets compagnon dans le même fichier source. La classe est appelée classe compagnon de cet objet singleton : classe compagnon. Une classe et ses objets compagnons peuvent accéder aux membres privés de chacun.
Instance d'objet 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);
}
}
}Exécutez le code ci-dessus, le résultat de sortie est :
$ scalac Test.scala $ scala Test x 的坐标点 : 10 y 的坐标点 : 20
Instance d'objet compagnon
/* 文件名：Marker.scala
* author:php中文网
* url:www.php.cn
*/
// 私有构造方法
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")
}
}Exécutez le code ci-dessus, la sortie le résultat est :
$ scalac Marker.scala $ scala Marker 创建颜色标记：red 创建颜色标记：blue 创建颜色标记：green 颜色标记：red 颜色标记：blue
