Scala增加

Scala

1.trait

• 相当于java中的接口,但比接口的功能要强大
• 与接口不同,可以定义属性和方法的实现
• 可以实现多重继承

package com.shsxt

trait Write {
  val name = "zs"
  val age = 20

  def write(): Unit = {
    println("write....")
  }
}

trait Read {
  val name = "ls"
  val money = 2000
  def read(): Unit ={
    println("reading....")
  }
}
class People extends Write with Read{
  override val name: String = "ww"
}

object Sxt_Trait {
  def main(args: Array[String]): Unit = {
    val people = new People()
    val name=people.name
    println(name)
    people.write()
    people.read()
  }
}

• trait中带方法不实现

package com.shsxt

trait Equal {
  def noEqual(o: Any): Boolean = {
    !equal(o)
  }

  def equal(o: Any): Boolean
}

class Point(xx: Int, yy: Int) extends Equal {
  val x = xx
  val y = yy

  override def equal(o: Any): Boolean = {
    if (o.isInstanceOf[Point]) {
      val point = o.asInstanceOf[Point]
      x == point.x && y == point.y
    } else {
      false
    }
  }
}

object Sxt_Trait2 {
  def main(args: Array[String]): Unit = {
    val point1 = new Point(1, 1)
    val point2 = new Point(1, 2)
    val result: Boolean = point1.equal(point2)
    println(result)
  }
}

2.模式匹配match

• 模式匹配不仅可以匹配值，还可以匹配类型
• 模式匹配中，如果匹配到对应的类型或值，就不再继续往下匹配
• 模式匹配中，都匹配不上时，会匹配到 case _ ，相当于default
• 匹配是将值往上放,类型往下放,防止遗漏

package com.shsxt


object Sxt_Match {
  def main(args: Array[String]): Unit = {
    val tuple = Tuple6(1, 2, 3f, 4, "abc", 55d)
    val tupleIterator = tuple.productIterator
    while (tupleIterator.hasNext) {
      matchTest(tupleIterator.next())
    }

    def matchTest(x: Any) = {
      x match {
        case x: Int => println("type is Int")
        case 1 => println("result is 1")
        case 2 => println("result is 2")
        case 3 => println("result is 3")
        case 4 => println("result is 4")
        case x: String => println("type is String")
        case x :Double => println("type is Double")
        case _ => println("no match")
      }
    }
  }
}

3.偏函数

偏函数定义时，不能使用括号传参，默认定义PartialFunction中传入一个值，匹配上了对应的case,返回一个值，只能匹配同种类型。

 /*
  * 一个函数中只有case 没有match ，可以定义成PartailFunction 偏函数
  */
object Lesson_PartialFunction {
  def MyTest : PartialFunction[String,String] = {
    case "scala" =>{"scala"}
    case "hello"=>{"hello"}
    case _=> {"no  match ..."}
  }
  def main(args: Array[String]): Unit = {
      println(MyTest("scala"))
  }
}

4.样例类

• 使用了case关键字的类定义就是样例类(case class)
• 当构造参数是声明为var类型的，它将帮你实现setter和getter方法
• 默认帮你实现了toString,equals，copy和hashCode等方法
• 样例类创建对象时可以new, 也可以不用new

case class Person1(name:String,age:Int)

object Lesson_CaseClass {
  def main(args: Array[String]): Unit = {
    val p1 = new Person1("zhangsan",10)
    val p2 = Person1("lisi",20)
    val p3 = Person1("wangwu",30)
    
    val list = List(p1,p2,p3)
    list.foreach { x => {
      x match {
        case Person1("zhangsan",10) => println("zhangsan")
        case Person1("lisi",20) => println("lisi")
        case _ => println("no match")
      }
    } }
  }
}

5.隐式转换

当调用方法时，不必手动传入方法中的隐式参数，Scala会自动在作用域范围内寻找隐式值自动传入

• 隐式值和隐式参数

  • 同类型的参数的隐式值只能在作用域内出现一次，同一个作用域内不能定义多个类型一样的隐式值
  • implicit 关键字必须放在隐式参数定义的开头
  • 一个方法只有一个参数是隐式转换参数时，那么可以直接定义implicit关键字修饰的参数，调用时直接创建类型不传入参数即可
  • 一个方法如果有多个参数，要实现部分参数的隐式转换,必须使用柯里化这种方式,隐式关键字出现在后面，只能出现一次

package com.shsxt

/**
  * 隐式转换
  */
object Sxt_Implicit {
  //隐式值,可以给多个隐式参数使用(数据类型一致)..
  implicit  val address="shanghai"
  implicit val age = 100

  //隐式参数
  def test1(implicit name:String)={
    println(name)
  }
  def test3(name:String)(implicit age: Int)={
  println(name+" "+age)
  }
  def main(args: Array[String]): Unit = {
    test1
    test3("ww")
  }
}

• 隐式转换函数

  • 使用关键字implicit修饰的方法叫做隐式转换函数
  • 隐式转换函数只与函数的参数类型和返回类型有关(参数的类型是A,返回类型是B,代表的是A->B,A就有B的功能)

class Animal(name:String){
  def canFly(): Unit ={
    println(s"$name can fly...")
  }
}
class Rabbit(xname:String){
    val name = xname
}
object Lesson_ImplicitFunction {

  implicit def rabbitToAnimal(rabbit:Rabbit):Animal = {
      new Animal(rabbit.name)
  }

  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit("RABBIT")
    rabbit.canFly()
  }
}

• 隐式类

  • 使用implicit关键字修饰的类就是隐式类
  • 隐式类必须定义在类，包对象，伴生对象中
  • 隐式类的构造必须只有一个参数，同一个类，包对象，伴生对象中不能出现同类型构造的隐式类

class Rabbit(s:String){
  val name = s
}

object Lesson_ImplicitClass {

  implicit class Animal(rabbit:Rabbit){
    def canFly() ={
      println(rabbit.name +" can fly...")
    }
  }

  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit("rabbit")
    rabbit.canFly()
  }
}

6.Actor Model(并发与分布式)

• ActorModel是消息传递模型,基本特征就是消息传递
• 消息发送是异步的，非阻塞的
• 消息一旦发送成功，不能修改
• Actor之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的

package com.shsxt

import scala.actors.Actor

class MyActor extends Actor{
  override def act(): Unit = {
    while(true){
      //接收数据
      receive{
        case x:String=>println("match string")
        case _=>println("no match")
      }
    }
  }
}

object Sxt_Actor {
  def main(args: Array[String]): Unit = {
    val actor = new MyActor()
    actor !"hello"
    actor ! 1
    actor.start()

  }
}

• Actor与Actor之间通信

case class Message(actor:Actor,msg:Any)

class Actor1 extends Actor{
  def act(){
    while(true){
      receive{
        case  msg :Message => {
          println("i sava msg! = "+ msg.msg)
          
          msg.actor!"i love you too !"
          }
        case msg :String => println(msg)
        case  _ => println("default msg!")
      }
    }
  }
}

class Actor2(actor :Actor) extends Actor{
  actor ! Message(this,"i love you !")
	def act(){
		while(true){
			receive{
  			case msg :String => {
  			  if(msg.equals("i love you too !")){
  			    println(msg)
  			   actor! "could we have a date !"
  			  }
  			}
  			case  _ => println("default msg!")
			}
		}
	}
}

object Lesson_Actor2 {
  def main(args: Array[String]): Unit = {
    val actor1 = new Actor1()
    actor1.start()
    val actor2 = new Actor2(actor1)
    actor2.start()
  }
}