scala的Trait和样例类

╰半夏微凉° 2021-12-05 04:59 347阅读 0赞

# scala的Trait和CaseClass #

## Trait ##

注意：

*  1 case \_ 表示什么都匹配不上，放在诸多匹配的最后
 *  2 match 既可以匹配值还可以匹配类型
 *  3 匹配过程中会有数值的转换
 *  4 自上向下匹配，匹配上后向下匹配
 *  5 模式匹配外部的\{\}可以省略

/**
      * 模式匹配
      */
    object Match {
      def main(args: Array[String]): Unit = {
        val tp = (1,1.0,"abc",'D',true)
        val iterator: Iterator[Any] = tp.productIterator
        iterator.foreach(MatchTest)
      }
    
     def MatchTest(o:Any)= {
       o match {
         case 1=> println("value is 1")
         case i:Int=> println(s"类型是Int，$i")
         case d:Double=> println(s"类型是Double $d")
         case _=> println("没有匹配上数据")
       }
     }

## CaseClass样例类 ##

样例类是包括了一些基本方法的类

注意：

*  使用了case关键字定义的类，是特殊的类
 *  实现了构造参数的getter方法，默认是val，可以在参数设置为var
 *  样例类实现了toString equals copy hashCode等方法
 *  可以new,也可以不new
 *  如果样例类中无其他逻辑，可以将\{\}去掉

/**
      * 样例类
      */
     case class Person1(var name:String,age:Int){
    
    }
    
    object CaseClass {
      def main(args: Array[String]): Unit = {
        val p1 = new Person1("zhangsan",age = 18)
        val p2 = new Person1("zhangsan",age = 18)
        println(p1.equals((p2)))

## 隐式转换 ##

隐式值和隐式参数

在调用时不给定值/参数，就会用定义好的值，只是值时隐式的

隐式转换函数

new出的对象通过隐式类型的装换，得到其他类中的方法

隐式类

通过a类得到b类信息

/**
      *隐式值和隐式参数
      */
    object Demo11_Implicit1 {
      //隐式参数  如果有多个值想要隐式参数就采用柯里化方式，将隐式参数写后面
      def sayName(age:Int)(implicit name:String)={
        println(s"$name is a student")
      }
      def main(args: Array[String]): Unit = {
        //隐式值
        implicit val name:String = "zhangsan"
        sayName(18)

**
      * 隐式转换函数
      * 一种作用域内只能定义一种（参数，进出类型）相同类型的，只能存在一个
      */
    class Animal(name:String){
      def canFly()={
        println(s"$name can fly")
      }
    }
    class Rabbit(xname:String){
      val name = xname
    }
    
    object Demo11_Implicit2 {
      implicit def RebbitToAnimal(r:Rabbit)={
        new Animal(r.name)
      }
    
      def main(args: Array[String]): Unit = {
        val rabbit = new Rabbit("rabbit")
        //本身new的Rabbit类没有canFly方法，找进来Rubbit类出去是Animal类的隐式方法
        rabbit.canFly()

/**
      * 隐式类
      * 不能在外部直接定义隐式类
      */
    class Rabbit1(xname:String){
      val name = xname
    }
    object Demo11_Implicit3 {
    
      implicit  class Animal1(r:Rabbit1){
        def showName()={
          println(s"${r.name} is Rabbit...")
        }
      }
    
      def main(args: Array[String]): Unit = {
        val rabbit = new Rabbit1("RABBIT")
        rabbit.showName()
      }

## Actor通信模型 ##

相当于 Java 中的线程，解决了多线程锁的机制，消息队列，异步非阻塞，

特征：

消息传递模型，基本 特征极是消息传递

消息发送是异步的，非阻塞

消息一旦发送成功，不能修改

Actor间传递锁，自己检查消息队列，非阻塞

/**
      * 给Actor发送消息
      */
    class MyActor extends Actor{
      override def act(): Unit = {
        receive{
          case s:String => println(s"$s is String")
          case _=>println("NONE")
        }
      }
    }
    object Actor1 {
      def main(args: Array[String]): Unit = {
        val actor = new MyActor
        actor.start()
    
        actor ! "hi"
      }

import scala.actors.Actor
    /**
      * Actor1之间通信
      */
    case class Msg(actor: Actor,message:String)
    
    class MyActor1 extends Actor{
      override def act(): Unit = {
        while (true){
        receive{
          case msg:Msg=>{
            if ("hello~".equals(msg.message)){
              println(msg.message)
              msg.actor ! "hi~"
            }else if("Could you ?".equals(msg.message)){
              println(msg.message)
              msg.actor !"no..."
            }
          }
          case _=>println("no match")
        }
      }
    }
    }
    class MyActor2(actor: Actor) extends Actor{
      actor ! Msg(this,"hello~")
      override def act(): Unit = {
        while (true){
        receive{
          case s:String =>{
            if ("hi~".equals(s)){
              println(s)
              actor ! Msg(this,"Could you ?")
            }else if ("no...".equals(s)){
              println(s)
              println("...")
            }
          }
          case _=> println("no match")
        }
      }