Scala学习笔记(三)类层级和特质

时间:2021-10-02 15:54:36

无参方法

功能:将方法的定义转换为属性字段的定义;

作用范围:方法中没有参数,并且方法仅能通过读取所包含的对象属性去访问可变状态,而不改变可变状态,就可使用无参方法;

例子:

abstract class Element{
    def texts:String
}

class Sub1Element(text:String) extends Element{
    val texts:String = text
}

object RunApplication{
    def main(args:Array[String]){
        var node:Element = new Sub1Element("Hello World 1");
        println(node.texts);
    }
}

说明:

Scala中仅有两个命名空间:
1、值(字段、方法、包还有单例对象)
2、类型(类和特质名)
正因为字段和方法在同一个命名空间,所以val可重写无参方法;

 

超类构造器的调用

例子:

class Element(text:String){
    println(text);
    def texts:String = text
}

class Sub1Element(text:String) extends Element("Hello World 2"){
    override val texts:String = text
}

object RunApplication{
    def main(args:Array[String]){
        var node:Element = new Sub1Element("Hello World 1");
        println(node.texts);
    }
}

 

override修饰符
1、若子类成员所有重写了父类成员则必须带有该修饰符;
2、若成员实现的是同名的抽象成员时,则该修饰符是可选的;
3、若成员并未重写或实现其它基类里的成员则禁用这个修饰符;

 

final
作用:当某个类的成员不需要被子类重写时,可通过final修饰对应的成员来实现;

 

zip

作用:将两个数组或集合等取出相应的元素生成二元对数组;

例子:

scala> val a = Array[String]("world","world")
a: Array[String] = Array(world, world)

scala> val b = Array[Int](1,2,3,4,5)
b: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val c = a zip b
c: Array[(String, Int)] = Array((world,1), (world,2))

scala> for ((p1,p2) <- c){
     | println(p1+p2)}

world1
world2

说明:

当两个数组中测长度不一致时,zip将舍弃多余的元素;

 

Scala类层级

1、scala中每个类都继承自Any的超类,即所有类都是Any的子类;

2、Nothing是所有其它类的子类;

层级图:

 Scala学习笔记(三)类层级和特质

 

 

==、!=、equals、eq、ne

1、Any类中的等号和不等号方法(==和!=)被声明为final,因此它们不能被子类重写,而实际上==总是与equals相同,!=总是与equals相反,所以子类可以通过重写equals方法来改变==和!=的意义;【适合值类型比较】

2、scala中对值的比较使用==或equals,而对引用的比较使用eq和ne,eq为判别引用是否相等,nq作用与eq相反;【适合引用类型比较】

 

Any有两个子类:AnyVal和AnyRef
1、AnyVal是Scala里每个内建值类(Byte、Short、Char、Int、Long、Float、Double、Boolean、Unit)的父类;
2、值类都被定义为即是抽象的又是final的;
3、AnyRef是scala里所有引用类的基类,在Java平台中对用java.lang.Object的别名,因此Java里面写的类和scala里面写的类都继承自AnyRef;
4、scala类与Java类的不同在于,scala中的类还继承自ScalaObject的特别的记号特质,有提高执行效率的作用,ScalaObject只包含一个方法,名为$tag,在内部使用加速模式匹配;

 

scala.Null

每个引用类的子类(继承自AnyRef),Null不兼容值类型,如:不能把null赋值给整型变量;

例子:

scala> val a:Int = null
<console>:7: error: an expression of type Null is ineligible for implicit conver
sion
       val a:Int = null
                   ^

scala.Nothing

scala的类层级的最低端,它是任何其它类型的的子类;

作用:标明不正常的终止

scala> def error(message:String):Nothing=

     throw new RuntimeException(message)

scala>  def divide(x:Int,y:Int):Int=
     | if (y!=0) x / y else
     | error("can't divide by zero")
warning: there were 1 deprecation warning(s); re-run with -deprecation for detai
ls
divide: (x: Int, y: Int)Int

scala> val b = divide(2,0)
java.lang.RuntimeException: can't divide by zero
  at scala.sys.package$.error(package.scala:27)
  at scala.Predef$.error(Predef.scala:139)
  at .divide(<console>:9)

 

特质
定义:带有具体方法的Java接口

例子:

trait trafunction{
     def showTrait(){println("trafunction")}
}
功能:特质可以声明字段和维护状态值,可以用特质的定义做任何用类定义做的事情;
与类的区别:
1、特质不能有任何参数(构造器的参数);
2、特质的调用是动态绑定的;

extends混入特质
格式:class 类名 extends 特质

特质混入扩展超类的类里
class 类名 extends 基类 with 特质1 with 特质2 ...

例子:

// 特质定义

trait Line{
    def left:Int
    def leftvalue=left+5
    def showLine = println("showTraitLine")
    def showLeft = println("Left is "+left);
}

// 工具类

class Graph(val left:Int) extends Line{
    def showGraph = println(leftvalue)
}

// 程序入口

object TestTrait{
    def main(args:Array[String]){
        val a = new Graph(5);
        a.showLine
        a.showLeft
        a.showGraph
    }
}

说明:

1、在特质Line中定义了left和leftLine两个无参方法,即可将这样的方法看做属性字段处理;

2、类Graph混入特质Line后,根据构造器传入的参数left自动为特质中的无参数方法left赋值(参数化字段),需要注意的是构造器中的参数名,与特质中定义的无参方法名必须同名;

3、特质Line中的left若定义为var运行将出错;

 

Ordered特质

功能:简话类对比较操作的实现;

例子:

class Unit(n:Int) extends Ordered[Unit]{
    def num = n
    def compare(that:Unit) = {
        this.num - this.num
    }
}

//程序入口

object TestUnit{
    def main(args:Array[String]){
        val a = new Unit(5)
        val b = new Unit(9)
        println(a>b)
    }
}

说明:

1、用compare方法替换了所有的比较方法,本质上是Ordered特质利用这个方定义了>、<、>=、<=,所以只需要实现compare那么所有的比较方法就都实现了;

2、compare返回值说明:相等返回0,this小于that返回负数,this大于that返回正数;

 

特质的堆叠

功能:改变类方法的实现,构造所需改造的新类;

例子:

import scala.collection.mutable.ArrayBuffer

abstract class IntQueue{
    def get():Int
    def put(x:Int)
}
class BaseQueue extends IntQueue{
    private val buf = new ArrayBuffer[Int]
    def get() = buf.remove(0)
    def put(x:Int){buf += x}
}
// 特质的定义改变原有方法的实现
trait Doubling extends IntQueue{
    abstract override def put(x:Int){
        super.put(2*x)
    }
}
// 程序入口
object TestApplication{
    def main(args:Array[String]){
        val a = new BaseQueue with Doubling
        a.put(10)
        println(a.get())
    }
}

说明:

1、Doubling特质定义了超类IntQueue,这意味着它只能混入扩展了IntQueue的类中;

2、特质在声明为抽象的方法中有一个super调用,特质里的super调用是动态绑定的,特质Doubling的super调用将直到被混入另一个特质或类之后,有了具体的方法定义才工作;

3、实现堆叠改动的方法必须使用abstract override 标识修饰;

4、在有多个特质混入的情况下,越靠近右侧的特质越先起作用,当调用带混入的类的方法时,最有侧特质的方法首先被调用。若果该方法调用了super,它将调用其左侧特质的方法,以此类推;