Les fonctions récursives sont également gourmandes en mémoire, car elles peuvent entraîner un grand nombre de niveaux imbriqués.

appels de fonction. Cela doit être gardé à l'esprit lors de son utilisation pour résoudre de grands problèmes.

Objets et classes R : Introduction et types

R a 3 classes. Dans ceci, vous serez introduit à toutes les trois classes (S3, S4 et référence)
classe) en programmation R.

We can do object oriented programming in R. In fact, everything in R is an object.

Un objet est une structure de données ayant des attributs et des méthodes qui agissent sur celui-ci.
attributs.

La classe est un modèle pour l'objet. Nous pouvons penser à la classe comme à un croquis (prototype) d'un
maison. Elle contient tous les détails sur les étages, les portes, les fenêtres, etc. Basé sur
ces descriptions nous construisons la maison.

La maison est l'objet. Comme on peut créer plusieurs maisons à partir d'une description, nous pouvons
créer plusieurs objets à partir d'une classe. Un objet est également appelé une instance d'une classe et
le processus de création de cet objet s'appelle l'instanciation.

Alors que la plupart des langages de programmation ont un système de classes unique, R a trois classes.
systèmes. À savoir, S3, S4 et plus récemment les systèmes de classe de référence.

Ils ont leurs propres caractéristiques et particularités et choisir l'un plutôt que l'autre est un
question de préférence. Ci-dessous, nous donnons une brève introduction à ceux-ci.

Classe S3
La classe S3 est quelque peu primitive par nature. Elle manque d'une définition formelle et d'un objet.
Une classe peut être créée simplement en ajoutant un attribut de classe à celle-ci.

Cette simplicité explique le fait qu'il est largement utilisé dans la programmation R.
langue. En fait, la plupart des classes intégrées de R sont de ce type.

Exemple 1 : classe S3
> Créer une liste avec les composants requis
> s <- list(name ="John", age =21, GPA =3.5)

Nommez la classe de manière appropriée

>classe(s) <-"étudiant"

L'exemple ci-dessus crée une classe S3 avec la liste donnée.

Classe S4
La classe S4 est une amélioration par rapport à la classe S3. Elles ont une définition formelle.
une structure qui aide à rendre les objets de la même classe plus ou moins similaires.

Les composants de classe sont correctement définis en utilisant lesetClass()fonction et objets

sont créés en utilisant lenouveau()fonction.

Exemple 2 : classe S4
< setClass("étudiant", slots=list(nom="caractère", âge="numérique",
GPA="numeric"))

Classe de référence
La classe de référence a été introduite plus tard, par rapport aux deux autres. Elle est plus similaire
à la programmation orientée objet à laquelle nous sommes habitués à voir dans d'autres grands
langages de programmation.

Les classes de référence sont essentiellement des classes S4 avec un environnement ajouté.

Exemple 3 : Classe de référence

< setRefClass("étudiant")

Comparaison entre S3 et S4
Classe de référence

Classe S3 Classe S4 Classe de Référence

Classe définie Classe définie

Manque de définition formelle
en utilisantsetClass() using setRefClass()

Les objets sont créés par Les objets sont créés Les objets sont créés en utilisant
définir l'attribut de classe en utilisantnouveau() fonctions génératrices

Les attributs sont accédés Les attributs sont accessibles

Les attributs sont accessibles à l'aide de$
utilisant$ utiliser@

Les méthodes appartiennent au générique Methods belong to Les méthodes appartiennent à la classe
fonction fonction générique
Suit le principe de la copie sur modification Suit la copie lors de la modification Ne suit pas la copie sur modification
sémantique sémantique sémantique

Classe R S3
Dans cet article, vous apprendrez à travailler avec les classes S3 (l'une des trois classes
systèmes en R).

La classe S3 est la classe la plus populaire et répandue dans le langage de programmation R.

La plupart des classes qui viennent prédéfinies dans R sont de ce type. Le fait que ce soit
simple et facile à mettre en œuvre est la raison derrière cela.

Comment définir une classe S3 et créer un S3

