斗破苍穹续集,大主宰之灵路天蚕土豆

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案

Ruby和Java的基礎(chǔ)語法比較

讓客戶滿意是我們工作的目標(biāo)，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術(shù)通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領(lǐng)域值得信任、有價(jià)值的長期合作伙伴，公司提供的服務(wù)項(xiàng)目有：申請域名、虛擬主機(jī)、營銷軟件、網(wǎng)站建設(shè)、杏花嶺網(wǎng)站維護(hù)、網(wǎng)站推廣。

本文轉(zhuǎn)載自微信公眾號「小二十七」，作者肖斌2 。轉(zhuǎn)載本文請聯(lián)系小二十七公眾號。

前言

這篇文章示例代碼比較多， Java 程序員可以看到一些 Ruby 相關(guān)語法和使用，Ruby 程序員可以看看 Java 的基本語法和使用方法，本文比較長，將近萬字左右，預(yù)計(jì)需要十幾分鐘，如果有耐心讀完文章的話，你將獲得和了解：

Ruby 語言的基本語法和使用方式
Java 語言的基本語法和使用方式
從老司機(jī)的角度分析和講解 Ruby 和 Java 語言語法的特點(diǎn)和區(qū)別
它們的各自適合并且擅長的應(yīng)用場景

網(wǎng)上單獨(dú)介紹 Ruby ，Java 的文章應(yīng)該很多，但是對比兩種編程語言的基本語法使用的文章應(yīng)該不多見，寫這篇文章的目的主要是對自己近期幾個月學(xué)習(xí) Ruby 做總結(jié)和回顧，我之前最熟悉的編程語言是 Java，我個人認(rèn)為合格的程序員應(yīng)該掌握多門語言，多學(xué)一門語言沒有壞處，在解決問題的時(shí)候可以多些思路，在經(jīng)歷最近幾個月的橫向?qū)Ρ群褪褂酶惺埽葤佄覀€人結(jié)論，在個人項(xiàng)目或者小型團(tuán)隊(duì)，技術(shù)能力較強(qiáng)的團(tuán)隊(duì)我推薦使用 Ruby，在團(tuán)隊(duì)需要快速擴(kuò)展和大型項(xiàng)目規(guī)劃的情況下我推薦 Java，因?yàn)榈靡嬗?Java 語法的嚴(yán)謹(jǐn)性和安全性，很大程度上可以保證團(tuán)隊(duì)水平的下限，Java 較強(qiáng)的工程化規(guī)約和代碼類型檢查，可以保證新手不至于寫出破壞性很強(qiáng)的代碼，如果把兩種語言作為一個簡單的比如，最直觀的感受就是可以把 Ruby 和 Java 比做金庸小說里的兩把武器：

Ruby 設(shè)計(jì)精妙，體積小巧靈活迅捷如風(fēng)，就像紫薇軟劍那般鋒芒畢露，使用者可以隨心所欲，不必被太多語法和規(guī)則限制
Java 老成持重，雖然語法和年代較為古板啰嗦，但是卻長年占據(jù) TIOBE 編程語言排行榜第一名，真可謂是重劍無鋒，大巧不工

在很多人的印象中 Ruby 主要是在初創(chuàng)公司會比較流行，例如早期的 Airbnb，GitLab 都是使用 Ruby 作為開發(fā)語言，Ruby 是一門很靈活也很優(yōu)雅的動態(tài)語言，解釋運(yùn)行，有興趣了解的同學(xué)可以點(diǎn)開鏈接查看維基百科的詞條，Ruby 語法精煉，做相同的事情代碼行數(shù)通常會比 Java 要短的多，使用 Ruby 寫程序的的過程是非常舒服的，因?yàn)椴槐鼐心嘤谀切┛贪鍙?qiáng)制的語法規(guī)范，可以讓開發(fā)者隨心所欲的表達(dá)自己的想法，不必強(qiáng)制分號結(jié)尾，不強(qiáng)制中括號，不強(qiáng)制方法參數(shù)長度等語法規(guī)范所限制，這種靈活的表達(dá)方式設(shè)計(jì)體現(xiàn)在語言使用的方方面面，并且如果你是用 Mac OS 則系統(tǒng)天生支持 Ruby 開發(fā)環(huán)境，在 Mac 終端輸入以下命令就可以看到 Ruby 版本號：

 
 
 
 
  
  
  
  ruby -v 
  
  
  
  # ruby 2.6.5p114 (2019-10-01 revision 67812) [x86_64-darwin19]

然后只要在終端里面鍵入 irb 就可以進(jìn)入調(diào)式模式，不像要運(yùn)行 Java 程序首先安裝 JDK 然后再配置環(huán)境變量 JAVA_HOME 和 CLASS_PATH 經(jīng)過繁瑣的配置才勉強(qiáng)可以執(zhí)行 java 命令執(zhí)行 class 程序，在 irb 模式下，對于簡單的邏輯程序可以先在調(diào)式模式將代碼寫出來驗(yàn)證想法的可行后再加入到代碼庫中去，使用起來非常的方便，示例如下：

 
 
 
 
  
  
  
  >irb 
  
  
  
  >2.6.5 :001 > p "hello world" 
  
  
  
  # => "hello world"

下面簡單的寫一個 Hello World 程序進(jìn)行對比，兩種編程語言在打印 HelloWorld 程序上的寫法，示例代碼如下：

 
 
 
 
  
  
  
  // java print 
  
  
  
  public class Main { 
  
  
  
      public static void main(String[] args) { 
  
  
  
          System.out.println("hello world!");   // 注意分號結(jié)尾 
  
  
  
      } 
  
  
  
  }

 
 
 
 
  
  
  
  # ruby print 
  
  
  
  p "hello world!"

通過一個簡單的 Hello World 程序你就可以發(fā)現(xiàn)兩者的明顯區(qū)別：

