Java 变量类型

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

格式说明：

type -- 数据类型。
identifier -- 是变量名，可以使用逗号 , 隔开来声明多个同类型变量。

以下列出了一些变量的声明实例。注意有些包含了初始化过程。

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 语言支持的变量类型有：

局部变量（Local Variables）：定义在方法、构造方法或语句块中的变量，作用域只限于当前方法、构造方法或语句块中。局部变量必须在使用前声明，并且不能被访问修饰符修饰。
成员变量（Instance Variables）：定义在类中、方法之外的变量，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问。成员变量可以被访问修饰符修饰。
静态变量（Class Variables）：定义在类中、方法之外的变量，并且使用 static 关键字修饰，作用域为整个类，可以被类中的任何方法、构造方法和语句块访问，静态变量的值在程序运行期间只有一个副本。静态变量可以被访问修饰符修饰。
参数变量（Parameters）：方法定义时声明的变量，作为调用该方法时传递给方法的值。参数变量的作用域只限于方法内部。

以下实例中定义了一个 RunoobTest 类，其中包含了一个成员变量 instanceVar 和一个静态变量 staticVar。

method() 方法中定义了一个参数变量 paramVar 和一个局部变量 localVar。在方法内部，我们将局部变量的值赋给成员变量，将参数变量的值赋给静态变量，然后打印出这些变量的值。

在 main() 方法中，我们创建了一个 RunoobTest 对象，并调用了它的 method() 方法。

实例

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

运行以上代码，输出如下：

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

Java 参数变量

Java 中的参数变量是指在方法或构造函数中声明的变量，用于接收传递给方法或构造函数的值。参数变量与局部变量类似，但它们只在方法或构造函数被调用时存在，并且只能在方法或构造函数内部使用。

Java 方法的声明语法如下：

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
    // 方法体
}

parameterType -- 表示参数变量的类型。
parameterName -- 表示参数变量的名称。

在调用方法时，我们必须为参数变量传递值，这些值可以是常量、变量或表达式。

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

值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。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和b的值
}

public static void swap(int x, int y) {
int temp = x;
x = y;
y = temp;
}
}

运行以上代码，输出如下：

a = 10, b = 20

Java 局部变量

局部变量声明在方法、构造方法或者语句块中。
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。
局部变量必须在使用前声明，并且不能被访问修饰符修饰，因为它们的作用域已经被限制在了声明它们的方法、代码块或构造函数中。
局部变量只在声明它的方法、构造方法或者语句块中可见，不能被其他方法或代码块访问。
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

局部变量的声明语法为：

type variableName;

type -- 表示变量的类型。
variableName -- 表示变量的名称。

局部变量必须在使用之前进行初始化，否则编译器会报错。初始化可以在声明时或后面的代码中进行。如果在声明时未初始化，变量将被赋予默认值，如 int 类型的变量默认为 0，boolean 类型的变量默认为 false，引用类型的变量默认为 null。

局部变量只在声明它的方法、构造方法或语句块内可见，其他方法、构造方法或语句块不能访问该局部变量。当方法、构造方法或语句块执行完毕后，局部变量将被销毁，其占用的内存也会被释放。

实例

以下是一个简单的例子，展示了局部变量的使用：

实例

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);
}
}

以上实例中我们声明并初始化了两个局部变量 a 和 b，然后打印出它们的值。注意，如果在使用局部变量之前不初始化它，编译器会报错。

在以下实例中 age 是一个局部变量，定义在 pupAge()方法中，它的作用域就限制在这个方法中：

