Scala_类-》Scala 类的构造

最新推荐文章于 2023-05-07 08:06:23 发布
最新推荐文章于 2023-05-07 08:06:23 发布
阅读量870 收藏
点赞数 1
分类专栏： Scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010003835/article/details/84778957
版权

 

本篇文章主要科普如何创建一个Scala的类，主要从以下几个方面阐述：

 

1. 基础的Scala构造函数

  1.1 基础语法

  1.2 构造参数对访问权限的影响

  1.3 对构造函数增加限定符

2.Scala类的辅助构造函数

  2.1 辅助构造函数 基本语法

  2.2 辅助构造函数 注意的事项

3.辅助构造函数对主构造函数的调用

4.继承关系下，调用父类构造函数

  4.1 一个基本的继承示例

  4.2 如何调用父类的构造函数

  4.3 构造函数经验总结

5.模板类 case 方法

  5.1 模板类样例

  5.2 使用模板类的构造方法

6.不调用new 方法创建类的实例   伴生类，  apply 方法

  6.1 伴生类与apply方法

  6.2 伴生类 apply 方法的重载

  6.3 伴生类 的 继承 与 apply 方法

 

简介：Scala 的类创建与Java 有较大不同，比如：

1）Scala 中创建类，可以不使用new 关键字。

2）Scala 中 可以通过模板类生成一些基础的方法。

。。。

 

下面根据目录对以上的点进行总结归纳：

 

1. 基础的Scala构造函数

 

1.1 基础语法

scala 的基础构造函数是直接写在类定义上的。

参考下面案例：

package classDefined

import scala.collection.mutable.ArrayBuffer

/**
  * Created by szh on 2018/12/4.
  */
class ClassOrigin(var name: String, var age: Int, var tel: Option[Long] = None, var address: Option[String] = None) {

  override def toString: String = {
   val d = new StringBuffer()
    d.append(name.toString).append(" ")
    d.append(age.toString).append(" ")
    d.append(tel.toString).append(" ")
    d.append(address.toString)
    d.toString
  }
}

object TestClassDefine1 extends App {

  val userA = new ClassOrigin(name = "sunzhenhua", age = 22)
  println(userA)

}

 

1.2 构造参数对访问权限的影响

此外，我们看下用不同修饰符，修饰构造函数参数的效果

不同修饰符的可见性
可见性可访问可修改
var是否
val是否

缺省可见性

(非 var , 非 val)

否否

给val 和 var

加 private 关键字

否否

 

参考案例 ：

package classDefined

/**
  * Created by szh on 2018/12/4.
  */
class ClassOrigin2(name: String, val age: Int, private var tel: Option[Long] = None, address: Option[String] = None) {

  override def toString: String = {
    val d = new StringBuffer()
    d.append(name.toString).append(" ")
    d.append(age.toString).append(" ")
    d.append(tel.toString).append(" ")
    d.append(address.toString)
    d.toString
  }
}

object TestClassDefine2 extends App {

  val userA = new ClassOrigin2(name = "sunzhenhua", age = 22)
  println(userA)

  //缺省访问权限
  println(userA.name)

  //val访问权限
  userA.age = 33

  //给var/val 增加private 限定符
  println(userA.tel)

}

 

1.3 对构造函数增加限定符

注意Scala 的构造函数，还可以用不同修饰符进行修饰，比如 private  

加了 private 修饰符，类的构造函数就是私有的，不能通过 new 创建。

示例 ：

package classDefined

/**
  * Created by szh on 2018/12/4.
  */
class ClassOrigin3 private (name: String, val age: Int, private var tel: Option[Long] = None, address: Option[String] = None) {

  override def toString: String = {
    val d = new StringBuffer()
    d.append(name.toString).append(" ")
    d.append(age.toString).append(" ")
    d.append(tel.toString).append(" ")
    d.append(address.toString)
    d.toString
  }
}

object TestClassDefine3 extends App {

  //val userA = new ClassOrigin3(name = "sunzhenhua", age = 22)
  //println(userA)

}

 

但是，这样仅有一个构造函数的类显然不能满足 所有的需求。为此，需要辅助构造函数进行支持。

 

 

