Scala学习(二)——类和对象、继承和特质、泛型

类和对象、继承

父类及伴生对象

Animal类及其伴生对象

package cool.gjh
class Animal(var name: String){ //主构造器
	//成员变量
	var age: Int = 0  
	//成员常量
	val id: String = "1001" 
	
	//辅助构造器
	def this(name: String, age: Int){ 
		this(name)  //辅助构造器必须以一个主构造器或辅助构造器开始
		this.age = age
	}
	//成员方法
	def sayHello(){
		println("Hello, I'm "+name+"(id: " + id + "),and I'm " + age +" years old." )
	}
}

//伴生对象
object Animal{
	//定义apply方法
	def apply(name: String, age: Int): Animal = new Animal(name, age)
	//main函数
	def main(args: Array[String]): Unit = {
		val animal = Animal("Jack", 20)
		animal.sayHello
		animal.name = "Tom"
		animal.age = 18
		animal.sayHello
	}
}

运行结果：

E:\>scala cool.gjh.Animal
Hello, I'm Jack(id: 1001),and I'm 20 years old.
Hello, I'm ACE(id: 1001),and I'm 20 years old.

子类及伴生对象

Dog类继承Animal类及其伴生对象

package cool.gjh
class Dog(name: String) extends Animal(name: String){ //子类的主构造器必须含有父类的成员，并且不需要声明为var或者val
	age = 0 //覆盖var声明的变量，不用写var和类型
	override val id: String = "100101" //覆盖val声明的常量，前面需要加override关键字
	var sex: Boolean = true //子类新增的成员
	def this(name: String, age: Int, sex: Boolean){ //子类辅助构造器
		this(name)  //必须以主构造器或其他辅助构造器开头
		this.age = age
		this. sex = sex
	}
	override def sayHello(){ //覆盖父类的方法
		println("Hello, I'm "+name+"(id: " + id + "), I'm " + age +" years old, and I'm a " + (if(sex) "boy" else "girl"))
	}
}

//子类伴生对象
object Dog{ 
	//定义apply方法
	def apply(name: String, age: Int, sex: Boolean): Dog = new Dog(name, age, sex)
	//main函数
	def main(args: Array[String]): Unit = {
		val dog = Dog("Bob", 8, true)
		dog.sayHello
		dog.name = "Cindy" //无法修改，因为父类中的该属性和其getter/setter都是私有的
		dog.age = 100 //可以修改
		dog.sex = false //可以修改
		dog.sayHello
	}
}

运行结果：

E:\>scala cool.gjh.Dog
Hello, I'm Bob(id: 100101), I'm 8 years old, and I'm a boy
Hello, I'm Bob(id: 100101), I'm 100 years old, and I'm a girl

特质

一般实现

Animal特质

package cool.gjh.zoo

//和java的接口相同，JDK1.8后也可以有具体实现
trait Animal {
  var name: String
  var age: Int
  def eat(food: String)
}

Cat实现Animal特质：

package cool.gjh.zoo.impl

import cool.gjh.zoo.Animal

class Cat extends Animal {
  override var name: String = _
  override var age: Int = _

  def this(name: String, age: Int) {
    this
    this.name = name
    this.age = age
  }

  override def eat(food: String): Unit = {
    println("I'm a cat, my name is " + name + " and my age is " + age + ".")
    println("I like eat "+ food + ".")
  }
}

object Cat{
  def apply(name: String, age: Int): Cat = new Cat(name, age)
}

运行结果：

I'm a cat, my name is Jack and my age is 5.
I like eat 猫粮.

动态混入

新增一个特质：

package cool.gjh.food

trait Food {

  var name: String
  def make(): Unit;

}

进行动态混入：

package cool.gjh

import cool.gjh.food.Food
import cool.gjh.zoo.impl.Cat

object Main {
  def main(args: Array[String]): Unit = {
    val cat1 = Cat("Jack", 5)
    cat1.eat("猫粮")
    //动态混入
    val cat2 = new Cat("Cindy", 3) with Food {
      override def make(): Unit = {
        println("猫屎咖啡制作中......")
      }
    }
    cat2.eat("咖啡豆")
    cat2.make()
  }
}

运行结果：

I'm a cat, my name is Jack and my age is 5.
I like eat 猫粮.
I'm a cat, my name is Cindy and my age is 3.
I like eat 咖啡豆.
猫屎咖啡制作中......

泛型

泛型类

class Animal[T, K](var name:T){
	//成员
}

泛型方法

scala> def fun[T](arg: T){val tuple2: Tuple2[T, Int] = (arg, 1); println(tuple2)}
fun: [T](arg: T)Unit

scala> fun(1)
(1,1)

scala> fun("hehe")
(hehe,1)

scala> fun(true)
(true,1)

泛型边界

上边界
[T <: S]T是S的子类型，包含S
下边界
[T >: S]T是S的父类型，包含S
多上边界
[T <: S with K]T是S和K的子类型
多下边界
[T >: S with K]T是S和K的父类型
上边界和下边界混合
[T >: S <:K]T是S的父类型，K的子类型