package com.runoob.test; public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("小狗的年龄是: " + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

以上实例编译运行结果如下:

小狗的年龄是: 7

在下面的例子中 age 变量没有初始化，所以在编译时会出错：

package com.runoob.test; public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("小狗的年龄是 : " + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

以上实例编译运行结果如下:

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

成员变量（实例变量）

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

成员变量的声明语法为：

accessModifier type variableName;

accessModifier --表示访问修饰符，可以是 public、protected、private 或默认访问级别（即没有显式指定访问修饰符）。
type -- 表示变量的类型。
variableName -- 表示变量的名称。

与局部变量不同，成员变量的值在创建对象时被分配，即使未对其初始化，它们也会被赋予默认值，例如 int 类型的变量默认值为 0，boolean 类型的变量默认值为 false。

成员变量可以通过对象访问，也可以通过类名访问（如果它们是静态成员变量）。如果没有显式初始化成员变量，则它们将被赋予默认值。可以在构造函数或其他方法中初始化成员变量，或者通过对象或类名访问它们并设置它们的值。

实例

以下实例我们声明了两个成员变量 a 和 b，并对其进行了访问和设置。注意，我们可以通过对象访问成员变量，也可以通过类名访问静态成员变量。

实例

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);

obj.b = "World"; // 访问成员变量b，并设置其值为"World"
System.out.println("b = " + obj.b);
}
}

以上实例编译运行结果如下:

a = 10
b = World

以下实例我们声明了两个成员变量 name 和 salary，并对其进行了访问和设置。

Employee.java 文件代码：

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 ); System.out.println("薪水 : " + salary); } public static void main(String[] args){ Employee empOne = new Employee("RUNOOB"); empOne.setSalary(1000.0); empOne.printEmp(); } }

以上实例编译运行结果如下:

$ javac Employee.java 
$ java Employee
名字 : RUNOOB
薪水 : 1000.0

类变量（静态变量）

Java 中的静态变量是指在类中定义的一个变量，它与类相关而不是与实例相关，即无论创建多少个类实例，静态变量在内存中只有一份拷贝，被所有实例共享。

静态变量在类加载时被创建，在整个程序运行期间都存在。

定义方式

静态变量的定义方式是在类中使用 static 关键字修饰变量，通常也称为类变量。

以下实例中我们定义一个静态变量 count ，其初始值为 0：

实例

public class MyClass {
public static int count = 0;
// 其他成员变量和方法
}

访问方式

由于静态变量是与类相关的，因此可以通过类名来访问静态变量，也可以通过实例名来访问静态变量。

实例

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

生命周期

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

初始化时机

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

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

实例

public class MyClass {
public static int count1 = 0;
public static int count2 = count1 + 1;
// 其他成员变量和方法
}

上面的例子中，count1 要先于 count2 初始化，否则编译时会报错。

常量和静态变量的区别

常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。与静态变量不同的是，常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。另外，常量通常用于存储一些固定的值，如数学常数、配置信息等，而静态变量通常用于存储可变的数据，如计数器、全局状态等。

总之，静态变量是与类相关的变量，具有唯一性和共享性，可以用于存储整个程序都需要使用的数据，但需要注意初始化时机和与常量的区别。

静态变量的访问修饰符

静态变量的访问修饰符可以是 public、protected、private 或者默认的访问修饰符（即不写访问修饰符）。

需要注意的是，静态变量的访问权限与实例变量不同，因为静态变量是与类相关的，不依赖于任何实例。

静态变量的线程安全性

Java 中的静态变量是属于类的，而不是对象的实例。因此，当多个线程同时访问一个包含静态变量的类时，需要考虑其线程安全性。

静态变量在内存中只有一份拷贝，被所有实例共享。因此，如果一个线程修改了静态变量的值，那么其他线程在访问该静态变量时也会看到修改后的值。这可能会导致并发访问的问题，因为多个线程可能同时修改静态变量，导致不确定的结果或数据一致性问题。

为了确保静态变量的线程安全性，需要采取适当的同步措施，如同步机制、原子类或 volatile 关键字，以便在多线程环境中正确地读取和修改静态变量的值。

静态变量的命名规范

静态变量的命名规范与实例变量相同，一般采用驼峰命名法，并且要用 static 关键字明确标识。例如：

实例

public class MyClass {
public static int MAX_COUNT = 100;
// 其他成员变量和方法
}

静态变量的使用场景

静态变量通常用于以下场景：

存储全局状态或配置信息
计数器或统计信息
缓存数据或共享资源
工具类的常量或方法
单例模式中的实例变量

实例

以下实例定义了一个 AppConfig 类，其中包含了三个静态变量 APP_NAME、APP_VERSION 和 DATABASE_URL，用于存储应用程序的名称、版本和数据库连接URL。这些变量都被声明为 final，表示它们是不可修改的常量。

