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:

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

---

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:

1. S3 – Simple and informal (most common)
2. S4 – Formal and strict
3. 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.