【Scala】之 处理对象

Scala 处理对象

---

（1）类与构造器

// Car.java

public class Car {
    private final int year;
    private int miles;
    
    public Car(int yearOfMake) {year = yearOfMake; }
    
    public int getYear() { return year; }
    public int getMiles() { return miles; }
    
    public void drive(int distance) {
        miles += Math.abs(distance);
    }
}

// UseCar.scala

class Car(val year: Int) {
  private var milesDriven: Int = 0
  
  def miles: Int = milesDriven
  
  def drive(distance: Int): Unit = {
    milesDriven += Math.abs(distance)
  }
}

在 scala 中，类构造器的参数定义了字段，并自动生成了访问器方法。

即：class Car(val year: Int) 相当于 Java 的 private final int year

同时，默认：var position: String = __ 下划线表示相应的默认值
Int 默认值　０，Double 默认值　0.0, 引用类型　默认值 null

（2）遵循　JavaBean　惯例

Scala 编译器默认生成的访问器并不遵循　JavaBean 方法的命名规范。

即使用 @BeanProperty

class Dude(@BeanProperty val fistName: String, val lastName: String) {
  @BeanProperty var position: String = __
}

这样Scala会创建访问器方法 getFirstName() getPosition() setPosition()

可以通过下面命令来查看：

scalac Dude.scala
javap -private Dude

（3）类型别名

使用别名： 类名要么太长要么不灵巧，或者有更好的名字

// WorkingWithObjects/PoliceOfficer.scala
class PoliceOfficer (val name: String)

// WorkingWithObjects/CopApp.scala
object CopApp extends App {
  type Cop = PoliceOfficer
  
  val topCop = new Cop("Jack")
  println(topCop.getClass)
}

别名只是在这个文件的作用域有效

例如，Set就是一个别名，它指向 immutable 包中的 Set 版本，而不是 mutable 包中的版本

（4）参数化类型

def echo[T](input1: T, input2: T): Unit = 
  println(s"got $input1 (${input1.getClass}) $input2 (${input2.getClass})")

[T] 表示一个参数化类型

在 Java 中 <> 指定泛型，Scala 则用 [] 代替

Tips：
Scala 的所有类型都派生自 Any

（5）单例对象

单例指的是只有一个实例的类。

// 类 
class Marker(val color: String) {
  println(s"Createing ${this}")
  
  override def toString = s"marker color $color"
}

// 单例
object MarkerFactory {
  private val markers = mutable.Map (
    "red" -> new Marker("red"),
    "blue" -> new Marker("blue"),
    "yellow" -> new Marker("yellow"))
    
  def getMarker(color: String): Marker = 
    markers.getOrElseUpdate(color, new Marker(color))
}

（6）伴生对象

可以选择将一个单例关联到一个类。
这样的单例，其名字和对应类的名字一致，因此被称为伴生对象（companion object）

class Marker private (val color: String) {
  println(s"Creating ${this}")
  
  override def toString = s"marker color $color"
}

object Marker {
    private val markers = mutable.Map (
    "red" -> new Marker("red"),
    "blue" -> new Marker("blue"),
    "yellow" -> new Marker("yellow"))
    
  def getMarker(color: String): Marker = 
    markers.getOrElseUpdate(color, new Marker(color))
}

Marker 的构造器 被声明为private， 它的伴生对象可以访问它

（6）包对象

如果你发现自己创建一个类，仅仅是为了保留在同一个包中的其他类之间共享的一组方法
那么包对象就能避免创建并重复引用这样一个额外的类的负担。