Ruby 的執(zhí)行是從上到下順序執(zhí)行，main 方法則是 Java 程序的唯一入口
Ruby 不必用 ; 號結(jié)束符，不必使用 {} 聲明代碼塊，函數(shù)式方法傳參甚至不用使用 () (挺有意思)

經(jīng)過以上講解，大家可能會對開始產(chǎn)生一些興趣，不過這僅僅只是開始，后面主要簡單介紹一下 Ruby 常用的對象，條件，循環(huán)，方法，運(yùn)算符，數(shù)值，數(shù)組，字符串，散列等使用方法，本文不算嚴(yán)格意義的文章，因?yàn)槭纠a量占了文章的 50% ，而且本文的特點(diǎn)就是會在語法將 Ruby 和 Java 進(jìn)行對比，不過還是會講解 Ruby 基本語法為主，本文偏入門級水平，介紹的內(nèi)容都是平時(shí)使用比較的多的場景，暫時(shí)不會涉及到例如 Ruby 的 metaprogramming 和 Java 的反射等較為深入的知識點(diǎn)，可能后續(xù)會有單獨(dú)的文章進(jìn)行分析，看完文章應(yīng)該可以用寫一些簡單的程序用于跑一些簡單的腳本應(yīng)該是夠用了，實(shí)際上腳本處理程序也正是 Ruby 很擅長的領(lǐng)域

補(bǔ)充：文章對比 Java，Ruby 兩種語言在語法上的區(qū)別，并不是爭論哪種編程語言的好壞優(yōu)劣，我個人觀點(diǎn)是：編程語言本身沒有好壞之分，只有在不同場景下做出合適的選擇，而且熟悉 Java 的同學(xué)也應(yīng)該明白 Java 的優(yōu)勢從來都不在語言和語法層面，而是在生態(tài)，并發(fā)編程，虛擬機(jī)和穩(wěn)定這些特性才是 Java 的核心競爭力，在生態(tài)上 Spring Framework為代表的高質(zhì)量輪子覆蓋 Java 應(yīng)用的方方面面，可以說在輪子的多樣性上面，暫時(shí)沒有哪種語言可以跟 Java 抗衡，所以如果簡單的用語法概括語言的好壞就非常以偏概全的看法，話不多說，我們進(jìn)入正題，先列一下文章大綱，入門篇只會簡單說一些基本語法：

多重賦值
條件判斷
循環(huán)
方法
類和模塊
運(yùn)算符
異常處理

多重賦值

每個變量單獨(dú)賦值的場景大多相同，就不做介紹，在程序開發(fā)中，我們經(jīng)常會把多個變量同時(shí)賦值，這樣效率會高很多，每種語言對多重賦值的支持都不同，我們先通過一段代碼對比 Java，Ruby 語言對于多重賦值的不同寫法：

 
 
 
 
  
  
  
  // Java 多重賦值 
  
  
  
  int a, b, c = 1, 2, 3;      // compile error 
  
  
  
  int a, long b, short c = 1, 2L, 3;  // complier error 
  
  
  
  int a = 1, b = 2, c =3;     // compile pass

 
 
 
 
  
  
  
  # Ruby 中多重賦值非常輕松 
  
  
  
  a, b, c = 1, 2, 3 
  
  
  
  # => [1, 2, 3] 
  
  
  
   
  
  
  
  # 兼容不同類型 
  
  
  
  a, s, c = 1, "2", 3 
  
  
  
  # => [1, "2", 3] 
  
  
  
       
  
  
  
  # 兼容不同長度 
  
  
  
  a, b, c = 1, 2 
  
  
  
  # => [1, 2, nil] 
  
  
  
  a, b, c, = 1, 2, 3, 4 
  
  
  
  # => [1, 2, 3]  自動裁掉超出的長度

結(jié)合以上案例感覺 Java 對多重賦值不是很友好，很多不合規(guī)范的語法在編譯期就會被攔截并且報(bào)錯，簡單對比后總結(jié)：

Java 因?yàn)閺?qiáng)類型，所以對賦值的比較限制多，例如只能對同類型的變量進(jìn)行簡單的賦值
Ruby 中多重賦值比較輕松，不用考慮類型，長度等問題，過長和過短都不會在編譯時(shí)拋出問題
Ruby 在聲明類型的時(shí)候不需要像 Java 那樣聲明類型，這也是動態(tài)語言的特性，我個人是比較喜歡的

條件判斷

Ruby 的條件判斷主要有以下三種：

if 語句
unless 語句
case 語句

先看實(shí)例和對比代碼：

 
 
 
 
  
  
  
  a, b = 10, 20 
  
  
  
  p "a 比 b 大" if a > b 
  
  
  
  p "a 比 b 小" if a < b 
  
  
  
  # => a 比 b 小 
  
  
  
   
  
  
  
  # unless 條件就不多做介紹，用法剛好與 if 語句相反，類似java中的 != 運(yùn)算符，實(shí)例代碼： 
  
  
  
  a, b = 10, 20 
  
  
  
  p "a 和 b 不相等" unless a == b 
  
  
  
  # => a 和 b 不相等

 
 
 
 
  
  
  
  int a = 10, b = 20; 
  
  
  
  if (a > b) System.out.println("a 比 b 大"); // 在合作項(xiàng)目中還是推薦使用中括號 {} 
  
  
  
  if (a < b) System.out.println("a 比 b 小"); 
  
  
  
  //=> a 比 b 小 
  
  
  
   
  
  
  
  int a = 10, b = 20; 
  
  
  
  if (a != b) System.out.println("a 和 b 不相等"); 
  
  
  
  //=> a 比 b 小

還有 case 語句主要用于多條件進(jìn)行判斷，語句用法是 case~when~end 進(jìn)行組合條件判斷，功能跟 Java 中的 switch 相同，還有邏輯運(yùn)算符 ==, !=, ||, && 都是通用的基本知識，所以就不寫詳細(xì)說明和寫示例代碼了，不然會顯得很啰嗦

總結(jié)：條件判斷語句用法非常簡單，兩種編程語言基本類似語言類似，不過還是有以下區(qū)別：

