Scala06--double_happy

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/weixin_39557512/article/details/100847495

隐式转换

存在的目的：增强

scala里有三种：
	隐式参数
	隐式类型转换
	隐式类

隐式类型转换：****

eg：
	A类型 ==》B类型 B对A已有的东西 进行增强（是感知不到的）
scala中 File这个类原声的并没有类似与count，read方法   但是
我们是可以通过隐式转换来增强File中并没有提供的方法

这个东西是双刃剑 用不好 代码流程你可能都看不明白

需求：如何为一个已存在的类添加一个新方法？

Java：使用代理
scala：使用Implicit

1.定义隐式转换函数

implict def man2superman（man:Man）:Surperman = new Superman(man.name)

代码：
object ImplicitApp {

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

    val bfx = new Surperman("bfx")

    bfx.fly()

    /**
      *隐式类型转换
      * 1。定义隐式转换函数
      *
      */

    //1。
    implicit def man2surperman(man:Man):Surperman= {
      new Surperman(man.name)
    }

    val double_happy = new Man("double_happy")
    double_happy.fly()


  }


  class Man(val name:String)

  class Surperman(val name : String){

    def fly(): Unit ={
      println(s"$name can fly...")
    }
  }

}

需求二：scala中 File这个类原声的并没有类似与count，read方法   但是
我们是可以通过隐式转换来增强File中并没有提供的方法

代码：
	object ImplicitApp {

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

    val bfx = new Surperman("bfx")

    bfx.fly()

    /**
      *隐式类型转换
      * 1。定义隐式转换函数
      *
      */

    //1。
    implicit def man2surperman(man:Man):Surperman= {
      new Surperman(man.name)
    }

    val double_happy = new Man("double_happy")
    double_happy.fly()

    //1.2 File 增强
    implicit def file2RichFile(file: File)=new RichFile(file)

    val file = new File("/Users/double_happy/zz/G7-03/工程/scala-flink/doc/implicit/file.txt")

    println(file.read())
  }


  class Man(val name:String)

  class Surperman(val name : String){

    def fly(): Unit ={
      println(s"$name can fly...")
    }
  }


  //2.增强File

  class RichFile(file:File){

    def read() ={

      //文件的路径+文件名字
       Source.fromFile(file.getPath).mkString
    }
  }



}

这样写 代码里全是implicit 比较乱 最好把他们抽取出来放到一个Obeject里面

隐式类型转换   在spark-core RDD里面有很多，
其中，RDD obeject里面就是把大部分的implicit放到这里面的
eg：
object RDD {

  private[spark] val CHECKPOINT_ALL_MARKED_ANCESTORS =
    "spark.checkpoint.checkpointAllMarkedAncestors"

  // The following implicit functions were in SparkContext before 1.3 and users had to
  // `import SparkContext._` to enable them. Now we move them here to make the compiler find
  // them automatically. However, we still keep the old functions in SparkContext for backward
  // compatibility and forward to the following functions directly.

  implicit def rddToPairRDDFunctions[K, V](rdd: RDD[(K, V)])
    (implicit kt: ClassTag[K], vt: ClassTag[V], ord: Ordering[K] = null): PairRDDFunctions[K, V] = {
    new PairRDDFunctions(rdd)
  }

  implicit def rddToAsyncRDDActions[T: ClassTag](rdd: RDD[T]): AsyncRDDActions[T] = {
    new AsyncRDDActions(rdd)
  }

隐式参数转换

隐式参数
	方法/函数的参数可以使用implicit修饰
	效果就是：

eg：
  //Int 类型就具有 add方法了 是不是很神奇
  implicit class Cal(x :Int){

    def add(a:Int) = a+x
  }

  //File类增强
  implicit class FileEnhance(file: File){

    def read2() = Source.fromFile(file.getPath).mkString
  }

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


    /**
      * 隐式类：
      *
      */


    val file2 = new File("/Users/double_happy/zz/G7-03/工程/scala-flink/doc/implicit/file.txt")
    
    println(file2.read2())

    println(4.add(2))

Scala泛型

/**
  * scala的泛型 ： 类型的约束
  */
object GeneticApp {


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


    val mm1 = new MM[Int,CupEnum,Int](90,CupEnum.A,175)
    val mm2 = new MM[Int,CupEnum,Int](10,CupEnum.F,150)
    val mm3 = new MM[Int,CupEnum,Int](80,CupEnum.B,165)

    println(mm1)
    println(mm2)
    println(mm3)


  }
}

abstract class Msg[T](content:T)

class WeChatMsg(content:String) extends Msg(content)

