Scala 面向对象

最新推荐文章于 2022-05-16 10:36:36 发布

原创最新推荐文章于 2022-05-16 10:36:36 发布 · 308 阅读

0 ·

CC 4.0 BY-SA版权

scala 专栏收录该内容

13 篇文章

订阅专栏

该博客主要介绍了Scala中类的相关知识，包括类的定义和使用、构造器、继承、重写、抽象类、伴生类与伴生对象、case class和Trait。其中提到占位符使用需指定类型，构造器执行顺序，继承用extend，Trait类似Java接口可实现多重继承等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述：

1.类的定义和使用

package ScalaTest1

object SimpleObjectApp {
  def main(args: Array[String]): Unit = {
    val person = new People()
    person.name = "Messi"
    println(person.name + "..." + person.age)

    person.printInfo()
    // person(person.gender) 调用不到，有private [this]修饰

    println("invoke eat method: " + person.eat())
    person.watchFootball("Barcelona")
  }
}

class People{
  // 定义属性
  var name:String = _     //使用占位符代替  var name:String = ""
  val age:Int = 10

  private [this] val gender = "male"   // 使用private [this] 只能在class内部被访问，

  def printInfo(): Unit ={
    println("gender: " + gender)
  }
  def eat():String = {
    name + "eat..."
  }
  def watchFootball(teamName: String): Unit = {
    println(name + " is watching match of "+ teamName)
  }
}

补充

占位符：变量在不知道赋什么值的时候可以先用占位符

注意：使用占位符必须先指定类型

2、构造器

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

    // 传两个参数，对应到主构造器
    val person = new Person("zhansan", 32)
    println(person.name + ":" + person.age + ":" + person.school)

    // 传三位参数，对应到附属构造器
    val person2 = new Person("zhansi", 18, "M")
    println(person2.name + ":" + person2.age + ":" + person2.school + ":" + person2.gender)

  }
}


// 跟在类名后面的称为“主构造器”
class Person(val name: String, val age: Int) {
  println("Person Constructor enter...")

  val school         = "ustc"
  var gender: String = _

  // 附属构造器，把主构造器的参数直接拿来用
  def this(name: String, age: Int, gender: String) {
    this(name, age) // 附属构造器的第一行，必须调用主构造器，或者其它附属构造器
    this.gender = gender

  }

  println("Person Constructor leave...")
}

运行结果可以看到先执行了主构造器，再执行附属构造器

Person Constructor enter...
Person Constructor leave...
zhansan:32:ustc

Person Constructor enter...
Person Constructor leave...
zhansi:18:ustc:M

3、继承

使用extend 继承父类

// Student 继承了Person，如果我们要使用Person的属性，Student构造器的参数不需要加 val 或var，否则要加上
class Student(name:String, age:Int, var major:String) extends Person(name, age){
  println("Student Constructor enter...")

  println("Student Constructor leave...")
}

调用student

val student = new Student("zhangwu", 16, "Math")
println(student.name + ":" + student.major)
println(student)

输出结果：先执行父类主构造器，再执行Student的构造器

Person Constructor enter...
Person Constructor leave...

Student Constructor enter...
Student Constructor leave...
zhangwu:Math

com.hhcycj.scala.object_04.Student@39aeed2f

println(student) 相当于 println(student.toString)

4、重写

通过 override 关键字，重写 Object 的 toString 方法

override def toString: String = "override def toString"

重写父类的 school 属性

 override val school: String = "li yang xiao xue"

5.抽象类

package ScalaTest1

object AbstractApp {

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

    val student=new Students2()
    println(student.name)
    student.speak

  }

}

/**
  * 类的一个或者多个方法没有完整的实现（只有定义，没有实现）
  */

abstract class Person2 {

  def speak

  val name: String
  val age: Int


}

// 子类实现抽象类
class Students2 extends Person2 {
  override def speak: Unit = {
    println("speak")
  }

  override val name: String = "lisi"
  override val age: Int = 20
}

6.伴生类与伴生对象

package ScalaTest1

object ApplyApp {

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

    for (i <- 1 to 10) {
      ApplyTest.incr
    }
    println(ApplyTest.count)

    val b = ApplyTest() // ==> Object.apply

    println("==================")

    // new一个class对象
    val c = new ApplyTest()
    println(c)
    c()

    // 类名() ==> Object.apply
    // 对象() ==> Class.apply
  }

}

/**
  * 伴生类与伴生对象
  * 若有一个class和其同名的object
  * 则就称object是class的伴生对象，class是object的伴生类
  */

class ApplyTest {

  def apply() = {
    println("Class ApplyTest apply ....")

  }

}

object ApplyTest {

  println("Object ApplyTest entering....")
  var count = 0

  def incr = {
    count = count + 1
  }

  // 最佳实践：在Object的apply方法中去new class
  def apply() = {
    println("Object ApplyTest apply ....")

    // 在Object中new一个class
    new ApplyTest
  }

  println("Object ApplyTest leaving....")
}

运行结果：

Object ApplyTest entering....
Object ApplyTest leaving....
10
Object ApplyTest apply ....
==================
com.lihaogn.ApplyTest@75bd9247
Class ApplyTest apply ....

7.case class

package ScalaTest1

object CaseClassApp {

  def main(args: Array[String]): Unit = {
    println(Dog("wangwang").name)
  }

}

// case class 不用new
// 通常用在模式匹配里
case class Dog(name: String)

8. Trait

类似于Java中的接口，与接口不同的是，它还可以定义属性和方法的实现。

一般情况下Scala的类只能够继承单一父类，但是如果是 Trait(特征) 的话就可以继承多个，从结果来看就是实现了多重继承。

// 第一个Trait用extends，其他的用with
class class-name(xxx:xxx) extends Cloneable with Logging with ....