2021-05-15

scala day07

偏函数

package com.gc.scala.day07

/**
 * Author guochao
 * Date 2021/5/15
 */
object Pattern2 {
  def main(args: Array[String]): Unit = {
    val list = List(10, 20, 1, "aa", false)

    /*val r = list.filter(_.isInstanceOf[Int]).map(_.asInstanceOf[Int]).sum
    println(r)*/

    val f: PartialFunction[Any, Int] = new PartialFunction[Any, Int] {
      // 只对返回值是true的那些元素进行处理, 是false的跳过
      override def isDefinedAt(x: Any): Boolean = x match {
        case a: Int  => true
        case _ => false
      }

      // 是true的时候, 交给apply进行处理
      override def apply(v1: Any): Int = v1 match {
        case a : Int => a
      }
    }

    // 等价于 filter + map
    val a =  list.collect(f)
    println(a)

  }
}

/*
偏函数
   偏的意思: 偏爱


 */

package com.gc.scala.day07

/**
 * Author guochao
 * Date 2021/5/15
 */
object Pattern3 {
  def main(args: Array[String]): Unit = {
    val list = List(10, 20, 1, "aa", false)

    val list2 = list.collect({
      case a: Int => a
    })
    println(list2)
  }
}

/*
用一对大括号括起来的一个或多个case语句就是偏函数

偏函数使用的地方很多, 但是大部分情况都是把给他当成一个普通的函数来使用

 */

异常

def main(args: Array[String]): Unit = {

    try {
        var n= 10 / 0
    }catch {
        case ex: ArithmeticException=>{
            // 发生算术异常
            println("发生算术异常")
        }
        case ex: Exception=>{
            // 对异常处理
            println("发生了异常1")
            println("发生了异常2")
        }
    }finally {
        println("finally")
    }
}

1）我们将可疑代码封装在try块中。在try块之后使用了一个catch处理程序来捕获异常。如果发生任何异常，catch处理程序将处理它，程序将不会异常终止。
2）Scala的异常的工作机制和Java一样，但是Scala没有“checked（编译期）”异常，即Scala没有编译异常这个概念，异常都是在运行的时候捕获处理。
3）异常捕捉的机制与其他语言中一样，如果有异常发生，catch子句是按次序捕捉的。因此，在catch子句中，越具体的异常越要靠前，越普遍的异常越靠后，如果把越普遍的异常写在前，把具体的异常写在后，在Scala中也不会报错，但这样是非常不好的编程风格。
4）finally子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作，这点和Java一样。
5）用throw关键字，抛出一个异常对象。所有异常都是Throwable的子类型。throw表达式是有类型的，就是Nothing，因为Nothing是所有类型的子类型，所以throw表达式可以用在需要类型的地方
def test():Nothing = {
throw new Exception(“不对”)
}
6）Scala提供了throws关键字来声明异常。可以使用方法定义声明异常。它向调用者函数提供了此方法可能引发此异常的信息。它有助于调用函数处理并将该代码包含在try-catch块中，以避免程序异常终止。在Scala中，可以使用throws注释来声明异常

def main(args: Array[String]): Unit = {
  	f11()
}

@throws(classOf[NumberFormatException])
def f11()={
  	"abc".toInt
}

package com.gc.scala.day07

import java.io.IOException
import scala.io.StdIn

/**
 * Author guochao
 * Date 2021/5/15 
 */
object ExecptionDemo1 {
  def main(args: Array[String]): Unit = {
    val i = StdIn.readInt()
    if(i == 0) throw new ArithmeticException("除数不能是0")


    try {
      //            var i = 1 / 1
      //            new FileInputStream("aa")

    }catch{
      case e: ArithmeticException =>
        println("发生算术异常")
      case e:Exception =>
        println("运行时异常")
      case _ =>
    }finally {
      //不管有没有异常, 都会走这里
      println("释放资源")
    }
    println("aaa")

    //----
    try{
      foo()
    }catch {
      case e: IOException =>
    }
  }

  @throws(classOf[IOException])
  @throws(classOf[RuntimeException])
  def foo() = {
    println("aaaa")
  }
}

/*
在scala中, 不强制要求必须处理异常

如何处理异常:
    1. 抛出异常类型
        throws 异常类型
    2. try
抛出异常对象:
    throw new 异常对象
java:
    运行时异常
        可以不用提前处理, 将来运行的时候可能会抛异常
    受检异常(checked)
        在编译阶段, 异常必须被处理
            1. try
            2. 抛出异常类型 throws 异常类
 */

泛型

泛型类和泛型函数

package com.gc.scala.day07.generic

/**
 * Author guochao
 * Date 2021/5/15 
 */
object Generic1 {
  def main(args: Array[String]): Unit = {
    val p1 = new Point[Int](10, 20)
    val x = p1.x

    val p2 = Point(11.1, 1)
    val y = p2.y

    val i = p1.dis[String]("10")

  }
}

case class Point[T](x: T, y: T){
  var z:T = x
  def foo():T = x

  def dis[A](a: A) = a
}


/*

1. 泛型类和泛型方法入手

 数据类型参数化

 a: 泛型类
    定义类的时候, 定义泛型, 这个泛型就可以在类的任何的地方使用

    当成一个类型来使用

 b: 泛型方法或者泛型函数
    定义函数的时候, 定义泛型, 这个泛型只能在函数的内部使用


*/

泛型的上下界

package com.gc.scala.day07.generic

/**
 * Author guochao
 * Date 2021/5/15 
 */
case class AA(val age: Int) extends Ordered[AA]{
  override def compare(that: AA): Int = age - that.age
}
object Generic2 {
  def main(args: Array[String]): Unit = {
    val aa = compare(new AA(10), new AA(20))

    println(aa)

  }

  def compare[T <: Ordered[T]](x: T, y: T):T = {
    if(x > y) x
    else y
  }
}
/*
泛型的界定

    泛型的上下界(上下限)

    上限

    上下文界定
    视图界定

下限
 */

上下文界定

package com.gc.scala.day07.generic

/**
 * Author guochao
 * Date 2021/5/15
 */
case class People(age:Int, name: String)
object People{
  implicit val ord: Ordering[People] = new Ordering[People](){
    override def compare(x: People, y: People): Int = x.age - y.age
  }
}

object ContextBound {
  def main(args: Array[String]): Unit = {
    println(max(10, 20))
    println(max("10", "20"))
    println(max(People(10, "a"), People(20, "b")))
  }
  // 让max方法可以比较一个普通的样例类对象


  def max[T: Ordering](x: T, y: T) = {
    // 从冥界召唤隐式值
    val ord = implicitly[Ordering[T]]
    if(ord.gt(x, y)) x
    else y
  }


  /*def max[T](x: T, y: T)(implicit ord: Ordering[T]) = {
      // x < y   | 找一个比较器, 去比较x, y Ordering[T]
      if(ord.gt(x, y)) x
      else y
  }*/
}
/*
上下文界定:
    [T: Ordering]
        表示存在一个隐式值: Ordering[T]

        得用召唤的方式把隐式召唤出来

    等价于: 隐式值 + 隐式参数
上下文:
    环境
 */