scala类和对象

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)*/