Scala中的面向对象

一 定义类

1.1 类

scala中定义类的方式：class 类名，例如我们定义个Person类

class Person{
}

1.2 属性/方法

在类中
1.添加属性的方式：val/var 名称[:类型]=值
2.添加方法的方式：def 方法名(参数列表):返回值类型={方法体}

class Person{
	// 类型可以省略
	var age = 18
	// _为占位符，那么name的默认值为null
	val name:String = _
	// 属性前面加上private表示私有的，外面就不可以直接调用
	private var gender = "M"
	// 定义方法
	def playbasketball(team:String)={
		println(name + " is playing basketball for " + team)
	}
	//定义方法
	def drinking() = {
		println(this.name + " is drinking...")
	}
}

我们调用一下上面的类

object SimpleClassApp {
  def main(args: Array[String]): Unit = {
  	//创建对象
    val person = new Person
    //给对象的属性赋值
    person.name="zhang san"
    //调用对象方法
    person.playBasketball("china")
    //调用对象方法
    person.drink()
  }
}

执行结果如下：

二 构造函数/继承

构造函数的方式：
1.类名（参数列表…）主构造器
2.def this (参数列表…) 附属构造器

class Person2(val name: String, val age: Int) {
  println("进入Person2构造器")
  val job = "解说员"
  var term = ""
  /**
    * 1.附属构造起的名称this
    * 2.每个附属构造起的第一行要么调用主构造器，要么调用其他附属构造起
    *
    */
  def this(name: String, age: Int, team: String) {
    this(name, age)
    this.term = team
  }
  println("执行完Person2构造器")
}

写一个student 继承Person2，继承的子类注意点已经在注释中写清楚了

/**
  * 继承：
  * 1.子类方法/构造器执行之前，会先执行父类的构造器
  * 2.对于父类没有的字段，需要加上val/var，否则访问不到
  *
  * @param name
  * @param age
  * @param stuId
  */
class Student(name: String, age: Int, val stuId: Int) extends Person2(name, age) {
  println("进入Student构造器")

  //如果要重写父类的属性或方法，那么前面要加上override
  override val job: String = "学生"
  //重写toString
  override def toString: String = {
    this.name + "\t" + this.age + "\t" + this.stuId
  }
  println("执行完Student构造器")
}

然后调用一下上面的类

object ConstructApp {

  def main(args: Array[String]): Unit = {
    val zhangsan = new Student("zhangsan", 20, 1001)
    println("name:" + zhangsan.name + ",age:" + zhangsan.age + ",stuId:" + zhangsan.stuId)
    println(zhangsan) 
  }
}

执行结果如下：

三 抽象类

Scala继承一个基类跟Java很相似，注意点：
1.类中有一个或者多个方法/属性，没有实现，那么为抽象方法
2.子类必须要实现父类的抽象方法或者属性
3.抽象类不能new
4.子类重写的抽象方法或者属性，不一定要加上override
5.重写一个非抽象方法必须使用override修饰符。

abstract class Person3 {
  //抽象方法
  def speak
  //抽象属性
  val name: String
  //非抽象方法
  def sayHello(): Unit = {
    println("abstract sayHello...")
  }
  //非抽象方法
  def walk(): Unit = {
    println("abstract walk...")
  }
}

class Student3 extends Person3 {
  //重写抽象方法
  def speak: Unit = {
    println("override speak...")
  }

  val name: String = "zhangsan"

  //重写非抽象方法
  override def sayHello(): Unit = {
    println("override sayHello...")
  }
}

写一个object调用上面的类

object AbstractApp {

  def main(args: Array[String]): Unit = {

    val student = new Student3
    println(student.name)
    student.speak
    student.sayHello()
    //调用继承过来的方法
    student.walk()
  }
}

运行结果：