Scala学习笔记------类和对象

一. 类

1.类的定义

• Scala中的类不声明为public（默认为public），一个Scala源文件中可以有多个类。
• 类可以传递参数，称为类参数，类参数在整个类中都可以访问。
• 用 var 修饰的变量默认拥有 getter/setter 属性
• 使用 val 关键字：变量只拥有 getter 属性
• 使用 private[this]：变量既没有 getter 属性、也没有 setter 属性，只能通过内部的方法访问
• 如果声明的变量不需要进行初始赋值，此时 Scala 就无法进行类型推断，所以需要显式指明类型

class Animal(name:String,age:Int){
   var a:String=_  // _代表赋予初始值，如果不指明类型就会报错
   val xname=name
   def sayName(): Unit ={
    println("my name is "+xname)
  }
   def sayAge: Unit ={
    println("ma age is "+age)
  }
}
object ClassAndObject {
  def main(args: Array[String]): Unit = {
    val rabbit: Animal = new Animal("rabbit",15)
    rabbit.sayName() //output:my name is rabbit
    rabbit.sayAge() //output:my age is 15
  }
}

2.类的构造器

• 主构造器-------指在类名的后面跟上一系列参数

1. 主构造器传入的参数默认就是 val 类型的，即不可变，你没有办法在内部改变传参；
2. 写在主构造器中的代码块会在类初始化的时候被执行，功能类似于 Java 的静态代码块 static{}

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){
    // 构造代码块
}

注：在构造器前面加修饰权限 说明主构造器是私有的，外部类或外部对象不能访问

class A private (name:String,age:Int){}  

• 辅构造器---------在类中使用this来定义

  1.必须调用主构造器、其他辅助构造器或者super父类的构造器
  2.辅助构造器的名称必须为 this

def this(参数名:类型, 参数名:类型) {
    ...
}

class Animal(name:String,age:Int){
   val xname=name
   val xage=age
   var xgender="Male"
  def sayName(): Unit ={
    println("my name is "+xname)
  }
  def sayAge: Unit ={
    println("ma age is "+age)
  }
  def this(yname:String,yage:Int,ygender:String){
    this()
    this.xgender=ygender
  }
}

3.继承

• 使用extends关键字，继承会继承父类的所有属性和方法，Scala 只允许继承一个父类

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

1、重写一个非抽象方法必须使用override修饰符。
2、只有主构造函数才可以往基类的构造函数里写参数。
3、在子类中重写超类的抽象方法时，你不需要使用override关键字。

abstract  class Animal(name:String,age:Int){
  val xname=name
  val xage=age
  def abt(o:Any):Unit
  def sayName(): Unit ={
    println("My name is "+xname)
  }
}
class Dog()extends Animal("dog1",10){
     def abt(o: Any): Unit = {
      if(xname=="dog")
        println("is a dog")
      else
        println("is not a dog")
    }
    override def sayName(): Unit ={
      println("the dog name is "+xname)
  }
}

object ClassAndObject {
  def main(args: Array[String]): Unit = {
    val dog: Animal = new Dog()
    dog.abt()
    dog.sayName()
  }
}

is a dog
the dog name is dog1

二.对象

• 对象不能带参数

Scala 中的 object(对象) 主要有以下几个作用：

因为 object 中的变量和方法都是静态的，所以可以用于存放工具类；
可以作为单例对象的容器；
可以作为类的伴生对象；
可以拓展类或特质；
可以拓展 Enumeration 来实现枚举。

1.单例对象

在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。调用这个单例对象的时候，不需要new。

object Test {
  def main(args: Array[String]): Unit = {
    Singleton.say("xyl")
  }
}

object Singleton{
  def say(msg:String){
    println("hello "+msg)  //output:hello xyl
  }
}

2.伴生对象

• 当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员。

//伴生对象
object Test { 
  def main(args: Array[String]): Unit = {
    val exp =new Test()
    exp.x="scala"
    exp.printx()
  }
}
//伴生类
class Test(){
  private var x:String="xt"
  private  def printx(): Unit ={
    println("x is "+x)
  }
}

output: x is scala