在 main() 方法中，我们打印出了这些静态变量的值。

AppConfig.java 文件代码：

public class AppConfig { public static final String APP_NAME = "MyApp"; public static final String APP_VERSION = "1.0.0"; public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb"; public static void main(String[] args) { System.out.println("Application name: " + AppConfig.APP_NAME); System.out.println("Application version: " + AppConfig.APP_VERSION); System.out.println("Database URL: " + AppConfig.DATABASE_URL); } }

以上实例编译运行结果如下:

Application name: MyApp
Application version: 1.0.0
Database URL: jdbc:mysql://localhost:3306/mydb

可以看到，这些静态变量存储的全局配置信息可以在整个程序中使用，并且不会被修改。这个例子展示了静态变量的另一个常见应用，通过它我们可以很方便地存储全局配置信息，或者实现其他需要全局共享的数据。

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

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

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

Counter.java 文件代码：

public class Counter { private static int count = 0; public Counter() { count++; } public static int 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

可以看到，计数器记录了创建了三个对象。这个例子展示了静态变量的一个简单应用，通过它我们可以很方便地统计对象的创建次数，或者记录其他需要全局共享的数据。

本章节中我们学习了Java的变量类型，下一章节中我们将介绍Java修饰符的使用。

Java 基本数据类型

Java 修饰符

12 篇笔记写笔记

#0
   h七宝
  135***8724@qq.com
  参考地址
331
Java 中静态变量和实例变量区别
- 静态变量属于类，该类不生产对象，通过类名就可以调用静态变量。
- 实例变量属于该类的对象，必须产生该类对象，才能调用实例变量。
在程序运行时的区别：
- 实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
- 静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个 staticInt 变量，并且每创建一个实例对象，这个 staticInt 就会加 1；但是，每创建一个实例对象，就会分配一个 random，即可能分配多个 random ，并且每个 random 的值都只自加了1次。
```
public class StaticTest {
    private static int staticInt = 2;
    private int random = 2;

    public StaticTest() {
        staticInt++;
        random++;
        System.out.println("staticInt = "+staticInt+"  random = "+random);
    }

    public static void main(String[] args) {
        StaticTest test = new StaticTest();
        StaticTest test2 = new StaticTest();
    }
}
```
执行以上程序，输出结果为：
```
staticInt = 3  random = 3
staticInt = 4  random = 3
```
h七宝
   h七宝
  135***8724@qq.com
  参考地址
7年前 (2017-03-09)
#0
   大白小爱
  362***275@qq.com
73
静态变量是用来声明规则的，一旦固定都是用用来引用的，类似社会中的法律，规定好后你只能拿来说。但是也可以改的，通过重新的声明法律就行。
大白小爱
   大白小爱
  362***275@qq.com
7年前 (2017-03-25)

java 实例变量在整个类内部是可访问的，而不管实例变量声明在类的哪个位置。

import java.io.*;

public class Employee{

    public Employee (String empName){
        name = empName;
    }
    
    public void setSalary(double empSal){
        salary = empSal;
    }
    
    public void printEmp(){
        System.out.println("name:" + name);
        System.out.println("salary:" + salary);
    }
    
    public static void main(String args[]){
        Employee empOne = new Employee("RUNOOB");
        empOne.setSalary(1000);
        empOne.printEmp();
        System.out.println(empOne.salary);
    }
    public String name;
    private double salary;
}

比如在上面代码中，尽管实例变量声明在类的尾部，在之前方法中仍可访问。

stinkaroo7年前 (2017-05-09)

类变量赋值方法

无final修饰，声明时赋值，构造器中赋值，静态语句块或静态方法赋值
有final修饰，声明时赋值，声明与赋值分开可在静态语句块中赋值

public class StaticTest {
    private static int staticInt = 2;
    private int random = 2;

    public StaticTest() {
        staticInt++;
        random++;
    }

