R6编程中的类

在R语言的面向对象编程（OOP）中，封装意味着在一个类中绑定数据和方法。R6包是一个封装的OOP系统，帮助我们在R中使用封装。R6包提供了R6类，它类似于R中的引用类，但独立于S4类。除了私有和公共成员，R6类还支持继承，即使这些类定义在不同的包中。一些使用R6类的流行R包是 dplyr 和 shiny。

例子

library(R6)
  
Queue <- R6Class("Queue",
  
# public members of the class
# that can be accessed by object
public  =  list(
      
# constructor/initializer  
initialize = function(...)
{
    privateelements = list(...)
},
  
# add to the queue
enqueue = function(num) 
{
    privateelements <- append(privateelements, num)
},
  
# remove from the queue
dequeue = function()
{
    if(selfsize() == 0)
    stop("Queue is empty")
    element <- privateelements[[1]]
    privateelements <- privateelements[-1]
    element
},
  
# get the size of elements
size = function()
{
    length(privateelements)
}),
  
private = list(
      
  # queue list
  elements = list())
)
  
# create an object
QueueObject = Queuenew()
  
# add 2
QueueObjectenqueue(2)
  
# add 5
QueueObjectenqueue(5)
  
# remove 2
QueueObjectdequeue()
  
# remove 5
QueueObject$dequeue()

输出

[1] 2
[1] 5

公有和私有成员都可以被使用。队列（元素）是私有的，这样对象就不能在外部修改它。initialize函数是初始化对象的构造函数。 object$member 用于访问类外的公共成员，而 private$member 用于访问类方法内的私有成员。

下面的例子是通过创建另一个继承了Queue类的childQueue类来演示R6类中的继承性。

例子

childQueue <- R6Class("childQueue",
  
# inherit Queue class which is the super class
inherit = Queue,
public = list(
initialize = function(...)
{
    privateelements <- list(...)
},
size = function()
{
    # super is used to access methods from super class
    supersize()
}
))
  
childQueueObject <- childQueuenew()
childQueueObjectenqueue(2)
childQueueObjectenqueue(3)
childQueueObjectdequeue()
childQueueObject$dequeue()

输出

[1] 2
[1] 3

childQueue类可以使用Queue超类的 enqueue() 和 dequeue() 函数。 size方法覆盖了超类Queue的 size() ，但在内部使用super .NET调用Queue的 size( )。这些类可以跨包继承。