objets ?
La classe S3 n'a pas de définition formelle et prédéfinie.

Fondamentalement, une liste avec son attribut de classe défini sur un nom de classe est un objet S3.
Les composants de la liste deviennent les variables membres de l'objet.

Voici un exemple simple de la façon dont un objet S3 de la classe étudiant peut être créé.

# créer une liste avec les composants requis

> s <- list(name ="John", age =21, GPA =3.5)

Nommer la classe de manière appropriée

>class(es) <-"étudiant"

C'est tout ! Nous avons maintenant un objet de la classe "étudiant".

s
$nom
John
$age
21

$GPA
3,5

attr(,"classe")
étudiant

Cela pourrait sembler gênant pour les programmeurs venant de C++, Python, etc. où
il existe des définitions de classe formelles et les objets ont des attributs correctement définis
méthodes.

Dans le système R S3, c'est assez ad hoc. Vous pouvez convertir la classe d'un objet selon
votre volonté avec des objets de la même classe ayant des apparences complètement différentes. Tout dépend de vous.

Comment utiliser des constructeurs pour créer

objets ?
Il est de bonne pratique d'utiliser une fonction avec le même nom que la classe (ce n'est pas une nécessité)
pour créer des objets.

Cela apportera une certaine uniformité dans la création d'objets et les rendra similaires.

Nous pouvons également ajouter un contrôle d'intégrité sur les attributs des membres. Voici un
exemple. Notez que dans cet exemple, nous utilisons leattr()fonction pour définir la classe
attribut de l'objet.

une fonction constructeur pour la classe "étudiant"

étudiant <-fonction(n,a,g) {
nous pouvons ajouter nos propres vérifications d'intégrité

si(g>4|| g<0) arrêter("La moyenne GPA doit être entre 0 et 4")

value <- list(name = n, age = a, GPA = g)

La classe peut être définie en utilisant la fonction class() ou attr()

attr(value,"class") <-"étudiant"
valeur
}

Voici un exemple d'exécution où nous créons des objets en utilisant ce constructeur.

> s <- student("Paul",26,3.7)

>s
$nom
Paul

$age
26

$GPA
3.7

attr(,"classe")
étudiant

classe(s)
étudiant

> s <- étudiant("Paul",26,5)

Errorinstudent("Paul",26,5) : GPA must be between0and4

> Ces vérifications d'intégrité ne fonctionnent que lors de la création de l'objet en utilisant

constructeur
s <- étudiant("Paul",26,2.5)

C'est à nous de le maintenir ou non.

> s$GPA <-5

Méthodes et Fonctions Génériques

Dans l'exemple ci-dessus, lorsque nous écrivons simplement le nom de l'objet, ses éléments internes obtiennent
imprimé.
En mode interactif, écrire le nom seul l'imprimera en utilisant leprint()fonction.

s
$name
Paul

$age
26

$GPA
3.7

attr(,"classe")
étudiant

De plus, nous pouvons utiliserimprimer()avec des vecteurs, des matrices, des cadres de données, des facteurs, etc. et
Ils sont imprimés différemment selon la classe à laquelle ils appartiennent.

Comment est-ce queprint()savoir comment imprimer cette variété d'objets aux apparences différentes ?

La réponse est,imprimer()est une fonction générique. En fait, elle a une collection d'un certain nombre
des méthodes. Vous pouvez vérifier toutes ces méthodes avecméthodes(imprimer).

> méthodes(print)
[1][Link]*
[2][Link]*
...
[181][Link]*
[182][Link]*

Les fonctions non visibles sont marquées par un astérisque

Nous pouvons voir des méthodes [Link]é[Link] la liste ci-dessus.

Quand nous appelonsprint()sur un cadre de données, il est dispatché à[Link]().

Si nous avions fait la même chose avec un facteur, l'appel serait envoyé à[Link]().
Ici, nous pouvons observer que les noms des méthodes sont dans le
formegeneric_name.class_name()C'est ainsi que R est capable de déterminer quelle méthode utiliser.
appel en fonction de la classe.

