查看原文
其他

R语言面向对象编程

2017-04-08 张丹 R语言中文社区



前言

面向对象是一种对现实世界理解和抽象的方法,当代码复杂度增加难以维护的时候,面向对象就会显得非常重要。我经历过Java和Javascript两种语言从面向过程到面向对象思路的改造,并感觉这种变化也会出现在R语言中。在工业界的引导下,R将走向大规则的企业应用,因此面向对象的编程方式将成为R语言的一种非常重要的发展方向,动起来迎接R的进步。


目录

  1. 什么是面向对象?

  2. R为什么要进行面向对象编程?

  3. R的面向对象编程

  4. 与其他语言的对比

1 什么是面向对象?

面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。早期的计算机编程是基于面向过程的方法,例如实现算术运算2+3+4=9,通过设计一个算法就可以解决当时的问题。

随着计算机技术的不断提高,计算机被用于解决越来越复杂的问题。一切事物皆对象,通过面向对象的方式,将现实世界的事物抽象成对象,现实世界中的关系抽象成类、继承,帮助人们实现对现实世界的抽象与数字建模。通过面向对象的方法,更利于用人理解的方式对复杂系统进行分析、设计与编程。同时,面向对象能有效提高编程的效率,通过封装技术,消息机制可以像搭积木的一样快速开发出一个全新的系统。面向对象是指一种程序设计范型,同时也是一种程序开发的方法。对象指的是类的集合。它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性。

面向对象的3个特征:封装,继承,多态

封装:是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。


我们通过面向对象的思想,定义老师和学生两个对象,并分别定义老师和学生的行为。

  • 老师的行为:讲课,布置作业,批作业

  • 学生的行为:听课,写作业,考试

通过封装就把两个客观事物进行了抽象,并设置了事情的行为。

继承:子类自动共享父类数据结构和方法的机制,这是类之间的一种关系。在定义和实现一个类的时候,可以在一个已经存在的类的基础之上来进行,使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”;被继承的类称为“基类”、“父类”或“超类”。


通常每门课都会从学生中选出这门课的课代表,来帮助老师和其他同学的沟通。课代表会有一些比普通同学更多特权。通过继承关系,把普通同学和课代表区别为两个子类,课代表不仅有普通同学的行为,还有帮助老师批作业的行为。

多态: 指由继承而产生的相关的不同的类,其对象对同一消息会做出不同的响应。


临近期末考试时,总有考的好的同学和考的不好的同学。所以,对于优等生来说,他的考试结果是优;次等生,考试结果就不是太好。相同行为对于由继承而产生的相关的不同的对象,结果是不同的。

所以,通过面向对象的思想,我们可以把客观世界的事物都进行抽象。

is a 和 has a

在客观世界中有若干类,这些类之间有一定的结构关系。通常有两种主要的结构关系,is a,和 has a。

  • is a: 为继承关系,比如 菱形、圆形和方形都是一种形状

  • has a:为组合关系或聚合关系,比如 电脑是由显示器、CPU、硬盘等组成


2 R为什么要进行面向对象编程?

R主要面向统计计算,而且代码量一般不会很大,几十行,几百行,使用面向过程的编程方法就可以很好地完成编程的任务。

不过,虽然R语言的持续手热,伴随着越来越多的工程背景的人的加入,R语言开始向更多的领域发展。原来的少量的代码的面向过程的编码方式,会越来越难以维护海量代码的项目,所以必须有一种新的编程方式来代码原来的面向过程的编码思路,这种新的编程方式就是面向对象编程(Object Oriented Programming, OOP)。

面向对象编程,早在C++/Java时代就被广泛使用了,几乎90%以上的Java框架都是按面向对象的方法设计的;8年前Javascript各种面向过程编码让前端开发困难重重,直到Google的Gmail的Web端出现,才让大家认识到原来Javascript也可以面向对象编程,随后的jQuery, ExtJS等类库的完全面向对象的实现,终于让Javascript承得起前端的天空,后来的Node的诞生更是让Javascript拓宽了应用领域。

当R语言被大家所看好的同时,我们也要开始思考,如何才能让R成为工业界的开发语言?应用如何构建非统计计算的项目?如何用R有效的编写10万行以上的代码?

