scala類和物件

fan_rockrock發表於2016-03-14
物件
  1. //類和物件  
  2. /* 
  3. 1.scala中的類不宣告為public(預設為public) 
  4. 2.一個scala原始檔中可以有多個類 
  5. 3.scala不允許類保護靜態元素，類似的功能是成為"單例物件"的物件 
  6. 4.單例物件使用object關鍵字,單例物件叫做這個物件的伴生物件，相應的類叫做伴生類 
  7. 5.伴生類和伴生物件要放在同一檔案中，可以互相訪問對方的私有成員 
  8. 6、單例物件會在第一次使用的時候初始化一次
  9. 7、使用object的非單例物件叫做獨立物件，通常作為程式的入口
  10. 8.scala使用類引數，scala編譯器會編譯scala類定義包含的任何不屬於類成員和類方法的其他程式碼，這些程式碼作為類的主建構函式 
  11. 9.除主建構函式之外的建構函式都稱為輔助建構函式,使用this(...)來定義輔助建構函式,所有輔助建構函式最終都會呼叫主建構函式 
  12.  
  13. */  
  14. /*import scala.collection.mutable.Map 
  15. object Test{ 
  16.     def main(args:Array[String]){ 
  17.         println(ChecksumAccumulator.calculate("welcome to scala")) 
  18.     } 
  19. } 
  20. //建立一個計算整數累計校驗和的類 
  21. class ChecksumAccumulator{ 
  22.     private var sum=0; 
  23.     def add(b:Byte):Unit=sum+=b 
  24.     def checksum():Int= ~ (sum & 0xFF) + 1 
  25. } 
  26.  
  27. //建立ChecksumAccumulator單例物件 
  28. object ChecksumAccumulator{ 
  29.     private val cache=Map[String,Int]() 
  30.     def calculate(s:String):Int={ 
  31.         if(cache.contains(s)) 
  32.             cache(s) 
  33.         else 
  34.             { 
  35.                 val acc=new ChecksumAccumulator 
  36.                 for(c<-s) 
  37.                     acc.add(c.toByte) 
  38.                 val cs=acc.checksum() 
  39.                 cache +=( s -> cs ) 
  40.                 cs 
  41.             } 
  42.     } 
  43. }*/  
  44.   
  45. /* 
  46. //深入理解伴生物件 
  47. object Companion{ 
  48.     def show=println("I am a companion") 
  49. } 
  50. class Companion{ 
  51.     def shout=Companion.show 
  52. } 
  53. //反編譯Companion.class得到以下內容 
  54. public class Companion extends java.lang.Object implements scala.ScalaObject{ 
  55.     public static final void show() 
  56.     public Companion() 
  57.     public void shout() 
  58. } 
  59. //即伴生物件和它對應的類在位元組碼層面走到了一起，換句話說，在Scala裡面的class和Object在java層面裡面合二為一 
  60. */  
  61.   
  62.   
  63. //下面定義一個有理數的類來介紹scala類定義的幾個特徵：類引數、建構函式、方法、操作符、私有成員、過載、過濾、條件檢查、引用自身  
  64. //有理數定義：n/d，n和d都是整數，d不為0，並且支援有理數的規範表示，如2/10，規範表示為1/5，分子和父母的最小公倍數為1  
  65. /*class Rational(n:Int,d:Int){ //n和d都是類引數，不能使用例項呼叫他們
  66.     println("Created "+n+"/"+d) 
  67. } 
  68. new Rational(1,2)//列印Created 1/2，即編譯器會編譯scala類定義包含的任何不屬於類成員和類方法的其他程式碼，這些程式碼作為類的主建構函式 
  69.  
  70. //重新定義類的toString()方法 
  71. class Rational(n:Int,d:Int){ 
  72.     override def toString()=n+"/"+d 
  73. } 
  74.  
  75. //前提條件檢查:scala會自動載入Predef物件，他有一個require方法，保證傳入建構函式的引數的限制範圍 
  76. class Rational(n:Int,d:Int){ 
  77.     require(d!=0) 
  78.     override def toString()=n+"/"+d 
  79. } 
  80. */  
  81.   
  82. //新增成員變數:需要實現兩個有理數相加的效果  
  83. /*class Rational(n:Int,d:Int){ 
  84.     require(d!=0) 
  85.     val number=n//類成員變數 
  86.     val denom=d//類成員變數 
  87.     override def toString()=n+"/"+d 
  88.     def add(that:Rational):Rational={ 
  89.         new Rational(number*that.denom+that.number*denom,denom*that.denom) 
  90.     } 
  91. } 
  92.  
  93. //自身引用 
  94. def lessThan(that:Rational)={ 
  95.     this.number*that.denom<that.number*this.denom//其中的this可以省略 
  96. } 
  97.  
  98. //輔助建構函式: 這裡如果定義一個整數，就沒必要指明分母，此時整數本身就是一個有理數 
  99. def this(n:Int)=this(n,1) 
  100.  
  101. //私有成員變數和方法:需要求分子和分母的最大公倍數的私有方法gcd，同時使用一個私有變數g來儲存最大公倍數 
  102. class Rational(n:Int,d:Int){ 
  103.     require(d!=0) 
  104.     private val g=gcd(n.abs,d.abs) 
  105.     val number=n/g //類成員變數 
  106.     val denom=d/g //類成員變數 
  107.     def this(n:Int)=this(n,1) 
  108.     override def toString()=n+"/"+d 
  109.     def add(that:Rational):Rational={ 
  110.         new Rational(number*that.denom+that.number*denom,denom*that.denom) 
  111.     } 
  112.     private def gcd(a:Int,b:Int):Int={ 
  113.         if(b==0) a else gcd(b,a%b) 
  114.     } 
  115. } 
  116.  
  117. //定義運算子:之前兩個數的加法可以寫成X.add(Y)或者X add Y，可以定義+，這樣可以直接X+Y 
  118. class Rational(n:Int,d:Int){ 
  119.     require(d!=0) 
  120.     private val g=gcd(n.abs,d.abs) 
  121.     val number=n/g //類成員變數 
  122.     val denom=d/g //類成員變數 
  123.     def this(n:Int)=this(n,1) 
  124.     override def toString()=n+"/"+d 
  125.     def +(that:Rational):Rational={ 
  126.         new Rational(number*that.denom+that.number*denom,denom*that.denom) 
  127.     } 
  128.     def *(that:Rational)={ 
  129.         new Rational(number*that.number,denom*that.denom) 
  130.     } 
  131.     private def gcd(a:Int,b:Int):Int={ 
  132.         if(b==0) a else gcd(b,a%b) 
  133.     } 
  134. }  
  135.  
  136. //方法過載:比如對於Rational物件，+的物件也可以為一個Int物件 
  137. def +(i:Int)=new Rational(number+i*denom,denom) 
  138.  
  139. //隱式型別轉化：上面定義了Rational的加法，並過載了+以支援整數，r+2,當我們需要2+r怎麼辦？這時就需要隱式型別轉化了 
  140. //scala通過implicit def來定義一個隱式型別轉化,對2+r的2進行自動呼叫該方法，把整數轉為Rational資料型別 
  141. implicit def intToRational(x:Int)=new Rational(x)*/   

相關文章