    public static void main(String[] args) {
        System.out.println("类变量与对象变量的值变化");
        StaticTest test = new StaticTest();
        System.out.println("  实例1：staticInt:" + test.staticInt + "----random:" + test.random);
        StaticTest test2 = new StaticTest();
        System.out.println("  实例2：staticInt:" + test.staticInt + "----random:" + test.random);
        System.out.println("静态变量赋值");
        System.out.println("  静态语句块起作用:" + A.staticA);
        A a = new A();
        System.out.println("  构造器起作用:" + a.staticA);
        a.toChange();
        System.out.println("  静态方法1起作用:" + A.staticA);
        a.toChange2();
        System.out.println("  静态方法2起作用:" + A.staticA);
        System.out.println("常量赋值");
        System.out.println("  静态语句赋值:" + B.staticB);
    }
}

class A { 
    public static  String  staticA ="A" ;  
    //静态语句块修改值 
    static{  staticA ="A1"; } 
    //构造器修改值
    public A (){  staticA ="A2"; } 
    //静态方法起作用 
    
    public static void toChange(){  staticA ="A3"; } 
    public static void toChange2(){  staticA ="A4"; }  
}

class B { 
    public static final String  staticB ;  // 声明与赋值分离 
    static{  staticB ="B"; }
}

九仞6年前 (2017-06-14)

类变量与实例变量的区别

类变量可在类中直接使用，实例变量需实例化后才能使用。

public class StaticTest {
    private static int staticInt = 2;
    private int random = 2;

    public static void main(String[] args) {
        System.out.println(staticInt);
        StaticTest test = new StaticTest();
        System.out.println(test.random);
    }
}

Smiley6年前 (2017-07-25)

156

成员变量、局部变量、静态变量的区别

	成员变量	局部变量	静态变量
定义位置	在类中,方法外	方法中,或者方法的形式参数	在类中,方法外
初始化值	有默认初始化值	无,先定义,赋值后才能使用	有默认初始化值
调用方式	对象调用	---	对象调用，类名调用
存储位置	堆中	栈中	方法区
生命周期	与对象共存亡	与方法共存亡	与类共存亡
别名	实例变量	---	类变量

GGBOND6年前 (2017-08-15)

class A{
    static int i;
    void change(int i1){i=i1;}
}

public class Test{
    public static void main(String[] args){
    A.i=10;
    A a=new A();
    A b=new A();
    System.out.println(A.i+","+a.i+","+b.i);//10,10,10
    a.change(40);
    System.out.println(A.i+","+a.i+","+b.i);//40,40,40
    b.i+=10;
    System.out.println(A.i+","+a.i+","+b.i);//50,50,50
    }
}

类的静态数据成员值被所有对象共享，任何对象都可以访问类的静态数据成员。但是他们使用的是同一个数据，操作的是同一块内存，无论哪个对象修改了它，对其他对象来说，他已经变了。

还作李寻欢6年前 (2017-09-21)

#0
   oba
  dyh***st.com
26
解释：private static final double PI = 3.14;

子类不可用（与类继承关系） + 非静态方法不可用（与方法的关系）+ 常量（与变量的关系） + 类型（与其他类型的关系）
oba
   oba
  dyh***st.com
6年前 (2017-11-22)

public class Test {
    public static int staticVar=0;//静态变量,加static关键字
    public int instanceVar=0;//实例变量
    public void VariantTest(){
           staticVar++;
           instanceVar++;
           System.out.println("staticVar"+staticVar+",instanceVar="+instanceVar);
    }
    public static void main(String[] args) {
        for(int k=0;k<6;k++){
            Test p=new Test();
            p.VariantTest();
        }
    }
}

输出结果

staticVar1,instanceVar=1
staticVar2,instanceVar=1
staticVar3,instanceVar=1
staticVar4,instanceVar=1
staticVar5,instanceVar=1
staticVar6,instanceVar=1

结论: 每次创建一个新对象就会分配一个实例变量，而始终只会分配一个静态变量

LOYO6年前 (2017-12-05)

是否可以从一个static方法内部无法对非static方法的调用?

public class Xix {
    // 静态成员 
    public static String string="static成员";
    // 普通成员
    public String string2="非static成员";
    // 静态方法
    public static void method(){
        string="sss";
        //string2="sss";编译报错,因为静态方法里面只能调用静态方法或静态成员
        //method2();
        System.out.println("这是static方法,static方法与对象无关");
    }