我想这个答案就是以面向对象进行编程,现在的R就像8年前的Javascript,需要大公司和牛人来推动。从我的观察来看,以Hadley Wickham为代表的R语言领军人物,已经开始在R包中全面引入面向对象思路进行R包的开发了。以面向对象思想开发的R包memoise,请参考文章:R语言本地缓存memoise


3 R的面向对象编程

R的面向对象编程是基于泛型函数(generic function)的,而不是基于类层次结构。接下来,我从面向对象的3个特征入手,分别用R语言进行实现,使用的案例为上文中,老师和学生的3幅图。


3.1 R语言实现封装


# 定义老师对象和行为
> teacher <- function(x, ...) UseMethod("teacher")
> teacher.lecture <- function(x) print("讲课")
> teacher.assignment <- function(x) print("布置作业")
> teacher.correcting <- function(x) print("批改作业")
> teacher.default<-function(x) print("你不是teacher")

# 定义同学对象和行为
> student <- function(x, ...) UseMethod("student")
> student.attend <- function(x) print("听课")
> student.homework <- function(x) print("写作业")
> student.exam <- function(x) print("考试")
> student.default<-function(x) print("你不是student")

# 定义两个变量,a老师和b同学
> a<-'teacher'
> b<-'student'

# 给老师变量设置行为
> attr(a,'class') <- 'lecture'
# 执行老师的行为
> teacher(a)
[1] "讲课"

# 给同学变量设置行为
> attr(b,'class') <- 'attend'
# 执行同学的行为
> student(b)
[1] "听课"

> attr(a,'class') <- 'assignment'
> teacher(a)
[1] "布置作业"

> attr(b,'class') <- 'homework'
> student(b)
[1] "写作业"

> attr(a,'class') <- 'correcting'
> teacher(a)
[1] "批改作业"

> attr(b,'class') <- 'exam'
> student(b)
[1] "考试"

# 定义一个变量,既是老师又是同学
> ab<-'student_teacher'
# 分别设置不同对象的行为
> attr(ab,'class') <- c('lecture','homework')
# 执行老师的行为
> teacher(ab)
[1] "讲课"
# 执行同学的行为
> student(ab)
[1] "写作业"

3.2 R语言实现继承


# 给同学对象增加新的行为
> student.correcting <- function(x) print("帮助老师批改作业")

# 辅助变量用于设置初始值
> char0 = character(0)

# 实现继承关系
> create <- function(classes=char0, parents=char0)
{
+     mro <- c(classes)
+     for (name in parents) {
+         mro <- c(mro, name)
+         ancestors <- attr(get(name),'type')
+         mro <- c(mro, ancestors[ancestors != name])
+     }
+     return(mro)
+ }

# 定义构造函数,创建对象
> NewInstance <- function(value=0, classes=char0, parents=char0) {
+     obj <- value
+     attr(obj,'type') <- create(classes, parents)
+     attr(obj,'class') <- c('homework','correcting','exam')
+     return(obj)
+ }

# 创建父对象实例
> StudentObj <- NewInstance()

# 创建子对象实例
> s1 <- NewInstance('普通同学',classes='normal', parents='StudentObj')
> s2 <- NewInstance('课代表',classes='leader', parents='StudentObj')

# 给课代表,增加批改作业的行为
> attr(s2,'class') <- c(attr(s2,'class'),'correcting')

# 查看普通同学的对象实例
> s1
[1] "普通同学"
attr(,"type")
[1] "normal"     "StudentObj"
attr(,"class")
[1] "homework"   "attend" "exam"      

# 查看课代表的对象实例
> s2
[1] "课代表"
attr(,"type")
[1] "leader"     "StudentObj"
attr(,"class")
[1] "homework"   "attend" "exam"       "correcting"

3.3 R语言实现多态


# 创建优等生和次等生,两个实例
> e1 <- NewInstance('优等生',classes='excellent', parents='StudentObj')
> e2 <- NewInstance('次等生',classes='poor', parents='StudentObj')

# 修改同学考试的行为,大于85分结果为优秀,小于70分结果为及格
> student.exam <- function(x,score) {
+     p<-"考试"
+     if(score>85) print(paste(p,"优秀",sep=""))
+     if(score<70) print(paste(p,"及格",sep=""))
+ }

# 执行优等生的考试行为,并输入分数为90
> attr(e1,'class') <- 'exam'
> student(e1,90)
[1] "考试优秀"

