Classes in R Programming

What are Classes in R?

In R, a class is a blueprint or a template for creating objects and defining their structure, attributes, and methods (functions) that operate on those objects. It is a cornerstone of object-oriented programming, empowering developers to organize and manage data and functions seamlessly. Classes facilitate the creation of user-defined data types, enabling programmers to model real-world entities in a program.

When an object is created based on a class, it is referred to as an instance of that class. Each instance can have its unique data and state while adhering to the characteristics defined by the class. This allows for efficient data manipulation and organisation within the R environment.

The key components of a class in R are:

• Attributes: Classes can have attributes, which are essentially variables associated with the class and its instances. These attributes define the properties of the objects and can be accessed or modified through specific methods.
• Methods: Methods are functions that are associated with a particular class and operate on its instances. They provide the means to interact with the data and implement various functionalities specific to the class.
• Generic Functions: In R, generic functions are defined independently of any particular class but have methods tailored for different classes. This concept allows for method dispatching, where the appropriate method is chosen based on the class of the object being used.

R's approach to OOP is primarily based on S3 and S4 classes, each with its distinct features and purposes. The S3 class system is simpler and more informal, while the S4 class system is more structured and formal. Both systems, however, enable developers to build complex and sophisticated data structures tailored to their specific needs.

S3 Class in R

S3, being the most popular and simplest OOP system in R, is characterized by its informal and flexible nature. Unlike other class systems, S3 lacks a formal definition and rigid structure. To create an object of this type, one can simply add an attribute to it.

Creating S3 Class

In R, the S3 class system is a simpler and more informal approach to object-oriented programming compared to the S4 class system. S3 classes allow developers to create objects with associated attributes and methods, making it a versatile and widely used mechanism for defining classes.

To create an S3 class, we follow these key steps:

• Define a function that represents the constructor of the class. This function is responsible for creating instances of the class and setting their initial attributes.
• Use the class() function to assign a class name to the object. This associates the object with the specified class.
• Implement methods that operate on objects of the defined class. Methods are functions tailored to work with specific classes and are selected based on the class of the object they are applied.

Examples:

Let's illustrate the creation of an S3 class with a simple example. Consider a class named Animal which represents various animals and their attributes:

Output:

In this example, we defined the constructor function create_animal() to create instances of the Animal class. We associated the objects lion and elephant with the class Animal using the class() function. Subsequently, we implemented the print.Animal() method to display the attributes of Animal instances in a user-friendly manner.

S4 Class in R

The S4 class system in R is an advanced and formal approach to object-oriented programming. Unlike the informal nature of S3 classes, S4 classes provide a structured and well-defined mechanism for creating complex data structures and organizing objects within R.

Creating S4 Class

In contrast to the informal nature of S3, the S4 class system in R provides a more formal and structured approach to object-oriented programming. S4 classes offer a robust way to define complex data structures with well-defined slots and methods.

To create an S4 class, the key steps include:

• Defining the Class: Use the setClass() function to define the class, specifying the class name and defining the slots (attributes) it contains. For each slot, you can also specify the data type it should hold, providing stricter type checking.
• Creating a Constructor Function: Implement a constructor function using the setMethod() function. The constructor function initializes the slots of the S4 class and returns the object instance.
• Implementing Methods: Define methods that operate on the S4 class objects using the setMethod() function. This allows you to associate specific functions with particular methods based on the class.

Example:

Let's illustrate the creation of an S4 class with an example. We will create an S4 class named Person to represent individuals with specific attributes such as name, age, and occupation:

Output:

In this example, we used the setClass() function to define the Person class with three slots: name, age, and occupation. We then created a constructor function, Person(), to initialize and return the object instance. Additionally, we implemented the printPerson() method to display the attributes of the Person instance in a formatted manner.

S4 classes in R offer the advantage of stricter data typing, as each slot can be associated with a specific class. This provides additional validation and enhances the reliability of the code.

Reference Class

Reference Class is an alternative approach to object-oriented programming in R, facilitated through the R6 library. Unlike the traditional S3 and S4 class systems, Reference Classes offer a more mutable and stateful approach to creating objects. In Reference Classes, objects maintain shared references to their attributes, allowing for dynamic modifications during runtime. This makes Reference Classes suitable for scenarios where mutable objects are required. Additionally, Reference Classes support the creation of public and private methods, encapsulating functionality within the class and providing controlled access to object properties. The R6 library introduces Reference Classes in R, providing developers with a more stateful and dynamic object-oriented programming experience.

Creating Reference Class

To create a Reference Class, we follow these key steps:

• Load the R6 library using library(R6).
• Define the Reference Class using the R6Class() function, specifying the class name and its methods. Unlike S4 classes, Reference Classes do not use formal slots.
• Implement methods inside the Reference Class using the public$ keyword. These methods can modify and access the internal state of the object.

Example

Let's illustrate creating a simple Reference Class using the R6 library. We will create a class named Counter, which represents a basic counter that can be incremented and decremented:

Output:

Explanation:

• The counter_instance is an object created from the Counter Reference Class.
• We used the increment() method three times to increase the count by 1, 5, and 1 again, resulting in a total increment of 7.
• We used the decrement() method twice to decrease the count by 2, resulting in a total decrement of 4.
• Finally, we printed the current count using cat("Current Count:", counter_instance$count, "\n"), which shows the value 4 as the output.

In this example, we defined the Counter Reference Class with three public methods: increment(), decrement(), and reset(). These methods can modify the internal state of the object, allowing us to perform increment, decrement, and reset operations on the counter.

Difference between S3 vs S4 vs Reference Class

Below is a table summarizing the key differences between S3, S4, and Reference Classes in R: