Posted 2019-08-02Updated 2021-08-02Java / Scala39 minutes read (About 5790 words)0 visits

Scala 自定义实体

Class

Scala是纯面向对象语言，所有变量都是对象，所有操作都是方法调用

class定义类，包括类名、主构造参数，其中成员可能包括
- 普通类可用new创建类实例

成员说明

常/变量：声明时必须初始化，否则需定义为抽象类，相应成员也被称为抽象成员常/变量
- 可以使用占位符_初始化
  - AnyVal子类：0
  - AnyRef子类：null
抽象类型：type声明
方法、函数
内部类、单例对象：内部类、单例对象绑定至外部对象
- 内部类是路径依赖类型
- 不同类实例中的单例对象不同

Java：仍然会为匿名类生成相应字节码文件

Java：public类成员常/变量在编译后自动生成getter、 setter（仅变量）方法

即使是公有成员也会被编译为private

对其访问实际上是通过setter、getter方法（可显式调用）

内部类型投影

类型投影：Outter#Inner类型Inner以Outter类型作为前缀， Outter不同实例中Inner均为此类型子类

class Outter{
	class Inner
	def test(i: Outter#Inner) = i
}

val o1 = new Outter
val o2 = new Outter

// 二者为不同类型
val i1 = new o1.Inner
val i2 = new o2.Inner

// 类型投影父类作为参数类型
o1.test(i2)
o2.test(i1)

单例类型

单例类型：所有对象都对应的类型，任意对象对应单例类型不同

import scla.reflect.runtime.universe.typeOf
class Dog
val d1 = new Dog
val d2 = new Dog
typeOf[d1.type] == typeOf[d2.type]		// `false`
val d3: d1.type = d1					// 两者单例类型也不同

链式调用

class Pet{
	var name: String = _
	var age: Float = _
	// 返回类型单例类型，保证类型不改变
	def setName(name: String): this.type = {
		this.name = name
		this
	}
	def setAge(age: Float): this.age = {
		this.age = age
		this
	}
}
class Dog extends Pet{
	var weight: Float = _
	def setWeight(weight: Float): this.type = {
		this.weight = weight
		this
	}
}

// 若没有设置返回类型为单例类型`this.type`，`setAge`之后
// 将返回`Pet`类型，没有`setWeight`方法，报错
val d = new Dog().setAge(2).setWeight(2.3).setName("Tom")

Constructor

// 带默认参数的、私有主构造方法
class Person private(var name: String, var age: Int=10){
	// 辅助构造方法
	def this(age: Int) = {
		// 必须调用已定义构造方法
		this("", age)
	}
}

主构造方法：类签名中参数列表、类体
- 其参数（类签名中）被自动注册为类成员变、常量
  - 其可变性同样由var、val声明
  - 其访问控制类似类似类体中成员访问控制
  - 但缺省继承父类可见性，否则为private[this] val
  - 参数中私有成员变、常量没有被使用，则不会被生成
  - case class主构造方法中缺省为public val
- 其函数体为整个类体，创建对象时被执行
- 可类似普通方法
  - 提供默认值来拥有可选参数
  - 将主构造方法声明为私有
辅助构造方法：this方法
- 辅助构造方法必须以先前已定义的其他辅助构造方法、或主构造方法的调用开始

主构造方法体现于其中参数被自动注册为类成员

类继承

// `extends`指定类继承
class Student(name: String, age: Int, var studentNo: Int)
	extends Person(name: String, age: Int){
}

必须给出父类的构造方法（可以是辅助构造方法）
- 类似强制性C++中初始化列表
构造函数按以下规则、顺序执行
- 父类、特质构造函数
- 混入特质：多个特质按从左至右
- 当前类构造函数
可用override重写从父类继承的成员方法、常/变量
- 重写父类抽象成员（未初始化）可省略override
- java中方法都可以视为C++中虚函数，具有多态特性

提前定义、懒加载

由于构造方法的执行顺序问题，定义于trait中的抽象成员常/变量可能会在初始化化之前被使用
可以考虑使用提前定义、懒加载避免

import java.io.PrintWriter
trait FileLogger{
	// 抽象变量
	val fileName: String
	// 抽象变量被使用
	val fileOutput = new PrintWriter(fileName: String)
	// `lazy`懒加载，延迟变量创建
	lazy val fileOutput = new PrintWriter(fileName: String)
}
class Person
class Student extends Person with FileLogger{
	val fileName = "file.log"
}
val s = new {
	// 提前定义
	override val fileName = "file.log"
} with Student

访问控制

缺省：Scala没有public关键字，缺省即为public

protected[<X>]：在X范围内的类、子类中可见

private[<X>]：在X范围内类可见

X可为包、类、单例对象等作用域
- 缺省为包含当前实体的上层包、类、单例对象，即类似Java 中对应关键字

特别的private[this]表示对象私有

只有对象本身能够访问该成员

类、伴生对象中也不能访问

class Person{
	private[this] age = 12
	def visit() = {
		val p = new Person
		// 报错，`age`不是`Person`成员
		println(p.age)
	}
}

特殊类

`abstract class`

抽象类：不能被实例化的类

抽象类中可存在抽象成员常/变量、方法，需在子类中被具体化

// 定义抽象类
abstract class Person(var name: String, var age: Int){
	// 抽象成员常量
	val gender: String
	// 抽象方法
	def print: Unit
}

// 抽象类、泛型、抽象类型常用于匿名类
val p = new Person("Tom", 8){
	override gender = "male"
	// 覆盖抽象成员可以省略`override`
	def print: Unit = println("hello")
}

`case class`

样例类

和普通类相比具有以下默认实现
- apply：工厂方法负责对象创建，无需new实例化样例类
- unapply：解构方法负责对象解构，方便模式匹配
- equals：案例类按值比较（而不是按引用比较）
- toString
- hashCode
- copy：创建案例类实例的浅拷贝，可以指定部分构造参数修改部分值
类主构造函数参数缺省为val，即参数缺省不可变公开
用途
- 方便模式匹配

样例类一般实例化为不可变对象，不推荐实例化为可变

case class Message(sender: String, recipient: String, body: String)
val message4 = Message("A", "B", "message")
// 指定部分构造参数的拷贝
val message5 = message.copy(sender=message4.recipient, recipient="C")

Value Class

Value Class：通过继承AnyVal以避免运行时对象分配机制

1	class Wrapper(val underlying: Int) extends AnyVal

特点
- 参数：仅有被用作运行时底层表示的公有val参数
- 成员：可包含def自定义方法，但不能定义额外val、 var、内嵌trait、class、object
- 继承：只能继承universal trait，自身不能再被继承
- 编译期类型为自定义类型，运行时类型为val参数类型
- 调用universal trait中方法会带来对象分配开销

用途

和隐式类联合获得免分配扩展方法

// 标准库中`RichInt`定义
implicit class RichInt(val self Int) extends AnyVal{
	def toHexString: String = java.lang.Integer.toHexString(self)
}

不增加运行时开销同时保证数据类型安全

1
2
3

class Meter(val value: Double) extends AnyVal{
	def +(m: Meter): Meter = new Meter(value + m.value)
}

JVM不支持value class，Scala有时需实例化value class

value class作为其他类型使用

value class被赋值给数组

执行运行时类型测试，如：模式匹配

Object

单例对象：有且只有一个实例的特殊类，其中方法可以直接访问，无需实例化

单例对象由自身定义，可以视为其自身类的单例
- 对象定义在顶层（没有包含在其他类中时），单例对象只有一个实例
  - 全局唯一
  - 具有稳定路径，可以被import语句导入
- 对象定义在类、方法中时，单例对象表现类似惰性变量
  - 不同实例中单例对象不同，依赖于包装其的实例
  - 单例对象和普通类成员同样是路径相关的
单例对象是延迟创建的，在第一次使用时被创建
- object定义
- 可以通过引用其名称访问对象

单例对象被编译为单例模式、静态类成员实现

Companion Object/Class

伴生对象：和某个类共享名称的单例对象

伴生类：和某个单例对象共享名称的类

伴生类和伴生对象之间可以互相访问私有成员
- 伴生类、伴生对象必须定义在同一个源文件中
用途：在伴生对象中定义在伴生类中不依赖于实例化对象而存在的成员变量、方法
- 工厂方法
- 公共变量

Java中static成员对应于伴生对象的普通成员

静态转发：在Java中调用伴生对象时，其中成员被定义为伴生类中static成员（当没有定义伴生类时）

`apply`

apply方法：像构造器接受参数、创建实例对象

import scala.util.Random

object CustomerID{
	def apply(name: String) = s"$name--${Random.nextLong}"
	def unapply(customerID: String): Option[String] = {
		val stringArray:[String] = customer.ID.split("--")
		if (stringArray.tail.nonEmpty) Some(StringArray.head)
		else None
	}
}

val customer1ID = CustomerId("Tom")
customer1ID match {
	case CustomerID(name) => println(name)
	case _ => println("could not extract a CustomerID")
}
val CustomerID(name) = customer1ID
// 变量定义中可以使用模式引入变量名
// 此处即使用提取器初始化变量，使用`unapply`方法生成值
val name = CustomerID.unapply(customer2ID).get

unapply、unapplySeq参见cs_java/scala/entity_components

应用程序对象

应用程序对象：实现有main(args: Array[String])方法的对象

main(args: Array[String])方法必须定义在单例对象中

实际中可以通过extends App方式更简洁定义应用程序对象，trait App中同样是使用main函数作为程序入口

trait App{
	def main(args: Array[String]) = {
		this._args = args
		for(proc <- initCode) proc()
		if (util.Propertie.propIsSet("scala.time")){
			val total = currentTime - executionStart
			Console.println("[total " + total + "ms")
		}
	}
}

包中可以包含多个应用程序对象，但可指定主类以确定包程序入口

`case object`

样例对象：基本同case class

对于不需要定义成员的域的case class子类，可以定义为 case object以提升程序速度
- case object可以直接使用，case class需先创建对象
- case object只生成一个字节码文件，case class生成两个
- case object中不会自动生成apply、unapply方法

用途示例

创建功能性方法

package logging
object Logger{
	def info(message: String): Unit = println(s"IFNO: $message")
}

// `import`语句要求被导入标识具有“稳定路径”
// 顶级单例对象全局唯一，具有稳定路径
import logging.Logger.info
class Test{
	info("created projects")
}

Trait

特质：包含某些字段、方法的类型

特点
- 特质的成员方法、常/变量可以是具体、或抽象
- 特质不能被实例化，因而也没有参数
- 特质可以extends自类
用途：在类之间共享程序接口、字段，尤其是作为泛型类型和抽象方法
- extend继承特质
- with混入可以组合多个特质
- override覆盖/实现特质默认实现
子类型：需要特质的地方都可以使用特质的子类型替换

Java：trait被编译为interface，包含具体方法、常/变量还会生成相应抽象类

Mixin

混入：特质被用于组合类

类只能有一个父类，但是可以有多个混入
- 混入和父类可能有相同父类
- 通过Mixin trait组合类实现多继承
多继承导致歧义时，使用最优深度优先确定相应方法

复合类型

复合类型：多个类型的交集，指明对象类型是某几个类型的子类型

1	<traitA> with <traitB> with ... {refinement}

`sealed trait`/`sealed class`

密封特质/密封类：子类确定的特质、类

sealed trait ST

case class CC1(id: String) extends ST
case object CC2 extends ST

密封类、特质只能在当前文件被继承
适合模式匹配中使用，编译器知晓所有模式，可提示缺少模式

自类型

自类型：声明特质必须混入其他特质，尽管特质没有直接扩展其他特质

特质可以直接使用已声明自类型的特质中成员

细分大类特质

trait User{
	def username: String
}
trait Tweeter{
	// 声明自类型，表明需要混入`User`特质
	this: User =>
	def tweet(tweetText: String) =
		println(s"$username: $tweetText")
}
class VerifiedTweeter(val username_: String)
	extends Tweeter with User{
	def username = s"real $username_"
}

定义`this`别名

class OuterClass{
	// 定义`this`别名，下面二者等价
	outer =>
	// outer: OuterClass =>
	val v1 = "here"
	class Innerclass {
		// 方便在内部类中使用
		println(outer.v1)
	}
}

Universal Trait

Universal Trait：继承自Any、只有def成员、不作任何初始化的trait

继承自universal trait的value class同时继承该trait方法，但是调用其会带来对象分配开销

泛型

泛型类、泛型trait
- 泛型类使用方括号[]接受类型参数
泛型方法：按类型、值进行参数化，语法和泛型类类似
- 类型参数在方括号[]中、值参数在圆括号()中
- 调用方法时，不总是需要显式提供类型参数，编译器通常可以根据上下文、值参数类型推断
泛型类型的父子类型关系不可传导
- 可通过类型参数注释机制控制
- 或使用类型通配符（存在类型）“构建统一父类”

存在类型/类型通配符

存在类型：<type>[T, U,...] forSome {type T; type U;...} ，可以视为所有<type>[]类型的父类

// 可以使用通配符`_`简化语法
// def printAll(x: Array[T] forSome {type T})
def printAll(x: Array[_]) = {
	for (i <- x) {
		print(i + " ")
	}
	println()
}

val a = Map(1 -> 2, 3 -> 3)
match a {
	// 类型通配符语法可以用于模式匹配，但存在类型不可
	case m: Map[_, _] => println(m)
}

省略给方法添加泛型参数

类型边界约束

T <: A/T >: B：类型T应该是A的子类/B的父类
- 描述is a关系
T <% S：T是S的子类型、或能经过隐式转换为S子类型
- 描述can be seen as关系
T : E：作用域中存在类型E[T]的隐式值

型变

型变：复杂类型的子类型关系与其组件类型的子类型关系的相关性

型变允许在复杂类型中建立直观连接，利用重用类抽象

abstract class Animal{
	def name: String
}
case class Cat(name: String) extends Animal
case class Cat(name: String) extends Animal

Covariant

协变：+A使得泛型类型参数A成为协变

类型List[+A]中A协变意味着：若A是B的子类型，则 List[A]是List[B]的子类型
使得可以使用泛型创建有效、直观的子类型关系

def ConvarienceTest extends App{
	def printAnimalNames(animals: List[Animal]): Unit = {
		animals.foreach{ animal =>
			println(animal.name)
		}
	}

	val cats: List[Cat] = List(Cat("Winskers"), Cat("Tom"))
	val dogs: List[Dog] = List(Dog("Fido"), Dog("Rex"))
	printAnimalNames(cats)
	printAnimalNames(dogs)
}

Contravariant

逆变：-A使得泛型类型参数A成为逆变

同协变相反：若A是B的子类型，则Writer[B]是 Writer[A]的子类型

abstract class Printer[-A] {
	def print(value: A): Unit
}
class AnimalPrinter extends Printer[Animal] {
	def print(animal: Animal): Unit =
		println("The animal's name is: " + animal.name)
}
class CatPrinter extends Printer[Cat]{
	def print(cat: Cat): Unit =
		println("The cat's name is: " + cat.name)
}

val myCat: Cat = Cat("Boots")
def printMyCat(printer: Printer[Cat]): Unit = {
	printer.print(myCat)
}

val catPrinter: Printer[Cat] = new CatPrinter
val animalPrinter: Printer[Animal] = new AnimalPrinter

printMyCat(catPrinter)
printMyCat(animalPrinter)

协变泛型
- 子类是父类的特化、父类是子类的抽象，子类实例总可以替代父类实例
- 协变泛型作为成员
  - 适合位于表示实体的类型中，方便泛化、组织成员
  - 作为[部分]输出[成员]
- 注意：可变的协变泛型变量不安全
逆变泛型
- 子类方法是父类方法特化、父类方法是子类方法抽象，子类方法总可以替代父类方法
- 逆变泛型提供行为、特征
  - 适合位于表示行为的类型中，方便统一行为
  - 仅作为输入
协变泛型、逆变泛型互补
- 对包含协变泛型的某类型的某方法，总可以将该方法扩展为包含相应逆变泛型的类

1 2	trait Function[-T, +R] // 具有一个参数的函数，`T`参数类型、`R`返回类型

Invariant

不变：默认情况下，Scala中泛型类是不变的

可变的协变泛型变量不安全

class Container[A](value: A){
	private var _value: A = value
	def getValue: A = _value
	def setValue(value: A): Unit = {
		_value = value
	}
}

// 若`A`协变
val catContainer: Container[cat] = new Container(Cat("Felix"))
val animalContainer: Container[Animal] = catCont
animalContainer.setValue(Dog("Spot"))
val cat: Cat = catContainer.getValue

Type Erasure

类型擦除：编译后删除所有泛型的类型信息

导致运行时无法区分泛型的具体扩展，均视为相同类型
类型擦除无法避免，但可以通过一些利用反射的类型标签解决
- ClassTag
- TypeTag
- WeakTypeTag
- 参见cs_java/scala/stdlib中

Java：Java初始不支持泛型，JVM不接触泛型

为保持向后兼容，泛型中类型参数被替换为Object、或类型上限

JVM执行时，不知道泛型类参数化的实际类

Scala、Java编译器执行过程都执行类型擦除

抽象类型

抽象类型：由具体实现决定实际类型

特质、抽象类均可包括抽象类型

trait Buffer{
	type T
	val element: T
}

抽象类型可以添加类型边界

abstract class SeqBuffer extends Buffer{
	type U
	type T <: Seq[U]
	def length = element.length
}

含有抽象类型的特质、类经常和匿名类的初始化同时使用

abstract class IntSeqBuffer extends SeqBuffer{
	type U = Int
}
def newIntSeqBuf(elem1: Int, elem2: Int): IntSeqBuffer =
	new IntSeqBuffer{
		type T = List[U]
		val element = List(elem1, elem2)
	}
	// 所有泛型参数给定后，得到可以实例化的匿名类

抽象类型、类的泛型参数大部分可以相互转换，但以下情况无法使用泛型参数替代抽象类型

abstract class Buffer[+T]{
	val element: T
}
abstract class SeqBuffer[U, +T <: Seq[U]] extends Buffer[T]{
	def length = element.length
}
def newIntSeqBuf(e1: Int, e2: Int): SeqBuffer[Int, Seq[Int]] =
	new SeqBuffer[Int, List[Int]]{
		val element = List(e1, e2)
	}

包和导入

`package`

Scala使用包创建命名空间，允许创建模块化程序

包命名方式
- 惯例是将包命名为与包含Scala文件目录名相同，但Scala 未对文件布局作任何限制
- 包名称应该全部为小写
包声明方式：同一个包可以定义在多个文件中
- 括号嵌套：使用大括号包括包内容
  - 允许包嵌套，可以定义多个包内容
  - 提供范围、封装的更好控制
- 文件顶部标记：在Scala文件头部声明一个、多个包名称
  - 各包名按出现顺序逐层嵌套
  - 只能定义一个包的内容
包作用域：相较于Java更加前后一致
- 和其他作用域一样支持嵌套
- 可以直接访问上层作用域中名称
  - 行为类似Python作用域，优先级高于全局空间中导入
  - 即使名称在不同文件中
包冲突方案：Java中包名总是绝对的，Scala中包名是相对的，而包代码可能分散在多个文件中，导致冲突
- 绝对包名定位包：__root__.<full_package_path>
  - 导入时：import __root__.<package>
  - 使用时：val v = new __root__.<class>
- 串联式包语句隐藏包：包名为路径分段串，其中非结尾包被隐藏

Scala文件顶部一定要package声明所属包，否则好像不会默认导入scala.等包，出现非常奇怪的错误，如：没有该方法

`import`

import语句用于导入其他包中成员，相同包中成员不需要 import语句

import users._
import users.{User, UserPreferences}
// 重命名
import users.{UserPreferences => UPrefs}
// 导入除`HashMap`以外其他类型
import java.utils.{HashMap => _, _}

若存在命名冲突、且需要从项目根目录导入，可以使用 __root__表示从根目录开始

scala、java.lang、object Predef默认导入

相较于Java，Scala允许在任何地方使用导入语句

包对象

包对象：作为在整个包中方便共享内容、使用的容器

// in file gardening/fruits/Fruit.scala
package gardening.fruits

case class Fruit(name: String, color: String)
object Apple extends Fruit("Appple", "green")
object Plum extends Fruit("Plum", "blue")
object Banana extends Fruit("Banana", "yellow")

// in file gardening/fruits/package.scala
package gardening
package object fruits{
	val planted = List(Apple, Plum, Banana)
	def showFruit(fruit: Fruit): Unit = {
		println(s"${fruit.name}s are ${fruit.color}")
	}
}

包对象中任何定义都认为时包自身的成员，其中可以定义包作用域级任何内容
- 类型别名
- 隐式转换
包对象和其他对象类似，每个包都允许有一个包对象
- 可以继承Scala的类、特质
- 注意：包对象中不能进行方法重载

按照惯例，包对象代码通常放在文件package.scala中

Annotations

注解：关联元信息、定义

注解作用于其后的首个定义、声明
定义、声明之前可以有多个注解，注解顺序不重要

确保编码正确性注解

此类注解条件不满足时，会导致编译失败

`@tailrec`

@tailrec：确保方法尾递归

1
2
3
4
5
6
7
8
9
import scala.annotations.tailrec

def factorial(x: Int): Int = {
	@tailrec
	def factorialHelper(x: Int, accumulator: Int): Int ={
		if (x == 1) accumulator
		else factorialHelper(x - 1, accumulator * x)
	}
}

影响代码生成注解

此类注解会影响生成字节码

`@inline`

@inline：内联，在调用点插入被调用方法

生成字节码更长，但可能运行更快
不能确保方法内联，当且仅当满足某些生成代码大小的启发式算法时，才会出发编译器执行此操作

`@BeanProperty`

@BeanProperty：为成员常/变量同时生成Java风格getter、setter 方法get<Var>()、set<Var>()

对成员变/常量，类编译后会自动生成Scala风格getter、 setter方法：<var>()、<var>_$eq()

Java注解

Java注解有用户自定义元数据形式
- 注解依赖于指定的name-value对来初始化其元素

`@interface`

// 定义跟踪某个类的来源的注解
@interface Source{
	public String URL();
	public String mail();
}

// Scala中注解应用类似构造函数调用
// 必须使用命名参数实例化Java注解
@Source(URL="http://coders.com",
		mail="support@coders.com")
public class MyClass

// 若注解中只有单个[无默认值]元素、名称为`value`
// 则可以用类似构造函数的语法在Java、Scala中应用
@interface SourceURL{
	public String value();
	public String mail() defualt "";
}
@SourceURL("http://coders.com/")
public class MyClass
// 若需要给`mail`显式提供值，Java必须全部使用命名参数
@Source(URL="http://coders.com",
		mail="support@coders.com")
public class MyClass
// Scala可以继续利用`value`特性
@SourceURL("http://coders.com/"
		mail = "support@coders.com")
public class MyClass

Scala 自定义实体

https://xyy15926.github.io/Java/Scala/diy_components.html

Author

UBeaRLy

Posted on

2019-08-02

Updated on

2021-08-02

Licensed under

Scala 自定义实体

Class

成员说明

内部类型投影

单例类型

链式调用

Constructor

类继承

提前定义、懒加载

访问控制

特殊类

abstract class

case class

Value Class

Object

Companion Object/Class

apply

应用程序对象

case object

用途示例

创建功能性方法

Trait

Mixin

复合类型

sealed trait/sealed class

自类型

细分大类特质

定义this别名

Universal Trait

泛型

存在类型/类型通配符

类型边界约束

型变

Covariant

Contravariant

Invariant

Type Erasure

抽象类型

包和导入

package

import

包对象

Annotations

确保编码正确性注解

@tailrec

影响代码生成注解

@inline

@BeanProperty

Java注解

@interface

Author

Posted on

Updated on

Licensed under

Like this article? Support the author with

Comments

Categories

Catalogue

Recents

Advertisement

follow.it

`abstract class`

`case class`

`apply`

`case object`

`sealed trait`/`sealed class`

定义`this`别名

`package`

`import`

`@tailrec`

`@inline`

`@BeanProperty`

`@interface`