初识Scala与Scala的简单应用

今日内容
    1.为什么要学习scala?
    2.scala的介绍
    3.与java语言的对比
    4.编译工具的安装
    5.main方法讲解
    6.常量和变量
    7.数据类型
    8.懒加载
    9.差值器
    
1.为什么要学习scala?
    1)离线计算
    2)在线计算   spark   scala   
        a.spark 底层是scala   ,我们需要看源码
        b.scala  基于java 
            开发效率高
            运行速度快
2.scala的介绍
    scala 是一门多范式的编程语言,即面向对象也是函数式编程
        面向对象:万物皆对象  封装  实例对象  类 继承 
        函数式编程: 面向过程  函数当成编程
3.scala语言和Java语言对比
        相同点:
            1.java和scala可以无缝混编,它们都是基于jvm
            2.二者可以相互调用
        不同点:
            1.类型自动推断,并如果写类型化,是写在变量名的后面
            2.val var
            3.支持函数式编程
            4.构造器不一样
            5.java中可以自动默认值,scala中必须手动给默认值
            6.scala 不需要分号,但是java 必须要有
            7.get set 方法自己实现
                age:相当于java中的getter方法
                age_$eq:相当于java中set方法
            8.java中的放回只用return scala 中没有return
            
4.编译工具的安装  
    1)jdk
    2)idea 
    3)插件安装(离线和在线都可以)
        scala-intellij-bin-2017.2.2.zip (一个插件就搞定了)
    4)创建一个scala项目测试一下
    5)字体背景稍微调整一下
    
5.main方法讲解
    main(static=object)
    1)语法
        关键字  方法名 (参数):返回值类型={
        方法体
        }
     def main(args: Array[String]): Unit = {

    }
6.常量和变量
    1)定义
    常量:是在运行的过程中,其值不会发生变化的量 例如:数值3 字母A   修饰的关键字val  
    变量:是在运行的过程中,其值可以发生变化的量 例如:时间,年龄  修饰的关键字var
    2)语法
    val name:Type=变量值
    var name:Type=变量值
    注意1：
        类型可以不写，scala 可以自动类型推断
    注意2:变量名称必须符合命名规范,不能使用关键字(命名规范和java一样)
        1.字母,下划线,数字组成,并且不能以数字开头
            val 4_tablename="t_user";
        2.变量名要做到见名知意,(如果英文不好我们通过通过有道翻译)
        3.用驼峰命名法命名多个单词组成的变量名
            val tablename="t_user";
        4.变量名不能使用关键字
            val def =12        
7.scala中的数据数据类型    
        any是所有类型的超类,也成为顶级类型
            anyVal (值类型)  :
                int  short byte long  double string char boolean Uint (9个)
            长度4    2     1    8     8        4      2      1 
            anyRef(引用类型) :
                List  map option  yourclass ....
        注意:java类型中没有和scala中Nothing对应的类型        
8.懒加载    
    1)scala 中使用lazy 关键字修饰变量，就是惰性变量，实现延迟加载
      注意:惰性变量只能是常量,并且只有在调用惰性变量时，才会去实例化这个变量
    2)案例演示
    //正常的      
    var str = {
      println("helloworld")
    }
    //懒加载的形式
        lazy val str1 = {
              println("helloworld")
            }
    //调用这个变量
    str1
    3)好处
    使用在比较耗时的业务中,如网络IO 磁盘IO  场景:    

9.差值器
        scala中有三种插值器
            1.在任何字符串前面加上s,就可直接在字符串中使用变量了
                val name:String="cat"
                println(s"she is name is ${name}")
            2.f插值器: 
             val height=1.23568
            println(f"身高是${height}%.2f")
                
            3.raw插值器:是输入字符串原样,不进行转义 
            例如:
            //没有使用raw
                println("a\nb\n\tc")
            //使用的效果
                println(raw"a\nb\n\tc")

    
补充知识:    
    
10.访问修饰符
        private  :一个类的内部可用
        protected:自己类  子类也可以被访问(这个比java更加严格,java同一个包的其他类也可以访问)
        public   ::如果没有指定修饰符  ,这样的成员在任何地方都可以被访问
        注意:
            如果不指定的情况下,就是public
        实例1:(只能自己访问)
            class Test01 {
              private val name = "毕老师"

              def main(args: Array[String]): Unit = {
                println(name)
              }
            }
        实例2:
            class Test01 {
              protected val name = "毕老师"

            }

            class Test02 extends Test01 {

              def main(args: Array[String]): Unit = {
                println(name)
              }
            }
        实例3:
            object Test {
                  def main(args: Array[String]): Unit = {
                    val test0 = new Test01
                    println(test0.name)
                  }
                }

                class Test01 {
                   val name = "毕老师"
                }
11.运算符
        1)算术运算符
        2)关系运算符
        3)逻辑运算符
        4)赋值运算符
        
        算术运算符:加 减 乘 除 取余
        object Test {
           def main(args: Array[String]) {
                val a = 100
                val b = 200
                val c = 250
                val d = 250
                println("a 加 b = " + (a + b))
                println("a 减 b = " + (a - b))
                println("a 乘 b = " + (a * b))
                println("b 除 a = " + (b / a))
                println("b 取余 a = " + (b % a))
           }
        }
                
        
        关系运算符: ==  !=  > < >=  <=
        object Test {
           def main(args: Array[String]) {
                val a = 100
                val b = 200
                println("a 等于 b     是: " + (a == b))
                println("a 不等于 b   是: " + (a != b))
                println("a 大于 b     是: " + (a > b))
                println("a 小于 b        是: " + (a < b))
                println("b 大于等于 a 是: " + (b >= a))
                println("b 小于等于 a 是: " + (b <= a))
           }
        }
        
        
        逻辑运算符:&&  ||  !
        object Test {
           def main(args: Array[String]) {
              var a = true;
              var b = false;
              println(a&&b)
              println(a||b)
              println(!a)
           }
        } 

        赋值运算符:  =  +=  -=  *=  /=  %=  
    
            var a = 10;
            val b = 20;
            var c = 0;
            c = a + b;
            println(c);
            
              var a = 10;    
              var c = 0;
              c += a ;
              println( c );
              
              var a = 10;    
              var c = 0;
              c -= a ;
              println( c );
            
              var a = 10;    
              var c = 0;
              c *= a ;
              println("c *= a = " + c );

              val a = 10;
              var c = 15;
              c /= a ;
              println("c /= a  = " + c );

              val a = 10;
              var c = 15;
              c %= a ;
              println("c %= a  = " + c );
              
              
              
12.类型转换
    1)String 类型转换为Int
    val age:String ="123"
    println(age.toInt.getClass.getName)
    2)Int 类型转换为String
    val b:Int =123
    println(b.toString.getClass.getName)
    3)String类型转换为Float类型
     val c:String ="123.123"
    println(c.toFloat.getClass.getName)

    
    
    
问题1:scala 语言如何接受键盘的输入?
        println("请输入姓名：")
        val int = Console.readLine()
        println("您的姓名是："+int)        
问题2:字符串中获取收尾字母
//获取首字符??
"Hello"(0)
"Hello".take(1)
//获取尾字符??
"Hello".reverse(0)
"Hello".takeRight(1)
问题3:快捷键补全不好使?

问题4:随机数字生成?
    val int = Random.nextInt(10)
    println(int)