Ruby 在關(guān)鍵字選擇上多一些，例如 unless 實(shí)際上是替代了運(yùn)算符 !=，也增加了一些可讀性
if 語法基本相似，但 Java 強(qiáng)制表達(dá)式必須使用括號 () ，Ruby則不需要
Ruby 使用 if~then~end 語法標(biāo)記代碼塊，不同于 Java 使用中括號 {} 標(biāo)記代碼塊
Ruby 條件判斷 if/unless 放在代碼后面，程序看上去可以更加緊湊和簡潔

循環(huán)

Ruby 的循環(huán)結(jié)構(gòu)語句比較豐富，相比 Java 只有 for，while 兩種循環(huán)方式來說，Ruby 中的可用的循環(huán)方法有：time，while，each，for，until，loop，不過大多都異曲同工，就不一一介紹了，本章節(jié)主要圍繞平時(shí)常用的幾個需求來做一個簡單的講解，對比兩種語言的使用區(qū)別，具體如下：

如何執(zhí)行一個固定次數(shù)的循環(huán) ?
如何遍歷一個數(shù)組 ?
如何遍歷一個 Hash ?

執(zhí)行固定次數(shù)的循環(huán)是 time循環(huán) 方法的拿手好戲，用于和語句也很簡單，如果不需要下標(biāo)值，|i| 參數(shù)也是可以移除的，示例代碼如下

 
 
 
 
  
  
  
  3.time do |i|  # i 也可以省略 
  
  
  
     p "第#{i}次打印" 
  
  
  
  end 
  
  
  
  # => 第0次打印 
  
  
  
  # => 第1次打印 
  
  
  
  # => 第2次打印

在 Java 中想要執(zhí)行固定長度的循環(huán)，不能通過 forEach只能通過古老的 for..i 來實(shí)現(xiàn)，具體代碼如下：

 
 
 
 
  
  
  
  for (int i = 0; i < 3; i++) { 
  
  
  
      System.out.println("第" + i + "次打印"); 
  
  
  
  } 
  
  
  
  // 第0次打印 
  
  
  
  // 第1次打印 
  
  
  
  // 第2次打印

如何遍歷一個數(shù)組?

在 Ruby 中通常會推薦使用 **each ** 不僅語法簡單，而且可以輕松拿到元素值，示例代碼如下：

 
 
 
 
  
  
  
  ["abc","efg","hmn"].each do |e| 
  
  
  
    p "#{e}!"  
  
  
  
  end 
  
  
  
  #=> abc! dfg! hmn!

Java 在 JDK 8 經(jīng)過 Stream 和 Lambda 語法增強(qiáng)后，遍歷數(shù)組也沒有想象中那么古板，示例代碼：

 
 
 
 
  
  
  
  Arrays.asList("abc", "dfg","hmn").forEach(e ->  
  
  
  
    System.out.println(e + "!") 
  
  
  
  ); 
  
  
  
  // abc! dfg! hmn!

不過在平時(shí)遍歷數(shù)組的時(shí)候經(jīng)常會遇到一種需求，不僅想要拿到數(shù)組的元素，還需要拿到當(dāng)前循環(huán)的索引值，Ruby 中提供一個特別的 each 方式實(shí)現(xiàn)，就是 each_with_index 方法，它會把 [元素, 索引] 傳入到 do 代碼塊的后，具體示例代碼：

 
 
 
 
  
  
  
  ["abc","def","ghi"].each_with_index do |e, i| 
  
  
  
    p "當(dāng)前元素 #{e} , 以及第 #{i} 次循環(huán)" 
  
  
  
  end 
  
  
  
  #=> "當(dāng)前元素 abc , 以及第 0 次循環(huán)" 
  
  
  
  #=> ...

Java 想要實(shí)現(xiàn)相同循環(huán)效果就不能用基于迭代器的 ForEach 實(shí)現(xiàn)了，只能用 for..i 實(shí)現(xiàn)，示例代碼如下：

 
 
 
 
  
  
  
  List list = Arrays.asList("abc", "deg", "ghi"); 
  
  
  
  for (int i = 0; i < list.size(); i++) { 
  
  
  
      String e = list.get(i); 
  
  
  
      System.out.println("當(dāng)前元素" + e + "，以及第 " + i + "次循環(huán)"); 
  
  
  
  } 
  
  
  
  // 當(dāng)前元素abc，以及第 0次循環(huán) 
  
  
  
  // ..

如何遍歷一個 Hash ?

Hash 是 Ruby 的常用的對象，因此循環(huán)遍歷獲取 K，V 也是相當(dāng)方便的，示例代碼：

 
 
 
 
  
  
  
  hash = {name: "apple", age: 15, phone: "15815801580"} 
  
  
  
  hash.each do |k, v| 
  
  
  
   p "key： #{k}， value： #{v}" 
  
  
  
  end 
  
  
  
  #=> key: name, value: apple 
  
  
  
  #=> ...

Java 中最常用的 K-V 結(jié)構(gòu)的 Hash 實(shí)現(xiàn)是基于 Map 接口的 HashMap，它是一種非線程安全的哈希表實(shí)現(xiàn)，之所以常用是因?yàn)樗骖櫟男屎蜁r(shí)間的平衡，內(nèi)部是通過數(shù)組實(shí)現(xiàn)，采用使用鏈表法處理哈希沖突，JDK 8 后又引入紅黑樹解決哈希沖突過多導(dǎo)致鏈表過長的問題，這塊就先不展開講了，不然可以講很久，示例代碼展示 Java 如何遍歷 Hash：

 
 
 
 
  
  
  
  Map hashMap = new HashMap<>(); 
  
  
  
  hashMap.put("name", "apple"); 
  
  
  
  hashMap.put("age", "15"); 
  
  
  
  hashMap.put("phone", "15815801580"); 
  
  
  
   
  
  
  
  for (Map.Entry entry : hashMap.entrySet()) { 
  
  
  
    System.out.println("key :" + entry.getKey() + ", value : " + entry.getValue()); 
  
  
  
  } 
  
  
  
  // key :name, value : apple 
  
  
  
  // ....

