scala类_继承

声明类（一个源文件中可以包含很多类，并且都是public级别）。

写一个person类

package cn.chinahadoop.scala
class Basic2 {
}
class Person {
  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
  val age = 10
}
object Basic2 {
  def main(args: Array[String]) {
    val p = new Person()//在没有参数的情况下你可以写括号也可以不写
    p.name="Jack"
      println(p.name+" : "+p.age)
  }
}

用var变量声明的话，他会生成get和set方法。

用val值声明的话，只会生成get方法。

package cn.chinahadoop.scala
class Basic2 {
}
class Person {
  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
  val age = 10
  private[this] val gender = "male"
}
object Basic2 {
  def main(args: Array[String]) {
    val p = new Person() //在没有参数的情况下你可以写括号也可以不写
    p.name = "Jack"
 println(p.name + " : " + p.age)
    
  }
}

声明一个私有常量，private[this]只能在Person内部使用。

构成函数

package cn.chinahadoop.scala
class Basic2 {
}
//class Person {
//  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
//  val age = 10
//  private[this] val gender = "male"
//}
class Person(val name: String, val age: Int) {
  println("this is the primary constructor")
}
object Basic2 {
  def main(args: Array[String]) {
    //    val p = new Person() //在没有参数的情况下你可以写括号也可以不写
    //    p.name = "Jack"
    // println(p.name + " : " + p.age)
    val p = new Person("Jacky", 20);
    println(p.name + " : " + p.age)
  }
}

结果

this is the primary constructor
Jacky : 20

主构造器直接跟在类名后面，主构造器的参数（参数类型不能省略）会被编译成字段。

主构造器执行的时候，会执行类中的所有语句。

假设参数声明时不带val或var，那么相当于private[this].

package cn.chinahadoop.scala
class Basic2 {
}
//class Person {
//  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
//  val age = 10
//  private[this] val gender = "male"
//}
class Person(val name: String, val age: Int) {
  println("this is the primary constructor")
  var gender:String=_
  
  //附构造器
  def this(name: String, age: Int, gender: String) {
    //附构造器都需要调用主构造器
    this(name, age)
    this.gender=gender
  }
}
object Basic2 {
  def main(args: Array[String]) {
    //    val p = new Person() //在没有参数的情况下你可以写括号也可以不写
    //    p.name = "Jack"
    // println(p.name + " : " + p.age)
    val p = new Person("Jacky", 20,"male");
    println(p.name + " : " + p.gender)
  }
}

结果：

this is the primary constructor
Jacky : male

附构造器不方法参数中可以不带var或val。

附属构造器名称为this。

每一个附属构造器必须首先调用已经存在的子构造器或者附属构造器。

package cn.chinahadoop.scala
class Basic2 {
}
//class Person {
//  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
//  val age = 10
//  private[this] val gender = "male"
//}
class Person(val name: String, val age: Int) {
  println("this is the primary constructor")
  var gender: String = _
  //副构造器
  def this(name: String, age: Int, gender: String) {
    //副构造器都需要调用主构造器
    this(name, age)
    this.gender = gender
  }
}
class Student(name: String, age: Int, val major: String) extends Person(name, age) {
  println("this is the subclass of Person,major is : " + major)

  }
object Basic2 {
  def main(args: Array[String]) {
    //    val p = new Person() //在没有参数的情况下你可以写括号也可以不写
    //    p.name = "Jack"
    // println(p.name + " : " + p.age)
//    val p = new Person("Jacky", 20, "male");
//    println(p.name + " : " + p.gender)
    val s=new Student("Justin",30,"Math")
  }
}

结果：

this is the primary constructor
this is the subclass of Person,major is : Math

先调用父类初始化，再调用子类初始化。

重写父类方法和重写父类字段。

需要使用override关键字。

package cn.chinahadoop.scala
class Basic2 {
}
//class Person {
//  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
//  val age = 10
//  private[this] val gender = "male"
//}
class Person(val name: String, val age: Int) {
  println("this is the primary constructor")
  var gender: String = _
  //副构造器
  def this(name: String, age: Int, gender: String) {
    //副构造器都需要调用主构造器
    this(name, age)
    this.gender = gender
  }
}
class Student(name: String, age: Int, val major: String) extends Person(name, age) {
  println("this is the subclass of Person,major is : " + major)
  override def toString="Override toString......."
}
object Basic2 {
  def main(args: Array[String]) {
    //    val p = new Person() //在没有参数的情况下你可以写括号也可以不写
    //    p.name = "Jack"
    // println(p.name + " : " + p.age)
//    val p = new Person("Jacky", 20, "male");
//    println(p.name + " : " + p.gender)
    val s=new Student("Justin",30,"Math")
    println(s.toString)
  }
}

结果为：

this is the primary constructor
this is the subclass of Person,major is : Math
Override toString.......

子类重写父类字段

package cn.chinahadoop.scala
class Basic2 {
}
//class Person {
//  var name: String = _ //这个意思是name出来了但暂时不给他赋初始值,这时参数类型不能省略
//  val age = 10
//  private[this] val gender = "male"
//}
class Person(val name: String, val age: Int) {
  println("this is the primary constructor")
  var gender: String = _
  val school = "ZJU"
  //副构造器
  def this(name: String, age: Int, gender: String) {
    //副构造器都需要调用主构造器
    this(name, age)
    this.gender = gender
  }
}
class Student(name: String, age: Int, val major: String) extends Person(name, age) {
  println("this is the subclass of Person,major is : " + major)
  override val school = "BJU"
  override def toString = "Override toString......."
}
object Basic2 {
  def main(args: Array[String]) {
    //    val p = new Person() //在没有参数的情况下你可以写括号也可以不写
    //    p.name = "Jack"
    // println(p.name + " : " + p.age)
    //    val p = new Person("Jacky", 20, "male");
    //    println(p.name + " : " + p.gender)
    val s = new Student("Justin", 30, "Math")
    println(s.toString)
    println(s.school)
  }
}

结果

this is the primary constructor
this is the subclass of Person,major is : Math
Override toString.......
BJU

父类字段是什么类型，子类也应该相应的类型来修饰。