scala官网：https://www.scala-lang.org/

Scala官网上的六个特征：

1. Java和Scala可以混编
2. 类型推测（scala会自动推测类型，类似python）
3. 并发和分布式（对集合使用数据并行操作，对并发和分发使用参与者，或者对异步编程使用futrure）
4. 特质、特征（类似Java中的interface和abstract结合）
5. 模式匹配（类似Java switch）
6. 高阶函数

   ---

    

Scala基础

1.数据类型

• Byte 8bit的有符号数字，范围在-128 --127
• Short 16 bit有符号数字，范围在-32768 -- 32767
• Int 32 bit 有符号数字，范围-2147483648 到 2147483647
• Long 64 bit 有符号数字，范围-9223372036854775808 到 9223372036854775807
• Float 32 bit IEEE 754单精度浮点数
• Double 64 bit IEEE 754 双精度浮点数
• Char 16 bit Unicode字符.范围 U+0000 到 U + FFFF
• String字符串
• Boolean布尔类型
• Unit表示无值，和其他语言中void等同
• Null空值或者空引用
• Nothing所有其他类型的子类型，表示没有值
• Any所有类型的超类，任何实例都属于Any类型
• AnyRef所有弓丨用类型的超类
• AnyVal所有值类型的超类

2.变量和常量的声明

• 定义变量或者常量的时候，也可以写上返回的类型，一般省略，如：val a:Int = 10
• 常量不可再赋值

    /**
     * 定义变量和常量
     * 变量 :用 var 定义 ，可修改 
     * 常量 :用 val 定义，不可修改
     */
    var name = "zhangsan"
    println(name)
    name ="lisi"
    println(name)
    val gender = "m"
    //gender = "m"//错误，不能给常量再赋值

3.类和对象

• scala object 相当于java中的单例，object中定义的全是静态的
• scala中定义变量使用var 定义常量使用val，变量可变，常量不可变，变量和常量的类型可以不写，他会自动推断
• scala中每行后面都会有分号推断机制，不用显示写出
• scala中命名建议使用驼峰命名法
• scala类中可以传参，有了参数就默认有了构造，传参一定要指定类型，类中的属性默认有getter和setter方法
• scala类中重写构造时，构造中第一行必须先调用默认的构造,def this(){...}
• scala中当new class时，类中除了方法不执行【除了构造方法】，其他都执行
• 在同一个scala文件中，class和object名称一样时，这个类叫做这个对象的伴生类，这个对象叫做这个类的伴生对象，他们可以互相访问私有变量
• object 不能传参，如果出现传参的话，说明有apply()方法 而且apply（）方法可以有多个【里面的参数不同】，相当于Java中的重载

创建类

class Person{
  val name = "zhangsan"
  val age = 18
  def see() = {
    name + " is seeing"
  }
}

创建对象

object Demo{
   def main(args: Array[String]): Unit = {
    val person = new Person()
    println(person.age);
    println(person.see())
  }
}

对象中的apply方法

/**
  * object 单例对象中不可以传参，
  * 如果在创建Object时传入参数，那么会自动根据参数的个数去Object中寻找相应的apply方法
  */
object Demo {
  def apply(s:String) = {
    println("name is "+s)
  }
  def apply(s:String,age:Int) = {
    println("name is "+s+",age = "+age)
  }
  def main(args: Array[String]): Unit = {
    Demo("zhangsang")
    Demo("lisi",18)
  }
}

伴生类和伴生对象

class Person(xname :String , xage :Int){
  var name = Person.name
  val age = xage
  var sex= "m"
  def this(name:String,age:Int,s:String){
    this(name,age)
    sex = s
  }
  
  def sayName() = {
    "my name is "+ name
  }

}

object Person {
  val name = "zhangsanfeng"
  
  def main(args: Array[String]): Unit = {
    val person = new Person("wagnwu",10,"f")
    println(person.age);
    println(person.sayName())
    println(person.sex)
  }
}

注意点：

• 建议类名首字母大写 ，方法首字母小写，类和方法命名建议符合驼峰命名法。
• scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数
• scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。
• 重写构造函数的时候，必须要调用默认的构造函数。
• class 类属性自带getter ，setter方法。
• 使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。
• 如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。

if else

  /**
   * if else
   */
    val age =18 
    if (age < 18){
        println("no allow")
    }else if (18<=age&&age<=20){
        println("allow with other")
    }else{
        println("allow self")
    }

 

for ,while,do…while

to和until 的用法（不带步长，带步长区别）

 /**
     * to和until
     * 例：1 to 10 返回1到10的Range数组，包含10
     * 1 until 10 返回1到10 Range数组 ，不包含10
     */
    println(1 to 10 )//打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    println(1.to(10))//与上面等价，打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
 
    println(1 to (10 ,2))//步长为2，从1开始打印 ，1,3,5,7,9
    println(1.to(10, 2))

    println(1 until 10 ) //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
    println(1.until(10))//与上面等价
    println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7

创建for循环

/**
 * for 循环 
 */
for(i <- 1 to 10){
    println(i)
}

for循环中可以加条件判断，可以使用分号隔开，也可以不使用分号

  //可以在for循环中加入条件判断
  for (i <- 1 to 10; if (i % 2) == 0; if (i == 4)) {
    println(i)
  }

for循环用yield 关键字返回一个集合

  //将for中的符合条件的元素通过yield关键字返回成一个集合
  val list = for (i <- 1 to 10; if (i > 5)) yield i
  for (w <- list) {
    println(w)
  }

while循环

  var index = 0
  while (index < 100) {
    println("第" + index + "次while 循环")
    index += 1
  }
  index = 0
  do {
    index += 1
    println("第" + index + "次do while 循环")
  } while (index < 100)