Impression de notre objet de classe "étudiantcherche une méthode de la formeimprimer.étudiant(),

mais il n'y a pas de méthode de cette forme.
Alors, quelle méthode notre objet de la classe étudiantappel?

Il s'[Link](). C'est la méthode de secours qui est appelée si aucune autre

Un match est trouvé. Les fonctions génériques ont une méthode par défaut.

Il existe de nombreuses fonctions génériques commeimprimer()Vous pouvez tous les lister

avecméthodes(classe="par défaut").

> méthodes(classe="par défaut")

[1] [Link]* agré[Link] défaut*

[3] [Link] défaut* tous.é[Link] défaut
...

Comment écrire votre propre méthode ?

Maintenant, mettons en œuvre une méthodeimprimer.étudiant()nous-mêmes.

print.étudiant <-fonction(obj) {
cat(obj$name, "\n")
chat(obj$âge,"ans ")
cat("Moyenne pondérée cumulative:", obj$GPA,"\n")
}

Maintenant, cette méthode sera appelée chaque fois que nousimprimer()un objet de la classe "étudiant".

Dans le système S3, les méthodes n'appartiennent ni à un objet ni à une classe, elles appartiennent à un générique.
Les fonctions. Cela fonctionnera tant que la classe de l'objet est définie.

Notre méthode mise en œuvre ci-dessus est appelée

>s
Paul
26 ans
GPA:3.7

En supprimant l'attribut de classe, il sera rétabli comme précédemment

déclassement
$name
Paul
$age
[1]26

$GPA
3.7

Écrire votre propre fonction générique

Il est possible de créer notre propre fonction générique commeimprimer()outracer(). Regardons d'abord
sur la façon dont ces fonctions sont mises en œuvre.

>impression

fonction(x, ...)
UseMethod("imprimer")
<bytecode:0x0674e230>
<environnement:nom_de_espace:base>

> tracer
fonction(x, y, ...)
Utiliser la méthode "plot"
<bytecode:0x04fe6574>
<environnement:nom_de_système:graphismes>

Nous pouvons voir qu'ils ont un seul appel àUtiliserMéthode()with the name of the generic
fonction passée à cela. C'est la fonction de répartition qui gérera tout le
Détails de contexte. Il est aussi simple que cela de mettre en œuvre une fonction générique.

À titre d'exemple, nous créons une nouvelle fonction générique appeléenote.

grade <-fonction(obj) {
UtiliserMéthode("grade")
}

Une fonction générique est inutile sans méthode. Mettons en œuvre le défaut.
méthode.

[Link]<-function(obj) {
cat("C'est une fonction générique\n")
}
Maintenant, créons une méthode pour notre classe "étudiant".

[Link] <-fonction(obj) {
cat("Votre note est", obj$GPA, "\n")
}

Un exemple d'exécution.

note(s)
Votre note est de 3,7

De cette manière, nous avons implémenté une fonction générique appeléenoteet plus tard une méthode pour
notre classe.

Classe R S4
Dans ce cours, vous apprendrez tout sur les classes S4 en R ; comment les définir,
créez-les, accédez à leurs emplacements et utilisez-les efficacement dans votre programme.

Contrairement aux classes et objets S3 qui manquent de définition formelle, nous regardons la classe S4.
qui est plus stricte dans le sens où elle a une définition formelle et une manière uniforme de
créer des objets.

Cela ajoute de la sécurité à notre code et nous empêche de faire des erreurs naïves par accident.
erreurs.

Comment définir une classe S4 ?

La classe S4 est définie à l'aide de lasetClass()fonction.