Java 遍歷 Hash 的方式還有很多種，我們這里只展示最常用的用法，通過 ForEach 遍歷 entrySet() 返回的集合即可。

最后再說一個有意思的循環(huán)方法，不過使用場景應(yīng)該很少，一個沒有終止的循環(huán) loop方法，因?yàn)闆]有終止條件，所以必須依賴 break 關(guān)鍵字跳出循環(huán)，Java 也可以很輕松實(shí)現(xiàn)這種循環(huán)效果，只是語法上不同而已，我們可以看看以下實(shí)例對比：

 
 
 
 
  
  
  
  // java 使用 while(true) 或者 for(;;) 實(shí)現(xiàn)無限循環(huán) 
  
  
  
  while (true) System.out.println("i use java");

 
 
 
 
  
  
  
  # ruby 無限循環(huán) 
  
  
  
  loop do 
  
  
  
    p "i use ruby" 
  
  
  
  end

如果程序進(jìn)入無限循環(huán)就只能通過 CTRL + C 來終止程序運(yùn)行了總結(jié)：循環(huán)上兩種語言區(qū)別不大，Ruby 雖然循環(huán)方式多，但是平時(shí)常用的也就 each， for 會比較多，在循環(huán)上的區(qū)別，大多只是兩種語言在語法上的區(qū)別

方法

分類

Ruby 中的方法大致可分為 3 類：

實(shí)例方法
類方法
函數(shù)式方法

實(shí)例方法：Ruby 中的實(shí)例方法 Instance method 和 Java 中的普通方法類似，顧名思義就是調(diào)用方必須是一個類的實(shí)例(對象)，需要調(diào)用實(shí)例方法就必須先通過類構(gòu)造一個實(shí)例對象才能進(jìn)行調(diào)用，具體請看示例代碼：

 
 
 
 
  
  
  
  # ruby 中的實(shí)例方法 
  
  
  
   [1, 2, 3] .clear # 清理數(shù)組 =>  [] 
  
  
  
  100.to_s   # int 轉(zhuǎn) string  => "100" 
  
  
  
  "100".to_i  # string 轉(zhuǎn) int => 100 
  
  
  
  ["a", "b", "c"].index("b")  # 查找下標(biāo) => result: 1

 
 
 
 
  
  
  
  // java 中的實(shí)例方法 
  
  
  
  StringBuilder stringBuilder = new StringBuilder(); 
  
  
  
  stringBuilder.append("abc");  // 實(shí)例方法 append 
  
  
  
  stringBuilder.append("efg"); 
  
  
  
   
  
  
  
  List strList = new ArrayList<>(); 
  
  
  
  strList.add("abc");  // 實(shí)例方法 add 
  
  
  
  strList.add("efg");

類方法：Ruby 的類方法 class method 可以理解為 Java 的靜態(tài)方法，就是需要類對象作為接收方的方法，指無需構(gòu)建類的對象即可以直接通過類調(diào)用其自身的方法，大多常見于工具類當(dāng)中，請看示例代碼：

 
 
 
 
  
  
  
  // java 中的靜態(tài)方法 
  
  
  
  Arrays.asList(T...a)    // 數(shù)組轉(zhuǎn)集合 
  
  
  
  Executors.newCachedThreadPool()  // 創(chuàng)建線程池

 
 
 
 
  
  
  
  # ruby 中的類方法 
  
  
  
  Hash.new  # 創(chuàng)建散列對象 
  
  
  
  Time.new  # 創(chuàng)建時(shí)間對象

函數(shù)方法是指沒有接收者的方法，這種類型方法在Java中倒是不存在，參考示例代碼，例如上文中函數(shù)方法 p

 
 
 
 
  
  
  
  p "hello" 
  
  
  
  puts "print words"

定義實(shí)例方法

Ruby 定義方法非常簡單，沒有 Java 那么多的格式規(guī)范：修飾符:靜態(tài)聲明:返回值:方法名:(參數(shù)...)，在方法聲明的形式上要簡單許多，主要通過 def 關(guān)鍵字定義，具體參考示例代碼：

 
 
 
 
  
  
  
  // java define method 
  
  
  
  public static int add(int x, int y) { 
  
  
  
     return x * y 
  
  
  
  } 
  
  
  
  add(2, 5) 
  
  
  
  // 10

 
 
 
 
  
  
  
  # ruby define method  
  
  
  
  def add(x, y) 
  
  
  
      x * y 
  
  
  
  end  
  
  
  
   
  
  
  
  add(2, 5) 
  
  
  
  #=> 10 
  
  
  
   
  
  
  
  # 帶默認(rèn)值的方法 
  
  
  
  def add(x=2, y=6) 
  
  
  
      x * y 
  
  
  
  end 
  
  
  
   
  
  
  
  # 省略參數(shù)使用默認(rèn)值調(diào)用方法 
  
  
  
  add 
  
  
  
  #=> 12 
  
  
  
   
  
  
  
  # 指定參數(shù)的方法 
  
  
  
  add(2, 5) 
  
  
  
  #=> 10

在方法的命名規(guī)則，兩種語言還有如下區(qū)別：

Ruby 方法名可由英文字母，數(shù)字，下劃線組成，但不能以數(shù)字開頭，例如 hello_with_name
Java 方法名首字母必須由英文小寫開頭，英文格式遵循駝峰原則，不允許出現(xiàn)連接符，例如 addPerson

返回值return：上面的 ruby 方法并沒有聲明 return 語句也可以拿到返回值，并不代表 ruby 沒有 return 關(guān)鍵字，ruby 有一個特點(diǎn)就是如果沒有聲明 return 語句那么方法最后一個表達(dá)式會成為方法的返回值遵循這個約定所以上述的方法就可以省略 return 關(guān)鍵字，所以在日常開發(fā)中會較少的使用 return 關(guān)鍵字