# 执行次等生的考试行为,并输入分数为66
> attr(e2,'class') <- 'exam'
> student(e2,66)
[1] "考试及格"

这样通过R语言的泛型函数,我们就实现了面向对象的编程。


4 R的面向过程编程

接下来,我们再次对比用R语言用面向过程实现上面的逻辑。


4.1 定义老师和同学两个对象和行为


# 辅助变量用于设置初始值
> char0 = character(1)

# 定义老师对象和行为
> teacher_fun<-function(x=char0){
+     if(x=='lecture'){
+         print("讲课")
+     }else if(x=='assignment'){
+         print("布置作业")
+     }else if(x=='correcting'){
+         print("批改作业")
+     }else{
+         print("你不是teacher")
+     }
+ }

# 定义同学对象和行为
> student_fun<-function(x=char0){
+     if(x=='attend'){
+         print("听课")
+     }else if(x=='homework'){
+         print("写作业")
+     }else if(x=='exam'){
+         print("考试")
+     }else{
+         print("你不是student")
+     }
+ }

# 执行老师的一个行为
> teacher_fun('lecture')
[1] "讲课"

# 执行同学的一个行为
> student_fun('attend')
[1] "听课"

4.2 区别普通同学和课代表的行为


# 重定义同学的函数,增加角色判断
> student_fun<-function(x=char0,role=0){
+     if(x=='attend'){
+         print("听课")
+     }else if(x=='homework'){
+         print("写作业")
+     }else if(x=='exam'){
+         print("考试")
+     }else if(x=='correcting'){
+         if(role==1){#课代表
+             print("帮助老师批改作业")  
+         }else{
+             print("你不是课代表")  
+         }
+     }else{
+         print("你不是student")
+     }
+ }

# 以普通同学的角色,执行课代表的行为
> student_fun('correcting')
[1] "你不是课代表"

# 以课代表的角色,执行课代表的行为
> student_fun('correcting',1)
[1] "帮助老师批改作业"

我在修改student_fun()函数的同时,已经增加了原函数的复杂度。


4.3 参加考试,以成绩区别出优等生和次等生


# 修改同学的函数定义,增加考试成绩参数
> student_fun<-function(x=char0,role=0,score){
+     if(x=='attend'){
+         print("听课")
+     }else if(x=='homework'){
+         print("写作业")
+     }else if(x=='exam'){
+         p<-"考试"
+         if(score>85) print(paste(p,"优秀",sep=""))
+         if(score<70) print(paste(p,"及格",sep=""))
+     }else if(x=='correcting'){
+         if(role==1){#课代表
+             print("帮助老师批改作业")  
+         }else{
+             print("你不是课代表")  
+         }
+     }else{
+         print("你不是student")
+     }
+ }

# 执行考试函数,考试成绩为大于85分,为优等生
> student_fun('exam',score=90)
[1] "考试优秀"

# 执行考试函数,考试成绩为小于70分,为次等生
> student_fun('exam',score=66)
[1] "考试及格"

我再一次用面向过程的代码,实现了整个的编辑逻辑。再用到面向过程来写程序的时候,每一次的需求变化,都需要对原始代码进行修改,从而不仅增加了复杂度,而且不利于长久的维护。更多思考留给了大家!

本文抛砖引玉地讲了R语言的面向对象的编程,其中部分代码有些不够严谨,本文只希望给大家思路上的认识,更具体的面向对象编程实例,会在以后的文章中进行讨论。


作者介绍:

张丹,R语言中文社区专栏特邀作者,《R的极客理想》系列图书作者,民生银行大数据中心数据分析师,前况客创始人兼CTO。

10年IT编程背景,精通R ,Java, Nodejs 编程,获得10项SUN及IBM技术认证。丰富的互联网应用开发架构经验,金融大数据专家。个人博客 http://fens.me, Alexa全球排名70k。

著有《R的极客理想-工具篇》、《R的极客理想-高级开发篇》,合著《数据实践之美》,新书《R的极客理想-量化投资篇》(即将出版)。


《R的极客理想-工具篇》京东购买快速通道:https://item.jd.com/11524750.html

《R的极客理想-高级开发篇》京东购买快速通道:https://item.jd.com/11731967.html

《数据实践之美》京东购买快速通道:https://item.jd.com/12106224.html


您可能也对以下帖子感兴趣

文章有问题?点此查看未经处理的缓存