8、Scala的类和对象

最新推荐文章于 2024-08-15 21:36:03 发布

张虎宇

最新推荐文章于 2024-08-15 21:36:03 发布

阅读量297

点赞数

分类专栏： scala 文章标签：类和对象 scala

本文链接：https://blog.csdn.net/make__It/article/details/86633474

版权

scala 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、类

1.类的定义

1.声明类

类并不用声明为public，所有这些类都具有公有可见性。Class Person{}

2.属性声明

Scala会自动生成相关属性的getter 和setter方法。用val修饰的变量是只读属性，有getter但没有setter。

3.访问修饰符：https://blog.csdn.net/make__It/article/details/86633631

//在Scala中，类并不用声明为public。
//Scala源文件中可以包含多个类，所有这些类都具有公有可见性。

  class Person {

  //用val修饰的变量是只读属性，有getter但没有setter
  //（相当与Java中用final修饰的变量）

  val id = "9527"

//用var修饰的变量既有getter又有setter

  var age: Int = 1
  //类私有字段,只能在类的内部使用

  private var name: String = "唐伯虎"

  

  //对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的字段

  private[this] val pet = "小强"
}

2.构造器

主构造器：每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起

2.  辅构造器：用this关键字定义辅助构造器，每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始

3. 构造器参数：可以不带val或var，如果不带val或var的参数至少被一个方法所使用

4. 构造器私有化：类名后面加private就变成了私有的，参数被类中的方法使用后，参数就变成了不可变得对象私有字段，等同于private[this] val prop。私有的构造器，只有在其伴生对象中使用

注意：主构造器会执行类定义中的所有语句

/**

  *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起

  */

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

  //主构造器会执行类定义中的所有语句

  println("执行主构造器")

  

  try {

    println("读取文件")

    throw new IOException("io exception")

  } catch {

    case e: NullPointerException => println("打印异常Exception : " + e)

    case e: IOException => println("打印异常Exception : " + e)

  } finally {

    println("执行finally部分")

  }

  

  private var gender = "male"

  

  //用this关键字定义辅助构造器

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

    //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
    this(name, age)

    println("执行辅助构造器")

    this.gender = gender

  }

}

/**

  *构造器参数可以不带val或var，如果不带val或var的参数至少被一个方法所使用，
  *那么它将会被提升为字段

  */
//在类名后面加private就变成了私有的

  class Queen private(val name: String, prop: Array[String], private var age: Int = 18){

  

  println(prop.size)

  

  //prop被下面的方法使用后，prop就变成了不可变得对象私有字段，等同于private[this] val prop

  //如果没有被方法使用该参数将不被保存为字段，仅仅是一个可以被主构造器中的代码访问的普通参数

  def description = name + " is " + age + " years old with " + prop.toBuffer

}

  

  object Queen{

  def main(args: Array[String]) {

    //私有的构造器，只有在其伴生对象中使用

    val q = new Queen("hatano", Array("蜡烛", "皮鞭"), 20)

    println(q.description())

  }

}

1.单例对象

在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的。Object称为对象，本身就是单例的

常作用途：

存放工具方法和常量
高效共享单个不可变的实例
单例模式

作为启动类，object对象中继承app类或者实现main方法可作为启动类

package cn.itcast.scala

  import scala.collection.mutable.ArrayBuffer

  object SingletonDemo {

  def main(args: Array[String]) {

    //单例对象，不需要new，用【类名.方法】调用对象中的方法

    val session = SessionFactory.getSession()

    println(session)

  }

}


  object SessionFactory{

  //该部分相当于java中的静态块

  var counts = 5

  val sessions = new ArrayBuffer[Session]()

  while(counts > 0){

    sessions += new Session

    counts -= 1

  }

  //在object中的方法相当于java中的静态方法

  def getSession(): Session ={

    sessions.remove(0)

  }

}

  class Session{
}

在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性。

对于伴生对象，我们可以这样理解，scala里没有静态方法和静态字段，伴生对象中定义的字段和方法，对应同名类中的静态方法，所以可以认为Scala中的object关键字是静态的另一种表示方式，只是scala将这些静态的东西也封装成了对象，统一放在伴生对象中。类和伴生对象之间可以相互访问私有的方法和属性这一规则也可以很好的说明这点。那出现个问题，object是单例的，如果必须存在伴生类，怎么保证伴生类是单例的呢？可以将伴生类的构造器私有，并且在伴生对象中创建一个伴生类的对象，这个对象就是唯一的。

package cn.itcast.scala

  class Dog {

  val id = 1

  private var name = "itcast"

 
  def printName(): Unit ={

    //在Dog类中可以访问伴生对象Dog的私有属性

    println(Dog.CONSTANT + name )

  }

}

  /**

  * 伴生对象

  */

  object Dog {

  //伴生对象中的私有属性

  private val CONSTANT = "汪汪汪 : "


  def main(args: Array[String]) {

    val p = new Dog

    //访问私有的字段name

    p.name = "123"

    p.printName()

  }

}

张虎宇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
8、Scala的类和对象

目录一、类1.类的定义2.构造器二、对象1.单例对象 2.伴生对象一、类1.类的定义 1.声明类类并不用声明为public，所有这些类都具有公有可见性。Class Person{} 2.属性声明 Scala会自动生成相关属性的getter 和setter方法。用val修饰的变量是只读属性，有get...
复制链接

扫一扫

专栏目录