scala类和对象

//类和对象

/*

1.scala中的类不声明为public(缺省为public)

2.一个scala源文件中可以有多个类

3.scala不允许类保护静态元素，类似的功能是成为"单例对象"的对象

4.单例对象使用object关键字,单例对象叫做这个对象的伴生对象，相应的类叫做伴生类

5.伴生类和伴生对象要放在同一文件中，可以互相访问对方的私有成员

6、单例对象会在第一次使用的时候初始化一次

7、使用object的非单例对象叫做独立对象，通常作为程序的入口

8.scala使用类参数，scala编译器会编译scala类定义包含的任何不属于类成员和类方法的其他代码，这些代码作为类的主构造函数

9.除主构造函数之外的构造函数都称为辅助构造函数,使用this(...)来定义辅助构造函数,所有辅助构造函数最终都会调用主构造函数

*/

/*import scala.collection.mutable.Map

object Test{

def main(args:Array[String]){

println(ChecksumAccumulator.calculate("welcome to scala"))

}

}

//创建一个计算整数累计校验和的类

class ChecksumAccumulator{

private var sum=0;

def add(b:Byte):Unit=sum+=b

def checksum():Int= ~ (sum & 0xFF) + 1

}

//创建ChecksumAccumulator单例对象

object ChecksumAccumulator{

private val cache=Map[String,Int]()

def calculate(s:String):Int={

if(cache.contains(s))

cache(s)

else

{

val acc=new ChecksumAccumulator

for(c<-s)

acc.add(c.toByte)

val cs=acc.checksum()

cache +=( s -> cs )

cs

}

}

}*/

/*

//深入理解伴生对象

object Companion{

def show=println("I am a companion")

}

class Companion{

def shout=Companion.show

}

//反编译Companion.class得到以下内容

public class Companion extends java.lang.Object implements scala.ScalaObject{

public static final void show()

public Companion()

public void shout()

}

//即伴生对象和它对应的类在字节码层面走到了一起，换句话说，在Scala里面的class和Object在java层面里面合二为一

*/

//下面定义一个有理数的类来介绍scala类定义的几个特征：类参数、构造函数、方法、操作符、私有成员、重载、过滤、条件检查、引用自身

//有理数定义：n/d，n和d都是整数，d不为0，并且支持有理数的规范表示，如2/10，规范表示为1/5，分子和父母的最小公倍数为1

/*class Rational(n:Int,d:Int){ //n和d都是类参数，不能使用实例调用他们

println("Created "+n+"/"+d)

}

new Rational(1,2)//打印Created 1/2，即编译器会编译scala类定义包含的任何不属于类成员和类方法的其他代码，这些代码作为类的主构造函数

//重新定义类的toString()方法

class Rational(n:Int,d:Int){

override def toString()=n+"/"+d

}

//前提条件检查:scala会自动加载Predef对象，他有一个require方法，保证传入构造函数的参数的限制范围

class Rational(n:Int,d:Int){

require(d!=0)

override def toString()=n+"/"+d

}

*/

//添加成员变量:需要实现两个有理数相加的效果

/*class Rational(n:Int,d:Int){

require(d!=0)

val number=n//类成员变量

val denom=d//类成员变量

override def toString()=n+"/"+d

def add(that:Rational):Rational={

new Rational(number*that.denom+that.number*denom,denom*that.denom)

}

}

//自身引用

def lessThan(that:Rational)={

this.number*that.denom<that.number*this.denom//其中的this可以省略

}

//辅助构造函数: 这里如果定义一个整数，就没必要指明分母，此时整数本身就是一个有理数

def this(n:Int)=this(n,1)

//私有成员变量和方法:需要求分子和分母的最大公倍数的私有方法gcd，同时使用一个私有变量g来保存最大公倍数

class Rational(n:Int,d:Int){

require(d!=0)

private val g=gcd(n.abs,d.abs)

val number=n/g //类成员变量

val denom=d/g //类成员变量

def this(n:Int)=this(n,1)

override def toString()=n+"/"+d

def add(that:Rational):Rational={

new Rational(number*that.denom+that.number*denom,denom*that.denom)

}

private def gcd(a:Int,b:Int):Int={

if(b==0) a else gcd(b,a%b)

}

}

//定义运算符:之前两个数的加法可以写成X.add(Y)或者X add Y，可以定义+，这样可以直接X+Y

class Rational(n:Int,d:Int){

require(d!=0)

private val g=gcd(n.abs,d.abs)

val number=n/g //类成员变量

val denom=d/g //类成员变量

def this(n:Int)=this(n,1)

override def toString()=n+"/"+d

def +(that:Rational):Rational={

new Rational(number*that.denom+that.number*denom,denom*that.denom)

}

def *(that:Rational)={

new Rational(number*that.number,denom*that.denom)

}

private def gcd(a:Int,b:Int):Int={

if(b==0) a else gcd(b,a%b)

}

}

//方法重载:比如对于Rational对象，+的对象也可以为一个Int对象

def +(i:Int)=new Rational(number+i*denom,denom)

//隐式类型转化：上面定义了Rational的加法，并重载了+以支持整数，r+2,当我们需要2+r怎么办？这时就需要隐式类型转化了

//scala通过implicit def来定义一个隐式类型转化,对2+r的2进行自动调用该方法，把整数转为Rational数据类型

implicit def intToRational(x:Int)=new Rational(x)*/