Scala是一种面向对象的功能编程语言，因此今天我们将简要介绍一下Scala类和对象。

Scala类和对象

可以将类定义为静态模板，可以在运行时从中实例化许多对象。

让我们看一下如何在Scala中定义类的示例；

class Student() {
 	var total:Int = 0
 	def calculateTotal(ma1:Int,ma2:Int) {
 	total = ma1 + ma2
 	}
 	override def toString(): String = "(" + total + ")";
}

其中我们使用关键字" class"定义一个名为" Student"的类。
然后，我们声明一个变量total并将变量值初始化为零。
方法" calculateTotal"由参数ma1和ma2定义，参数ma1和ma2是两个主题的单独分数/得分。
分数相加，总计被计算并存储在" total"变量中。

我们将重写toString标准方法，以便在打印它时，我们可以获得有用的信息。
下图显示了它在Scala终端中的外观。

现在，我们将通过创建Student类的对象来测试该方法，如下所示。

object Stud1 {
	def main(args:Array[String]) {
	val totalMarks = new Student()
	totalMarks.calculateTotal(55,60)
	println("Grand Total Marks of the Student is"+totalMarks)
}
}

Stud1是Student类的对象。
我们使用String类型数组作为参数定义main方法。
我们使用new关键字将totalMarks创建为Student类的实例，并调用传递标记的calculateTotal方法并打印受保护的总标记。

请注意，应定义main方法，因为它是程序执行的入口点。

现在通过调用Stud1的主要方法来运行以上代码：

scala>Stud1.main(null)
Total Marks secured by the Student is(115)

在Scala中，我们将必须明确指定null作为参数，因为它是一种功能语言，并且所有函数都接受参数。
下图显示了创建对象并在Scala shell中执行它。

在Scala中扩展程序

可以扩展与Java类似的基类，但有两个限制，即只有子类的主构造函数可以将参数传递给基类构造函数，并且必须指定override关键字。

考虑重写基类方法的示例；

class Student(val m1:Int,val m2:Int) {
 	var total:Int = m1 + m2
	var ma1:Int = m1
	var ma2:Int = m2
 	def calculateTotal(ma1:Int,ma2:Int) {
 	total = ma1 + ma2
	println("Total is :"+total)
 	}
 	override def toString(): String = "(" + total + ")";
 }

学生是基类，它具有一个calculateTotal方法，该方法接受两个主题的分数并输出总分数。

现在，我们将创建一个扩展Student类的子类，该子类将四个主题的分数相加并计算总计，如下所示。

class CollegeStudent(override val m1:Int,override val m2:Int,val m3:Int,val m4:Int) extends Student(m1,m2) {
	var ma3:Int = m3
	var ma4:Int = m4
	var tot:Int = 0;
 	def calculateTotal( ma1:Int, ma2:Int, ma3:Int,  ma4:Int) {
	tot = ma1 + ma2 + ma3+ ma4
	println("Total is :"+tot)
	}
	override def toString():String = "(" + tot + ")";
}

我们将" override"关键字添加到变量m1和m2。
关键字" extends"用于扩展基类Student。
但是由于实现具有不同的定义，因此不会覆盖该方法。

创建一个CollegeStudent类的对象ColStud作为；

object ColStud {
def main(args:Array[String]) {
val total = new CollegeStudent(72,65,85,60);
total.calculateTotal(72,65,85,60);
println("Grand Total Marks of the Student is"+total)
}
}

通过执行以下命令运行以上代码；

scala> ColStud.main(null)
Total is :282
Grand Total Marks of the Student is(282)

Scala中的Singleton对象

Scala中没有static关键字，相反，我们有单例对象。
我们需要做的就是使用object关键字创建一个单例对象。
我们可以直接调用它的方法，我们不能将参数传递给它的主要构造函数。
下面是Scala中单例对象的快速示例。

object Test{
  def say(){
  println("Hi")
}
}

下图显示了如何执行上面定义的方法，请注意它与Java静态方法执行的相似程度。

Scala库中的内置对象

Scala库中有许多内置对象，其中之一是Console对象，它读取值并在终端上打印。

让我们考虑一个Console对象的例子。

object Cons {
def main(args:Array[String]) = {
  Console.println("Enter a number :");
  val num = Console.readInt;
  Console.println("Entered Number is :"+num)
  }
}

我们正在创建一个Cons对象。
在主要方法中，我们要求用户输入一个数字，并使用readInt从终端读取输入的数字并打印输入的数字。

运行代码，如下所示

>Cons.main(null)
Enter a number :
Entered Number is :345

Scala弃用模式

下图显示了在Scala shell中定义Cons对象时发生的情况。

注意警告"有一个弃用警告；请使用-deprecation重新运行以获取详细信息"。
它不会告诉我们引起该警告的行号，但是已定义了对象。
但是，使用不推荐使用的方法不是一个好主意。
因此，我们可以使用-deprecation选项运行Scala shell，它可以提供有用的信息来对其进行更正。
下图显示了它的作用。

Scala中的伴侣类和对象

与类对象同名的对象是伴随对象，该类称为伴随类。
例如;

class Student(sid:Int, sname:String){
val Id = sid
val name = sname
 
override def toString() =
this.Id+" "+" , "+this.name
}

其中我们创建一个以sid和sname作为参数的Student类，并显示这些参数。

使用displayDetails方法创建一个与学生同名的对象，我们将其中打印学生的详细信息。
该Student对象被称为伴随对象，因为它与该类具有相同的名称，并且Student类被称为Companion类。

object Student{
def displaydetails(st: Student){
println("Student Details: " + st.Id+","+st.name);
}
}

现在创建testStud对象，以调用这些伴随对象和类的方法，如下所示；

object testStud {
 
def main(args: Array[String]) = {
  
var st = new Student(21,"Peter")
println(st)
  
Student.displaydetails(st)
}
}

其中我们正在打印学生对象，并通过传递学生对象st来调用displaydetails方法。

将以上代码作为testStud.main(null)运行，将产生以下输出；

scala> testStud.main(null)
21  , Peter
Student Details: 21,Peter

如果您查看上面的图像，您会注意到警告，因为"先前定义的类Student不是对象Student的同伴。
伙伴必须一起定义；您可能希望使用：paste模式。
"

请注意，建议您使用粘贴模式，下图显示了如何使用粘贴模式来避免此警告。

Scala编译器

在结束本文之前，我想向您展示如何在Scala中编译和运行类。
如果您注意到上面的示例，我正在使用Scala shell创建类并使用它，但是一旦关闭它，我的代码就会丢失。
因此，我们可以将Scala程序保存在扩展名为.scala的文件中，然后编译并运行它。

Test.scala

object Test{
	def main(args: Array[String]) = {
	println("Welcome to theitroad!")
	}
}

这与用Java编译和运行类非常相似，如下面的Shell执行代码所示。

hyman:~ hyman$scalac Test.scala 
hyman:~ hyman$scala Test
Welcome to theitroad!

您会注意到在编译Test类时创建了一个名为Test.class的文件。