Objekte und Klassen in R

Lerne OOP in R kennen: R-Objekte, die Klassen S3 und S4, ihre Konstruktion sowie eigene Generics — mit praxisnahen Beispielen und mehr.

Aktualisiert 18. Sept. 2026 · 9 Min. lesen

Mit KI erkunden

ChatGPT Claude Perplexity

Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, bei dem Software rund um Daten bzw. Objekte statt um Funktionen herum entworfen wird. Eine Methode ist dabei schlicht eine Funktion im OOP-Kontext. Sie ist objektorientiert, weil sich die gesamte Verarbeitung um Objekte und deren Felder dreht. Jedes Objekt hat eigene Attribute und ein spezifisches Verhalten.

In der objektorientierten Programmierung lässt sich ein Programm in Klassen gliedern, was das Verständnis der Programmausführung erleichtert. R ist primär eine funktionale Sprache, und OOP hilft dabei, große Systemprobleme zu strukturieren. OOP wird häufig für GUI-Anwendungen eingesetzt, insbesondere Webanwendungen. Für das Bauen von Tools zur Datenanalyse ist OOP gut geeignet — für die eigentliche Analyse hingegen weniger.

OOP-Systeme

Es gibt im Wesentlichen zwei große OOP-Systeme, die unten beschrieben sind:

S3-Klassen: Erlauben das Überladen von Funktionen.
S4-Klassen: Geben der Datenstruktur striktere Grenzen, was das Debuggen erleichtert.

Hinweis: Diese Klassen werden im weiteren Verlauf ausführlich besprochen.

Objekte in R

Objekte sind Instanzen von Klassen. In R ist im Grunde alles ein Objekt. Mehr dazu findest du hier: Datentypen in R. Objekte besitzen zudem Attribute wie class, attributes, dimnames, names usw.

Werte werden Objekten in R z. B. mit <-, zugewiesen. Im folgenden Beispiel erhalten die Variablen „a1“ und „a2“ numerische Werte:

a1 <- 10
a2 <- 20

Ein Objekt kann auch einen ganzen Zahlenvektor aufnehmen. Hier enthält „a3“ einen Vektor mit mehreren Zahlen:

a3 <- c(10,20,30)

Die Funktion c packt hier die Zahlen 10, 20, 30 in einen Vektor.

Nehmen wir ein Beispiel aus dem Alltag: Ein Schüler hat Attribute wie Name, Alter, Klasse und Geschlecht; eine Lehrkraft hat Name, Alter und Geschlecht.

st_name <- "andrew"
st_age <- 16
st_class <- 10
st_gender <- "male"

t_name <- "angelina"
t_age <- 26
t_gender <- "female"

student <- c(st_name, st_age, st_class, st_gender)
teacher <- c(t_name, t_age, t_gender)


print(student)
print(teacher)

[1] "andrew" "16"     "10"     "male"  
[1] "angelina" "26"       "female"

Der obige Code führt zur folgenden Ausgabe:

"andrew" "16" "10" "male"  
"angelina" "26"  "female"

Im Beispiel siehst du unterschiedliche Objekttypen. Die Objekte bzw. Variablen „student“ und „teacher“ enthalten Zeichenketten („character“) und Gleitkommazahlen („double“).

Meistere deine Datenkenntnisse mit DataCamp

Mehr als 10 Millionen Menschen lernen Python, R, SQL und andere technische Fertigkeiten in unseren praxisorientierten Kursen, die von Branchenexperten entwickelt wurden.

Lernen Beginnen

Klassen in R

Eine Klasse ist der Bauplan für Objekte. Sie definiert Member-Variablen sowie Attribute.

Wie zuvor erwähnt, gibt es in R zwei Klassenmodelle: S3 und S4.

S3-Klasse

S3 unterstützt das Überladen von Funktionen, indem es zwischen Generics und Methoden unterscheidet.

Funktionen = Generic + Methoden