定義類方法

前面講過 Ruby 的類方法實(shí)際上就等于 Java 的靜態(tài)方法，Ruby 中定義類方法的示例代碼：

 
 
 
 
  
  
  
  # ruby 定義類方法 
  
  
  
  class Hello 
  
  
  
   
  
  
  
   # class << self 定義類方法的一種方式 
  
  
  
   class << self 
  
  
  
    def say_morning 
  
  
  
     p "hello good morning" 
  
  
  
    end 
  
  
  
   
  
  
  
   #... class << self 塊后面還可以定義多個類方法 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  Hello.say_morning  # 類方法 
  
  
  
  #=> "hello good morning" 
  
  
  
     
  
  
  
  h = Hello.new 
  
  
  
  h.say_morning  # 如果用實(shí)例對象類方法就會報(bào)錯！undefined method 'say_morning'

在 Java 中定義靜態(tài)方法的示例：

 
 
 
 
  
  
  
  public class Hello { 
  
  
  
   
  
  
  
      public static void sayMorning() { 
  
  
  
          System.out.println("hello good morning"); 
  
  
  
      } 
  
  
  
   
  
  
  
      public static void main(String[] args) { 
  
  
  
          Hello.sayMorning(); 
  
  
  
      } 
  
  
  
  } 
  
  
  
   
  
  
  
  #=> "hello good morning"

定義方法也都是很簡單的知識點(diǎn)，通過以上程序，我們可以得出：

Ruby 使用 class << self 或者 class << 類名可以將代碼塊內(nèi)的方法全部聲明為類方法
Java 使用 static 修飾符定義靜態(tài)方法，不能定義塊，我想可能因?yàn)橐?guī)范和可讀性的原因

Ruby 的特點(diǎn)是特定的功能都可以有N種不同的方式實(shí)現(xiàn)，所以定義類方法不但只有 class << self ~ end 還可以使用 def class_name.method_name ~ end 這種形式定義 class_name 是類名，method_name 為方法名，如果是在當(dāng)前 class 上下文中可以像示例代碼用同樣的形式 def self.method_name ~ end 定義類方法

方法參數(shù)

默認(rèn)參數(shù) Rudy 的方法默認(rèn)參數(shù)是我個人比較喜歡的特性，Java 程序里方法參數(shù)是強(qiáng)類型檢查的，就是必須按照參數(shù)定義的類型進(jìn)行傳參，JDK 1.5 后 Java 也出了可變參的特性，不過因?yàn)閷?shí)現(xiàn)效果不是很理性，目前在主流 Java 開發(fā)規(guī)范中還是不被推薦使用的，我們先看一段 Java 定義參數(shù)和使用參數(shù)的示例代碼：

 
 
 
 
  
  
  
  // 方法要求類型，順序，并且必傳 
  
  
  
  public void show(String name, int age, String address) { 
  
  
  
      System.out.println(name + ", " + age + ", " + address); 
  
  
  
  } 
  
  
  
   
  
  
  
  //  new Person().show("胖大海");          // 編譯出錯，參數(shù)不符合要求 
  
  
  
  // new Person().show("胖大海", 19);          // 編譯出錯，參數(shù)不符合要求 
  
  
  
    new Person().show("胖大海", 19, "北京朝陽區(qū)");     // 編譯通過輸出：胖大海, 19, 北京朝陽區(qū)

Ruby 則會靈活一些，具體請看示例代碼：

 
 
 
 
  
  
  
  # 無需聲明類型，帶默認(rèn)值的參數(shù)可不傳 
  
  
  
   def show(name, age=18, address="北京市") 
  
  
  
    p "#{name}, #{age}, #{address}" 
  
  
  
   end 
  
  
  
   
  
  
  
  Person.new.show("胖胖")  #=> 輸出：胖胖, 18, 北京市

不過對于可變參數(shù)兩種語言的實(shí)現(xiàn)幾乎相同，形式上都是對參數(shù)進(jìn)行特殊標(biāo)記，Java 是通過在參數(shù)前面加...標(biāo)識，ruby 則在參數(shù)前面使用 * 號標(biāo)識，解釋器會對這種語法用數(shù)組進(jìn)行轉(zhuǎn)換，兩者代碼量也差不多，沒有什么差別，簡單看下示例代碼：

 
 
 
 
  
  
  
   public void names(String ...names) { 
  
  
  
          System.out.println("params :" + Arrays.toString(names)); 
  
  
  
      } 
  
  
  
   
  
  
  
      new Person().names("java", "ruby", "go", "c++");  
  
  
  
  // 輸出結(jié)果 ：params :[java, ruby, go, c++]

 
 
 
 
  
  
  
   def names(*names) 
  
  
  
    p "params: #{names}" 
  
  
  
   end 
  
  
  
   
  
  
  
  Person.new.names("java", "ruby", "go", "c++") 
  
  
  
  # 輸出結(jié)果：params: [\"java\", \"ruby\", \"go\", \"c++\"]

簡單通過 2 段代碼的對比，我們可以對兩種語言的方法參數(shù)得出以下結(jié)論：

Java 方法會嚴(yán)格按照定義，強(qiáng)制要求類型，值必傳，否則編譯期會報(bào)錯，并且無法在聲明時(shí)定義參數(shù)的默認(rèn)值
Ruby 方法參數(shù)未設(shè)定默認(rèn)值，不傳參數(shù)，只會在執(zhí)行期報(bào)錯，但如果聲明時(shí)定義參數(shù)默認(rèn)值，則參數(shù)可不傳
Ruby 方法參數(shù)無需定義類型，動態(tài)語言的類型大多是推斷出來的
可變參數(shù)兩者實(shí)現(xiàn)方式相同，Java 通過類型...names 實(shí)現(xiàn)，Ruby 通過 *names 語義實(shí)現(xiàn)

