Les Classes R6 (POO Classique)

1 Introduction à R6 et installation du package

R6 est un système de classes plus récent en R qui suit un modèle de programmation orientée objet (POO) plus traditionnel, similaire à ceux que l’on trouve dans des langages comme Python ou Java. Pour utiliser R6, vous devez d’abord installer et charger le package R6.

# Installation du package R6 (si nécessaire)
# install.packages("R6")

# Chargement du package R6
library(R6)

2 Définition de classes R6 avec R6Class()

Les classes R6 sont définies à l’aide de la fonction R6Class(). Cette fonction permet de spécifier les champs (attributs) et les méthodes (fonctions) de la classe.

Example 1  

# Définition de la classe "personne"
Personne <- R6Class(
1  "Personne",
  public = list(
    nom = NULL,
    age = NULL,
    initialize = function(nom, age) {
      self$nom <- nom
      self$age <- age
2    },
    print = function() {
      cat("Personne :", self$nom, "\n")
      cat("Âge :", self$age, "ans\n")
    }
3  )
)

1

Nom de la classe

2

Le constructeur qu’on appelle avec ‘Personne$new’

3

Les attributs et méthodes publiques

p = Personne$new("Jean", 25) # Appelle la méthode 'initialize'
p

Personne : Jean 
Âge : 25 ans

3 Champs et méthodes R6

• Champs : Les champs ou attributs sont des variables qui stockent les attributs de l’objet. Ils sont définis dans la liste public ou private.
• Méthodes : Les méthodes sont des fonctions qui définissent le comportement de l’objet. Elles sont également définies dans la liste public ou private.
• self : Dans les méthodes R6, self fait référence à l’objet courant.

3.1 Encapsulation et méthodes publiques/privées

R6 permet de définir des méthodes et des champs publics (accessibles depuis l’extérieur de l’objet) et privés (accessibles uniquement depuis l’intérieur de l’objet).

Example 2  

library(R6)

Personne <- R6Class(
1  "Personne",
  private = list(
    neLe = NULL
2  ),
  public = list(
3    nom = NULL,
    initialize = function(nom, neLe) {
      stopifnot(
        exprs = {
          is.character(nom)
          inherits(neLe, "Date")
        }
      )
      self$nom <- nom
      private$neLe <- neLe
4    },
    age = function() {
      annee_naissance <- as.numeric(format(private$neLe, "%Y"))
      annee_courante <- as.numeric(format(Sys.Date(), "%Y"))
      return(annee_courante - annee_naissance)
5    },
    setNeLe = function(nouvelle_date) {
      if (!inherits(nouvelle_date, "Date")) {
        stop("La date de naissance doit être de type Date.")
      }
      private$neLe <- nouvelle_date
6    },
    getNeLe = function(){
      private$neLe
7    },
    print = function() {
      cat("Personne :", self$nom, "\n")
      cat("Âge :", self$age(), "ans\n")
      cat("Date de naissance :", private$neLe, "\n")
8    }
  )
)

# Création d'un objet Personne
9john <- Personne$new("John Doe", as.Date("1993-05-15"))

# Utilisation de la méthode age()
john$age()

# Utilisation de la méthode print()
john$print()

# Utilisation du mutateur set_date_naissance()
john$setNeLe(as.Date("1992-07-20"))

# Vérification de la mise à jour
john$print()

# Tentative de modification directe (provoque une erreur)
#john$neLe <- as.Date("1990-01-01")

1

Nom de la classe R6

2

Liste des attributs et méthodes privés

3

Un attribut public

4

Constructeur

5

Méthode public qui calcule l’âge

6

Mutateur de la date de naissance

7

Accesseur de la date de naissance

8

Surcharge de la méthode print

9

Une instanciation

[1] 32
Personne : John Doe 
Âge : 32 ans
Date de naissance : 8535 
Personne : John Doe 
Âge : 33 ans
Date de naissance : 8236 

4 Héritage en R6

R6 permet de créer des classes qui héritent des champs et des méthodes d’autres classes.

Example 3  

Etudiant <- R6Class(
  "Etudiant",
1  inherit = Personne,
  public = list(
    matricule = NULL,
    initialize = function(nom, neLe, matricule) {
2      super$initialize(nom, neLe)
      self$matricule <- matricule 
    },
    print = function() {
3      super$print()
      cat("Matricule :", self$matricule, "\n")
    }
  )
)

alice <- Etudiant$new("Alice Smith", as.Date("1992-07-20"), "12345")
alice$print()

1

Hérite de Personne

2

Appelle du constructeur de la classe mère

3

Appelle print de la classe mère

Personne : Alice Smith 
Âge : 33 ans
Date de naissance : 8236 
Matricule : 12345 

5 Exemples et cas d’utilisation (simulations, interfaces graphiques)

R6 est souvent utilisé pour :

• Les simulations complexes.
• Les interfaces graphiques interactives.
• Les applications nécessitant une POO classique.

6 Avantages et limites de R6

6.1 Avantages

• Plus simple et plus intuitif que S4.
• Plus facile à apprendre et à utiliser pour les personnes familières avec la POO classique.
• Syntaxe concise pour la définition des classes et des méthodes.

6.2 Limites

• Moins de vérification des types et moins de robustesse que S4.
• Peut être moins adapté aux projets complexes nécessitant une grande fiabilité.

Dans la section suivante, nous comparerons en détail les systèmes de classes S3, S4 et R6.