S3 unterscheidet sich stark von Sprachen wie C# oder Java. Die Implementierung ist sehr unkompliziert und nutzt lediglich das erste Argument für das Dispatching. Daher braucht es vergleichsweise wenig Vorwissen aus Programmiererperspektive.

S3 basiert auf einer strikten Namenskonvention der Form generic.klasse.

                             generic.class

Die Argumente einer Methode sollten die Argumente des Generics enthalten; außerdem sollte die Methode ein ...arg aufnehmen.

S3-Klasse konstruieren – mit Beispiel

Im folgenden Beispiel erstellst du eine S3-Klasse. Wir erzeugen eine Liste, übergeben die Komponenten, vergeben eine Klassenbezeichnung und geben anschließend das Ergebnis aus.

Das Beispiel zeigt „studentBio“ als Liste mit den Komponenten „student_name“, „student_age“ und „student_contact“. Die Klasse heißt „StudentInfo“. „studentBio“ ist die neu erzeugte Instanz, deren Werte unten angezeigt werden.

studentBio <- list(studentName = "Harry Potter", studentAge = 19, studentContact="London")
class(studentBio) <- "StudentInfo"
studentBio

$studentName
[1] "Harry Potter"

$studentAge
[1] 19

$studentContact
[1] "London"

attr(,"class")
[1] "StudentInfo"

Der Code erzeugt folgende Ausgabe:

$studentName
 "Harry Potter"

$studentAge
19

$studentContact
"London"

attr(,"class")
"StudentInfo"

Wenn dir das Schreiben von Funktionen in R noch nicht vertraut ist, lies diesen Leitfaden: A Tutorial on Using Functions in R!

Eigenes Generic in S3 erstellen

Als Nächstes implementierst du ein eigenes Generic mithilfe des folgenden Codes.

Das Generic heißt „contact“. Mit „UseMethod“ wird das entsprechende Methoden-Dispatching für „contact“ ausgelöst — also der Prozess, bei dem das Ergebnis abhängig von den übergebenen Argumenten variiert.

contact <- function(object) {
UseMethod("contact")
}

Nun definieren wir eine Methode für die zuvor erstellte Klasse „StudentInfo“. Die Methode „contact“ wird per Punktnotation und Klassenname gebunden. Im Funktionskörper greifen wir über „$“ auf das Attribut „studentContact“ zu.

contact.StudentInfo <- function(object) {
cat("Your contact is", object$studentContact, "\n")
}
contact(studentBio)

Your contact is London

Die Methode nutzt object$studentContact, um per „$“ auf das Attribut zuzugreifen. Das Ergebnis lautet wie folgt:

Your contact is London

S4-Klasse

S4 ist strikter, konventioneller und näher an klassischen OOP-Konzepten. S4-Klassen werden durch formale Klassendefinitionen beschrieben. Insbesondere bietet S4 Setter- und Getter-Funktionen für Methoden und Generics. Im Vergleich zu S3 unterstützt S4 Mehrfach-Dispatch (multiple dispatch).

Schauen wir uns S4 anhand eines Beispiels an.

Eine S4-Klasse wird mit der Funktion setClass definiert.

 setClass()

S4-Klasse konstruieren – mit Beispiel

Wie erwähnt, definierst du eine S4-Klasse mit setClass(). Wir verwenden setClass(), um die Klasse zu erstellen und zu definieren. Zudem kann eine Routine zur Validierung eingesetzt und Standardwerte (Prototyp) gesetzt werden.

So definierst du die Klasse und ihre Slots:

Im folgenden Beispiel wird eine Klasse (Prototyp) definiert. Die Slots legen fest: Klassenname „employee“, name als character, id als numeric und contact als character.

setClass("employee", slots=list(name="character", id="numeric", contact="character"))

Mit folgendem Code erzeugst du konkrete Instanzen (Objekte) der S4-Klasse.

Wir erstellen ein Objekt mit „new“ der Klasse „employee“ und belegen die Slots name, id und contact mit Werten.

