Introduction
Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around objects, rather than functions and logic alone. Objects represent real-world entities and combine data (attributes) and behavior (methods) into a single unit.
In R, Object-Oriented Programming is especially important for:
- Statistical modeling
- Data analysis
- Package development
- Complex data structures
- Reusable and maintainable code
Unlike many languages (Java, C++), R supports multiple OOP systems, each designed for different use cases.
What is Object-Oriented Programming?
Object-Oriented Programming is based on four core principles:
- Encapsulation – bundling data and methods together
- Abstraction – exposing only essential details
- Inheritance – creating new objects from existing ones
- Polymorphism – same function behaving differently for different objects
Why OOP is Important in R
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.
Object-Oriented Systems in R
R supports three main OOP systems:
- S3 – Simple and informal (most common)
- S4 – Formal and strict
- R6 – Modern, reference-based OOP
Objects in R
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
Classes in R
A class defines the type or category of an object.
class(x)
Example:
v <- c(1, 2, 3)
class(v)
Output:
"numeric"
Encapsulation in R
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 in R
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 in R
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 in R
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 Object-Oriented System (Introduction)
What is S3?
S3 is the simplest and most widely used OOP system in R.
Characteristics:
- Informal
- No strict class definitions
- Easy to use and flexible
Creating an S3 Object
person <- list(name = "Alice", age = 25)
class(person) <- "Person"
Creating an S3 Method
print.Person <- function(obj) {
cat("Name:", obj$name, "\n")
cat("Age:", obj$age, "\n")
}
print(person)
Polymorphism with S3
print(10)
print(person)
Same function name, different behavior.
S4 Object-Oriented System (Brief Introduction)
What is S4?
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 Object-Oriented System (Introduction)
What is R6?
R6 is a modern OOP system similar to Python and Java.
Features:
- Reference-based objects
- Encapsulation
- Private and public members
Creating an R6 Class
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()
Inheritance in R6
Student <- R6Class(
"Student",
inherit = Person,
public = list(
course = NULL,
initialize = function(name, age, course) {
super$initialize(name, age)
self$course <- course
}
)
)
Comparison of OOP Systems in R
| Feature | S3 | S4 | R6 |
|---|---|---|---|
| Formality | Low | High | High |
| Syntax | Simple | Verbose | Modern |
| Inheritance | Yes | Yes | Yes |
| Encapsulation | Weak | Strong | Strong |
| Reference-based | No | No | Yes |
When to Use Which OOP System
- S3: Simple modeling, quick prototyping
- S4: Complex statistical packages
- R6: Applications, APIs, large systems
Common Mistakes in OOP with R
- Mixing S3 and S4 incorrectly
- Not understanding method dispatch
- Misusing reference-based objects
- Overcomplicating simple tasks
Summary
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.