Objects and Classes in R

Class in R

Class is the blueprint that helps to create an object and contains its member variable along with the attributes.

As discussed earlier in the previous section, there are two classes of R, S3, and S4.

S3 Class

These classes help in overloading functions by splitting them into generic and methods.

functions = generic + methods

S3 is very different from other programming languages like C#, Java, etc. Because it's straightforward to implement, it uses only the first argument to dispatch. That's why it doesn't require too much knowledge as a programmer's perspective.

S3 works by defining a strict naming convention of generic dot class.

                             generic.class

The arguments of methods should contain arguments of generic, and method should include a ...arg.

Constructing along with Example of S3 Class

You will be demonstrated to construct an S3 class in the following example, which shows the creation of the list where components are being passed along with proper class name followed by the result to be printed.

The following example shows 'studentBio' contains a list where components are passed as a list where 'student_name,' 'student_age,' and 'student_contact' are being given. The class is named 'Student Info,' and 'studentBio' is the newly created class whose values are displayed below.

studentBio <- list(studentName = "Harry Potter", studentAge = 19, studentContact="London")
class(studentBio) <- "StudentInfo"
studentBio

$studentName
[1] "Harry Potter"

$studentAge
[1] 19

$studentContact
[1] "London"

attr(,"class")
[1] "StudentInfo"

The above code gives the output as below:

$studentName
 "Harry Potter"

$studentAge
19

$studentContact
"London"

attr(,"class")
"StudentInfo"

If you are not comfortable about writing function in R, then read a A Tutorial on Using Functions in R!

Creating your Own Generic Method in S3

You will be implementing your generic function below by using the following code.

The code below shows the generic function called 'contact' where the function passing with the object is assigned to it. Also, 'UseMethod' is used with the generic function called 'contact' is passed where 'dispatching' of method occurs, which is the process where the result varies based on the arguments passed.

contact <- function(object) {
UseMethod("contact")
}

Let's make a method for the particular class that you've created earlier named 'StudentInfo.' The method 'contact' followed by dot notation along with the class 'StudentInfo' is used where the function body contains the access of the attribute 'studentContact' is done by using '$.'

contact.StudentInfo <- function(object) {
cat("Your contact is", object$studentContact, "\n")
}
contact(studentBio)

Your contact is London

The above code uses object$studentContact, where the object passed as an argument to function along with '$' to access attribute 'studentContact,' which results in output as below.

Your contact is London

S4 Class

S4 Class is stricter, conventional, and closely related to Object-Oriented concepts. The classes are represented by the formal class definitions of S4. More specifically, S4 has setter and getter functions for methods and generics. As compared to the S3 class, S4 can be able to facilitate multiple dispatches.

Let us see the above-discussed classes of R by creating them and discuss with an example.

An S4 class is defined using the set class function.

 setClass()

Constructing along with Example of S4 Class

As discussed earlier, the S4 class is defined by the setClass() method. You will use the setClass() method to create and define the S4 class. We will use a subroutine to verify that the data is consistent (validation) and also set the default values (the paradigm).

Following is the code to define the class and its slots:

The following is used to define a class, also called 'prototype', where the slots are defined where the class name is 'employee', name is a character, id as a numeric, and contact as a character.

setClass("employee", slots=list(name="character", id="numeric", contact="character"))

The following code can create the specific instance or objects of S4.

Let's create an object using 'new' with the class name inside as 'employee' with the slots like name, id, and contact are filled with a value.

obj <- new("employee",name="Steven", id=1002, contact="West Avenue")
obj

An object of class "employee"
Slot "name":
[1] "Steven"

Slot "id":
[1] 1002

Slot "contact":
[1] "West Avenue"

An object of class "employee"
Slot "name":
"Steven"

Slot "id":
1002

Slot "contact":
"West Avenue"

The above output shows that the object created was of class "employee" and the Slot with "name" called "Steven" along with Slot "id" with value 1002 and Slot "contact" with value is "West Avenue".

Function and commands

For checking whether an object is an S4 object or not following two commands can be used:

The command 'is.object(obj)'checks whether a variable or instance refers to an object or not.

is.object(obj)

TRUE

The above code gives the following output as below:

TRUE

The command 'is.S4(obj)'checks, whether a variable or instance is an S4 object or not.

isS4(obj)

TRUE

The above code gives the following output as below:

TRUE

Accessing and Modifying the slot value

Accessing the slot

The slot can be accessed using the "@" instead of "$".

'obj@name' is used where the object name along with the slot name is to access the name 'Steven' and is similarly done to 'obj@id'.

obj@name
obj@id

'Steven'

1002

The above code gives the following output:

'Steven'
1002

Modifying the slot

Let's modify the slot value just by using the assignment operator("<-") where the 'obj@contact' is assigned with a new value as "North Avenue".

obj@contact <- "North Avenue"
obj

An object of class "employee"
Slot "name":
[1] "Steven"

Slot "id":
[1] 1002

Slot "contact":
[1] "North Avenue"

The above code gives the following output:

An object of class "employee"
Slot "name":
"Steven"

Slot "id":
1002

Slot "contact":
"North Avenue"

The above output shows that the Slot "contact" has changed it's value previously "West Avenue" to "North Avenue".

Alternatively, there is an option to use 'slot()' to change the value.

'slot(obj, "id")' indicates the slot "id" value to ve changed with the assignment of 1004, and the result is printed with 'obj'.

slot(obj,"id") <- 1004
obj

An object of class "employee"
Slot "name":
[1] "Steven"

Slot "id":
[1] 1004

Slot "contact":
[1] "North Avenue"

An object of class "employee"
Slot "name":
"Steven"

Slot "id":
1004

Slot "contact":
"North Avenue"

The above output shows that the Slot "id" has changed its value previously 1002 to 1004.

Creating your own Generic Method in S4

Let's create a function that helps print the output according to our needs, where the 'setMethod()' and the generic function called 'show()' is used. Also, all the slots' value is accessed by '@', and their names are printed out. Finally, the output is obtained with the help of 'obj'.

setMethod("show",
"employee",
function(object) {
cat("Name:",object@name, "\n")
cat("Id:",object@id, "\n")
cat("Contact:", object@contact, "\n")
}
)
obj

Name: Steven
Id: 1004
Contact: North Avenue

Name: Steven
Id: 1004
Contact: North Avenue

The above output shows that the results are printed as in the form of Slot names along with respective Slot values.

Congratulations

Congratulations, you have made it to the end of this tutorial!

In this tutorial, you've learned about Object-Oriented Programming(OOP) along with R's objects, different classes like S3 and S4, along with its construction, creating its generic function with examples and many more.

If you would like to learn more about R, check DataCamp's courses:

Object-Oriented Programming with S3 and R6 in R