目录
基本概念:
- 类(class)
- 抽象类(abstract class)
- 单例对象(object)
- 特质(trait)
- 样例类(case class)
类(class)
- 类通过class关键字定义
- 类通过new关键字创建实例对象
- 类拥有成员变量和方法
- 类的成员默认为public,也支持private、protected
- 类中无法定义静态成员变量和方法
- 类无需明确定义构造方法,通过构造参数列表声明为类的一部分
1.类的定义:
- 构造器
- 主构造器(带参构造)
- 辅构造器(无参构造) - 成员变量与方法
- 类的实例化
2.类的继承
- Scala使用“extends”关键字实现继承
- 子类重写父类的方法必须使用“override”关键字
3.抽象类
- 抽象类可包含未实现的方法,即抽象方法
- 抽象类无法实例化
- 抽象类使用“abstract”关键字修饰
-子类重写父类的抽象方法,“override”可选
- 子类重写父类非抽象方法,“override”必写
单例对象(object)
- 使用“object”关键字声明,可包含变量、方法与代码定义
- 单例对象中的成员变量、成员方法通过单例对象名直接调用
- 单例对象第一次被访问时初始化,并执行全部代码块
- 单例对象不能new,且无构造参数
- 程序入口main()方法必须定义在单例对象中
- 单例对象与同名类定义在同一文件中时形成绑定关系
//定义单例对象
object Blah {
println("Blah initializing...")
def sum(l: List[Int]): Int = l.sum
}
def main(args:Array[String]):unit = {
Blah.sum(List[Int](1, 2, 3, 4, 5))
}
伴生对象:
当你的类需要用到你的对象时,即用到既有实例方法又有静态方法的类.通常我们使用伴生对象完成
- 单例对象与同名类定义在同一个文件中时形成绑定关系
-同名类称为单例对象的伴生类
- 单例对象称为同名类的伴生对象 - 伴生类与伴生对象可相互访问各自私有成员
- 伴生对象可为伴生类增加静态成员
//伴生类
class Student(n: String, a: Int) {
private var name = n //私有变量,伴生对象可以访问
private var age = a
}
//伴生对象
// 用伴生对象来代替new
object Student {
def apply(n: String, a: Int): Student = new Student(n, a)
def main(args: Array[String]): Unit = {
val stu=Student("Jason",9) //通过伴生对象的apply()方法创建实例
println(stu.name)
}
}
特质(trait):
- Scala中没有接口(interface)的概念
- 特质用于在类之间共享程序接口和字段,类似Java接口
- 特质是字段和方法的集合,可以提供字段和方法实现
- 类和单例对象都可以扩展特质(extends)
- 特质不能被实例化,因此没有构造参数,类似Java接口
- 特质使用“trait”关键字定义
- 实现特质中的方法使用“override”
trait Pet {
val name: String
def cry():Unit
}
class Dog(val name: String) extends Pet{
override def cry()=println("wow ...")
}
val dog = new Dog("Harry")
val animals = ArrayBuffer.empty[Pet]
animals.append(dog)
animals.foreach(pet => {println(pet.name);pet.cry()}) // Prints Harry wow ...
混入特质(mixin):
- 当某个特质被用于组合类时,被称为混入
- 一个类只能有一个父类,但是可以有多个混入(分别使用extends和with)
案例:
class Person{
val mag:String="person"
def act()={
println("person")
}
}
trait MyFather extends Person{
override val mag: String = "father"
override def act()={
println("father")
}
}
trait MyMather extends Person{
override val mag: String = "mather"
override def act()={
println("mather")
}
}
trait MySister extends Person{
override val mag: String = "sister"
override def act()={
println("sister")
}
}
class MyMutleTrait extends MyFather with MyMather with MySister {
override val mag: String = "son"
}
object test{
def main(args: Array[String]): Unit = {
var mmt = new MyMutleTrait
println(mmt.mag)
mmt.act()
}
}
//最终结果由最右边一个特质决定,如果在特质类中有指定某个属性则按指定属性结果输出,若没有则按照最右边的特质结果输出
最终结果:
动态混入特质:
b和c如果 都应用了某特质,b去实现了该特质的某种方法,c并不会收到影响,完成了解耦而java接口会因为传递性,c会有b实现的方法。
案例:
//书类
class Books {
//冒号前面为别名,后面为该类实例化时必须混入相应的特质或子特质
eb:EBook=>
val ctx:String="我是书的内容"
val name:String="我是书名"
def seeBook():Unit={
play()
println(info())
}
def info():String = {
name+":"+ctx
}
}
//电子书特质(抽象类)
trait EBook {
def play():Unit;
}
//两种实现
trait IPad extends EBook{
override def play(): Unit = {
println("平板播放")
}
}
trait Phone extends EBook{
override def play(): Unit = {
println("手机播放")
}
}
//测试类
object MyDemo {
def main(args: Array[String]): Unit = {
(new Books() with IPad).seeBook()
}
}
特质与抽象类的选择
- 优先使用特质
- 抽象类只能继承一次
- 特质可以混入多个 - 需要使用带参构造方法时,使用抽象类
- 与Java互操作性
- 抽象类 与Java完全可以互操作
- 特质只有在不包含任何实现代码是才可以互操作
内部类:
- 一个类可以作为另一个类的成员,称为内部类
- Java内部类是外部类的成员
- Scala内部类绑定到外部类的对象实例
案例:
class Graph {
class Node {
var connectedNodes: List[Node] = Nil
def connectTo(node: Node) {
if (connectedNodes.find(node.equals).isEmpty) {
connectedNodes = node :: connectedNodes
}
}
}
var nodes: List[Node] = Nil
def newNode: Node = {
val res = new Node
nodes = res :: nodes
res
}
}
//测试类
val g: Graph = new Graph
val n1: g.Node = g.newNode
val n2: g.Node = g.newNode
n1.connectTo(n2) // legal
val h: Graph = new Graph
val n3: h.Node = h.newNode
n1.connectTo(n3) // illegal
//n1与n3被认为是不同的类型
//当按照如下写法时n1和n3就可以被认为是同一类型
class Graph {
class Node {
var connectedNodes: List[Graph#Node] = Nil
def connectTo(node: Graph#Node) {
if (connectedNodes.find(node.equals).isEmpty) {
connectedNodes = node :: connectedNodes
}
}
}
var nodes: List[Node] = Nil
def newNode: Node = {
val res = new Node
nodes = res :: nodes
res
}
}
样例类:
- 样例类常用于描述不可变的值对象
case class Student(name:String,age:Int) //定义样例类
val stu=Student("Jason",19) //创建样例类的实例,无需new关键字
println(stu.name) //访问对象属性
- 样例类构造参数默认声明为"val",自动实现类构造参数的getter
- 样例类构造参数声明为"var"时,自动实现类构造参数的setter和getter方法
- 样例类自动创建伴生对象
- 样例类自动实现的其他方法
- toString()、equal()、copy()、hashCode()
- 伴生对象中的apply()、unapply()
(apply主要是根据传入参数值创建伴生对象,而unapply主要接受一个对象,从对象中提取出相对应的值,主要用于模式匹配中。)
泛型类
- 泛型类指可以接受类型参数的类,泛型类在集合中被广泛使用
- 与Java不同,定义泛型类使用“[ ]”
class Stack[T] {
var elements: List[T] = Nil
def push(x: T) { elements = x :: elements }
def top: T = elements.head
def pop() {
var t = elements.head
elements = elements.tail
t
}
def showElements(){
elements.foreach(x=>print(s"$x "));println()}
}
类型边界:
- 在Scala中,类型参数可以有一个类型边界约束
- 类型上界:将类型限制为另一种类型的子类
- T<:A 表示类型变量T应该是类型A的子类
- A是具体类型,T是泛型 - 类型下界:将类型声明为另一种类型的超类
- T>:A 表示类型变量T应该是类型A的超类
-A是具体类型,T是泛型
案例:
//爷爷类
class GrandFather {
}
//父亲类
class Father extends GrandFather{
}
//儿子类
class Son extends Father {
}
//方法类
class MyTest[T<:Father]{
def abc(t:T)={
println(t)
}
}
//测试类
val value = new MyTest[Father]
value.abc(new Son()) //正确
value.abc(new GrandFather()) //报错
}
型变:
- 协变
class Foo[+T]
- 对于两种类型A和B,如果A是B的子类型,那么Foo[A]是Foo[B]的子类型 - 逆变
class Bar[-T]
- 对于两种类型 A 和 B,如果 A 是 B 的子类型,那么 Bar[B] 就是 Bar[A] 的子类型 - 不变
class Baz[T]
- 默认情况下,Scala的泛型类是不变的
案例:
class Card[+T] {
}
//大师类
class Master {
}
//教授类
class Perforess extends Master {
}
//教师类
class Teacher {
}
//方法
class MyDemo {
def abc(s:Card[Master])={
println(s)
}
}
//测试类
object Runs {
def main(args: Array[String]): Unit = {
val mt = new Card[Master]
val pf = new Card[Perforess]
val th = new Card[Teacher]
val md = new MyDemo()
md.abc(mt) //正确
md.abc(pf) //正确
// md.abc(th) //报错
}
}
//因为教授类继承了大师类,所以在方法中可以传入子类作为参数