2021-04-18

Scala day01

注释

package com.gc.scala.day01

/**
 * 文档注释
 */
object HelloWord {
  def main(args: Array[String]): Unit = {
    System.out.println("hello")
    println("hello world")
    //单行注释
  }
}
/*多行注释
注释占20%-30%
执行代码
  java：定义类，然后在类中定义一个静态的main方法
  scala：没有静态的概念。  创建对象，在对象中定义main方法
 */

变量和常量

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 14:22
 */
object VarValDemo1 {
  def main(args: Array[String]): Unit = {
    var a:Int=10 //scala的类型推导，可以不写类型，会自动根据后面的赋值推断类型
    a=20
    println(a) //快捷键：a.sout tab/enter

    val b: Int =100
    println(b)
  }
}
/*
java:
  变量和常量
  int a=10
  final int A=100
  final类 不能有子类
scala:
   var a:Int=10//声明变量

    val b:Int=100//声明常量
   注意：在scala中，能用常量的地方别用变量，因为常量更安全

        必须在声明的同时给变量和常量赋值，不然会报错


        万能键
        eclipse：ctrl+1
        idea:alt+enter   补全类型
 */

标识符的命名

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 14:44
 */
object NameReguoar {
  def main(args: Array[String]): Unit = {
  val ++ :Int=10;//不能使用单个运算符
    val a_++ :Int=10//字符和运算符如果混用，要用下划线_隔开
    val `asdkksjdj` :Int=10//用反引号`....`包括的任意字符串，即使是关键字（39个）也可以  ESc下面
    val `type`=10
  }
}
/*
标识符（变量，常量，对象，类，方法，函数）命名规范
  1.使用java的命名规范
    数字字母下划线
    scala中的下划线慎重使用
   2.不要使用$
   将来scala编译的时候，一些类会自动添加$
  3.支持使用运算符（+ - * / # !等）来命名标识符
    在Scala中没有真正的运算符，所有的运算符其实都是对象的方法


 */

字符串的输出和字符串插值

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 15:07
 */
object String_1 {
  def main(args: Array[String]): Unit = {
  val a :Int=20
    printf("格式化输出 %d",a)
    printf("浮点数 %.2f",math.Pi)
    printf("字符串： %s,%f,%d","abc",1.2,1)
    val b :Int=10
    val s="a="+a+",b="+b
    println(s)
    val s1: String=s"a=${a*2},b=$b"//s插值
    println(s1)
    val s2:String=raw"\n"//raw 插值，写啥就是啥
    println(s2)

  }
}
/*
1.java的输出
  System.out.println("")
2.scala的输出
  println("")
3.printf
  格式化输出
  %d输出整数
  %f输出浮点数
  %s输出字符串
4.字符串插值
 */

多行字符串

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 15:19
 */
object String_2 {
  def main(args: Array[String]): Unit = {
  val s:String=
    """
      |saddsadsad
      |asdsddffsdfsf
      |sadasdasd
      |asdsad
      |""".stripMargin
   printf(s)
  }
}
/*
多行字符串


 */

从键盘输入数据

package com.gc.scala.day01

import scala.io.StdIn
import scala.xml.dtd.Scanner

/**
 * Author guochao
 * Date 2021/4/18 15:24
 */
object Input {
  def main(args: Array[String]): Unit = {
   /* val scanner:Scanner=new Scanner(System.in)
     println(scanner.next())
    */

    val line:String=StdIn.readLine("请输入你的卡号")
    println(line)
  }
}
/*
从键盘输入数据：
java：
 1.高级写法 1.5之后支持
    val scanner:Scanner=new Scanner(System.in)
     println(scanner.next())

scala：
  val line:String=StdIn.readLine("请输入你的卡号")
    println(line)

  StdIn.readLine()、StdIn.readShort()、StdIn.readDouble()

 */

数据类型

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 15:36
 */
