Scala异常处理、隐式转换、泛型、协变和逆变、上下限

目录

Scala异常处理

 隐式转换

泛型、协变和逆变、上下限 

---

Scala异常处理

package chapter09plus

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

    try{
      val n =10 /0 //被除数为0

    }catch {
      case e:ArithmeticException => {
        println("发生算数异常")
      }
      case e:Exception=>{
        println("发生一般异常")
      }
    }finally {
      println("处理结束")

    }

  }

}

 隐式转换

package chapter09plus
//隐式转换
object Test02_Implicit {
  def main(args: Array[String]): Unit = {

    val new12=new MyRichInt(12)
    println(new12.myMax(15))

//    1.隐式函数
    implicit def convert(num:Int):MyRichInt=new MyRichInt(num)
    //Int 转换成MyRichInt
    //将val new12=new MyRichInt(12)转换成通用操作
    println(new12.myMax(15)) //需要在隐式函数定义后

    println("-------------------------------------------------")

    //2.隐式类 不能放在最顶级的空间里面 当前某个对象或者类的内部
    implicit class MyRichInt2(val self:Int){
      def myMax2(n:Int):Int =if (n<self) self else n
      def myMin2(n:Int):Int =if (n<self) n else self


    }
    println(12.myMin2(15)) //需要在隐式函数定义后

    println("-------------------------------------------------")

    //3.隐式参数 可以不传参 让编译器在作用域或者上下文内 去寻找对应的隐式值直接传入
    implicit val str:String="alice"
//    implicit val str:String="bob"  //在同一作用范围内 相同类型的隐式值只能有一个
    implicit val num:Int=18

    def sayHello()(implicit name:String):Unit={
      println("hello " +name)
    }
    def sayHi(implicit name:String="bob"):Unit={ //隐式值会覆盖掉默认值的定义
      println("hi "+name)
    }

    sayHello()
    sayHi
    println("------------------------------------")


    //简便写法
//    def hiAge(implicit age:Int):Unit={
//      println("hi," +age)
//    }
//    hiAge

    def hiAge():Unit={
      println("hi," +implicitly[Int])
    }
    hiAge()




  }

}

//自定义类
class MyRichInt(val self:Int){
  def myMax(n:Int):Int =if (n<self) self else n
  def myMin(n:Int):Int =if (n<self) n else self
}

package aa.bb
import aa.bb.Impliciteg._
//加入类名 隐式包含了方法
class ImplicitDemo{

}

object ImplicitDemo {


  //调用含有隐式参数的方法时，传值 > 隐式参数 >默认值
  def sum(a:Int)(implicit b:Int=5,str:String):Int={
    var sum=a+b
    println(str+sum)
    sum

  }
  val a:Int="3"
  val b:String=4

  val c:Double="3.5"





  def main(args: Array[String]): Unit = {
    val i=sum(10)(2,"kkk")
    println(i)

    val sumValue=sum(a)
    println(sumValue)

    val demo = new ImplicitDemo
    val jiResult=demo.ji(10,20)
    println(jiResult)


    val stra=demo.madeString("kb15")
    println(stra)



  }

}

泛型、协变和逆变、上下限 

package chapter09plus
//泛型
object Test03_Generics {
  def main(args: Array[String]): Unit = {

    //1.协变和逆变
    val child:Parent=new Child
//    val childList:MyCollection[Parent]=new MyCollection[Child]  //协变 帮助实现集合也符合继承关系
    val childList:MyCollection[SubChild]=new MyCollection[Child]


    //2.上下限
    def test[A <:Child](a:A):Unit={
      println(a.getClass.getName)
    }

    test[Child](new Child)
    test[SubChild](new SubChild)
//    test[SubChild](new Child) //error
//    test[Parent](new Child) //error

  }

}




//定义继承关系
class Parent{}
class Child extends Parent{}
class SubChild extends Child{}

//定义带泛型的集合类型
//class MyCollection[E]{} //默认不变
//class MyCollection[+E]{} //协变
class MyCollection[-E]{} //逆变

package aa.bb

/**
  * 协变 逆变 不变
  */

object ObjConvariantDemo {

  class Animal{  //动物
    println("动物吃东西")
  }

  class CatAnimal extends Animal{    //猫科动物
    println("猫科动物吃肉")
  }

  class Tiger extends CatAnimal{    //老虎属于猫科动物
    println("老虎吃人")
  }



  class PetMaster[T]{}   //老虎和猫科动物是父子关系 tiger <catanimal
  // 老虎主人和猫科动物的主人没有任何关系 PetMaster[CatAnimal]  PetMaster[Tiger] 不变

  class SkillMaster[+T]{}   // 老虎和猫科动物是父子关系 tiger <catanimal
                            // 具有饲养猫科动物技能的饲养员 是只能饲养老虎技能饲养员的父类 协变

  class Contravariant[-T]{}  //逆变(Contravariant) 老虎和猫科动物是父子关系 tiger <catanimal 不变


  def main(args: Array[String]): Unit = {
//    var tiger:Tiger =new Tiger
//    var cat :CatAnimal=new Tiger
//    var tiger:Tiger=new Animal

    //不变
    var tigerMaster:PetMaster[Tiger]=new PetMaster[Tiger]()
//    var tigerMaster:PetMaster[CatAnimal]=new PetMaster[Tiger]()  //error
    //协变
    var tigerSkillMaster:SkillMaster[Tiger]=new SkillMaster[Tiger]()
    var catAnimalSkillMaster:SkillMaster[CatAnimal]=new SkillMaster[CatAnimal]()
    var catAnimalSkillMaster2:SkillMaster[CatAnimal]=new SkillMaster[Tiger]()


//    var petMaster:PetMaster[Int]=new PetMaster[Int]

    //逆变
    var contravariant:Contravariant[Tiger]=new Contravariant[Tiger]();
//    var catAnimalCon:Contravariant[CatAnimal]=new Contravariant[Tiger]();   //逆变中此写法不正确
    var catAnimalCon:Contravariant[Tiger]=new Contravariant[CatAnimal]();





  }
  
}