R语言-S3系统

最新推荐文章于 2023-06-18 20:48:23 发布

hukun1995

最新推荐文章于 2023-06-18 20:48:23 发布

阅读量3.4k

点赞数

分类专栏： R语言学习文章标签： r语言

R语言学习专栏收录该内容

20 篇文章 20 订阅

订阅专栏

本文参考R语言基于S3的面向对象编程

R的面向对象编程提供了3种底层对象类型，一种是S3类型，一种是S4类型还有一种是RC类型。
S3对象简单、具有动态性、结构化特征不明显；S4对象结构化、 功能强大；RC对象是2.12版本后使用的新类型，用于解决S3,S4很难实现的对象。

1.S3对象介绍
在R语言中，基于S3对象的面向对象编程，是一种基于泛型函数的实现方式。泛型函数是一种特殊的函数, 根据传入对象的类型决定调用哪个具体的方法。基于S3对象实现的面向对象编程，不同其他语言的面向对象编程，是一种动态函数调用的模拟实现。S3对象被广泛应用于R的早期的开发包中。

2.创建S3对象
以下有许多检测类的函数都是pryr包的内容，记得先加载哦~
(1) 通过变量创建S3对象

> x<-1
> attr(x,'class')<-'foo'   为了x增加class属性

> x
[1] 1
attr(,"class")
[1] "foo"

> class(x)
[1] "foo"

# 用pryr包的otype函数，检查x的类型
> otype(x)
[1] "S3"

(2) 通过structure函数创建S3对象

> y <- structure(2, class = "foo")

> y
[1] 2
attr(,"class")
[1] "foo"

> class(y)
[1] "foo"

> otype(y)
[1] "S3"

(3) 创建一个多类型的S3对象
S3对象没有明确结构关系，一个S3对象可以有多个类型, S3对象的 class 属性可以是一个向量，包括多种类型。

> x<-1
> attr(x,'class')<- c("foo", "bar")
> class(x)
[1] "foo" "bar"
> otype(x)
[1] "S3"

3.泛型函数和方法调用
对于S3对象的使用，通常用UseMethod()函数来定义一个泛型函数的名称，通过传入参数的class属性，来确定不同的方法调用。

定义一个teacher的泛型函数

用UseMethod()定义teacher泛型函数
用teacher.xxx的语法格式定义teacher对象的行为
其中teacher.default是默认行为

# 用UseMethod()定义teacher泛型函数
> teacher <- function(x, ...) UseMethod("teacher")

# 用pryr包中ftype()函数，检查teacher的类型
> ftype(teacher)
[1] "s3"      "generic"

# 定义teacher内部函数
> teacher.lecture <- function(x) print(paste(x,"讲课"))
> teacher.assignment <- function(x) print(paste(x,"布置作业"))
> teacher.correcting <- function(x) print(paste(x,"批改作业"))
> teacher.default<-function(x) print("你不是teacher")

S3所谓的类其实只是将一系列同类动作封装在了teacher泛化函数下，并没有很强的结构关系，各函数间也没有什么联系。而且并不存在所谓个体是类的实例化的概念，调用的方法并不是对象本身的，而是泛化函数的。

方法调用时，通过传入参数的class属性，来确定不同的方法调用。

定义一个变量a，并设置a的class属性为lecture
把变量a，传入到teacher泛型函数中
函数teacher.lecture()函数的行为被调用

> a<-"张三"
> attr(a,"class")<-"lecture"
> teacher(a)
[1] "张三 讲课"

当然我们也可以直接调用teacher中定义好的函数，因为S3的实现策略并不需要对象产生必要的实例化动作，但这样做它仅有的面向对象封装的意义也将失去。

> teacher.default()
[1] "你不是teacher"

4.查看S3对象的函数
当我们使用S3对象进行面向对象封装后，可以用methods()函数来查看S3对象中的定义的内部行为函数。

> teacher
function(x,...)UseMethod("teacher")
> methods(teacher)
[1] teacher.assignment teacher.correcting teacher.default teacher.lecture

通过methods()的generic.function参数，来匹配泛型函数名字。

methods(generic.function=predict)
 [1] predict.ar*                predict.Arima*             predict.arima0*            predict.glm               
 [5] predict.glmmPQL*           predict.HoltWinters*       predict.lda*               predict.lm                
 [9] predict.loess*             predict.lqs*               predict.mca*               predict.mlm* 
……

通过methods()的class参数，来匹配类的名字。

> methods(class=lm)
 [1] add1.lm*           alias.lm*          anova.lm           case.names.lm*
 [5] confint.lm*        cooks.distance.lm* deviance.lm*       dfbeta.lm*
 [9] dfbetas.lm*        drop1.lm*          dummy.coef.lm*     effects.lm*
……

用getAnywhere()函数，查看所有的函数。

> getAnywhere(teacher.lecture())
A single object matching ‘teacher.lecture’ was found
It was found in the following places
  .GlobalEnv
  registered S3 method for teacher
with value

function(x) print(paste(x,"讲课"))

# 查看不可见的函数predict.ppr
> predict.ppr
Error: object 'predict.ppr' not found
> exists("predict.ppr")
[1] FALSE

# getAnywhere()函数查找predict.ppr
> getAnywhere("predict.ppr")
A single object matching ‘predict.ppr’ was found
It was found in the following places
  registered S3 method for predict from namespace stats
  namespace:stats
with value

function (object, newdata, ...)
{
    if (missing(newdata))
        return(fitted(object))
    if (!is.null(object$terms)) {
        newdata <- as.data.frame(newdata)
        rn <- row.names(newdata)
        ……

可以看出来teacher.lecture()函数是被存储在全局环境中的，可见泛化函数与具体动作函数之间并不是真正的包含关系。
使用getS3method()函数，也同样可以查看不可见的函数，效果类似

5.S3对象的继承关系
S3对象有一种非常简单的继承方式，用NextMethod()函数来实现。

定义一个 node泛型函数

> node <- function(x) UseMethod("node", x)
> node.default <- function(x) "Default node"

# father函数
> node.father <- function(x) c("father")

# son函数，通过NextMethod()函数指向father函数
> node.son <- function(x) c("son", NextMethod())

# 定义n1
> n1 <- structure(1, class = c("father"))
# 在node函数中传入n1，执行node.father()函数
> node(n1)
[1] "father"

# 定义n2，设置class属性为两个
> n2 <- structure(1, class = c("son", "father"))
# 在node函数中传入n2，执行node.son()函数和node.father()函数
> node(n2)
[1] "son"    "father"