1 类的定义
package com /** * Created by Administrator on 2019/6/3. */ //类并不用声明为public。 class Person { //用val修饰的变量是只读属性，有getter但没有setter //（相当与Java中用final修饰的变量） val id = "9527" //用var修饰的变量既有getter又有setter var age = 18 //类私有字段,只能在类的内部使用 private var name = "唐伯虎" //对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的字段 private[this] val pet = "小强" }
2构造器
package com /** * Created by Administrator on 2019/6/4. */ //跟类名交织在一起的叫主构造器 class Student(val name: String, var age: Int, faceValue: Double = 99.99, private var height: Int = 18) { private[this] var gender: String = null def show(): Unit = { //faceValue = 1000 println(faceValue) } //辅助构造器 def this （参数） def this(name: String, age: Int, gender: String) { //辅助构造器第一行一定要先调用主构造器 this(name, age) this.gender = gender } } object Student { def main(args: Array[String]) { val p = new Student("zx", 30, 100, 180) println(p.age) println(p.name) p.age = 18 p.height = 199 println(p.age) println(p.height) //val per = new Person //println(per) } } object Main { def main(args: Array[String]) { val s = new Student("zx", 30, 100) //s.height } }
3 单例对象
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的
1.存放工具方法和常量
2.高效共享单个不可变的实例
3.单例模式
package com import scala.collection.mutable.ArrayBuffer /** * Created by Administrator on 2019/6/4. */ object SingletonDemo { def main(args: Array[String]) { //单例对象不需要new，用 类名.方法 调用对象中的方法 val session = SessionFactory.getSession() println(session) } } object SessionFactory { //该部分相当于java的静态块 var counts = 5 val sessions = new ArrayBuffer[Session]() while (counts > 0) { sessions += new Session } //在object中的方法相当于java的静态方法 def getSession(): Session = { sessions.remove(0) } } class Session { }
4 伴生对象
在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性
package com /** * Created by Administrator on 2019/6/4. */ class Dog { val id = 1 private var name = "itcast" def printName(): Unit = { //在Dog类中可以访问伴生对象Dog的私有属性 println(Dog.CONSTANT) } } //伴生对象 object Dog { //伴生对象中的私有属性 private val CONSTANT = "汪汪汪汪汪汪：" def main(args: Array[String]) { val p = new Dog //访问私有的字段name p.name = "123" println(p.name) p.printName() } }
5 apply方法
通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,...参数n)时apply方法会被调用
package com /** * Created by Administrator on 2019/6/4. */ object ApplyDemo { def main(args: Array[String]) { //调用了Array伴生对象的apply方法 //def apply(x: Int, xs: Int*): Array[Int] //arr1中只有一个元素5 val arr1 = Array(5) println(arr1.toBuffer) //new了一个长度为5的array，数组里面包含5个null var arr2 = new Array(5) } }
6 应用程序对象
package com /** * Created by Administrator on 2019/6/4. */ object AppObjectDemo extends App { //不用写main方法 println("i love you scala") }
7 继承
扩展类
在Scala中扩展类的方式和Java一样都是使用extends关键字
重写方法
在Scala中重写一个非抽象的方法必须使用override修饰符
类型检查和转换
| Scala |
Java |
| obj.isInstanceOf[C] |
obj instanceof C |
| obj.asInstanceOf[C] |
(C)obj |
| classOf[C] |
C.class |
超类的构造
package com /** * Created by Administrator on 2019/6/4. */ object ClazzDemo { def main(args: Array[String]) { } } trait Flyable { def fly(): Unit = { println(" I Can Fly") } def fight(): String } abstract class Animal { def run(): Int val name: String } class Human extends Animal with Flyable { val name = "abc" val t1, t2, (a, b, c) = { println("ABC") (1, 2, 3) } println(a) println(t1._1) //在Scala中重写一个非抽象方法必须用override修饰 override def fight(): String = { "fight with 棒子" } //在子类中重写超类的抽象方法时，不需要使用override关键字，写了也可以 def run(): Int = { 1 } }
8 模式匹配和样例类
Scala有一个十分强大的模式匹配机制，可以应用到很多场合：如switch语句、类型检查等。
并且Scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配
匹配字符串
package com import scala.util.Random /** * Created by Administrator on 2019/6/4. */ object CaseDemo01 extends App { val arr = Array("zhangsan", "lisi", "wangwu", "zhaoliu") val name = arr(Random.nextInt(arr.length)) println(name) name match { case "zhangsan" => println("张三") case "lisi" => println("李四") case _ => println("王五") } }
匹配类型
object CaseDemo02 extends App { val arr2 = Array("zhangsan", 1, 2.0, CaseDemo01) val v = arr2(Random.nextInt(arr2.length)) println(v) v match { case x: Int => println("Int" + x) case y: Double if (y > 0) => println("Double" + y) case z: String => println("String" + z) case _ => throw new Exception("not match exception") } }
匹配数组，元组
注意：在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
object CaseDemo03 extends App { val arr = Array(1, 3, 5) arr match { case Array(1, x, y) => println(x + " " + y) case Array(0) => println("only 0") case Array(0, _*) => println("0 ...") case _ => println("something else") } val lst = List(3, -1) lst match { case 0 :: Nil => println("only 0") case x :: y :: Nil => println(s"x: $x y: $y") case 0 :: tail => println("0 ...") case _ => println("something else") } val tup = (2, 3, 7) tup match { case (1, x, y) => println(s"1, $x , $y") case (_, z, 5) => println(z) case _ => println("else") } }
样例类
在Scala中样例类是一中特殊的类，可用于模式匹配。case class是多例的，后面要跟构造参数，case object是单例的
package com import scala.util.Random /** * Created by Administrator on 2019/6/4. */ case class SubmitTask(id: String, name: String) case class HeartBeat(time: Long) case object CheckTimeOutTask object CaseDemo04 extends App { val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask("0001", "task-0001")) arr(Random.nextInt(arr.length)) match { case SubmitTask(id, name) => { println(s"$id, $name") } case HeartBeat(time) => { println(time) } case CheckTimeOutTask => { println("check") } } }
option类型
在Scala中Option类型样例类用来表示可能存在或也可能不存在的值(Option的子类有Some和None)。Some包装了某个值，None表示没有值
object OptionDemo { def main(args: Array[String]) { val map = Map("a" -> 1, "b" -> 2) val v = map.get("b") match { case Some(i) => i case None => 0 } println(v) //更好的方式 val v1 = map.getOrElse("c", 0) println(v1) } }
偏函数
被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例，A代表参数类型，B代表返回类型，常用作输入模式匹配
object PartialFuncDemo { def func1: PartialFunction[String, Int] = { case "one" => 1 case "two" => 2 case _ => -1 } def func2(num: String) : Int = num match { case "one" => 1 case "two" => 2 case _ => -1 } def main(args: Array[String]) { println(func1("one")) println(func2("one")) } }