    // 普通方法 
    public void method2(){
        string ="string1";
        string2="string2";
        method(); //非静态方法里面可以发出对static方法的调用
        System.out.println("这是非static方法,此方法必须和指定的对象关联起来才起作用");
    }
    public static void main(String[] args) {
        Xix x=new Xix();
        x.method2();// 引用调用普通方法 
        x.method();// 引用调用静态方法
    }
}

运行结果:

这是static方法,static方法与对象无关
这是非static方法,此方法必须和指定的对象关联起来才起作用
这是static方法,static方法与对象无关

结论:

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部无法对非static方法的调用。

LOYO6年前 (2017-12-05)

package hello;

//首先要知道变量应该是赋值以后才能使用的，但是有些不必人为赋值就有默认初始值，但是有些要人为定义初始值
//所以有些直接使用的并不是没有赋值，而是系统自定义了初始值，所以不会报错

public class Variable {
    public String instance = "实例变量";
    public static String variable = "静态变量";    //静态变量的定义方式
    public static String CONST = "静态常量";    //静态常量的定义方式 
    public static void main(String[] args) {
        String local = "局部变量";    //类似这个就是局部变量，不可用访问修饰符修饰，没有默认初始值
        System.out.println(local);    //局部变量就是在方法或语句块中的变量
        Global global = new Global();    //类似这个就是实例变量，也称全局变量
        System.out.println(global.instance);    //实例变量就必须先把类new一个出来才能使用,因为他是在类中,方法外的
        System.out.println(variable);    //来瞅瞅静态变量，也叫类变量，静态变量的访问方式1(在自己类的时候)
        System.out.println(Global.variable);    //静态变量的访问方法2(不在自己类的时候)
    }
}

class Global{
    public String instance = "实例变量";    //实例变量在一个类的里面,语句块的外面
    public static String variable = "静态变量";
    Global(){    //在类的内部使用自己的实例变量：要么老老实实new一个出来,就像上面那个
        //第二种方法就是在函数里面使用实例变量，注意，如果方法是静态方法参照方法1
        System.out.println(instance);
        System.out.println(variable);
    }
    public void Instance() {
        System.out.println(instance);    //静态变量访问方法1(在自己类的时候),静态常量和静态变量访问相同
        System.out.println(Variable.CONST);
    }
}

豌豆6年前 (2018-03-20)

#0
233333
135***8036@qq.com
23
Java语言支持的变量类型有：
- 类变量：独立于方法之外的变量，用 static 修饰。
- 实例变量：独立于方法之外的变量，不过没有 static 修饰。
- 局部变量：类的方法中的变量
```
public calls Student{
    static String schoolName ="清华小学"; //类变量
    String classNane ="中班";  //实例变量
    public void show(){
        /*局部变量*/
        int age =7;

        String name ="张华"；
    }
}
```
233333
233333
135***8036@qq.com
6年前 (2018-04-13)

菜鸟教程 -- 学的不仅是技术，更是梦想！

Java 面向对象

Java 高级教程

Java 变量类型

实例

Java 参数变量

实例

Java 局部变量

实例

实例

成员变量（实例变量）

实例

实例

Employee.java 文件代码：

类变量（静态变量）

定义方式

实例

访问方式

实例

生命周期

初始化时机

实例

常量和静态变量的区别

静态变量的访问修饰符

静态变量的线程安全性

静态变量的命名规范

实例

静态变量的使用场景

实例

AppConfig.java 文件代码：

Counter.java 文件代码：

12 篇笔记写笔记

Java 中静态变量和实例变量区别

点我分享笔记

菜鸟教程 -- 学的不仅是技术，更是梦想！

Java 面向对象

Java 高级教程

Java 变量类型

实例

Java 参数变量

实例

Java 局部变量

实例

实例

成员变量（实例变量）

实例

实例

Employee.java 文件代码：

类变量（静态变量）

定义方式

实例

访问方式

实例

生命周期

初始化时机

实例

常量和静态变量的区别

静态变量的访问修饰符

静态变量的线程安全性

静态变量的命名规范

实例

静态变量的使用场景

实例

AppConfig.java 文件代码：

Counter.java 文件代码：

12 篇笔记 写笔记

Java 中静态变量和实例变量区别

点我分享笔记

微信关注

12 篇笔记写笔记