类定义

在scala类中,与类名相同的对象叫做伴生对象,类和伴生对象之间可以相互访问私有的方法和属性

  1. //scala中,类不必声明为public
  2. //scala源文件中可以包含多个类,所有这些类都具有公有可见性
  3. class Person {
  4.   //用val修饰的变量是只读属性,有getter但没有setter(相当于java中用final修饰的变量)
  5.   val id = "9527"
  7.   //用var修饰的变量既有getter又有setter
  8.   var age: Int = 18
  10.   //类私有字段,只能在类的内部使用
  11.   private var name: String = "唐伯虎"
  13.   //对象私有字段,访问权限更加严格,Person类的方法只能访问到当前对象的字段
  14.   private[this] val pet = "小强"
  16.   def sayHi(): Unit = {
  17.     println(name)
  18.     println(pet)
  19.     println("------------")
  20.   }
  21. }
  23. //(单例对象,静态对象)
  24. //伴生对象: 与类名相同并且在同一个文件中
  25. object Person {
  26.   def main(args: Array[String]): Unit = {
  27.     val p = new Person()
  28.     println(p.id)
  29.     println(p.age)
  30.     p.age=20
  31.     println(p.age)
  32.     println(p.name)
  33.     p.name="abc"
  34.     println(p.name)
  35.     //pet访问不到
  36.   }
  37. }

构造器

主构造器中的参数使用后会被升级为字段

  1. //每个类都有主构造器,主构造器的参数直接放置类名后面,与类交织在一起
  2. class Student(val name: String, val age: Int, faceValue: Double = 99.99, private var height: Int = 18) {
  3.   //主构造器会执行类定义中的所有语句
  4.   println("执行主构造器")
  6.   private[this] var gender: String = null
  8.   def show(): Unit = {
  9.     println(faceValue)
  10.   }
  12.   //辅助构造器 def this (参数),可以重载
  13.   def this(name: String, age: Int, gender: String) {
  14.     //辅助构造器第一行,一定要调用主构造器
  15.     this(name, age)
  16.     this.gender = gender
  17.   }
  19. }
  21. object Student {
  22.   def main(args: Array[String]): Unit = {
  23.     val p = new Student("zx", 30, 100)
  24.     println(p.age)
  25.     println(p.name)
  27.   }
  28. }

