介绍

Scala类可以包含两种构造函数：

• 主要构造函数
• 辅助构造函数

在之前的文章中，我们已经讨论了有关Primary Constructor的问题。
在本文中，我们将通过适当的示例深入讨论辅助构造函数。

什么是辅助构造函数？

在Scala中，我们可以使用" def"和" this"关键字来定义类似于方法的辅助构造函数。
" this"是构造函数名称。

辅助构造函数也称为辅助构造函数。
Scala类可以包含零个或者一个或者多个辅助构造函数。

辅助构造方法的优缺点

Scala辅助构造函数的主要优势是什么？在Scala中，辅助构造函数用于提供构造函数重载。

Scala辅助构造函数的主要缺点是什么？我们需要编写大量代码以使用辅助构造函数提供构造函数重载。
那么如何解决这个问题呢？请仔细阅读这篇文章的最后一部分。

我们应该使用与辅助构造函数名称相同的" this"，然后如何在Scala中定义更多的辅助构造函数。
我们可以使用不同的参数列表定义多个辅助构造函数。

什么是构造函数，方法或者函数的不同参数列表？参数列表不同意味着：a)参数数量不同或者b)参数类型不同

现在，我们将在下一节中讨论辅助构造器以及语法和示例。

Scala辅助构造函数示例：

我们在类主体中使用" def"和" this"关键字定义辅助构造函数，但不在类定义中定义。
我们使用类定义来声明主构造函数。

要记住的要点：-注意：-每个辅助构造函数都应调用以前定义的构造函数之一。
辅助构造函数可以使用"此"名称来调用主构造函数或者另一个辅助构造函数。

示例1：-使用一个主构造函数和零参数辅助构造函数创建一个Scala类。

员工1.scala

class Employee1(val empId : Int, val empName:String){	
  println("From Primary Constructor")	
  def this(){
	this(0,null)
	println("From Zero-Argument Auxiliary Constructor")
  }	
}

测试Employee1.scala：-为了测试about程序，我们将编写一些示例示例，如下所示：

Employee1Test1.scala

object Employee1Test1 extends App{
val emp1 = new Employee1()  
}

输出：-我所有的Scala示例都放置在Windows计算机中的" E：>"驱动器中。

E:\>scalac Employee1.scala
E:\>scalac Employee1Test1.scala
E:\>scala Employee1Test1
From Primary Constructor
From Zero-Argument Auxiliary Constructor

通过观察此输出，我们可以说零参数辅助构造函数调用了主要构造函数。
因此，它首先执行主构造函数，然后执行零参数辅助构造函数。
因为辅助构造函数包含对主构造函数的调用。

Employee1Test2.scala

object Employee1Test2 extends App{
val emp2 = new Employee1(1001, "Scala")  
}

输出：

E:\>scalac Employee1.scala
E:\>scalac Employee1Test2.scala
E:\>scala Employee1Test2
From Primary Constructor

javap输出：

E:\>scalac Employee1.scala

E:\>javap Employee1.class
Compiled from "Employee1.scala"
public class Employee1 {
public int empId();
public java.lang.String empName();
public Employee1(int, java.lang.String);
public Employee1();
}

示例2：-创建一个具有一个主构造函数和多个辅助构造函数的Scala类。

员工2.scala

class Employee2(val empId : Int, val empName:String){	
	println("From Primary Constructor")	
  def this(){
	this(0,null)
	println("From Zero-Argument Auxiliary Constructor")
  }	
  def this( empId : Int){
	this(empId, null)
	println("From One-Argument Auxiliary Constructor")
  }	 
}

其中我们开发了一个Scala程序，其中包含一个主构造函数和两个辅助构造函数。

测试Employee2.scala：-为了测试about程序，我们将编写一些示例示例，如下所示：

Employee2Test1.scala

object Employee2Test1 extends App{
val emp21 = new Employee2  
}

输出：-我所有的Scala示例都放置在Windows计算机中的" E：>"驱动器中。

