变量及四种变量类型

一、规则

1.java 是一种强类型语言，每个变量都必须先声明其类型

2.Java变量是程序中最基本的存储单元，包括 变量名、 变量类型 和作用域

3.格式： 数据类型 变量名 = 值

4.变量名 可以使用逗号来隔开声明多个同类型变量 (但为了程序的可读性，不建议这样做)

5.每个变量都有类型，类型可以是基本类型，也可以是引用类型。

6.变量名必须是合法的标识符。

7.变量声明是一条完整的语句，因此每一个声明都必须以分号结束（注意，得使用英文的分号）。

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

二、变量类型

java语言支持的变量类型有：局部变量 、成员变量 、静态变量（类变量） 、参数变量

public class RunoobTest {
    public static void main(String[] args) {
        RunoobTest v = new RunoobTest();
        v.method(20);
    }
    
    // 成员变量
    private int instanceVar;
    
    // 静态变量
    private static int staticVar;
    
    //参数变量
    public void method(int paramVar) {
        
        // 局部变量
        int localVar = 10;
        
        // 使用变量
        instanceVar = localVar;
        staticVar = paramVar;
        
        System.out.println("成员变量: " + instanceVar);  //10
        System.out.println("静态变量: " + staticVar);   //20
        System.out.println("参数变量: " + paramVar);  //20
        System.out.println("局部变量: " + localVar);  //10
    }
    
    
}

（1）静态变量（类变量 Static）

1.定义：

定义在类中、方法之外的变量并且使用 static 关键字修饰，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问，静态变量的值在程序运行期间只有一个副本。静态变量可以被访问修饰符修饰。初始值为 0；

2.访问方式：

可以通过类名来访问静态变量，也可以通过实例名来访问静态变量

3.生命周期：

静态变量的生命周期与程序的生命周期一样长，即它们在类加载时被创建，在整个程序运行期间都存在，直到程序结束才会被销毁。因此，静态变量可以用来存储整个程序都需要使用的数据，如配置信息、全局变量等。

public class MyClass {
    public static int count = 0;

    MyClass.count = 10; // 通过类名访问

MyClass obj = new MyClass();
obj.count = 20; // 通过实例名访问
}

4.初始化时机：

静态变量在类加载时被初始化，其初始化顺序与定义顺序有关。

如果一个静态变量依赖于另一个静态变量，那么它必须在后面定义。

public class MyClass {
    public static int count1 = 0;
    public static int count2 = count1 + 1;
    // count1 要先于 count2 初始化，否则编译时会报错。
}

5.常量和静态变量的区别

a. 常量用final关键字修饰变量 ；静态变量用static关键字修饰变量

b. 常量在编译时就已经确定的了它的值，不能被修改 ；而静态变量的值可以在运行时改变

c. 常量通常用于存储一些固定的值，如数学常数、配置信息等 ；静态变量通常用于存储可变的数据，如计数器、全局状态等。

d. 静态变量具有唯一性和共享性

6.静态变量的计数器实例

定义了一个 Counter 类，其中包含了一个静态变量 count，用于记录创建了多少个 Counter 对象。

每当创建一个新的对象时，构造方法会将计数器加一。静态方法 getCount() 用于获取当前计数器的值。

在 main() 方法中，我们创建了三个 Counter 对象，并打印出了计数器的值。

public class Counter {
    private static int count = 0; //设立int型的静态私有变量count 

    public Counter() { //构造器
        count++;
    }

    public static int getCount() { //getCount()
        return count;
    }

    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        System.out.println("目前为止创建的对象数: " + Counter.getCount());//3
    }
}

（2）局部变量

• 声明在方法、构造方法或者语句块中。
• 在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。
• 必须声明和初始化值，并且不能被访问修饰符修饰。
• 只在声明它的方法、构造方法或者语句块中可见。
• 是在栈上分配的。
• 没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
• 局部变量的声明语法： 变量类型 变量名称

public class LocalVariablesExample {
    public static void main(String[] args) {
        int a = 10; // 局部变量a的声明和初始化
        int b;     // 局部变量b的声明
        b = 20;    // 局部变量b的初始化
       
        System.out.println("a = " + a);
        System.out.println("b = " + b);
       
        // 如果在使用之前不初始化局部变量，编译器会报错
        // int c;
        // System.out.println("c = " + c);
    }
}

（3）成员变量（实例变量）

• 成员变量声明在一个类中，但在方法、构造方法和语句块之外。
• 当一个对象被实例化之后，每个成员变量的值就跟着确定。
• 成员变量在对象创建的时候创建，在对象被销毁的时候销毁。
• 成员变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息。
• 成员变量可以声明在使用前或者使用后。
• 访问修饰符可以修饰成员变量。
• 成员变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把成员变量设为私有。通过使用访问修饰符可以使成员变量对子类可见。
• 成员变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是 false，引用类型变量的默认值是 null。变量的值可以在声明时指定，也可以在构造方法中指定；
• 成员变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObjectReference.VariableName。
• 成员变量的声明语法： 访问修饰符 数据类型 变量名
• 访问符：（public 、protected 、 private 或默认访问级别）

public class RunoobTest {
      private int a; // 私有成员变量a
      public String b = "Hello"; // 公有成员变量b
     
      public static void main(String[] args) {
         RunoobTest obj = new RunoobTest(); // 创建对象
         
          obj.a = 10; // 访问成员变量a，并设置其值为10
          System.out.println("a = " + obj.a);  //10
         
          obj.b = "World"; // 访问成员变量b，并设置其值为"World"
          System.out.println("b = " + obj.b);  //world
      }
  }

import java.io.*;
public class Employee{
   // 这个成员变量对子类可见
   public String name;
   // 私有成员变量，仅在该类可见
   private double salary;
   //在构造器中对name赋值
   public Employee (String empName){
      name = empName;
   }
   //设定salary的值
   public void setSalary(double empSal){
      salary = empSal;
   }  
   // 打印信息
   public void printEmp(){
      System.out.println("名字 : " + name );   //RUNOOB
      System.out.println("薪水 : " + salary);  //1000.0
   }
 
   public static void main(String[] args){
      Employee empOne = new Employee("RUNOOB");
      empOne.setSalary(1000.0);
      empOne.printEmp();
   }
}

（4）参数变量

1.定义

• 参数变量是指在方法或构造函数中声明的变量，用于接收传递给方法或构造函数的值。
• 只在方法或构造函数被调用时存在，并且只能在方法或构造函数内部使用。
• 声明语法： 方法（参数变量类型 变量名称）
• 在调用方法时，我们必须为参数变量传递值，这些值可以是常量、变量或表达式。

2.参数变量的值传递方式有两种 ：值传递 和 引用传递

• 值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
• 引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。

public class RunoobTest {
    public static void main(String[] args) {
        int a = 10, b = 20;
        swap(a, b); // 调用swap方法
        System.out.println("a = " + a + ", b = " + b);// 输出a=10，b=20
        
    }
   
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
        System.out.println("x = " + x + ", y = " + y);// 输出x=20，y=10
    }
}