方法的基本使用大概就講到這里，函數(shù)方法定義平時(shí)使用不多就暫時(shí)先不聊，繼續(xù)了解還可以看看：定義帶塊的方法，關(guān)鍵字參數(shù)等都是一些語法糖，就不詳細(xì)講解了，接下來聊聊類和模塊

類和模塊

類

Ruby 也是通過 class 關(guān)鍵字定義類，簡單的用法參考以下代碼：

 
 
 
 
  
  
  
  class Hello 
  
  
  
  end 
  
  
  
   
  
  
  
  h = Hello.new

Java 也是通過 class 定義類，不同的是最外層的類 Java 必須使用 public 進(jìn)行修飾，具體請看示例代碼：

 
 
 
 
  
  
  
  public class Hello { 
  
  
  
   
  
  
  
      public static void main(String[] args) { 
  
  
  
          Hello h = new Hello(); 
  
  
  
      } 
  
  
  
  }

那么 Ruby 和 Java 在定義類方面有什么區(qū)別?

Ruby 類只有 initialize 構(gòu)造函數(shù)，Java 可以根據(jù)參數(shù)不同定義不同的構(gòu)造函數(shù)，Java 構(gòu)造函數(shù)必須于類名相同
Ruby 和 Java 在類的命名規(guī)則上是一致的，類名必須是首字母大寫開頭
Java 通過 public class 修飾類(內(nèi)部類通過 class 修飾)，Ruby 則通過 class 修飾類
Java 類名必須與文件名相同，Ruby 的文件名和類名不要求強(qiáng)制關(guān)聯(lián)

兩種編程語言在構(gòu)造函數(shù)上對比的示例代碼：

 
 
 
 
  
  
  
  # 帶構(gòu)造函數(shù)的 Ruby 類 
  
  
  
  class Hello 
  
  
  
   def initialize(name="Ruby") # 默認(rèn)參數(shù) 
  
  
  
    @name = name 
  
  
  
   end 
  
  
  
   
  
  
  
   def say_hello  # 實(shí)例方法 
  
  
  
    p "hello #{@name} ! how are you?" 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  h = Hello.new("james") 
  
  
  
  h.say_hello 
  
  
  
  #=> "hello james ! how are you?" 
  
  
  
  // 帶構(gòu)造函數(shù)的 java 類 
  
  
  
  public class Hello { 
  
  
  
   
  
  
  
      private String name; 
  
  
  
   
  
  
  
     // 有參構(gòu)造函數(shù) 
  
  
  
      public Hello(String youName) { 
  
  
  
          this.name = youName; 
  
  
  
      } 
  
  
  
   
  
  
  
      public void sayHello() { 
  
  
  
          System.out.println("hello! " +name+ " how are you ?"); 
  
  
  
      } 
  
  
  
   
  
  
  
      public static void main(String[] args) { 
  
  
  
          Hello h = new Hello("jack"); 
  
  
  
          h.sayHello(); 
  
  
  
      } 
  
  
  
  } 
  
  
  
  #=> "hello! jack how are you ?"

方法聊到這里，下來聊聊方法里的常量

常量對比

如果在 Java 和 Ruby 中定義常量，參考示例代碼：

 
 
 
 
  
  
  
  // Java 中定義常量 
  
  
  
  public class Hello { 
  
  
  
    // 常量必須是 static final 修飾，代表不可變 
  
  
  
      public static final String VERSION = "1.0"; 
  
  
  
   
  
  
  
      public static void main(String[] args) { 
  
  
  
         // Hello.VERSION = "1.5";    // 嘗試修改則會在編譯期報(bào)錯 
  
  
  
          System.out.println(Hello.VERSION); 
  
  
  
      } 
  
  
  
  } 
  
  
  
  #=>"1.0" 
  
  
  
  # Ruby 中定義常量 
  
  
  
  class PhoneNumber 
  
  
  
   BeiJing = "020" 
  
  
  
   GuangZhou = "021" 
  
  
  
  end 
  
  
  
   
  
  
  
  p PhoneNumber::BeiJing  #=> "020" 
  
  
  
  p PhoneNumber::GuangZhou  #=> "021" 
  
  
  
   
  
  
  
  Phonenumber::BeijING = "303"  #=> Ruby 可以修改常量，不會報(bào)錯，但會提示警告 
  
  
  
   
  
  
  
  p PhoneNumber.Beijing  #=> ERROR undefined method !

在定義常量上的區(qū)別：

命名規(guī)則：Ruby 要求常量首字母大寫，可用駝峰也可全大寫，Java 則要求常量全部大寫，并且必須是 final static 修飾(Java 里的 final 代表不可變，可以聲明類，方法和變量)
調(diào)用方式：Ruby 必須使用 :: 通過類名進(jìn)行外部訪問常量，java 把常量只是當(dāng)成普通的局部變量，使用連接符 . 直接訪問即可
修改變量：Java 不允許修改常量，任何修改的動作會讓編譯器報(bào)錯 Connot assign a value to final variable 并且無法通過編譯，Ruby 則不同，允許修改常量，但解釋器會提示警告信息：warning: already initialized constant

訪問級別

Ruby 和 Java 在方法訪問級別上沒有什么很大不同，只是 Ruby 沒有包(Package)的概念，所有自然也就沒有 Java 里面的包訪問權(quán)限，細(xì)節(jié)上但是還有些許區(qū)別，Ruby 的三種訪問級別的定義方法，具體用法直接看示例代碼：

 
 
 
 
  
  
  
  # 定義方法時(shí)聲明訪問權(quán)限 
  
  
  
   private def call_v1 
  
  
  
    p "call_v1 is private" 
  
  
  
   end 
  
  
  
   
  
  
  
   # 定義方法后，再設(shè)定訪問權(quán)限 
  
  
  
   def call_v2 
  
  
  
    p "call_v2 is private" 
  
  
  
   end 
  
  
  
   
  
  
  
   private :call_v2  # 設(shè)定 call_v2 為 private 
  
  
  
   
  
  
  
   # 對代碼塊設(shè)定， 以下的方法定義為 private  
  
  
  
   private 
  
  
  
   def call_v3 
  
  
  
    p "call_v3 is private" 
  
  
  
   end 
  
  
  
   
  
  
  
   def call_v3 
  
  
  
    p "call_v4 is private" 
  
  
  
   end