object Type1 {
  def main(args: Array[String]): Unit = {
  val a:Unit=()//相当于java的void，只不过是类型
     println(a)
  }
}
/*
数据类型
Java：
  基本数据类型
      8大基本数据类型：
        byte 1
        short 2
        char 2
        int 4
        long 8
        float 4
        double 8
        boolean 1(有的用一个字节，有的用一位)
        引用数据类型
        对象类型
        除了基本数据类型，就是引用类型
        基本类型=》包装类
scala:

    所有的数据都是对象,函数也是对象
    Scala数据类型关系总结
1）Scala中一切数据都是对象，都是Any的子类。
2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
4）Scala特殊的类型之Null，它只有一个实例就是Null，它是所有引用类型（AnyRef）的子类。
5）Scala特殊类型之Nothing，是所有数据类型的子类，主要在一个函数没有正常返回值使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

    Unit(类型)对应java中的void
    Unit类型用来标识过程，也就是没有明确返回值的函数。
    由此可见，Unit类似于Java里的void。Unit只有一个实例——( )，这个实例也没有实质意义

    StringOps是String的加强版
    当使用Java的Sting的时候，一些没有方法，会自动从这个类型找（隐式转换）

    null（关键字） 在Java中可以给任何的引用数据类型赋值
  在scala中：
  Null是所有的AnyRef的子类型

  只有一个值：null（其实就是Java中的null)
  Nothing在Scala中，是所有类型的子类型
  是一个象征意义，用于辅助类型推导，一般用于非正常结束情况下的返回值
  抛出一个异常
 */

数据类型转换

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 15:50
 */
object Type2 {
  def main(args: Array[String]): Unit = {
     val a:Long=1
     val b:Double=a  //自动转换
     val a1:Long=1L
     val int:Int= a1.toInt //强制转换
     val s:String="123"
     val i:Int=Integer.parseInt(s)
     println(i)
     println(123.toString)

  }
}
  /*
    1.自动转换（自动提升）：
    byte->short->int->long->float->double
    char ->int
    scala中照样适用
    2.强制转换：
    java:(int)lL
    scala: .toInt
    .toDouble

    字符串中，如果是纯数字，也可以转换成相应的类型
    如果想把 “123”->123
    java:
    Integer.parseInt(“123”)
    scala:
    “123”.toInt
    任何转换成字符串：
    123+“”
    123.toString

    引用类型的转换：
    遵守面向对象的规则，多态
 */

运算符

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 16:02
 */
object Operator01 {
  def main(args: Array[String]): Unit = {
    /* val r:Int=1.+(2)
     println®
     */

    var i:Int=1
    i += 1
    println(i)
    val a:String="a"
    val ab1:String=a+"b"
    val ab2:String=a+"b"
    println(ab1 == ab2)//true
    println(ab1.eq(ab2))//false
  }
}
  /*
  运算符：
  在Scala中没有真正的运算符，运算符其实是一个方法（函数）名
   ±* /都是方法名
   1.在Scala中调用方法的点可以省略
   2.在给方法传递参数的时候，如果这个函数的参数只有一个参数或者没有参数，则原括号也可以省略
   .和（）都省略后，这个时候的方法名我们就称为运算符
   ++ --这两个垃圾运算符被去掉

  Java：
  基本类型比较的就是值
  引用类型：比的也是值：对象的地址值
  equals只能用于引用类型

  Scala:
  == 等价于equals（！=）
  equals 等价于==
  自定义类型应该复写equals
  不要忘记复写hashCode，这两个方法的返回要一致
  eq 等价于Java的== 只能用于AnyRef （ne）

  快捷键：
  1.alt+enter 万能键
  2.双击shift 打开查找类的对话框
 */

分支结构

package com.gc.scala.day01

/**
 * Author guochao
 * Date 2021/4/18 16:17
 */
object IfDemo {
  def main(args: Array[String]): Unit = {
    val a:Int=10
     if(a%2==0){
     println(s"$a 是偶数")
     }
  }
}
/*

在Scala中任何的语句（正常的执行语句，表达式等等）都有值
是执行最后一行的值自动返回

注意：
1.在Scala中，赋值语句的值是Unit

流程控制：
    1.顺序流程
    2.分支
      java：
        if分支

        switch分支
    3.循环
      scala：
      if:和java一样
      模式匹配：
      替换掉java的switch，但远远强于switch



 */

while循环

package com.gc.scala.day01.loop

/**
 * Author guochao
 * Date 2021/4/18 16:34
 */
object WhileDemo {
  def main(args: Array[String]): Unit = {
    var a:Int=1;
     while (a<=100){
     println(a)
      a += 1
     }
     var a1:Int=1;
     do{
     println(a1)
     a1 += 1
     }while(a1<=100)
  }
}
  /*
循环：
        Java：
        while 2
        do…while 3
        for 1
        //增强for循环
        //其实是在遍历（迭代）foreach
     for(a:集合）{
     }
        Scala：
        while
        do…while
        和Java完全一样
        scala是一种函数式语言
        函数式语言中，不应有循环, 应该用递归
        haskell
        for不是一种循环，而是一种遍历，其实是遍历集合中的每个元素
 */