R語言面向對象編程

面向對象是一種對現實世界理解和抽象的方法，當代碼復雜度增加難以維護的時候，面向對象就會顯得非常重要。我經歷過Java和Javascript兩種語言從面向過程到面向對象思路的改造，并感覺這種變化也會出現在R語言中。在工業界的引導下，R將走向大規則的企業應用，因此面向對象的編程方式將成為R語言的一種非常重要的發展方向，動起來迎接R的進步。
目錄
    什么是面向對象？
    R為什么要進行面向對象編程?
    R的面向對象編程
    與其他語言的對比
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語言的面向對象的編程，其中部分代碼有些不夠嚴謹，本文只希望給大家思路上的認識，更具體的面向對象編程實例，會在以后的文章中進行討論。