class DigitMsg[Int](content:Int) extends Msg(content)

class MM [A,B,C](val faceValue:A,val cap:B,val height:C){

  override def toString: String = faceValue +"\t"+cap+"\t"+height
}

//scala中枚举的使用  固定写法

object CupEnum extends Enumeration {

  type  CupEnum = Value

  val A,B,C,D,E,F = Value

}

Scala中的排序

对比java

两种：
1.sort里的 Comparator
2.实现 Comparable

public class MM  implements Comparable<MM>{


    public static void main(String[] args) {


        MM mm1 = new MM("mm1", 32);
        MM mm2 = new MM("mm2", 34);
        MM mm3 = new MM("mm3", 31);

        List<MM> mms = new ArrayList<>();
        mms.add(mm1);
        mms.add(mm2);
        mms.add(mm3);
        // 1. 第一种方式 排序cpm01(mms);
        //2。第二种方式 排序

        cmp02(mms);


    }

    private static void cmp02(List<MM> mms) {
        Collections.sort(mms);
        for (MM mm : mms) {
            System.out.println(mm);
        }
    }

    private static void cpm01(List<MM> mms) {
        //排序
        Collections.sort(mms, new Comparator<MM>() {
            @Override
            public int compare(MM o1, MM o2) {
                return o1.cup - o2.cup;
            }
        });

        for (MM mm : mms) {
            System.out.println(mm);
        }
    }

    private String name;

    private int cup;

    public MM() {
    }

    public MM(String name, int cup) {
        this.name = name;
        this.cup = cup;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getCup() {
        return cup;
    }

    public void setCup(int cup) {
        this.cup = cup;
    }

    @Override
    public String toString() {
        return "MM{" +
                "name='" + name + '\'' +
                ", cup=" + cup +
                '}';
    }

    @Override
    public int compareTo(MM o) {
        return -(this.cup - o.cup);
    }
}

scala排序与java相对应的：
	1. Ordering  ==>comparator
	2. Ordered ==>comparable

java里的上下界
	上界（upper bounds）<T extends Test > T 可以是Test的子类型   <? extends Test>
	下界(lower bounds)   < T super Test > T可以是Test的父类型			<? super Test >

Scala 里的上下界


object UpperLowerBountsApp {

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


    //3.Man 排序

//    val man1 = new Man("double",24)
//    val man2 = new Man("xiao fang",18)
//
//    println(new MaxValue(man1,man2).compare)
//    println(new MaxValue2(man1,man2).compare)

    //3.2

    val man3 = new Man2("double",24)
    val man4 = new Man2("xiao fang",18)

   // println(new MaxValue2(man3,man4).compare)  //是不行的 Man2需要隐式转换 或者 实现compareble接口 或者 extends  Ordered[Man2]

    implicit def man2ToOrderedMan2(man2: Man2) = new Ordered[Man2] {
      override def compare(that: Man2): Int = that.age - man2.age
    }

    println(new MaxValue2(man3,man4).compare)


    //3.3 上下文界定

    implicit val cpmtor = new Ordering[Man2] {
      override def compare(x: Man2, y: Man2): Int = -(x.age -y.age)
    }
    println(new MaxValue3(man3,man4).compare())


    



    //0。。

    val maxInt = new MaxInt(3,6)

    println(maxInt.compare())

    //1。需要需要写泛型 如果实现compareble接口 就不用写
    val maxValue = new MaxValue[Integer](6,10) //Int 没有实现compareble接口

    println(maxValue.compare)

    //2。使用视图界定 不用写泛型
    val maxValue2 = new MaxValue2(13,15)

    println(maxValue2.compare)

  }

}

//求最大值  Int 类型的
class  MaxInt(x :Int , y:Int){

  def compare()={
    if(x > y) x else y
  }
}

class  MaxLong(x :Long , y:Long){

  def compare()={
    if(x > y) x else y
  }
}

//引入 scala里的上界  这里是表示 T是Comparable[T]的子类型
class  MaxValue[T <: Comparable[T]] (x:T,y:T){

  def compare = if(x.compareTo(y) >0)  x else  y

}

//视图界定 ： 底层是使用隐式转换的
class  MaxValue2[T <% Comparable[T]] (x:T,y:T){

  def compare = if(x.compareTo(y) >0)  x else  y

}

//上下文界定
class  MaxValue3[T : Ordering](x : T,y:T)(implicit cpmtor:Ordering[T]){

  def compare() =if(cpmtor.compare(x,y) > 0) x else y

}


class Man(val name :String , val age : Int) extends  Ordered[Man]{

  override def compare(that: Man): Int = that.age - age

