Scala学习笔记：03-Scala的类与Trait

Scala类和对象

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板
Scala中的类不声明为public，一个Scala源文件中可以有多个类。

类的声明定义

• Scala中的类不声明为public，一个Scala源文件中可以有多个类。
• 构造函数在类名以后，括号与类名之间可以使用private和public修饰，默认是public。
• 如果不加修饰符，类的成员变量默认是public
• 如果需要重写一个非抽象的方法，需要使用override关键字修饰被重写的方法。
• 同java一样，一个类只能有一个直接的父类，使用关键字extends 继承。
• 函数重载：同java一样，类中可以定义多个函数名相同，函数参数列表不同的函数

class Person ( name: String,age: Int) {

  private var m_name: String = name;
  private var m_age: Int = age;
  var classNo: String = ""

  def getName(): String={
    return this.m_name
  }

  def setName(name: String): Unit={
      this.m_name = name
  }

  def getAge():Int={
    return this.age
  }

  def setAge(age: Int): Unit ={
    this.m_age = age
  }
  
  def eat():Unit ={
      println("eate fish ")
  }

  def eat(fish: String): Unit ={
    println("eate "+ fish)
  }

  override def toString: String = {
    return "name:"+this.m_name + "\n" 
    + "age:" + this.age + "\n" + "calssNo:"+this.classNo+"\n";
  }

}

object Test{

  def main(args: Array[String]): Unit = {
    var person = new Person("zhangsan",23)
    val name:String = person.getName()
    person.classNo = "00001"
    println(name)
    val strPerson = person.toString
    println(strPerson)
    person.eate()
  }
}

抽象类

使用关键字abstract 修饰的类是虚类，虚类不能实例化，虚类中至少含有一个或多个虚函数。

虚函数: 只有函数声明没有函数实现的函数。

abstract class Animal {

  def run()

  def eat()
  
  def get(): Int

}

继承

Scala继承一个基类跟Java很相似, 但我们需要注意以下几点：

• 重写一个非抽象方法必须使用override修饰符。
• 只有主构造函数才可以往基类的构造函数里写参数。
• 在子类中重写超类的抽象方法时，你不需要使用override关键字。
• 一个子类只能有一个直接的父类，同java一样不支持多继承。

abstract class Animal(intLegs: Int) {

  private var legs: Int = intLegs;

  def getLegs(): Int={
    return this.legs
  }

  def setLegs(legs: Int): Unit={
    this.legs = legs
  }

  def run();

  def eat();

  def fly(): Unit ={
    println("I can't fly")
  }

}

class Dog(legs: Int,strColor: String) extends Animal(intLegs = legs){
  var color: String = strColor;

  def run(): Unit = {
    println("I run with legs")
  }

  def eat(): Unit = {
    println("I eat pork")
  }

  override def fly(): Unit ={
    println("I can't fly")
  }
}
object Test{

  def main(args: Array[String]): Unit = {
    val dog = new Dog(4,"red")

    dog.eat()
    dog.fly()
    dog.run()
    println(dog.getLegs())
    println(dog.color)

  }
}

伴生对象

在 Scala 中，是没有 static这个关键字，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。

Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。

当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象(companion object)。类被称为是这个单例对象的伴生类：companion class。

• 伴生对象的名称和类名一样
• 伴生对象不能带参数
• 你必须在同一个源文件里定义类和它的伴生对象。
• 类和它的伴生对象可以互相访问其私有成员。
• 实现apply方法，就可以直接获取到类对象进行操作

如下示例为单例模式的实现：

abstract class Animal(intLegs: Int) {

  private var legs: Int = intLegs;

  def getLegs(): Int={
    return this.legs
  }

  def setLegs(legs: Int): Unit={
    this.legs = legs
  }

  def run();

  def eat();

  def fly(): Unit ={
    println("I can't fly")
  }

}

class Dog private (legs: Int,strColor: String) extends Animal(intLegs = legs){
  private var color: String = strColor;

  def run(): Unit = {
    println("I run with legs")
  }

  def eat(): Unit = {
    println("I eat pork")
  }

  private def printMyself(): String ={
    println("I am private")
    return "private"
  }
  override def fly(): Unit ={
    println("My color is :" + this.color +" I can't fly")
  }
}

object Dog{

  //可以访问伴生类的私有方法
  private var dogs:Dog = new Dog(4,"color")

  //访问类的私有成员
  def getPrivateColor(): String={
    return this.dogs.printMyself()
  }
}


object Test{

  def main(args: Array[String]): Unit = {
    Dog.getPrivateColor()
  }
}

trait(特征)

Trait(特征) 相当于Java的接口，但是它比接口还功能强大，trait更像是java中的抽象类。

trait与类的区别:

• trait 不能实例化对象，类可以
• trait 可以多重继承，类只能继承一个父类

Trait 与java接口的区别

• trait中可以定义普通方法，接口不能
• trait可以有构造函数，接口则不能
• trait可以有成员变量，接口则不能

多个继承之间采用关键字 with 分割开

• 如果两个父特征Trait中有函数名相同且参数列表相同的方法，那么在子类中必须重载该方法，否则会引起冲突。

trait Action {
  def fly(){
    println("I can fly low")
  }

}

trait Equal{
  def isEqual(x: Any):Boolean
  def isNotEqual(x: Any):Boolean= !isEqual(x)
}

trait CatAnimal{
  var corlor: String = "sColor";
  def fly(): Unit ={
   println("I can fly high")
  }
}
class Cat(sName: String,sColor:String) extends CatAnimal with Action with Equal{
  var name: String = sName
  this.corlor = sColor

  override def fly(): Unit = {
    println("I can't fly")
  }

  override def isEqual(x: Any): Boolean = {
    if(x.isInstanceOf[Cat]){
      if(this.name == x.asInstanceOf[Cat].name) return true
    }
    return false
  }
}

object Test{

  def main(args: Array[String]): Unit = {
    var catObj: Cat = new Cat("maomao","red");

    var catObj2: Cat = new Cat("maomao","red");

    val ret = catObj.isEqual(catObj2)
    println(ret)

    catObj.fly()
  }
}