Java 設(shè)定方法訪問級別的方式則比較單一，只能在定義時(shí)聲明：

 
 
 
 
  
  
  
  private String priv() { 
  
  
  
         return "priv is private"; 
  
  
  
     }

綜上所述，兩種語言在訪問級別的差異和總結(jié)：

Java 方法默認(rèn)修飾符是包訪問權(quán)限

Ruby 方法默認(rèn)訪問級別是 public(initialize 例外)

Java 方法只能在定義的時(shí)候使用關(guān)鍵字設(shè)定訪問級別

Ruby 常用的則有三種方式可以設(shè)定方法的訪問級別，非常靈活

繼承

Ruby 和 Java 的所有類都是基于 Object 的子類，Ruby 則還有更加輕量級的 BasicObject原始類，這里先不詳細(xì)描述，繼承這個概念也不多說，面向?qū)ο蟮幕A(chǔ)知識，直接先看兩種語言實(shí)現(xiàn)繼承的方式

Ruby 通過 < 父類名實(shí)現(xiàn)繼承，示例代碼：

 
 
 
 
  
  
  
  class Car 
  
  
  
   def drive 
  
  
  
    p "car start.." 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  class SuperCar < Car 
  
  
  
   def speed_up 
  
  
  
    p "speed to 200km ..." 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  s = SuperCar.new 
  
  
  
  s.drive 
  
  
  
  s.speed_up 
  
  
  
   
  
  
  
  #=> "car start.." 
  
  
  
  #=> "speed to 200km ..."

Java 通過 extends實(shí)現(xiàn)繼承的，示例代碼：

 
 
 
 
  
  
  
  class Car { 
  
  
  
      void drive(){ 
  
  
  
          System.out.println("Car Start ..."); 
  
  
  
      } 
  
  
  
  } 
  
  
  
   
  
  
  
  public class SuperCar extends Car { 
  
  
  
   
  
  
  
      void speedUp() { 
  
  
  
          System.out.println("speed to 200km..."); 
  
  
  
      } 
  
  
  
   
  
  
  
      public static void main(String[] args) { 
  
  
  
          SuperCar c = new SuperCar(); 
  
  
  
          c.drive(); 
  
  
  
          c.speedUp(); 
  
  
  
      } 
  
  
  
  } 
  
  
  
  // Car Start ... 
  
  
  
  // speed to 200km...

關(guān)于類的繼承方面我們可以得出以下總結(jié)：

Ruby 通過 < 實(shí)現(xiàn)繼承， Java 通過 extends 關(guān)鍵字實(shí)現(xiàn)繼承
Ruby ，Java 在類沒有指定父類的情況下都默認(rèn)繼承 Object類

關(guān)于繼承還有一些經(jīng)驗(yàn)分享的就是，繼承的特性更多用于重寫父類和多態(tài)，如果是想要復(fù)用公共的功能，但是類之類沒有明顯的繼承關(guān)系的話，就應(yīng)該遵循組合優(yōu)先大于繼承的原則，不過在 Ruby 中很好的通過 Mix-in 擴(kuò)展解決的繼承這個問題

模塊和Mix-in

模塊使用 module 關(guān)鍵字創(chuàng)建，命名規(guī)則和類一樣，首字母必須大寫，我們先來看看如何創(chuàng)建模塊

 
 
 
 
  
  
  
  module Display 
  
  
  
   def open 
  
  
  
    p "open display..." 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  Display.open # private method `open' called for Display:Module (NoMethodError)

模塊是 Ruby 的特色功能，定位也很明確，有以下幾個特點(diǎn)：

不能擁有實(shí)例，不能被繼承，所以模塊定位清晰，僅僅表示事物的通用行為
函數(shù)僅僅只能在內(nèi)部被調(diào)用，除非使用 module_function 聲明模塊函數(shù)
模塊更多是結(jié)合 Mix-in 和 include 使用，為類提供增強(qiáng)和更多的可能性

Ruby 中的模塊提供的命名空間 namespace 概念就跟 Java 的包(Package)類似，都是用于區(qū)分相同的類，常量，Mix-in 結(jié)合 include 也就類似 Java 里面的靜態(tài)導(dǎo)入，在 Java 中 import static 可以無需聲明包路徑直接調(diào)用導(dǎo)入類的變量和方法，所謂的 Mix-in 就是利用模塊的抽象能力把非繼承關(guān)系的類之間的共性進(jìn)行抽象和復(fù)用，有些類似 AOP 的概念，可以使代碼既強(qiáng)大又靈活

當(dāng)我們用 OOP 思想對現(xiàn)實(shí)進(jìn)行抽象的時(shí)候，會發(fā)現(xiàn)很多非繼承關(guān)系又存在共同功能的事物，例如智能手機(jī)，手表繼承自不同的父類，但是他們又都有看時(shí)間 watch_time的能力，我們用代碼展現(xiàn)這種繼承關(guān)系，請看示例代碼：

 
 
 
 
  
  
  
  class Phone 
  
  
  
   def call 
  
  
  
    p "phone call.." 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  class IPhone < Phone 
  
  
  
   # iPhone 繼承自 Phone 類，但是不僅可以打電話，還可以看時(shí)間 
  
  
  
   def watch_time 
  
  
  
    p "watch_time 12:00:000" 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  class Watch 
  
  
  
   # 手表都可以看時(shí)間 
  
  
  
   def watch_time 
  
  
  
    p "watch_time 12:00:000" 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  class AppleWatch < Watch 
  
  
  
   # AppleWatch 不僅看時(shí)間，還有運(yùn)動的功能 
  
  
  
   def run 
  
  
  
    p "start run" 
  
  
  
   end 
  
  
  
  end