Dans la terminologie R, les variables membres sont appelées emplacements. Lors de la définition d'une classe, nous avons besoin
pour définir le nom et les emplacements (ainsi que la classe de l'emplacement) qu'il aura.
Exemple 1 : Définition de la classe S4
setClass("étudiant", slots=list(nom="caractère", âge="numérique",
GPA="numeric"))

Dans l'exemple ci-dessus, nous avons défini une nouvelle classe appeléestudentavec trois emplacements
ça va avoirnom, âgeetMoyenne Générale.

Il existe d'autres arguments optionnels desetClass()que vous pouvez explorer dans l'aide
section avec?setClass.

Comment créer des objets S4 ?

Les objets S4 sont créés à l'aide denouveau()fonction.

Exemple 2 : Création d'un objet S4

Créer un objet en utilisant new()
Fournir le nom de la classe et la valeur pour les emplacements

> s <-new("étudiant", nom="John", âge=21, GPA=3.5)

>s
Un objet de la classe "étudiant"
Slot"name":
Jean

Slot"age":
21

Slot"GPA":
3.5

Nous pouvons vérifier si un objet est un objet S4 à l'aide de la fonctionisS4().

isS4(s)
VRAI

La fonctionsetClass()renvoie une fonction génératrice.

Cette fonction génératrice (ayant généralement le même nom que la classe) peut être utilisée pour
créer de nouveaux objets. Cela agit comme un constructeur.
> student <- setClass("student", slots=list(name="character",
age="numeric", GPA="numeric"))

étudiant
fonction de génération de classe pour la classe ‚étudiant‘ du paquet
.GlobalEnv
fonction(...)
nouveau("étudiant", ...)

Now we can use this constructor function to create new objects.

Note above that our constructor in turn uses the nouveau()fonction pour créer des objets. C'est
juste un enveloppement.

Exemple 3 : Création d'objets S4 à l'aide d'un générateur

fonction
> student(name="John", age=21, GPA=3.5)
Un objet de la classe "étudiant"
Slot"name":
John

Slot"age":
21

Slot"GPA":
3.5

Comment accéder et modifier un slot ?

Tout comme les composants d'une alistare accessibles en utilisant$les emplacements d'un objet sont accessibles
utiliser@.

Accéder au créneau
> s@name
John

> s@GPA
3.5
> âge
21

Modification du créneau directement

Un emplacement peut être modifié par réaffectation.

Modifier la moyenne générale

> s@GPA <-3.7

>s
Un objet de la classe "étudiant"
Slot"name":
"Jean"

Slot"age":
21

Slot"GPA":
3.7

Modification des emplacements à l'aide de la fonction slot()

De même, les emplacements peuvent être accessibles ou modifiés à l'aide deslot()function.

> emplacement(s,"nom")

[1]"John"

> slot(s,"name") <-"Paul"

>s
Un objet de la classe "étudiant"
Slot"name":
Paul

Slot"age":
21
Slot"GPA":
3.7

Methods and Generic Functions

Comme dans le cas de la classe S3, les méthodes pour la classe S4 appartiennent également à des fonctions génériques.
plutôt que la classe elle-même. Travailler avec les génériques S4 est assez similaire à S3
génériques.

Vous pouvez lister toutes les fonctions et méthodes génériques S4 disponibles, en utilisant le
fonctionshowMethods().

Exemple 4 : Lister toutes les fonctions génériques

montrerMéthodes()
Fonction : - (paquet de base)

Fonction : != (paquet de base)

...
Fonction : trigamma (paquet de base)

Fonction : trunc (paquet de base)

Écrire le nom de l'objet en mode interactif l'imprime. Cela se fait en utilisant le S4

fonction génériquemontrer().

Vous pouvez voir cette fonction dans la liste ci-dessus. Cette fonction est l'analogie S4 de la
S3imprimer()fonction.

Exemple 5 : Vérifiez si une fonction est une fonction générique

> estS4(print)
FAUX

> estS4(montrer)

VRAI

Nous pouvons lister toutes les méthodes de la fonction générique show en utilisantmontrerMéthodes(montre).

Exemple 6 : Lister toutes les méthodes d'une fonction générique

> showMethods(show)
Function: show (packagemethods)
object="ANY"
object="classGeneratorFunction"
...
object="standardGeneric"
(inheritedfrom:object="genericFunction")
object="traceable"

Comment écrire votre propre méthode ?

Nous pouvons écrire notre propre méthode en utilisantsetMethod()fonction d'aide.

Par exemple, nous pouvons mettre en œuvre notre méthode de classe pour lemontrer()générique comme suit.

setMethod("show",
étudiant
fonction(objet) {
chat(object@name," ")
chat(object@age,"ans ")
cat("Moyenne Générale :", object@GPA, "\n")
}
)

Maintenant, si nous écrivons le nom de l'objet en mode interactif comme auparavant, le ci-dessus
le code est exécuté.

> s <-new("student",name="John", age=21, GPA=3.5)

> s c'est la même chose que show(s)

Jean
21 ans
GPA:3.5

De cette manière, nous pouvons écrire nos propres méthodes de classe S4 pour les fonctions génériques.

Classe Référence R
Dans cela, vous apprendrez à travailler avec la classe de référence qui est l'une des trois
systèmes de classe (les deux autres sont S3 et S4).
La classe de référence en programmation R est similaire à la programmation orientée objet.
sont utilisés pour voir dans des langages courants comme C++, Java, Python, etc.

Contrairement aux classes S3 et S4, les méthodes appartiennent à la classe plutôt qu'aux fonctions génériques.
Les classes de référence sont implémentées en interne comme des classes S4 avec un environnement.
ajouté à cela.

Comment définir une classe référence ?

Définir une classe de référence est similaire à définir une classe S4. Au lieu desetClass()nous
utiliser lesetRefClass()fonction.

> setRefClass("étudiant")

Les variables membres d'une classe, si elles sont définies, doivent être incluses dans la définition de la classe.
Les variables membres de la classe de référence sont appelées champs (analogues aux emplacements dans S4)
classes).

