Einleitung: Objektorientierte Programmierung in R

Die objektorientierte Programmierung (OOP) ist ein Konzept, bei dem Daten und zugehörige Funktionen in sogenannten Objekten zusammengefasst werden. Dies fördert die Strukturierung, Wiederverwendbarkeit und Wartbarkeit von Code – besonders bei komplexeren Programmen.

R bietet dafür mehrere Systeme: S3, S4 und das modernere, klassenbasierte R6-System. Anders als S3 und S4 orientiert sich R6 stärker an klassischen OOP-Sprachen wie Python oder Java. Es erlaubt die Definition von Klassen mit Konstruktoren, Methoden, Vererbung und Zugriffskontrolle.

Ziel dieses Beispiels

In diesem Notebook definieren wir eine einfache R6-Klasse namens Zahl, die grundlegende Rechenoperationen kapselt: Addition, Subtraktion, Multiplikation und Division.

Dabei werden zwei häufige Fehlerquellen berücksichtigt:

• Division durch null
• Ungültiger Operand (z. B. kein Zahl-Objekt)

Das Beispiel dient als verständlicher Einstieg in OOP mit R6. Es zeigt, wie man Werte und zugehörige Operationen in einer klaren, objektorientierten Struktur verpackt und gleichzeitig robuste Fehlerbehandlung integriert.

Klassendefinition

library(R6)

# Definition der Klasse "Zahl"
Zahl <- R6Class("Zahl",
  public = list(
    wert = NULL,  # Attribut zur Speicherung des Zahlenwerts
    
    # Konstruktor
    initialize = function(wert) {
      self$wert <- wert
    },
    
    # Addition
    addiere = function(anderer) {
      private$check_typ(anderer)
      return(Zahl$new(self$wert + anderer$wert))
    },
    
    # Subtraktion
    subtrahiere = function(anderer) {
      private$check_typ(anderer)
      return(Zahl$new(self$wert - anderer$wert))
    },
    
    # Multiplikation
    multipliziere = function(anderer) {
      private$check_typ(anderer)
      return(Zahl$new(self$wert * anderer$wert))
    },
    
    # Division (mit Fehlerprüfung)
    dividiere = function(anderer) {
      private$check_typ(anderer)
      if (anderer$wert == 0) stop("Fehler: Division durch null ist nicht erlaubt.")
      return(Zahl$new(self$wert / anderer$wert))
    },
    
    # Ausgabe
    anzeigen = function() {
      cat("Wert:", self$wert, "\n")
    }
  ),
  
  private = list(
    # Interne Typprüfung
    check_typ = function(obj) {
      if (!inherits(obj, "Zahl")) {
        stop("Fehler: Argument ist kein Objekt der Klasse 'Zahl'.")
      }
    }
  ) 
)

# Beispielnutzung
a <- Zahl$new(12)
a

<Zahl>
  Public:
    addiere: function (anderer) 
    anzeigen: function () 
    clone: function (deep = FALSE) 
    dividiere: function (anderer) 
    initialize: function (wert) 
    multipliziere: function (anderer) 
    subtrahiere: function (anderer) 
    wert: 12
  Private:
    check_typ: function (obj) 

b <- Zahl$new(4)
b

<Zahl>
  Public:
    addiere: function (anderer) 
    anzeigen: function () 
    clone: function (deep = FALSE) 
    dividiere: function (anderer) 
    initialize: function (wert) 
    multipliziere: function (anderer) 
    subtrahiere: function (anderer) 
    wert: 4
  Private:
    check_typ: function (obj) 

a$addiere(b)$anzeigen()        # 12 + 4 = 16

Wert: 16 

a$subtrahiere(b)$anzeigen()    # 12 - 4 = 8

Wert: 8 

a$multipliziere(b)$anzeigen()  # 12 * 4 = 48

Wert: 48 

a$dividiere(b)$anzeigen()      # 12 / 4 = 3

Wert: 3 

# Fehlerbeispiele (auskommentiert, damit sie den Code nicht abbrechen)
# a$dividiere(Zahl$new(0))     # Division durch null
# a$addiere("nicht_zahl")      # Typfehler