2.Scala类的辅助构造函数

 

2.1 辅助构造函数 基本语法

辅助构造 主要是对单一的构造函数的一个辅助支持。 但是这个功能， 个人感觉跟Scala 的参数的默认值有些重复，

示例：

package classDefined

/**
  * Created by szh on 2018/12/4.
  */
class ClassConstructSupport(var name: String, var age: Int, var tel: Option[Long] = None, var address: Option[String] = None) {

  def this(name: String, age: Int) {
    this(name, age, None, None)
  }

  def this(name: String) {
    this(name, 0, None, None)
  }

  override def toString: String = {
    val d = new StringBuffer()
    d.append(name.toString).append(" ")
    d.append(age.toString).append(" ")
    d.append(tel.toString).append(" ")
    d.append(address.toString)
    d.toString
  }
}

object TestClassDefine4 extends App {

  val userA = new ClassConstructSupport(name = "sunzhenhua", age = 22)
  println(userA)

  val userB = new ClassConstructSupport("copy")
  println(userB)

}

此外，辅助构造函数有些需要主要的地方

 

2.2 辅助构造函数 注意的事项

 

1.辅助构造函数不能设置修饰符

错误示例：

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

2.辅助构造函数的第一行代码，必须从调用之前的构造函数开始

错误示例：

 def this(name: String, age: Int) {
    var age2 = 33
    this(name, age2, None, None)
  }

3.辅助构造函数必须用 this 命名创建

4.每个构造函数必须有不同的签名

5.一个构造函数通过 this 调用另一个不同的构造函数。

 

 

3.辅助构造函数对主构造函数的调用

 

辅助构造函数对主构造函数主要通过  this 进行调用。

 

 

4.继承关系下，调用父类构造函数

 

4.1 一个基本的继承示例

 

本篇不详细介绍 scala 继承，但是给出一个 基本的模板：

package classDefined

/**
  * Created by szh on 2018/12/4.
  */
class ClassConstructSupportExtend(var name: String, val age: Int, var tel: Option[Long] = None, var address: Option[String] = None) {

  def this(name: String) {
    this(name, 0, None, None)
  }

  def this() {
    this("")
  }

  override def toString: String = {
    val d = new StringBuffer()
    d.append(name.toString).append(" ")
    d.append(age.toString).append(" ")
    d.append(tel.toString).append(" ")
    d.append(address.toString)
    d.toString
  }
}

class ClassConstructSupportExtendChild(name: String, var qq: Long = 0) extends ClassConstructSupportExtend(name) {

  override val age: Int = 22
}

object TestClassDefine7 extends App {

  val userA = new ClassConstructSupportExtendChild(name = "sunzhenhua")
  println(userA)

}

 

 

 

4.2 如何调用父类的构造函数

 

       可以在子类的主构造函数中控制被调用的超类的构造函数，

但是无法控制被子类构造调用的超类构造函数。

 

原因：

   对子类构造函数而言，因为一个辅助构造函数的第一行必须去调用当前类的另一个构造函数，

那么它就无法调用超类的构造函数。

 

额外注意的点:

1.继承的主构造函数，继承的同名参数，不能修改其类型

2.尽量不要使用参数默认值混用的方式，即若有辅助构造函数，尽量不要使用参数默认值，容易产生编译错误 ！！！！

 

下面给出一个示例：

package classDefined

/**
  * Created by szh on 2018/12/4.
  */
class ClassConstructSupportExtend(var name: String, val age: Int, var tel: Option[Long] = None, var address: Option[String] = None) {

  def this(name: String) {
    this(name, 0, None, None)
  }

  def this() {
    this("")
  }

  override def toString: String = {
    val d = new StringBuffer()
    d.append(name.toString).append(" ")
    d.append(age.toString).append(" ")
    d.append(tel.toString).append(" ")
    d.append(address.toString).append(" ")
    d.toString
  }
}

class ClassConstructSupportExtendChild(name: String, var qq: Long, var mail: String) extends ClassConstructSupportExtend(name) {

  override val age: Int = 22

  def this(name: String, mail: String) {
    this(name, 0, mail)
  }

  def this(mail: String) {
    this("???", mail)
  }