Voici un exemple pour définir une classe appeléeétudiantavec 3

champsnom, âgeetMoyenne Générale.

setRefClass("student", fields = list(name = "caractère", age =

"numérique", GPA ="numérique"

Comment créer des objets de référence ?

La fonctionsetRefClass()renvoie une fonction génératrice qui est utilisée pour créer
objets de cette classe.

> étudiant <- setRefClass("étudiant",

fields = list(name ="character", age ="numeric", GPA =
"numérique"))
> maintenant student() est notre fonction génératrice qui peut être utilisée pour
créer de nouveaux objets

> s <- student(name ="John", age =21, GPA =3.5)

>s
Objet de classe "étudiant" de la classe Referenceclass

Field"name":
Jean
Field"age":
21
Field"GPA":
3.5

Comment accéder et modifier les champs ?

Les champs de l'objet peuvent être accédés en utilisant le$ opérateur.

> s$name
[1]"John"

> s$age
21

> s$GPA
3.5

De même, il est modifié par réaffectation.

> s$name <-"Paul"

>s
Objet de la classe de référence "étudiant"
Field"name":
Paul
Field"age":
21
Field"GPA":
3.5

Note d'avertissement :

Dans le langage R, les objets sont copiés lorsqu'ils sont assignés à une nouvelle variable ou passés à un
fonction (passage par valeur). Par exemple.

# créer une liste a et l'assigner à b

> a <- list("x"=1,"y"=2)

> b <- a

# modifier b
> b$y =3

a reste inchangé
a
$x
[1]1

$y
[1]2

> seulement b est modifié

b
$x
1

$y
[1]3

Mais ce n'est pas le cas avec les objets de référence. Il n'existe qu'une seule copie et tout
les variables font référence à la même copie. D'où le nom, référence.

># créer un objet de référence a et l'assigner à b

a <- étudiant(nom ="John", âge =21, moyenne =3.5)

> b <- a
># modifier b
> b$name <-"Paul"

# a et b sont tous deux modifiés

à
Objet de classe de référence "étudiant"
Field"name":
Paul
Field"age":
21
Field"GPA":
3.5

b
Objet de classe "étudiant" de la classe Referenceclass

Field"name":
Paul
Field"age":
21
Field"GPA":
3.5

Cela peut provoquer des modifications indésirables des valeurs et être la source de bugs étranges.
Nous devons garder cela à l'esprit en travaillant avec des objets de référence. Pour faire une copie,
nous pouvons utiliser lecopier()méthode mise à notre disposition.

># créez un objet de référence a et assignez la copie de a à b

a <- étudiant(nom ="John", âge =21, GPA =3.5)

b <- a$copie()

> modifier b
> b$name <-"Paul"

a reste inchangé
a
Référence de l'objet de la classe "étudiant"

Field"name":
Jean
Field"age":
21
Field"GPA":
3.5

> seulement b est modifié

>b
Objet de classe référence "étudiant"
Field"name":
Paul
Field"age":
21
Field"GPA":
3.5

Méthodes de référence
Les méthodes sont définies pour une classe de référence et n'appartiennent pas aux fonctions génériques comme
dans les classes S3 et S4.

Toutes les classes de référence ont des méthodes prédéfinies car elles sont toutes héritées.
de la superclasseenvRefClass.

étudiant
Generatorfor class"student":

Classfields:

Name: nom âge GPA

Classe : personnage numérique numérique

Class Methods:
"callSuper","copy","export","field","getClass",
"getRefClass",
"import","initFields","show","trace","untrace","usingMethods"
 Superclasses de référence :

envRefClass

Nous pouvons voir des méthodes de classe commecopier(), champ()etshow()dans la liste ci-dessus. Nous pouvons
create our own methods for the class.

Cela peut être fait lors de la définition de la classe en passant une liste de définitions de fonctions.
àméthodesargument desetRefClass().

étudiant <- setRefClass("étudiant",

fields = list(name ="character", age ="numeric", GPA =
numérique
methods = list(
inc_age =function(x) {
âge <<- âge + x
},
dec_age =function(x) {
âge <<- âge - x
}
)
)

Dans la section ci-dessus de notre code, nous avons défini deux méthodes.
appeléinc_age()etdec_age()Ces deux méthodes modifient le champâge.

Notez que nous devons utiliser l'opérateur d'affectation non local.<<-puisque l'âge n'est pas dans le
l'environnement local de la méthode. C'est important.

Utiliser l'opérateur d'affectation simple<-aurait créé une variable locale

appeléâge, ce qui n'est pas ce que nous voulons. R émettra un avertissement dans ce cas.

Voici un exemple d'exécution où nous utilisons les méthodes définies ci-dessus.

> s <- student(name ="John", age =21, GPA =3.5)

> s$inc_age(5)
s$âge
[1]26

s$dec_age(10)
> s$age
16

Héritage R
Dans ce cours, vous apprendrez tout sur l'héritage en R. Plus précisément, comment
créer l'héritage dans les classes S3, S4 et Reference, et les utiliser efficacement dans
votre programme.

Une des fonctionnalités les plus utiles d'un langage de programmation orienté objet est
héritage.

Defining newclassesout of existing ones. This is to say, we can derive new classes
à partir des classes de base existantes et en ajoutant de nouvelles fonctionnalités. Nous n'avons pas besoin d'écrire à partir de
Par conséquent, l'héritage offre une réutilisabilité du code.

L'héritage forme une hiérarchie de classes tout comme un arbre généalogique. Il est important de noter que
que les attributs définis pour une classe de base seront automatiquement présents dans la classe dérivée
classe.

De plus, les méthodes de la classe de base fonctionneront pour la dérivée.

Ci-dessous, nous discutons de la manière dont l'héritage est effectué pour les trois différents systèmes de classes.
dans le langage de programmation R.

Héritage dans la classe S3

Les classes S3 n'ont pas de définition fixe. Par conséquent, les attributs des objets S3 peuvent être
arbitraire.

Cependant, la classe dérivée hérite des méthodes définies pour la classe de base. Supposons que
nous avons une fonction qui crée de nouveaux objets de la classeétudiantcomme suit.

étudiant <-fonction(n,a,g) {
value <- list(name=n, age=a, GPA=g)
attr(value, "class") <- "étudiant"
valeur
}

De plus, nous avons une méthode définie pour la fonction génériqueimprimer()comme suit.

[Link] <-fonction(obj) {
chat(obj$name," ")
chat(obj$age, "ans ")
cat("Moyenne Pondérée:", obj$GPA,"\n")
}

Maintenant, nous voulons créer un objet de la classeÉtudiantinternationalqui hérite

deétudiant.

Cela se fait en assignant un vecteur de caractères de noms de classe commeclass(obj) <-

c(enfant, parent).

># créer une liste

> s <- list(name="John", age=21, GPA=3.5, country="France")

># faites-en de la classe InternationalStudent qui est dérivée de

l'élève de la classe
>classe(s) <- c("ÉtudiantInternational", "étudiant")

Imprimez-le
>s
Jean
21 ans
GPA:3.5

Nous pouvons voir ci-dessus que, puisque nous n'avons défini aucune méthode de la
[Link](), la méthodeimprimer étudiant()a été appelé. Cela
méthode de classeétudianta été hérité.
Définissons [Link]().

[Link]<-function(obj) {
cat(obj$name, "est de", obj$country, "\n")
}

Cela écrasera la méthode définie pour la classeétudiantcomme indiqué ci-dessous.

>s
John vient de France

Nous pouvons vérifier l'héritage avec des fonctions commehérite()ouest().

> hérite(s, "étudiant")

VRAI

est(s,"étudiant")
VRAI

Héritage dans la classe S4

Étant donné que les classes S4 ont une définition appropriée, les classes dérivées hériteront des deux attributs.
et méthodes de la classe parente.

Définissons une classeétudiantavec une méthode pour la fonction génériquemontre().

# définir une classe appelée étudiant

setClass("étudiant",
slots=list(name="character", age="numeric", GPA="numeric")
)

# définir la méthode de classe pour la fonction générique show()

setMethod("show",
étudiant
function(objets) {
cat(object@name, "\n")
chat(object@age,"ans ")
chat("GPA:", objet@GPA, "\n")
 }
)

L'héritage se fait lors de la définition de la classe dérivée avec l'[Link]

montré ci-dessous.

hériter de l'étudiant
setClass("ÉtudiantInternational",
slots=list(country="character"),
contains="student"
)

Ici, nous avons ajouté un attributpays, le reste sera hérité du parent.

s <-new("ÉtudiantInternational", nom="John", âge=21, GPA=3.5,

country="France")

spectacles
Jean
21 ans
GPA:3.5

Nous voyons que la méthode est définie pour la classeétudianta été appelé quand nous l'avons faitmontre(s).

Nous pouvons définir des méthodes pour la classe dérivée qui remplaceront les méthodes de la
classe de base, comme dans le cas des systèmes S3.

Hérédité dans la classe de référence

L'héritage dans la classe de référence est très similaire à celui de la classe S4. Nous définissons
dans lecontientargument, de quelle classe de base dériver.

Voici un exemple deétudiantclasse de référence avec deux

méthodesinc_age()etdec_age().

étudiant <- setRefClass("étudiant",

fields=list(name="character", age="numeric", GPA="numeric"),
methods=list(
inc_age =fonction(x) {
âge <<- âge + x
 },
dec_age =function(x) {
âge <<- âge - x
}
)
)

Nous allons maintenant hériter de cette classe. Nous réécrivons égalementdec_age()méthode pour ajouter un
vérification d'intégrité pour s'assurerâgeis never negative.

InternationalStudent<- setRefClass("InternationalStudent",
fields=list(country="character"),
contains="student",
methods=list(
dec_age = fonction(x) {
si((âge - x)<0) arrêter("L'âge ne peut pas être négatif")
âge <<- âge - x
}
)
)

Let us put it to test.

> s <-InternationalStudent(name="John", age=21, GPA=3.5,

country="France")

> s$dec_age(5)
s$âge
16

> s$dec_age(20)
Erreur dans $dec_age(20) : L'âge ne peut pas être négatif

> s$age
16

De cette manière, nous sommes en mesure d'hériter de la classe parente.