Scala - Classes et objets
Ce chapitre vous explique comment utiliser les classes et les objets dans la programmation Scala. Une classe est un plan pour les objets. Une fois que vous avez défini une classe, vous pouvez créer des objets à partir du plan de classe avec le mot-clénew. Grâce à l'objet, vous pouvez utiliser toutes les fonctionnalités de la classe définie.
Le diagramme suivant illustre la classe et l'objet en prenant un exemple de classe student, qui contient les variables membres (name et roll no) et les méthodes membres (setName () et setRollNo ()). Enfin, tous sont membres de la classe. La classe est un plan et les objets sont réels ici. Dans le diagramme suivant, Student est une classe et Harini, John et Maria sont les objets de la classe Student, ceux-ci ont un nom et un numéro de rôle.
Classe de base
Voici une syntaxe simple pour définir une classe de base dans Scala. Cette classe définit deux variablesx et y et une méthode: move, qui ne renvoie pas de valeur. Les variables de classe sont appelées, les champs de la classe et les méthodes sont appelés méthodes de classe.
Le nom de classe fonctionne comme un constructeur de classe qui peut prendre un certain nombre de paramètres. Le code ci-dessus définit deux arguments de constructeur,xc et yc; ils sont tous deux visibles dans tout le corps de la classe.
Syntaxe
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);
}
}Comme mentionné précédemment dans ce chapitre, vous pouvez créer des objets à l'aide d'un mot-clé new puis vous pouvez accéder aux champs de classe et aux méthodes comme indiqué ci-dessous dans l'exemple -
Exemple
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);
}
}Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.
Commander
\>scalac Demo.scala
\>scala DemoProduction
Point x location : 20
Point y location : 30Extension d'une classe
Vous pouvez étendre une classe Scala de base et concevoir une classe héritée de la même manière que vous le faites en Java (utilisez extends mot clé), mais il y a deux restrictions: la substitution de méthode nécessite le override mot-clé, et seulement le primaryLe constructeur peut transmettre des paramètres au constructeur de base. Étendons notre classe ci-dessus et ajoutons une autre méthode de classe.
Exemple
Prenons un exemple de deux classes La classe Point (comme le même exemple que ci-dessus) et la classe Location est une classe héritée à l'aide du mot-clé extend. Un tel 'extendsLa clause 'a deux effets: elle fait que la classe Location hérite de tous les membres non privés de la classe Point et elle fait du type Location un sous-type du type Classe Point . Donc ici la classe Point est appeléesuperclasset la classe Location est appeléesubclass. L'extension d'une classe et l'héritage de toutes les fonctionnalités d'une classe parent s'appellentinheritance mais Scala autorise l'héritage d'une seule classe.
Note - Méthodes méthode move () dans la classe Point et move() method in Location class ne remplacez pas les définitions de déplacement correspondantes car ce sont des définitions différentes (par exemple, la première prend deux arguments tandis que la seconde prend trois arguments).
Essayez l'exemple de programme suivant pour implémenter l'héritage.
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);
}
}Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.
Commander
\>scalac Demo.scala
\>scala DemoProduction
Point x location : 20
Point y location : 30
Point z location : 20Classes implicites
Les classes implicites permettent des conversations implicites avec le constructeur principal de la classe lorsque la classe est dans la portée. La classe implicite est une classe marquée par un mot clé «implicite». Cette fonctionnalité est introduite dans Scala 2.10.
Syntax- Voici la syntaxe des classes implicites. Ici, la classe implicite est toujours dans la portée de l'objet où toutes les définitions de méthode sont autorisées car la classe implicite ne peut pas être une classe de niveau supérieur.
Syntaxe
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}Exemple
Prenons un exemple d'une classe implicite nommée IntTimesavec la méthode times (). Cela signifie que times () contient une transaction en boucle qui exécutera l'instruction donnée le nombre de fois que nous donnons. Supposons que l'instruction donnée soit «4 fois println (« Hello »)» signifie que l'instruction println («» Hello ») s'exécutera 4 fois.
Voici le programme de l'exemple donné. Dans cet exemple, deux classes d'objets sont utilisées (Exécuter et Démo) afin que nous devions enregistrer ces deux classes dans des fichiers différents avec leurs noms respectifs comme suit.
Run.scala - Enregistrez le programme suivant dans 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 - Enregistrez le programme suivant dans Demo.scala.
import Run._
object Demo {
def main(args: Array[String]) {
4 times println("hello")
}
}Les commandes suivantes sont utilisées pour compiler et exécuter ces deux programmes.
Commander
\>scalac Run.scala
\>scalac Demo.scala
\>scala DemoProduction
Hello
Hello
Hello
HelloNote -
Les classes implicites doivent être définies dans une autre classe / objet / trait (pas au niveau supérieur).
Les classes implicites ne peuvent accepter qu'un seul argument non implicite dans leur constructeur.
Les classes implicites ne peuvent pas être une méthode, un membre ou un objet de la portée portant le même nom que la classe implicite.
Objets Singleton
Scala est plus orienté objet que Java car dans Scala, nous ne pouvons pas avoir de membres statiques. Au lieu de cela, Scala asingleton objects. Un singleton est une classe qui ne peut avoir qu'une seule instance, à savoir, Object. Vous créez un singleton à l'aide du mot-cléobjectau lieu du mot-clé de classe. Comme vous ne pouvez pas instancier un objet singleton, vous ne pouvez pas passer de paramètres au constructeur principal. Vous avez déjà vu tous les exemples utilisant des objets singleton où vous avez appelé la méthode principale de Scala.
Voici le même exemple de programme pour implémenter singleton.
Exemple
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);
}
}
}Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.
Commander
\>scalac Demo.scala
\>scala DemoProduction
Point x location : 10
Point y location : 20