  override def toString: String = {
    val tmp = new StringBuffer(super.toString)
    tmp.append(qq).append(" ")
    tmp.append(mail).append(" ")
    tmp.toString
  }
}

object TestClassDefine7 extends App {

  val userA = new ClassConstructSupportExtendChild(name = "sunzhenhua", mail = "KK")
  println(userA)

  var userB = new ClassConstructSupportExtendChild("870991173@qq.com")
  println(userB)

}

 

 

4.3 构造函数经验总结

 

1.主构造函数，参数尽量写全部的参数。在辅助构造函数对参数进行精简。

 

2.若存在继承并调用主类构造函数的场景。由于只能继承一个主类的构造函数，所以，推荐继承参数最多的构造函数。

 

 

 

5.模板类 case 方法

 

 5.1 模板类样例

 

将一个类定义为case类会生成许多模板代码，好处在于：

1.会生成一个apply 方法，这样可以不调用new 关键字创建新的实例。

2.由于case类的构造函数参数默认是 val, 那么构造函数参数会自动生成访问方法。如果是 var 也会有修改方法。

3.会生成一个默认的toString 方法。

4.会生成一个 unapply 方法，在模式匹配时很好用。

5.会生成equals 和 hashCode 方法。

6.还有一个copy 方法。

 

下面给出一个模板类的样例:

case class Person(var name: String, var age: Int)

是不是非常简易 ！！

 

5.2 使用模板类的构造方法

 

当使用 case 生成模板类，由于生成的是apply 方法，此时我们不需要使用 new 关键字，就可以生成一个实例了。

package classDefined


case class Person(var name: String, var age: Int)

/**
  * Created by szh on 2018/12/5.
  */
object ClassCaseConstruct extends App {

  val d = Person("cc", 22)
  println(d.toString)
}

 

 

 

6.不调用new 方法创建类的实例   伴生类，  apply 方法

 

  6.1 伴生类与apply方法

 

伴生类，其实主要是 类 + 同名的对象 实现的。使用 伴生类 的 apply 的方法，可以在生成类实例的时候，不需要 new 关键字。

下面是一个简易的伴生类。

 

  6.2 伴生类 apply 方法的重载

伴生类的apply 的方法，也可以进行重载。下面演示一个较为复杂的案例。

跟 6.1 结合成一个样例：

package classDefined

class PersonCC {

  var userName = ""
  var password = ""
  var age = 0

  override def toString : String = {
    val s = new StringBuffer()
    s.append(userName).append(" ")
    s.append(password).append(" ")
    s.append(age).append(" ")
    s.toString
  }
}

object PersonCC {

  def apply(userName: String = "sunzhenhua", password: String = "123456", age: Int): PersonCC = {
    val d = new PersonCC
    d.userName = userName
    d.password = password
    d.age = age
    d
  }

  def apply(userName : String): PersonCC = {
    this.apply(userName = userName, age = 0)
  }

}


/**
  * Created by szh on 2018/12/5.
  *
  * @author sunzhenhua
  */
object OjectClassConstruct extends App {

  val d = PersonCC(age = 12)
  println(d.toString)

  val f = PersonCC("cccc")
  println(f.toString)

}

 

 

  6.3 伴生类 的 继承 与 apply 方法

当我们继承上面的 PersonCC ，apply 方法是否帮我们生成了一个真正的构造函数呢？

 

 

可以看到实际上，apply 并未为我们生成真实的构造函数。 只是。我们在对象中定义一个 apply 方法，可以减少 new 生成对象而已。apply 实际上，还是调用了对象真正的构造函数生成实例。这点我们要特别注意。

示例代码：

package classDefined

class PersonCC {

  var userName = ""
  var password = ""
  var age = 0

  override def toString: String = {
    val s = new StringBuffer()
    s.append(userName).append(" ")
    s.append(password).append(" ")
    s.append(age).append(" ")
    s.toString
  }
}

object PersonCC {

  def apply(userName: String = "sunzhenhua", password: String = "123456", age: Int): PersonCC = {
    val d = new PersonCC
    d.userName = userName
    d.password = password
    d.age = age
    d
  }

