4 - Cedric

Les objets, les classes et les méthodes
• Un objet possède une identité propre
(penser aux objets du monde réel : chaise, table ...)
• Ils sont regroupés en classes (distinguer la notion de “chaise” d’une chaise particulière)
• Les classes décrivent les attributs et les méthodes applicables (comment décrire une chaise ? que
peut-on faire avec ?)
Exemple de classe Scala
class Point(var x: Int, var y: Int) {
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}
override def toString(): String = "(" + x + ", " + y + ")";
}
object Test {
def main(args: Array[String]) {
val pt = new Point(1, 2)
println(pt); pt.move(10, 10); println(pt)
}
}
Second constructeur
class Point(var x: Int, var y: Int) {
def this(z: Int) {
this(z,z)
}
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}
override def toString(): String = "(" + x + ", " + y + ")";
}
object Test {
def main(args: Array[String]) {
val pt = new Point(1, 2)
println(pt); pt.move(10, 10); println(pt)
}
}
Méthodes
• En Scala, les paramètres du constructeur sont donnés avec la déclaration de la classe.
• Comme en Java, dans une classe C, toute méthode possède un paramètre supplémentaire implicite,
appelé this, de type C.
• Comme en Java, un appel à f, se note par exemple : o.f(arg)
Si f était une fonction C, on écrirait f(o, arg)
Un appel de la forme f(arg) correspond en fait à this.f(arg)
• Il n’y a pas de méthode statique en Scala, elles doivent être regroupées dans une “classe singleton”
qui est déclarée par le mot-clé object.
La même classe en Java
class Point {
Integer x; Integer y;
Point(Integer x, Integer y) {
this.x = x; this.y = y;
}
public void move(dx: Int, dy: Int) {
x = x + dx; y = y + dy;
}
@override
public String toString() {
return "(" + x + ", " + y + ")";
}
public void main(String[] args) {
Point pt = new Point(1, 2);
println(pt); pt.move(10, 10); println(pt);
}
}
Généralisation/spécialisation et héritage
• Une classe Scala peut spécialiser une autre classe
• Elle hérite alors des attributs et des méthodes de sa super-classe.
On parle donc d’héritage dans les langages objet.
• La conversion de type entre une classe et sa super-classe est implicite.
• Les méthodes et attributs visibles sont donnés par les types des variables ou des expressions.
• Les méthodes peuvent être redéfinies (mot-clé override).
• La methode executée et celle de la classe de l’objet (celle a été utilisée au moment de la création
avec New).
Exemple
Classes Person et Employee en Scala
class Person {
var firstName : String = ""
var lastName : String = ""
}
class Employee extends Person {
var job : String = ""
}
object Test {
val p : Person = new Employee
}
... avec les constructeurs
class Person(var firstName: String, var lastName: String) {}
class Employee(firstName: String, lastName: String, var job :
String) extends Person(firstName, lastName) {}
object Test {
val p : Person = new Employee
}
Exemple : figures géométriques
Hiérarchie de classes
(diagramme extrait de la documentation)