私有主类构造器

  1. class Student private(val name: String, val age: Int, faceValue: Double = 99.99, private var height: Int = 18) {

这样用户只能通过辅助构造器来构造对象了

限制包使用

  1. private[cn] class Student private(val name: String, val age: Int, faceValue: Double = 99.99, private var height: Int = 18) {

单例对象

在scala中没有静态方法和静态字段,但是可以使用object这个语法结构来达到同样的目的

  1. class SingletonDemo {
  3. }
  5. object SingletonDemo {
  6.   def main(args: Array[String]): Unit = {
  7.     val s1 = SingletonDemo
  8.     val s2 = new SingletonDemo
  9.     val s3 = SingletonDemo
  10.     println(s1)
  11.     println(s2)
  12.     println(s3)
  13.   }
  14. }

输出

  1. SingletonDemo$@6debcae2
  2. SingletonDemo@5ba23b66
  3. SingletonDemo$@6debcae2

在伴生对象内,不用new就是单例

apply方法

通常我们会在类的伴生对象中定义apply方法,当遇到类名(参数1,…参数n)时apply方法会被调用

  1. object ApplyDemo {
  3.   def apply(): Unit = {
  4.     println("apply invoked")
  5.   }
  7.   def main(args: Array[String]): Unit = {
  8.     val a = ApplyDemo()
  9.     println(a)
  10.   }
  11. }

继承

在scala中重写一个非抽象的方法必须使用override修饰符

类型检查和转换

scala java
obj.isInstanceOf[C] obj instanceof C
obj.asInstanceof[C] (C)obj
classOf[C] C.class 
  1. //接口,但是可以有实现
  2. trait Flyable{
  3.   def fly(): Unit = {
  4.     println("I can fly")
  5.   }
  7.   def fight(): String
  8. }
  10. abstract class Animal {
  11.   def run(): Int
  12.   val name: String
  13. }
  15. //如果接口是第一个实现的,也用extends,后面的用with
  16. class Human extends Animal with Flyable {
  17.   val name = "abc"
  19.   //在scala中重写一个非抽象方法必须用override修饰
  20.   override def fight(): String = {
  21.     "fight"
  22.   }
  24.   //在子类中重写超类的抽象方法时,不需要使用override关键字,写了也可以
  25.   def run(): Int = {
  26.     1
  27.   }
  28. }

静态方法和非静态方法

调用方法,静态方法(scala中没有静态方法这个概念,需要通过伴生类对象来实现)

  1. scala> BigInt.probablePrime(16, scala.util.Random)

调用方法,非静态方法,使用对象调用

  1. scala> "HelloWorld".distinct

对象私有化字段

变量: workDetails在封闭包professional中的任何类中可访问
封闭包: friends的任何类都可以被society包中任何类访问
变量: secrets只能在实例方法的隐式对象(this)中访问

  1. package unit7{
  2.   package society {
  3.     package professional {
  5.       class Executive {
  6.         private[professional] var workDetails = null
  7.         private[society] var friends = null
  8.         private[this] var secrets = null
  10.         def help(another: Executive): Unit = {
  11.           println(another.workDetails)
  12.           //another是不能用的,因为他是其他对象
  13. //          println(another.secrets)
  14.         }
  16.       }
  17.     }
  18.   }
  19. }

image.png

嵌套类

在class中,再定义一个class,以此类推
java中的内部类从属于外部类.scala中内部类从属于实例

  1. class Network {
  2.   class Member(val name: String) {
  3.     val contacts = new ArrayBuffer[Member]
  4.   }
  6.   private val members = new ArrayBuffer[Member]
  8.   def join(name: String) = {
  9.     val m = new Member(name)
  10.     members += m
  11.     m
  12.   }
  13. }

这里的member没有指定是属于类的还是对象的
实际上是属于对象的

这个代码会报错

  1. object ObjectDemo extends App {
  2.   val network1 = new Network
  3.   val nick = network1.join("Nick")  //network1.Member
  4.   val alice = network1.join("Alice")  //network1.Member
  6.   nick.contacts += alice
  7.   alice.contacts += nick
  9.   val network2 = new Network
  10.   val jone = network2.join("Jone")  //network2.Member
  12.   nick.contacts += jone
  13. }

指定属于哪个对象的就不会报错了

  1. class Network {
  3.   private val members = new ArrayBuffer[Network.Member]
  5.   def join(name: String) = {
  6.     val m = new Network.Member(name)
  7.     members += m
  8.     m
  9.   }
  10. }
  12. object Network {
  13.   class Member(name: String) {
  14.     val contacts = new ArrayBuffer[Member]()
  15.   }
  16. }

注意: 类和他的伴生对象可以相互访问私有特性,他们必须存在同一个源文件中.必须同名

枚举

scala中没有枚举类型,定义一个扩展Enumeration类的对象,并以value调用初始化枚举中的所有可能值

  1. object TrafficLightColor extends Enumeration {
  2.   val Red = Value(0, "stop")
  3.   val Yello = Value(1, "slow")
  4.   val Green = Value(2, "Go")
  5. }
  7. object ObjectDemo extends App {
  8.   println(TrafficLightColor.Red)
  9.   println(TrafficLightColor.Yello)
  10.   println(TrafficLightColor.Green.id)
  11. }

包和引用

在java和scala中管理项目可以使用包结构,c和c#使用命名空间
对于package,有如下几种形式

  1. package com
  2. package nick.impatient
  3. package people
  5. class Person {
  6.   val name = "Nick"
  7.   def play(message: String): Unit = {
  9.   }
  10. }

等同于

  1. package com.nick.impatient { //com和com.nick在这不可见
  2.   package people {
  3.     class Person {
  4.       val name = "Nick"
  5.       def play(message: String): Unit = {
  7.       }
  8.     }
  9.   }
  10. }

提示: 在文件顶部不带花括号的包声明在整个文件范围内有效

访问父package中的内容.(即:作用域)

包对象可以持有函数和变量
引入语句可以引入包,类和对象
源文件的目录和包之间并没有强制的关联关系
可以在同一个.scala文件中,声明多个并列的package
包名可以相对也可以绝对,比如,访问ArrayBuffer的绝对路径是: _root_.scala.collection.mutable.ArrayBuffer

包对象

包可以包含类,对象和特质trait,但是不能包含函数或变量的定义.很不幸,这是java虚拟机的局限.
把工具函数或常量添加到包而不是某个utils对象,这是更加合理的做法.包对象出现正是为了解决这个局限.每个包都可以有一个包对象.你需要在父包中定义他,而且名称与子包一样

  1. package object people {
  2.   val defaultName = "Nick";
  3. }
  5. package people {
  6.   class people {
  7.     //从包对象拿到的
  8.     val name = defaultName
  9.   } 
  10. }

包可见性

在java中,没有声明为public,private或protected的类成员在包含类的包中可见.
在scala中,你可以通过修饰符达到同样的效果

  1. package com.nick.impatient.people
  3. class Person {
  4.   //只在当前包可见
  5.   private[people] def description = "desc"
  7.   //可以将可见度延展到上层包
  8.   private[impatient] def name = "name"
  9. }

重命名

如果你想要引入包中的几个成员,可以像这样使用选取器(selector),而且选取的通俗,可以重命名

  1. import java.util.{HashMap=>JavaHashMap, List}

这样一来,javaHashMap就是java.util.HashMap,而HashMap对应scala.collection.mutable.HashMap

受保护的字段和方法

protected在scala中比java要跟严格一点,只有继承关系才可以访问,同一个包下,也是不可以的

超类构造

类有一个主构造器和任意数量的辅助构造器,而每个辅助构造器都必须对先前定义的辅助构造器或主构造器的调用开始.

子类的辅助构造器最终都会调用主构造器,只有主构造器可以调用超类的构造器,辅助构造器永远不可能直接调用超类的构造器.

在scala的构造器中,你不能调用super(params)

  • 当前类的(辅助构造器),最终都会调用当前类的(主构造器)
  • 子类的主构造器,最终都会调用父类的构造器(可以是辅助构造器,可以是主构造器)
  1. class Animal(age: Int, hairColor: String) {
  3. }
  5. //可以给默认值
  6. class Dog(age: Int, hairColor: String) extends Animal(age, hairColor = "11") {
  8. }

抽象类

可以通过abbstract关键字标记不能被实例化的类.方法不用标记abstract,只要省掉方法体即可.
抽象类可以拥有抽象字段
抽象字段就是没有初始值的字段

  1. abstract class Person(val pname: String) {
  2.   val id: Int
  3.   var name: String
  4.   def idString: Int
  5.   def play: Unit
  6. }
  8. class Employee(pname: String) extends Person(pname) {
  9.   val id = 5;
  10.   var name = ">>>"
  11.   def idString = pname.hashCode
  13.   override def play: Unit = {
  14.     println(name)
  15.   }
  16. }

构造顺序和提前定义

  1. class Father {
  2.     val range = 10
  3.     val arr = new ArrayBuffer(range)
  4. }
  6. class Child extends Father {
  7.     override val range = 20
  8. }
  1. new Father
    —- 初始化range变量等于10
    —- 发现该变量被子类覆写了
    —- 提取range值,去子类中提取,通过提取器,提取子类中的range值 = 0
    —- new ArrayBuffer(range = 0)
  2. new Child
    —- 覆写range = 20

打印
—- arr.length = 0
—- range = 20

问题解决: 3种方案

  1. 可以将val声明为final,这样子类不可改写
  2. 可以将超类中将val声明为lazy,这样安全但是并不高效
  3. 还可以使用提前定义语法,可以在超类的构造器执行之前初始化子类的val字段:
  1. class Ant2 extends {
  2.     override val range = 3
  3. } with Creature

里面大括号表示是Creature的子类,并且在初始化的时候先初始化这个匿名类

scala继承层级

在scala中,所有其他类都是AnyRef的子类,类似java的Object
AnyVal和AnyRef都扩展自Any类.Any类是根节点
Any中定义了isInstanceOf,asInstanceOf方法,以及哈希方法等
Null类型的唯一实例就是null对象.可以将null赋值给任何引用,但不能赋值给值类型的变量

当做接口使用的特质

特质中没有实现的方法就是抽象方法.类通过extends继承特质,通过with可以继承多个特质

  1. trait Logger {
  2.   def log(msg: String)
  3. }
  5. class ConsoleLogger extends Logger with Cloneable with Serializable {
  6.   override def log(msg: String): Unit = {
  7.     println(msg)
  8.   }
  9. }

特质中的方法并不一定是抽象的

混入

  1. /**
  2.   * 叠加特质的执行顺序
  3.   * 1. 动态混入: 右向左执行
  4.   * 2. 情景: 混入的多个特质,是继承了同一个特质
  5.   * 3. super关键字为向左调用
  6.   */
  8. trait Logger3 {
  9.   def log(msg: String)
  10. }
  12. trait ConsoleLogger3 extends Logger3 {
  13.   def log(msg: String) {
  14.     println(msg)
  15.   }
  16. }
  18. trait TimestampLogger3 extends ConsoleLogger3 {
  19.   override def log(msg: String) {
  20.     super.log(new java.util.Date() + " " + msg)
  21.   }
  22. }
  24. trait ShortLogger3 extends ConsoleLogger3 {
  25.   override def log(msg: String): Unit = {
  26.     super.log(if (msg.length <= 15) msg else  s"${msg.substring(0, 12)}...")
  27.   }
  28. }
  30. class Account3 {
  31.   protected var balance = 0.0
  32. }
  34. abstract class SavingsAccount3 extends Account3 with Logger3 {
  35.   def withdraw(amount: Double) {
  36.     //没有实体下面有混入的
  37.     if (amount > balance) log("余额不足")
  38.     else balance -= amount
  39.   }
  40. }
  42. object Main3 extends App {
  43.   //TimestampLogger3
  44. //  val acct1 = new SavingsAccount3 with TimestampLogger3 with ShortLogger3
  45. //  acct1.withdraw(100)
  47.   //ShortLogger3
  48.   val acct1 = new SavingsAccount3 with ShortLogger3 with TimestampLogger3
  49.   acct1.withdraw(100)
  50. }