scala 既是面向对象 也是函数式编程
从Java 发展而来，依赖JVM环境

一、 scala 在linux中运行

1. scala 模式中直接编写运行
   
2. scala文件，load执行
   
3. scala编译程序
   编译
   
   
   运行

• scala
  
• java
  

二、scala 数据类型

1. 基础数据类型
   

val 不可变变量 函数式编程
var 可变变量 面对对象编程

两种方式 ：

2. 数据结构

• 数组 Array
  
  

• 多元数组
  

• 元组 Tuple
  可以存放不同类型（）
  

• 容器 Colection
  scala.collection.mutable 可变 的容器 的包
  scala.collection.immutable 不可变 的容器 的包
  
  seq 0,1,2 索引
  map 键索引
  set 无序

• list(值类型相同，些初始化赋值不可变)/queue <- linearSeq
  List
  var st = List(“Big”,“small”,“person”)
  val otherList = “Apple”::st 一个新列表，前面加个字符串 apple
  val intList = 1::2::3::Nil(从右向左执行) <->val intList = List(3,2,1)

• vector/arrayBuffer <- indexedSeq
  Vector
  

• Range
  val r = new Range(1,5,1) ->1,2,3,4,5
  1 to 5 ->1,2,3,4,5
  1.to(5) -> 1,2,3,4,5
  1 to 5 by 2 ->1,3,5
  1 unitl 5 ->1,2,3,4(不包含5)
  0.1f to 2.5f by 0.4f ->0.1,0.5,0.9,1.3,1.7.2.1

• Set 集合
  情况一：
  var myset =Set(“hadoop”,“spark”) – 一个不可变集合，但是myset 是一个可变变量
  mySet += “scala” 是形成新的不可变集合后，将 mySet指向 变过去，见下图
  
  情况二：
  
  这里 myMutableSet 是不可变变量，，但它指向的Set集合是可变的

• Map 映射
  键值对容器：键唯一，值不唯一
  val myMap = Map(“XMU”->“xiamen University”,“THU”->“Tsinghua University”)
  val xmu = if(myMao.contains(“XMU”)) myMap(“”) else 0 先判断存不存在键再取数，否则报错

三、面向对象编程

• 方法定义：
  def 方法名(参数列表):返回结果类型={方法体}
  注：

  • 不返回结果时 结果类型Unit，也可以省略:Unit
  • 参数列表中不能用val,var来修饰
  • 没参数时，()可以省略【此时调用时也不能带()】，还可以用def 方法名 {参数列表} :返回结果类型={方法体}
  • 一个方法只有一个参数，可以省略圆点 采用 中缀操作符调用方法
  • 结果类型也可以省略，可以判断，，只要最后一行是要返回的值就可以
    

• 类定义及实例化
  
  public private protect
  private:
  value_= 写（value_= 相当于 java setter）
  value 读(value 相当于 Java getter)
  

• 类构造器：
  class myClass(val/var name:String)
  会成为myClass的一个参数，并自动给他创建读写方法 name_= 和 name
  辅助构造器 this()
  
  运行：
  

• 单例对象
  object,不需要实例化便可使用

  • 伴生对象：同一个代码文件中的同名的类与对象 互为半生关系，可调用对方的内部成员
    
    举例：
    
    
    

  因为new Person() 所以Person指的class,俩个类实例通用一个伴生对象，，所以结果打印 一个是1 一个是2

  • 孤立对象：
    仅有object,不存在伴生类

    举例：
    对象 内部成员，，可理解其是静态的
    
    

• 继承
  

  类	类型	存储位置	实例化
  AnyVal	值类型	寄存器	不能实例化 不能new Int
  AnyRef	引用类型	堆	可实例化 new Array
  Nothing	只能用来错误处理、异常处理		没有实例
  Null	与Java Null 对应
  Option	返回应用类型时无返回值不建议Null，建议Option		Some()对象封装返回，其中有一个None对象，处理返回为空

  case class Book(val name:String,val price:Double)//case class 默认给生成apply这些方法
  val books= Map("hadoop"->Book("Hadoop",35.1),"spark"->Book("Spark"),55.0)
  

  
  

  • 抽象类
    内有有未实现的方法 abstract修饰

  abstract class Car(val name:String){
  	val carBrand:String //未初始化，抽象字段，必须给类型声明:String
  	def info() // 抽象方法
  	def greeting(){
  		println("Welcome to my car"}
  	}
  }
  

  • 扩展类
    注意：如果是重写 父类的 已实现的方法或者赋值字段 必须加 override关键字，否则可写可不写；只能重载val的字段，var的本身不可变不能重载

  class BMWCar extends Car{
  	override val carBrand = "BMW"
  	def info(){
  		printf("This is a %s Car",carBrand)
  	}
  	override def greeting(){
  		println("Welcome to my BMW car")
  	}
  }
  

四、scala 特性

• apply方法 生成对象
  scala 的类定义了apply方法时，类名() <-> 类名.apply()
  原因：融合 面向对象编程 与 函数式编程

  举例说明 函数调用->类调用
  
  举例说明 类调用->函数调用
  
  
  利用这个特性可以生成 一个对象工厂：
  
  

• update
  当 对带有括号并包括一到若干参数的对象，进行赋值时，，调用update

val myStrArr = new Array[String](3)  // 声明一个长度为3的字符串组，初始化null
myStrArr(0) = "BigData" //(0) 带有括号，一个参数；=“” 赋值,其实调用了伴生类的update
myStrArr.update(0,"BigData") // 等效

• unapply 提取参数

class Car(val brand:String,val price:Int){
	def info(){
		println("Car brand is "+brand+"and price is "+price)
	}
}
object Car{ // 伴生对象
	def apply(brand:String,price:Int)={
		println("Debug:calling apply..")
		new Car(brand,price)
	}
	def unapply(c:Car):Option[(String,Int)]={
		println("Debug:calling unapply ...")
		Some((c.brand,c.price))
	}
}
object TestUnapply{
	def main(args:Array[String]){ // 入口函数
		var Car(carbrand,carprice) = Car("BMW",800000)
		//Car("BMW",800000) 先调用apply生成一个Car类
		//var Car(carbrand,carprice)= 调用unapply  将参数提取出来 
		println(carbrand+":"+carprice)
	}
}

• 特质 【类似接口（只能由抽象方法），但是可以提供具体的方法实现】
  • trait 定义
    
  • 混入（mixin） class ，写在一个代码文件中
    
  • 混入多个特质 ，with
    

• 模式匹配

  • switch-case <-> match
    匹配值，char,int,string …

  
  匹配某一类型
  
  添加守卫 guard,条件表达式
  

  • case class:多用于模式匹配
    scala 自动给case类 生成一个伴生对象和多种方法
    
    

五、包