  override def toString: String = name + "\t" + age

}

class Man2(val name :String , val age : Int) {

  override def toString: String = name + "\t" + age
}
	

总结下来 scala里排序：  那些界定 能看懂即可 
	不管你使用什么界定 ，转换的类不用说 里面是一定有compare的
	bean类 不管是隐式转换也好 还是继承或实现 ordered ，最终 bean类 和转换类 结合使用的时候 他们都存在
	类似compare的东西 才不会报错！！！ 

逆变和协变

scala里 泛型类型是不可变的  本意  但是人为的让他可以

/**
  * scala的泛型 ： 类型的约束
  */
object GeneticApp {


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


    //1. 泛型
    val mm1 = new MM[Int,CupEnum,Int](90,CupEnum.A,175)
    val mm2 = new MM[Int,CupEnum,Int](10,CupEnum.F,150)
    val mm3 = new MM[Int,CupEnum,Int](80,CupEnum.B,165)

    println(mm1)
    println(mm2)
    println(mm3)


    //2.nb  xb

    /**
      * 泛型类型是不可变的
      *
      *  [UserA] 能不能放 Child
      *  eg：val test: Test[UserA] = new Test[Child]     //默认是不行的哈 泛型类型是不可变的
      *
      *  UserA ==》 Child  协变   补充增强    在Test里属性参数 加一个+ 号即可实现
      *
      *  UserA ==》Person 逆变   减少    在Test里属性参数 加一个- 号即可实现
      *
      */
    val test: Test[UserA] = new Test[UserA]
    val test1: Test[UserA] = new Test[Child]
    println(test)
    println(test1)

//    val test3: Test[UserA] = new Test[Person]
    println(test)


    //使用场景
    val list = List(1,2,3,4,5)
   // list.reduceLeft[UserA]()  点开看一下 就知道  这是一个下界 返回值类型 就是 UserA
    

  }

  def test[T](t:T)=println(t)
}

class Person

class  UserA extends  Person

class Child extends  UserA

class Test[+UserA]

abstract class Msg[T](content:T)

class WeChatMsg(content:String) extends Msg(content)

class DigitMsg[Int](content:Int) extends Msg(content)

class MM [A,B,C](val faceValue:A,val cap:B,val height:C){

  override def toString: String = faceValue +"\t"+cap+"\t"+height
}

//scala中枚举的使用  固定写法

object CupEnum extends Enumeration {

  type  CupEnum = Value

  val A,B,C,D,E,F = Value

}

Scala操作JDBC

1.pom.xml  添加jdbc
2.开发
	最基础的方法
	2.使用scalikejdbc

object ScalalikJDBCAPP {


  def  insert()={
    DB.autoCommit({
      implicit session =>{
        SQL("insert into tmp(topic,groupid,partititions,offset) values(?,?,?,?)")
          .bind("happy","test-happy-group",3,8)    //插入具体的值
          .update().apply()  //执行
      }
    })
  }

  def update(): Unit = {
    DB.autoCommit({
      implicit session =>{
        SQL("update  tmp(topic,groupid,partititions,offset) set offset=? where topic=? and groupid=? and partititions=? and offset=? ")
          .bind(18,"happy","test-happy-group",3)    //修改具体的值
          .update().apply()  //执行
      }
    })
  }

  def query(): Unit = {
    val queryresult = DB.readOnly({
      implicit session => {
        SQL("select * from tmp ").map(rs => {

          tmp(
            rs.string("topic"),
            rs.string("groupid"),
            rs.int("partitions"),
            rs.long("offset")
          )
        }).list().apply() //执行
      }
    })
    queryresult.foreach(println(_))
  }

  case class tmp(topic:String,groupid:String,partitions:Int,offset:Long)

  def delete(): Unit = {
    DB.autoCommit({
      implicit session =>{
        SQL("delete from tmp where partition=? ")
          .bind(3)    //删除具体的值
          .update().apply()  //执行
      }
    })
  }

  def transaction(): Unit = {
    DB.localTx({
      implicit session =>{
        SQL("delete from tmp where partition=? ")
          .bind(3)    //删除具体的值
          .update().apply()  //执行

        //1/0   测试用  加上即  3删除了2没有删除 如果事务保证 那么谁都不会删除 ***

        SQL("delete from tmp where partition=? ")
          .bind(2)    //删除具体的值
          .update().apply()  //执行

      }
    })
  }

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

    //1.解析配置文件
    DBs.setupAll()

    //插入
    insert()

    //修改
    update()

    //查询
    query()

    //删除
    delete()

    //事务
    transaction()

  }

}