  def apply(userName: String): PersonCC = {
    this.apply(userName = userName, age = 0)
  }

}

//class PersonDD(userName: String, password: String, age: Int) extends PersonCC(userName, password, age) {
//
//
//}

class PersonDD2(userName: String, password: String, age: Int) extends PersonCC {


}


/**
  * Created by szh on 2018/12/5.
  *
  * @author sunzhenhua
  */
object OjectClassConstruct extends App {

  val d = PersonCC(age = 12)
  println(d.toString)

  val f = PersonCC("cccc")
  println(f.toString)

  val g = new PersonDD2("22","cc",10)
  println(g.toString)

}

 

高达一号
关注
专栏目录
Scala 类的构造方法
安纳西丶小雨的博客
06-12 3090
scala类的构造器scala的构造，分为主构造器和辅助构造器辅助构造器scala和java的构造器的区别 scala的构造，分为主构造器和辅助构造器 主构造器的定义和类的定义交织在一起 定义一个主构造器 class Xxx(参数列表) { } 类名后面的内容就是主构造器， 如果参数列表为空的话，()可以省略 scala的类有且仅有一个主构造器，要想提供更加丰富的构造器，就需要使用辅助构造器 辅...
scala的构造函数
齐梦星空
05-26 3631
主构造函数里的参数,如果不声明为var或者val,则该参数只能被当做一个类内不可变参数使用,不能被当做类的字段,既外部不能访问该变量 当为主构造函数的的参数添加var,或者val声明,则该参数被升级为类的成员变量 ...
Scala-构造函数
weixin_30904593的博客
02-13 249
/*scala的构造函数分为主构造函数和辅助构造函数。 一、主构造函数在Scala中，每个类都有主构造函数，和类的定义交织在一起。一个Scala类的主构造函数包括：1、构造函数的参数；2、类体中调用的方法；3、在类体中执行的语句和表达式。如果类名之后没有参数，则该类具备一个无参主构造函数，这样一个构造函数仅仅是简单地执行类体中的所有语句。 二、辅助构造函数1.辅助构造函数的名称为this,这主...
scala构造方法入门
最新发布
鸭梨的博客
05-07 526
辅助构造方法必须调用主构造方法或其他已经定义的辅助构造方法，这是 Scala 的语法要求。当定义一个辅助构造方法时，它必须以 def 关键字开始，后面跟着构造方法的名称和参数列表。在定义辅助构造方法时，我们可以使用 this 关键字调用类的其他构造方法。如果我们要调用主构造方法，则可以使用 this 关键字并传入主构造方法所需的参数列表；如果我们要调用其他辅助构造方法，则可以使用 this 关键字并传入其他辅助构造方法所需的参数列表。
Scala之主构造函数
热门推荐
Laurence的技术博客
03-15 2万+
主构造函数首先，我们必须要非常清晰明确的认识到：主构造函数不是你看到class后面跟的参数列表，那怎么可能是主构造函数呢？那只是主构造函数的函数列表！那主构造函数的函数体在那里呢？答案是：class body里所有出去字段和方法声明的语句，剩下的一切都是主构造函数的，它们在class实例化时一定会被执行的。所以说，Scala的主构造函数包含这些部分： The constructor paramete
jdbi-scala_2.9.1-0.2.0.zip
10-14
6. **插件机制**：Jdbi Scala支持插件扩展，允许开发者自定义SQL构造器、结果集处理器等，以满足特定需求。 7. **函数式编程支持**：结合Scala的函数式编程特性，可以使用高阶函数和柯里化等手法，写出简洁且可复用...
scala-io-performace_2.9.1-0.2.0.zip
10-23
Javadoc是Java的一种规范，用于生成关于源代码的文档，包括类、接口、构造函数、方法等的注释。这个工具的目的是使得Java方法能够更方便地与Javadoc注释关联，提高代码的可读性和维护性。在开发过程中，良好的...
scala 主构造函数_Scala-构造函数
weixin_33737167的博客
01-14 1588
/*scala的构造函数分为主构造函数和辅助构造函数。一、主构造函数在Scala中，每个类都有主构造函数，和类的定义交织在一起。一个Scala类的主构造函数包括：1、构造函数的参数；2、类体中调用的方法；3、在类体中执行的语句和表达式。如果类名之后没有参数，则该类具备一个无参主构造函数，这样一个构造函数仅仅是简单地执行类体中的所有语句。二、辅助构造函数1.辅助构造函数的名称为this,这主要是考虑...
scala-java8-compat：用于Scala的Java 8兼容性工具包
03-04
这些设计用于使用Java 8 lambda语法方便地构造Scala函数。 用法 import scala.concurrent.* ; import static scala.compat.java8.JFunction.* ; class Test { private static Future< Integer> futureExample ( ...
accord-scalatest_2.10-0.2.1.zip
10-13
【标题】"Accord-ScalaTest_2.10-0.2.1.zip" 提供的是一个基于ScalaTest的测试框架Accord的版本，它适用于Scala 2.10。Accord是一个强大的验证库，它允许开发者在Scala中编写简洁、可读性强的测试代码。这个版本可能...
scala 构造函数_具有示例的Scala构造函数
cumtb2009的博客
07-27 533
scala 构造函数 Scala构造函数 (Scala constructors) A constructor is a function that is called at the time of initialization of objects. A constructor is just like a method of a class that contains instructions...
scala 构造函数
杨鑫newlife的专栏
07-19 868
class Calculator(brand: String) { // 构造函数 val color: String = if (brand == "TI") { "blue" } else if (brand == "HP") { "black" } else { "write" } // 自定义函数 def add(m: Int, n:I...
Scala构造器（构造方法）的使用
FlatTiger的博客
03-06 1593
构造器作用 构造对象 初始化属性 构造器分类 主构造器：声明类时，同时声明了类的主构造器。一个类只能有一个主构造器。 辅助构造器：               =>方法名必须叫this。               =&
Scala讲座：类定义和构造函数
付哥的技术课堂
04-20 1143
转载自：http://developer.51cto.com/art/200912/166814.htm 本文选自Scala讲座的第三篇的第一部分，首先，从定义Java中的类出发，然后看看如何定义Scala中的类及构造函数，希望大家喜欢。 有的时候，不同的编程语言，就是换了一件衣服而已。穿着穿着，就舒服了。 本文节选自最近在日本十分流行
Scala 构造函数
Simple 专栏
09-18 757
 Scala默认主构造函数 在scala中，如果不指定主构造函数，编译器将创建一个主构造函数的构造函数。 所有类的主体的声明都被视为构造函数的一部分。它也被称为默认构造函数。 Scala默认主构造函数示例 class Student{ println("Hello from default constructor"); }     Scala主要构造函数 Scal...
scala自学之路-20-构造函数
u012045045的博客
03-03 165
/*class ConstructorDemo { var a: Int = 0 println(" Constructor study") //定义辅助构造函数 def this(a1: Int) { //需要调用主构造函数或者其他辅助构造函数 this() this.a = a1 } }*/ //定义带有参数的主构造函数 /*class ConstructorDemo(var b: Int) { var a: Int = 0 printl.
scala构造参数
w_mchen的博客
12-25 544
package cn.kgc //伴生类 class Oop1 (name:String,age:Int){//scala默认的主构造函数 private var uname:String=name private var uage :Int=age private var uaddress:String=_ def this(){ this(" ",0) println("无参") } def this(name:String){ this(name,0) } def this(
Scala 中的构造器
afei2530的博客
09-01 175
Scala上的从构造器也有一定的限制，Scala编程中写道。 “Scala 里的每一个从构造器的第一个动作都是调用同一个类里面其他的构造器。换句话说 就是，每个 Scala 类里的每个从构造器都是以“this(...)”形式开头的。被调用的构造器既可以是主构造器（好像 Rational 这个例子），也可以是从文本上来看早于调用构造器的其它从构造器。这个规则的根本结果就是每一个 Sca...
Scala语言规范详解-中文版
"Scala语言规范-中文教程，由EPFL编程方法实验室发布，涵盖了Scala的词法、标识符、命名和域、类型系统、声明与定义、类与对象等多个方面的详细内容，旨在帮助学习者理解Scala的语法和特性。" Scala是一种多范式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值