可以将变量定义为存储器中用于存储分配值的保留空间。
根据变量的数据类型，由编译器/类型系统分配内存，并存储与该变量有关的值。

Scala变量声明

变量声明指定将存储在内存中的变量名称，可以使用该名称进一步访问该变量。
声明变量的语法是；

var variablename : datatype = value

var是一个关键字，指示它是一个变量，后跟变量名称和数据类型，value表示初始变量值。

例如;

var studentId:Int = 12

关键字var表示studentId是一个变量，类型为Int。
studentId的值初始化为12，并且程序员可以更改此值。

常量也可以使用以下语法声明：

val variablename:datatype = value

val是关键字，后跟变量名称和数据类型。
右侧的value表示该值保持不变，这意味着我们无法在程序中更改该值。

例如;

val pi= 3.14f

pi是带有关键字val的变量的名称，其值初始化为3.14。
val表示pi变量的值不能更改。

尝试如下更改它；

scala> pi=5
<console>:8: error: reassignment to val
     pi=5
       ^
scala>

可变数据类型

变量数据类型在变量名之后和等号之前指定。
"数据类型"指示变量的类型，即是否为整数，字符串等。

用数据类型声明变量的语法是

var variablename:Datatype = value
OR
val variablename:Datatype = value

例如;

var studage:Int = 8
val studid:Int = 4

以上声明的变量studage和studid指示这些变量为Integer类型。

变量类型推断

Scala编译器可以根据分配的初始值识别变量类型的现象称为变量类型推断。
这是通过类型系统接口执行的。

该变量可以声明为：

val studid = 10;
var studname = "Adam"

这里我们没有指定数据类型，而是根据分配的值，编译器将变量studd的数据类型标识为整数，并将studname标识为字符串。

多项分配

代码块可以返回一个元组，并且可以将其分配给一个变量。
Scala支持多种变量分配。

例如，变量可以声明为；

val(sid:Int,sname:String) = (12,"John")

上面的示例声明了两个整数类型的变量sid和字符串类型的sname，并为其分配了值，并用圆括号括起来。

或者

val(sid,sname)=(12,"John")

其中我们不指定数据类型而是分配初始值。

现在让我们通过一个例子来理解以上概念。

class Student {
var sid:Int = 10
var sname = "John"
var marks = 72.5f
val(sage,city) = (13,"Mysore")

def studdetails() {
println("Student Id is:"+sid);
println("Student Name is:"+sname);
println("Marks secured is:"+marks);
println("Student Age is:"+sage);
println("City is:"+city);
  }
}

其中我们创建一个具有变量sid，sname，mark，city和sage变量的学生类。
sage和city是多重分配，调用此方法时studdetails显示所有学生详细信息。

object test {
def main(args:Array[String]) {
val st = new Student();
st.studdetails()
  }
}

创建对象测试并创建学生对象，然后调用studdetails方法。
请注意，元组是一对值，我们将在后面详细讨论。

现在通过输入test.main(null)运行上面的代码

输出：

Student Id is:10
Student Name is:John
Marks secured is:72.5
Student Age is:13
City is:Mysore

下图显示了以上在Scala shell中执行的程序。

可变范围/类型

Scala变量根据声明的位置分为三个范围。
它们是字段，方法参数和局部变量。
让我们一一讨论。

字段变量：根据用于声明字段的访问修饰符的类型，可以从对象中的每个方法以及对象外部访问这些类型的变量。
它们属于对象，根据var和val关键字可以是可变的或者不可变的。

考虑一个描述字段变量的例子。

class Window {
var height = 3.2f
var width = 5.6f

def windet() {
println("Window height is :"+height)
}

println("Window width is :"+width);

}

窗口类是使用字段变量height和width创建的。
可以在方法内部访问这两个变量，并通过创建引用从对象中调用这两个变量。

创建对象Win，如下所示；

object Win {

def main(args:Array[String]) {
val win = new Window()
win.windet()
}
}

我们创建一个窗口对象" win"，并访问变量height和width。

通过执行Win.main(null)运行上面的代码

输出：

Window width is :5.6
Window height is :3.2

方法参数：这些是在调用方法时用于在方法内部传递值的变量。
如果从方法外部引用了对象，则可以在方法内部和方法外部访问这些变量。
这些变量总是可变的，用val关键字定义。

考虑一个方法参数的例子。

class Subtract {

def sub(s1:Int,s2:Int){
var res = s1-s2
println("Result is:"+res);
}
}

用接受两个方法参数变量s1和s2的子方法创建减法类。

object TestSub {
def main(args:Array[String]){
val su = new Subtract()
su.sub(40,10)
}
}

通过将值传递给变量s1和s2，创建TestSub对象，并调用子方法。

通过输入TestSub.main(null)运行代码

输出：

Result is:30

局部变量：局部变量是在方法内部声明的变量，只能在方法内部访问。
根据var和val关键字，它们可以是可变的，也可以是不变的。

考虑一个方法参数的例子。

class Addition {
def add() {
var(a,b) = (10,20);
var c = a+b;
println("Result is:"+c)
}
}

其中我们创建一个Addition类，并定义一个在方法内部具有变量a，b和c的方法。
如果我们尝试在方法之外访问变量a，b和c，则找不到值a引发错误。

创建对象Test以访问方法变量；

object Test {
def main(args:Array[String]) {
val ad = new Addition()
ad.add()
}
}

通过执行命令Test.main(null)运行代码

输出：

Result is:30