結(jié)合上面的代碼，我們可以看到 watch_time 代碼重復(fù)，對于不同繼承體系但是相同功能的時(shí)候，就可以用 Mix-in 解決這個問題，思路如下：

將例如 watch_time 相同的方法和代碼，抽出定義在 module 模塊中
使用 include 引入模塊，將方法引入到實(shí)際的類中

使用 Mix-in 后我們可以看下代碼變化，示例代碼：

 
 
 
 
  
  
  
  module WatchTime 
  
  
  
   # 抽出通用的方法 
  
  
  
   def watch_time 
  
  
  
    p "watch_time 12:00:000" 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  class Phone 
  
  
  
   def call 
  
  
  
    p "phone call.." 
  
  
  
   end 
  
  
  
  end 
  
  
  
   
  
  
  
  class IPhone < Phone 
  
  
  
   include WatchTime 
  
  
  
  end 
  
  
  
   
  
  
  
  class Watch 
  
  
  
   include WatchTime 
  
  
  
  end 
  
  
  
   
  
  
  
  class Apple_watch < Watch 
  
  
  
   # apple_watch 不僅看時(shí)間，還可以運(yùn)動 
  
  
  
   def run 
  
  
  
    p "start run" 
  
  
  
   end 
  
  
  
  end

使用 Mix-in 這種靈活的語法實(shí)現(xiàn)了魚和熊掌兼得，即沒有破壞繼承結(jié)構(gòu)關(guān)系又實(shí)現(xiàn)共性方法的代碼復(fù)用問題，因?yàn)?Java 沒有 Mix-in 的概念所以就不展示示例代碼了，不過 Java 也有自己的解決方案，而且在 Java 的解決代碼復(fù)用問題通常都應(yīng)該遵循組合大于繼承的原則，因?yàn)?Java 的語言設(shè)計(jì)讓繼承更多用于多態(tài)而非復(fù)用

運(yùn)算符

簡單說一下運(yùn)算符，雖然大多編程語言的運(yùn)算符非常的簡單，賦值運(yùn)算，邏輯運(yùn)算，條件運(yùn)算符所有語言的使用方式都幾乎差不多，好像沒什么好講的，但 Ruby 靈活的語法是有不少語法糖，還是可以 Java 程序員羨慕的一下的，假設(shè)一張我們在業(yè)務(wù)代碼中經(jīng)常遇到的情況，根據(jù)表達(dá)式取值，當(dāng)表達(dá)式為 true 時(shí)改變變量的值，這種簡單邏輯賦值在 Java 只能這樣寫，請看示例代碼

 
 
 
 
  
  
  
  String value = "abc"; 
  
  
  
  if (condition != null) { 
  
  
  
    value = condition; 
  
  
  
  } 
  
  
  
  // 看上去很啰嗦

這種情況在 Ruby 中一行代碼可以實(shí)現(xiàn)相同語義：

 
 
 
 
  
  
  
  # 當(dāng) condition 表達(dá)式為 true 執(zhí)行 value = condition ， 否則執(zhí)行 value = "abc" 
  
  
  
  value = condition || "abc"

只所以可以實(shí)現(xiàn)是因?yàn)?Ruby 有一個不同 Java 的特定， Ruby 對象都可以用于進(jìn)行布爾表達(dá)式判斷，判斷邏輯為**對象本身不為 nil 或者 false 表達(dá)式則為 true，否則為 false **

還有一種邏輯則是取相反的情況，例如我們經(jīng)常遇到一種情況是，判斷數(shù)組不為空的時(shí)候取數(shù)組的某一個下標(biāo)，在 Java 中只能這樣寫，示例代碼

 
 
 
 
  
  
  
  List list = Arrays.asList("a", "b", "c"); 
  
  
  
  String item = null; 
  
  
  
  if (list != null) { 
  
  
  
          item = list.get(0); 
  
  
  
  } 
  
  
  
  // "a"

這種情況可以用邏輯運(yùn)算符 &&，它剛好與上面 || 相反，也是一行代碼可以實(shí)現(xiàn)相同功能

 
 
 
 
  
  
  
  str_list = ["a", "b", "c"] 
  
  
  
  item = str_list && str_list[0] 
  
  
  
  #=> "a"

我個人非常喜歡這種簡潔的寫法，不過建議在多人項(xiàng)目中不要用太多語法糖，不然可能會造成項(xiàng)目代碼可讀性混亂

異常處理

很多程序員大部分時(shí)間都花在查錯上，所以迅速定位異常很關(guān)鍵，先看看 Ruby 的異常格式文件名:行號:in 方法名:錯誤信息(異常類名) 簡單的用法就不寫示例代碼了，不然占用太多篇幅，兩種語言處理異常方法大同小異，具體處理方式有如下區(qū)別：

Ruby 處理異常使用 begin ~ rescue ~ ensure ~ end 這里太簡單就不寫示例代碼了
Java 7 使用 try ~ catch ~ finally 到 Java 8 后有了更高效的 try ~ with ~ resources 可自動關(guān)閉資源

不過 Ruby 的 Retry 倒是 Java 沒有的特性，它適合對一些容易出錯的程序(例如調(diào)用外部 API )可以進(jìn)行快速重試，具體可以請看示例代碼

 
 
 
 
  
  
  
  class HandleException 
  
  
  
   def zero 
  
  
  
    x, y = 100, 0 
  
  
  
    begin 
  
  
  
     x = x / y 
  
  
  
    rescue 
  
  
  
     p '執(zhí)行異常邏輯' 
  
  
  
     y = 2 
  
  
  
     retry 
  
  
  
    end 
  
  
  
    x 
  
  
  
   end
                                                當(dāng)前名稱：Ruby和Java的基礎(chǔ)語法比較                                                

                                                本文網(wǎng)址：http://m.fisionsoft.com.cn/article/dhdiiji.html

新聞中心

其他資訊