Introduction to Object-Oriented Programming in R Language

Object-Oriented Programming is based on four core principles:

1. Encapsulation – bundling data and methods together
2. Abstraction – exposing only essential details
3. Inheritance – creating new objects from existing ones
4. Polymorphism – same function behaving differently for different objects

OOP helps:

• Organize large programs
• Reuse code efficiently
• Write cleaner and modular code
• Build extensible statistical models
• Create professional R packages

Many built-in R functions like plot(), print(), and summary() use OOP concepts internally.

R supports three main OOP systems:

1. S3 – Simple and informal (most common)
2. S4 – Formal and strict
3. R6 – Modern, reference-based OOP

An object in R is any data structure stored in memory.

Examples:

x <- 10
y <- "R"
z <- c(1, 2, 3)

Everything in R is an object:

• Variables
• Vectors
• Data frames
• Functions
• Models

A class defines the type or category of an object.

class(x)

Example:

v <- c(1, 2, 3)
class(v)

Output:

"numeric"

Encapsulation means combining data and functions that operate on that data.

In R:

• Objects store data
• Functions operate on objects

Example:

person <- list(name = "Alice", age = 25)

Abstraction means hiding implementation details and showing only essential functionality.

Example:

summary(lm(mpg ~ wt, data = mtcars))

You don’t need to know how summary() works internally.

Polymorphism allows the same function to behave differently depending on object type.

Example:

print(10)
print("R")
print(c(1, 2, 3))

The print() function behaves differently for each object.

Method dispatch is how R decides which function to call for an object.

Example:

plot(1:10)
plot(mtcars$wt, mtcars$mpg)

Different plots, same function name.

S3 is the simplest and most widely used OOP system in R.

Characteristics:

• Informal
• No strict class definitions
• Easy to use and flexible

person <- list(name = "Alice", age = 25)
class(person) <- "Person"

print.Person <- function(obj) {
  cat("Name:", obj$name, "\n")
  cat("Age:", obj$age, "\n")
}

print(person)

print(10)
print(person)

Same function name, different behavior.

S4 is a formal OOP system with:

• Explicit class definitions
• Defined slots (attributes)
• Strict type checking

Example:

setClass("Person",
         slots = list(
           name = "character",
           age = "numeric"
         ))

R6 is a modern OOP system similar to Python and Java.

Features:

• Reference-based objects
• Encapsulation
• Private and public members

library(R6)

Person <- R6Class(
  "Person",
  public = list(
    name = NULL,
    age = NULL,
    initialize = function(name, age) {
      self$name <- name
      self$age <- age
    },
    greet = function() {
      cat("Hello, my name is", self$name, "\n")
    }
  )
)

p <- Person$new("Alice", 25)
p$greet()

Student <- R6Class(
  "Student",
  inherit = Person,
  public = list(
    course = NULL,
    initialize = function(name, age, course) {
      super$initialize(name, age)
      self$course <- course
    }
  )
)

• S3: Simple modeling, quick prototyping
• S4: Complex statistical packages
• R6: Applications, APIs, large systems

• Mixing S3 and S4 incorrectly
• Not understanding method dispatch
• Misusing reference-based objects
• Overcomplicating simple tasks

R supports multiple object-oriented programming systems. OOP in R allows you to write reusable, modular, and maintainable code. Understanding S3, S4, and R6 is essential for advanced R programming, package development, and professional data science work.