class Person{

// _ 是占位符;

    var name : String = _

    val age : Int = 27

// private[this] 定义的内容无法外部使用，起到保护作用;

    private[this] val gender = "male"

}

//类的构造函数，主构造器的使用;

//1.主构造器直接跟在类名后面，主构造器中的参数会被编译成类的字段;

//2.主构造器执行的时候会执行类中的所有不包含在方法体中的语句;

//3.如果在主构造器函数中没有用 val 或者 var 去声明变量，那此时的变量是 private[this] 级别的，只能够被类内部访问 ;

class Person1 (val name : String,val age : Int) {

      println("this is constructor")

}

//附属构造器：

//1.附属构造器是用 this 来声明的;

//2.附属构造器中必须调用主构造或者其他附属构造器;

class Person2(var name : String , val age : Int) {

       println("this is constructor")

       var gender : String = _

       def this(name : String , age : Int , gender : String) {

         this(name,age)

         this.gender = gender

       }

       val University = "BJU"

}

//scala中的继承

class Student (name : String , age : Int , val major : String) extends Person2(name , age){

      println("student extends from person,major is : "+ major)

// override 覆写父类的方法

      override def toString = "override the method ..."

// override 覆写字段

      override val University = "tsinghua"

}

//scala中的抽象类，使用 abstract 关键字

abstract class people{

      def speak

      val name : String

      var age : Int

}

class Worker extends people{

      def speak{

        println("I'm a worker")

      }

      val name = "lsw"

      var age = 21

}

object OOPinScala{

       def main(args : Array[String]){

          val person = new Person

          person.name = "lucy"

          println(person.name + " : " + person.age)

          val person1 = new Person1("lucy",22)

          println(person1.name + " : " + person1.age)

          val person2 = new Person2("lsw",27,"male")

          println(person2.name+":"+person2.gender)

          val student = new Student("lsw" , 27 ,"computer")

          println(student.toString)

          println(student.University)

          val worker = new Worker()

          println(worker.name+" : "+ worker.age)

       }

}

运行结果：