1.Scala类
1.1定义类
Scala在定义类时，使用class作为定义类的关键字，对于定义构造函数而言，我们不需要像java那样重新定义构造函数，只需要在定义类的时候，在类名后面直接定义构造函数。
scala> class Student(Id:Int,Name:String,Sex:String) {
| val Student_Id = Id
| var Student_Name = Name
| val student_Sex = Sex
| def rename(newName:String)={
| Student_Name = newName
| }
| }
defined class Student可以发现，Scala定义类非常的方便，我们不需要再去使用this关键字，在定义的时候操作性更强。
1.2对象声明
定义完类之后，我们可以开始声明对象，和java一样，我们可以使用new关键字进行对象声明，声明对象的时候，我们可以使用val和var来限定对象类型。
scala> val zhangsan = new Student(1,"zhangsan","man")
zhangsan: Student = Student@285b491f
scala> val xiaohua = new Student(2,"xiaohua","women")
xiaohua: Student = Student@3fa50a24我们可以发现，每创建完一个对象，都会基于该对象的类给对象分配内存，并显示内存地址。
1.3单例模式
Scala支持单例模式开发，所谓的单例模式就是一个类只可以有一个实例。 通过object关键字代替class来实现。
1.4样例类
Scala中有一种特殊的类，叫做样例类，使用case作为关键字进行定义。这种类可以不用定义new定义对象。
scala> case class Student(Id:Int,Name:String,Sex:String)
defined class Student
scala> val wangwu = Student(3,"wangwu","man")
wangwu: Student = Student(3,wangwu,man)我们可以在class前面加上case关键字代表定义样例类，我们使用样例类声明对象的时候，我们可以直接通过类名进行调用。定义样例类的时候，我们默认把Id,Name,Sex前面添加了关键字val。因此，当保证对象不可变的时候，我们可以使用样本类，此外样本类还支持一些操作方法(toString,hashCode,equals,copy),使用起来非常的方便。
2.Scala模式匹配
所谓的模式匹配就是类似于其他编程语言的switch关键字。Scala使用match关键字来作为模式匹配的关键字，并且Scala模式匹配中最大的优点就是不需要自己定义break语句。因为一旦匹配到结果之后，只会执行相应的代码，其他的代码并不会执行。
scala> def spark(x:Int,y:Int,matching:String):Double={
| matching match{
| case "+" => x + y
| case "-" => x - y
| case "*" => x * y
| case "/" => x / y.toDouble
| }
| }
spark: (x: Int, y: Int, matching: String)Double
scala> val div = spark(5,3,"/")
div: Double = 1.66666666666666673.Scala的接口
Scala可以创建接口，又叫做特征类。在java中接口是不可以定义函数的，只可以通过继承然后创建接口的函数。并且一个类可以继承许多接口，通过使用trait关键字定义接口。
scala> trait ShapeInt{
| def area():Int
| }
defined trait ShapeInt
scala> trait ShapeDouble{
| def area():Double
| }
defined trait ShapeDouble
scala> class Square(length:Int) extends ShapeInt {
| def area = length*length
| }
defined class Square
scala> class Rectangle(length: Int,width:Int) extends ShapeDouble{
| def area = length*width
| }
defined class Rectangle
scala> val square = new Square(10)
square: Square = Square@bd93bc3
scala> val area = square.area
area: Int = 100
scala> val Rectangle = new Rectangle(10,10)
Rectangle: Rectangle = Rectangle@7aa3857b
scala> val area1 = Rectangle.area
area1: Double = 100.0可以发现我们通过使用关键字extends继承特征类来控制不同的函数的返回值。
4.解决空指针异常--Option类型
在java中，我们定义类的对象的时候，如果出现，有下列5种情况：
1.当一个类对象不存在，又去调用该对象的类的方法。
我们定义对象的时候都要使用 new来声明，所以，如果我们在创建类的对象的时候，如果定义对象不使用new定义，也就是说对象为空，再去使用类中的方法的时候就会报错。
class Student{
public int score(int score){
return score;
}
public static void main(String args[]){
Student zhangsan = null;
int zhangsan_score = zhangsan.score(100);
System.out.println(zhangsan_score);
}
}
objc[778]: Class JavaLaunchHelper is implemented in both /Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home/bin/java (0x10cc824c0) and /Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home/jre/lib/libinstrument.dylib (0x10dd054e0). One of the two will be used. Which one is undefined.
Exception in thread "main" java.lang.NullPointerException
at Student.main(Student.java:7)2.当一个对象不存在，而去修改或使用该对象的类的变量。
3.当一个数组为null，试图用属性length获得其长度时。
4.当一个数组为null，试图访问或修改其中某个元素时。
5.在需要抛出一个异常对象，但是该对象却为null。
说了这么多java，我们再来看看如何Scala中如何使用Option。
Option是一种特殊的数据类型，它有两种对象类型，一种是Some还有一种是None。通过Some(返回值)，可以确保是有值的，而None表示无值。通过Option可以结合上述模式匹配，也可以用来检验对象是否为空，这样避免了空指针异常。
5.Scala基本数据结构
Scala数据结构组合叫做Scala集合类(PS:集合类和集合不一样)，提供了一些集合类型的抽象。
对于Array,List,Set,Map,Option,Element,Iterator这些都属于集合类
5.1 Scala数组
5.1.1创建数组
可以直接通过枚举的方式创建数组，代码如下：
scala> val arr = Array(1,2,3,4,5)
arr: Array[Int] = Array(1, 2, 3, 4, 5)也可以通过数组声明的方式创建数组，代码如下：
scala> var arr1:Array[String] = new Array[String](10)
arr1: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)
scala> var arr2 = new Array[String](10)
arr2: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)以区间的方式创建数组，使用range(开头，结尾，步长)，创建数组，代码如下：
scala> var arr4:Array[Int] = range(1,5,1)
arr4: Array[Int] = Array(1, 2, 3, 4)5.1.2合并数组
通过导入 Array包，使用函数concat()进行数组合并，代码如下：
scala> import Array._
import Array._
scala> var arr3 = concat(arr1,arr2)
arr3: Array[String] = Array(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null)通过Array关键字可以创建数组，数组的索引依旧是从0开始，也可以通过数组值查找或者修改数组。
具体数组操作方法，可参见http://www.runoob.com/scala/scala-arrays.html
5.2 Scala列表
5.2.1创建列表
Scala列表和python的列表并不一样，Scala列表中的元素类型必须相同。并且创建后，不可修改，使用关键字List进行创建，创建代码如下：
scala> val L1 = List(1,2,3,4,5)
L1: List[Int] = List(1, 2, 3, 4, 5)
scala> val L2 = (1 to 10).toList
L2: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)Scala中的列表是一种递归的结构，我们可以使用递归的方式创建列表，使用关键字Nil 和 :: ，具体代码如下：
scala> val Ld = 1 :: (2 :: (3 :: (4 :: Nil)))
Ld: List[Int] = List(1, 2, 3, 4)5.2.2列表操作
Nil代表空列表
可以使用head和tail来访问列表元素，head访问首元素，tail访问首元素以外的元素，代码如下：
scala> L1.head
res1: Int = 1
scala> L1.tail
res2: List[Int] = List(2, 3, 4, 5)使用isEmpty查看列表是否为空，代码如下：
scala> val empty = Nil
empty: scala.collection.immutable.Nil.type = List()
scala> empty.isEmpty
res3: Boolean = true具体列表操作方法，可参见http://www.runoob.com/scala/scala-lists.html
5.3Scala元组
上文说过Scala的数组和列表的元素类型都是相同的。对于元组而言，元素中类型可以不相同。此外，元组访问是从下标1开始访问，元组在创建之后，元素也是不可变的，元组不需要使用关键字进行创建，具体代码如下：
scala> val Elements = ("hello","你好",2018)
Elements: (String, String, Int) = (hello,你好,2018)
scala> val fir = Elements._1
fir: String = hello
scala> val sec = Elements._2
sec: String = 你好
scala> val third = Elements._3
third: String = 20185.4Scala向量
向量是一种非常好用的数据类型，它结合了数组和列表的特性，并且可以简答的利用索引访问和对向量进行追加等操作，使用Vector关键字进行创建，代码如下：
scala> val v1 = Vector(1,2,3,4,5)
v1: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5)
scala> val v2 = v1:+6
v2: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 6)
scala> val v3 = v1(0)
v3: Int = 15.5Scala集合
集合有两个性质，第一是无序，第二是没有重复的元素，因此无法用索引访问，使用关键字Set来创建集合。
集合可以使用contains来查找集合中是否有该元素，也可以使用isEmpty来查看集合是否为空。