E:\>scalac Employee2.scala
E:\>scalac Employee2Test1.scala
E:\>scala Employee2Test1
From Primary Constructor
From Zero-Argument Auxiliary Constructor

其中我们正在调用零参数辅助构造函数。
它调用了主构造函数，因此我们可以同时看到主构造函数和零参数辅助构造函数的输出。

Employee2Test2.scala

object Employee2Test2 extends App{
val emp22 = new Employee2(1001)   
}

输出：-我所有的Scala示例都放置在Windows计算机中的" E：>"驱动器中。

E:\>scalac Employee2.scala
E:\>scalac Employee2Test2.scala
E:\>scala Employee2Test2
From Primary Constructor
From One-Argument Auxiliary Constructor

其中我们将调用一个单变量辅助构造函数。
它调用了主构造函数，因此我们可以同时看到主构造函数和单参数辅助构造函数的输出。

Employee2Test3.scala

object Employee2Test3 extends App{
val emp23 = new Employee2(1001, "Scala")   
}

输出：-我所有的Scala示例都放置在Windows计算机中的" E：>"驱动器中。

E:\>scalac Employee2.scala
E:\>scalac Employee2Test3.scala
E:\>scala Employee2Test3
From Primary Constructor

其中我们直接调用Primary Constructor，这样我们只能看到该构造函数的输出。

javap输出：

E:\>scalac Employee2.scala

E:\>javap Employee2.class
Compiled from "Employee2.scala"
public class Employee2 {
public int empId();
public java.lang.String empName();
public Employee2(int, java.lang.String);
public Employee2();
public Employee2(int);
}

要记住的要点：-注意：-在本文中的所有示例中，辅助构造函数仅对主构造函数进行调用。
但是，它们也可以调用以前定义的其他辅助构造函数。

Scala辅助构造函数规则

在Scala编程中，我们需要遵循以下规则来定义辅助构造函数：

• 与方法类似，辅助构造函数是使用" def"关键字定义的。

• 与方法重载一样，所有辅助构造函数都应使用相同的名称：" this"。

• 每个辅助构造函数必须具有不同的签名，即，不同的参数列表。

• 每个辅助构造函数都必须调用先前定义的构造函数：它可以是主构造函数或者辅助构造函数。
  此调用应该是该构造方法中的第一个语句。

• 一个辅助构造函数通过使用"此"名称调用主构造函数或者另一个辅助构造函数。

辅助构造函数的构造函数重载

因此，我们讨论了"如何使用辅助构造函数开发构造函数重载"。
但是我的问题是"是否可以在不使用辅助构造函数的情况下提供构造函数重载"？是否可以仅使用Primary Constructor重载构造函数。

感谢Scala的新功能。
是的，有可能。
让我们在本节中探讨这个概念。

我们可以使用" Scala的默认参数概念"来解决此问题。
Scala在Scala 2.9版中引入了此功能。

示例：-让我们用主构造函数和默认参数重写相同的Employee类，而不使用辅助构造函数。

员工3.scala

class Employee3(val empId : Int = 0, val empName:String = "No-Name"){	
 println("From Primary Constructor")
}

如果在Scala REPL中执行此示例，则可以看到以下输出：

scala> class Employee3(val empId : Int = 0, val empName:String = ""){
   |    println("From Primary Constructor")
   |    println("Empid = " + (empId == 0))
   |    println("Empname = " + empName.isEmpty)
   | }
defined class Employee3

scala> var e31 = new Employee3
From Primary Constructor
Empid = true
Empname = true
e31: Employee3 = Employee3@78d6692f

scala> var e32 = new Employee3(1003)
From Primary Constructor
Empid = false
Empname = true
e32: Employee3 = Employee3@1e097d59

scala> var e33 = new Employee3(1004,"Scala Play")
From Primary Constructor
Empid = false
Empname = false
e33: Employee3 = Employee3@554e218

我们可以观察到，只有一个主要构造函数，我们实现了"构造函数重载"。