- //类和对象
- /*
- 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)*/
scala类和对象
最新推荐文章于 2023-01-12 10:27:47 发布