变量是编程语言中最基本的术语，用来指计算机中存储的可变数据——例如整数、小数、字符或称为内存空间。
变量可以存储不同的变量类型，如整数、布尔类型、对象、数组等。每个变量对应内存中的一个内存地址，但如果变量存储的是原始数据类型（整数、布尔值、字符串），则其值变量的值存储在栈内存中，而相比那些更复杂的数据类型（数组、对象），栈中只存储一个固定长度的地址，这个地址指向堆内存中的值。 。这是由于栈和堆这两种数据结构的性质决定的。
变量的使用一般包括变量定义、变量调用、变量值传递、变量销毁和内存释放。
变量可以是任何数据类型、数字、字符串、方法、对象等。变量的定义归结为不同语言的语法，例如：
//java
//简单数据类型
String name = "_小许_";
String name = null;
int age = 21;
boolean flag = true;
//复杂数据类型对象
class Person{
String name;
Integer age;
}
Person person1 = new Person();
# python
a = 10
b = "_小许_"
# 函数变量
def showName:
print("_小许_")
# 对象变量
class Person:
def __init__():
print("_小许_")
Person.__init__()
// go
var x int =10
y := "_小许_"
const name = "_小许_"
//结构体变量
type Person struct {
name string
age int
}
变量的销毁是由语言编译器或解析器的GC完成的。
变量的传递是变量的核心。定义变量是为了传递给不同的方法来实现不同的操作，最终得到用户需要的结果。
变量的传递包括值传递和引用传递，这也与语言的特性密切相关。值传输是浅层传输，引用传输是深度传输。前者是值的简单复制，后者是对内存地址的引用，通常通过修改指针变量来完成。
传递变量的方式。变量一般包括局部变量和全局变量。变量最终通过IO输出并在内存中销毁，因此变量只有在编译时才有意义。
一般来说，方法是程序中对变量实现附加操作的主体。算术运算、逻辑运算等一般也附加在方法上。无论是面向对象语言还是过程语言。
例如，在过程语言 c 中：
#include <stdio.h>
int sum(){
int i, sum=0;
for(i=1; i<=100; i++){
sum+=i;
}
return sum;
}
int main(){
int a = sum();
printf("The sum is %d\n", a);
return 0;
}
//java
public class Main {
public static void main(String[] args) {
// write your code here
NumUtil un = new NumUtil();
int sum = un.sum();
System.out.println(sum);
}
}
class NumUtil{
private int tmp = 0;
public int sum(){
for (int i =0 ;i<=100;i++){
tmp = tmp + 1;
}
return tmp;
}
}
在上面的传递方法中，方法中有一个默认值作为初始值，也可以自定义初始值：
public class Main {
public static void main(String[] args) {
// write your code here
NumUtil un = new NumUtil();
int sum = un.sum();
System.out.println(sum);
}
}
class NumUtil{
private int tmp = 0;
public int sum(int a){
tmp = a;
for (int i =0 ;i<=100;i++){
tmp = tmp + 1;
}
return tmp;
}
}
sum(int a)中传递了一个名为a大的变量，在其数据类型是int，那么在调用该函数时传递的参数就必须时int类型。
不同语言的规范不一样，定义的规则也一样，传递的规则也是。例如，在C语言中int i;就是表示定义了一个int内置类型的变量，名称为i；在Java中String name就是定义了一个名为name的String类型；这些是强类型语言的定义，像js，python等弱类型语言的定义方式又不一样a = 1是python定义变量的方式，a可以是是任意类型，最终类型又开发者赋予的值类决定。在js中提供了val，let，const定义局部和全局变量，且也是自动类型推断。在许多后来的语言中都有局部变量和全局变量的关键字定义，例如在scala中,var a :String = "_小许_"等等。
以下是常见的变量定义：
//c语言变量定义
int i, sum=0;
//变量传递
//java
String name = "";
# python
a = 0;
//go
a := 0
强类型语言中函数的定义必须声明类型，比如在函数中定义局部变量，在函数的参数中定义变量。在类型化语言中，定义变量不需要声明类型，但它必须有一个初始值。 ，类型由编译器或解析器推断。
有些语言如Scala提供了var,val等一些关键字，Go的var,const关键字来区别于局部变量和常量，这些只在方法体内生效。（方法的参数是方法的一部分，不能使用这些关键字）。
一般来说，函数变量可以分为：局部变量、全局变量、形式变量。
- 函数内定义的变量称为局部变量
- 在函数外部定义的变量称为全局变量
- 函数定义中的变量称为形式参数
在函数体中声明的变量称为局部变量。它们的作用域仅在函数体内。函数的参数和返回值变量都是局部变量。局部变量并不总是存在。它仅在定义它的函数被调用之后才存在。该局部变量将在函数调用结束后被销毁。
//go
func addNum(a int,b int) int{
y := 3*a+4*b;
return y
}
//java
public class Util{
public int addNum(int a,int b){
int y = 3*a + 4*b;
return y;
}
}
y 都是局部变量。
在函数外部声明的变量称为全局变量。全局变量只需要在一个源文件中定义，并且可以在所有源文件中使用。有的语言变量必须在类中定义，比如Java，有的语言可以在源文件中定义，比如Go。外部包中使用的全局变量首字母必须大写。
//go语言
package main
import "fmt"
//声明全局变量
var c int
func main() {
//声明局部变量
var a, b int
//初始化参数
a = 3
b = 4
c = a + b
fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}
//java
public class Person{
private int id;
private String name;
private Double price;
}
定义函数时，函数名后括号内的变量称为形参（简称形参）。形参只有在函数调用时才会生效，函数调用完成后就会被销毁。当函数没有被调用时，函数的形参不占用实际的存储单元，没有实际值。
//go
func operation(n int, m int) (int, int, int, int) {
return n + m, n - m, n * m, n / m
}
//java
public class Person{
private int id;
private String name;
private Double price;
public void setId(int id){
this.id = id;
}
public int getId(){
return this.id;
}
public void setName(String name){
this.name = name;
}
public int getName(){
return this.name;
}
public void setPrice(Double price){
this.price = price;
}
public Double getPrice(){
return this.price;
}
}