scala学习(2)-面向对象

最新推荐文章于 2025-08-04 15:47:37 发布

doudoudouy

最新推荐文章于 2025-08-04 15:47:37 发布

阅读量88

点赞数

CC 4.0 BY-SA版权

文章标签： scala 学习开发语言

本文链接：https://blog.youkuaiyun.com/doudoudouy/article/details/134938417

本文介绍了Scala中的封装机制，包括属性私有化、set/get方法，不同访问权限（public、private、protected和包内访问），以及伴生对象和单例模式。此外，特质的使用、动态混入、父类与特质的叠加及其钻石问题也进行了详细阐述。

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

一、封装

1、封装操作包含有：1)将属性进行私有化；2)提供一个公共的set方法，用于对属性赋值；3)提供一个公共的get方法，用于获取属性的值。

2、访问权限：public为scala属性和方法的默认访问权限，但scala无该关键字；private为私有权限，只在类的内部和伴生对象中可用；protected为受保护权限，scala中受保护权限比jav中更为严格，同类、子类可以访问，同包无法访问；private[包名]增加包访问权限，包名下的其他类可以使用。

package chapter01

object ClassAccess {



}

class Person {

  private var id = "123456"
  protected var name = "alice"
  var sex = "femeal"
  private[chapter01] var age = 18

  def printInfo(): Unit = {
    println(s"Person: $id $name $sex $age")
  }

}

package chapter01

class ClassAccess02 {

  def main(args: Array[String]): Unit = {
    val person = new Person()
//    person.name //error只能在当前类和子类中访问
    println(person.age)
    println(person.sex)
    val worker = new Worker()
    worker.printInfo()
  }

}

class Worker extends Person {
  override def printInfo(): Unit = {
    println("Worker: ")
//    println(id) //error私有属性不可访问
    name = "llm"
    age = 25
    sex = "male"
    println(s"Person: $name $sex $age")
  }
}

3、伴生对象-单例设计模式

package chapter01

object Singleton {

  def main(args: Array[String]): Unit = {
    val student1 = Student5.getInstance()
    val student2 = Student5.getInstance()
    student1.printInfo()
    student2.printInfo()
    
    println(student1)
    println(student2)
  }
}
class Student5 private(val name: String, val age: Int){
  
  def printInfo(): Unit ={
    println(s"student: name = $name, age = $age")
  }
  
}
//饿汉式
//object Student5{
//  private val student:Student5 = new Student5("alice", 20)
//  def getInstance(): Student5 = student
//}

//懒汉式
object Student5{
  
  private var student:Student5 = _
    
  def getInstance(): Student5 = {
    if (student == null){
      student = new Student5("alice", 20)
    }
    student
  }
  
}

二、特质

1、采用特质来代替接口的概念，可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入多个特质，类似于Java中的抽象类。

2、动态混入特质，新建对象时混入特征。

package chapter01

/*hell0 from: student
student student is dating
student student is studying
young people is playing*/

object Trait {

  def main(args: Array[String]): Unit = {
    val student = new Student6
    student.sayHello()
    student.dating()
    student.study()
    student.play()

    //动态混入特质
    val studentWithTelent = new Student6 with Telent {

      override def daceing(): Unit = println("student is good at dancing")

      override def singing(): Unit = println("student is good at singing")
    }

  }

}


class Person3 {
  val name: String = "person"
  var age: Int = 15
  def sayHello(): Unit = {
    println("hell0 from: " + name)
  }
}

trait Young {
  var age: Int
  val name: String = "young"
  def play() = {
    println("young people is playing")
  }
  def dating(): Unit
}

trait Telent {
  def singing(): Unit
  def daceing(): Unit
}

class Student6 extends Person3 with Young {
  //重写冲突的属性
  override val name: String = "student"

  override def dating(): Unit = println(s"student $name is dating")
  def study() = {
    println(s"student $name is studying")
  }

  override def sayHello(): Unit = println("hell0 from: " + name)
}

3、父类和多个特质叠加在一起时，特质中包含相同的方法，从后往前进行寻找。

4、特征叠加钻石问题