obj <- new("employee",name="Steven", id=1002, contact="West Avenue")
obj

An object of class "employee"
Slot "name":
[1] "Steven"

Slot "id":
[1] 1002

Slot "contact":
[1] "West Avenue"

An object of class "employee"
Slot "name":
"Steven"

Slot "id":
1002

Slot "contact":
"West Avenue"

Die Ausgabe zeigt: Das Objekt ist von Klasse „employee“. Der Slot „name“ enthält „Steven“, der Slot „id“ den Wert 1002 und der Slot „contact“ „West Avenue“.

Funktionen und Befehle

Um zu prüfen, ob ein Objekt ein S4-Objekt ist, kannst du folgende Befehle nutzen:

Mit „is.object(obj)“ prüfst du, ob eine Variable bzw. Instanz auf ein Objekt verweist.

is.object(obj)

TRUE

Die Ausgabe lautet:

TRUE

Mit „isS4(obj)“ prüfst du, ob es sich um ein S4-Objekt handelt.

isS4(obj)

TRUE

Die Ausgabe lautet:

TRUE

Slots auslesen und ändern

Slot auslesen

Auf Slots greifst du mit „@“ zu — nicht mit „$“.

„obj@name“ liest den Namen „Steven“ aus; analog „obj@id“.

obj@name
obj@id

'Steven'

1002

Die Ausgabe lautet:

'Steven'
1002

Slot ändern

Du kannst einen Slotwert mit dem Zuweisungsoperator („<-") ändern. Hier erhält „obj@contact“ den neuen Wert „North Avenue“.

obj@contact <- "North Avenue"
obj

An object of class "employee"
Slot "name":
[1] "Steven"

Slot "id":
[1] 1002

Slot "contact":
[1] "North Avenue"

Die Ausgabe lautet:

An object of class "employee"
Slot "name":
"Steven"

Slot "id":
1002

Slot "contact":
"North Avenue"

Zu sehen ist, dass der Slot „contact“ von „West Avenue“ auf „North Avenue“ geändert wurde.

Alternativ kannst du auch „slot()“ verwenden, um Werte zu ändern.

„slot(obj, "id")“ adressiert den Slot „id“, der anschließend auf 1004 gesetzt wird; danach wird „obj“ ausgegeben.

slot(obj,"id") <- 1004
obj

An object of class "employee"
Slot "name":
[1] "Steven"

Slot "id":
[1] 1004

Slot "contact":
[1] "North Avenue"

An object of class "employee"
Slot "name":
"Steven"

Slot "id":
1004

Slot "contact":
"North Avenue"

Hier wurde der Slot „id“ von 1002 auf 1004 geändert.

Eigenes Generic in S4 erstellen

Erstellen wir eine Funktion, die die Ausgabe nach unseren Wünschen formatiert. Dazu verwenden wir „setMethod()“ für das Generic „show()“. Über „@“ greifen wir auf alle Slots zu und geben ihre Namen mit Werten aus. Abschließend rufen wir „obj“ auf.

setMethod("show",
"employee",
function(object) {
cat("Name:",object@name, "\n")
cat("Id:",object@id, "\n")
cat("Contact:", object@contact, "\n")
}
)
obj

Name: Steven
Id: 1004
Contact: North Avenue

Name: Steven
Id: 1004
Contact: North Avenue

Die Ausgabe zeigt die Slot-Namen zusammen mit den jeweiligen Werten.

Glückwunsch

Glückwunsch, du hast das Ende dieses Tutorials erreicht!

In diesem Tutorial hast du OOP in R kennengelernt: R-Objekte, die Klassenmodelle S3 und S4, deren Konstruktion, das Erstellen eigener Generics anhand von Beispielen und vieles mehr.

Wenn du mehr über R lernen möchtest, schau dir diese DataCamp-Kurse an:

Object-Oriented Programming with S3 and R6 in R

Themen

Datenwissenschaft