Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
Java的变量类型有：

1. 成员变量类中的变量（独立于方法之外的变量）
2. 局部变量类的方法中的变量。

而 java类的成员变量又有俩种：

1. 静态变量（类变量）： 独立于方法之外的变量，用 static 修饰。
2. 实例变量： 独立于方法之外的变量，不过没有 static 修饰。

在语法定义上的区别：

静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：

• 实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
• 静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

public class CSDNTest {
    //类变量
    public static int judge = 0;

    //实例变量
    String str = "hello world";  

    public void method() {
        //局部变量
        int i = 0;
    }
}

一、类变量（静态变量）

1. 类变量在类里定义，声明变量时，在变量类型前面加上 static 即可，但必须在方法之外。
2. 类变量有默认值，数值型变量默认值是 0（或者0.0），布尔型默认值是 false，引用类型默认值是 null。
3. 类变量可以直接在该类的方法里使用。

public class CSDNTest {
    //定义类变量
    public static double i = 2000;       

    public static void main(String[] args) {
        //直接使用类变量
        System.out.println(i);//2000
    }
}

二、实例变量

1. 实例变量声明在一个类中，但在方法、构造方法和语句块之外 。
2. 实例变量具有默认值。数值型变量的默认值是0（或者0.0），布尔型变量的默认值是false，引用类型变量的默认值是null。
3. 实例变量从属于对象。

public class CSDNTest {
    //实例变量
    String name;
    int age;

    public static void main(String[] args) {
        //变量类型 变量名 = new 类名();
        CSDNTest test = new CSDNTest();

        System.out.println(test.age);//0
        System.out.println(test.name);//null
        //因为 age 和 name 都没有初始化，直接输出了默认值。
    }
}

三、局部变量

1. 局部变量声明在方法、构造方法或者语句块中。
2. 局部变量没有默认值。所以局部变量被声明后，必须经过初始化，才可以使用。
3. 局部变量只能在自己的方法中被使用。

public class CSDNTest {
    public static void main(String[] args) {
        //局部变量
        int i = 10;
        System.out.println(i);//10
    }
}

四、常量

1. 常量：初始化之后不会再变动的值。
2. 常量名一般使用大写字符。

/**
 * 常量定义： final 常量类型 常量名 = 值
 */
public class CSDNTest {
    //final static 皆为修饰符，不存在先后顺序
    final public static double x = 110;
    final public static String s = "hello world";

    public static void main(String[] args) {
        System.out.println(x);//110
        System.out.println(s);//hello world
    }
}

成员变量和局部变量的区别

成员变量：

      1、成员变量定义在类中，在整个类中都可以被访问。

      2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

      3、成员变量有默认初始化值。

局部变量：

      1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

      2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

      3、局部变量没有默认初始化值 

  在使用变量时需要遵循的原则为：就近原则

  首先在局部范围找，有就使用；接着在成员位置找。

成员变量和类变量（静态变量）的区别：

1、两个变量的生命周期不同

  成员变量随着对象的创建而存在，随着对象的回收而释放。
  静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

  成员变量只能被对象调用。
  静态变量可以被对象调用，还可以被类名调用。

3、别名不同

  成员变量也称为实例变量。
  静态变量也称为类变量。

4、数据存储位置不同

  成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
  静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

成员变量所属于对象。所以也称为实例变量。
静态变量所属于类。所以也称为类变量。

成员变量存在于堆内存中。
静态变量存在于方法区中。

成员变量随着对象创建而存在。随着对象被回收而消失。
静态变量随着类的加载而存在。随着类的消失而消失。

成员变量只能被对象所调用 。
静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

static关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

3、静态随着类的加载而加载。而且优先于对象存在。

弊端：

1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2、静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

3、静态方法中不能使用this，super关键字。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

1、成员变量。（数据共享时静态化）

  该成员变量的数据是否是所有对象都一样：

  如果是，那么该变量需要被静态修饰，因为是共享的数据。 

  如果不是，那么就说这是对象的特有数据，要存储到对象中。 

2、成员函数。（方法中没有调用特有数据时就定义成静态）

  如果判断成员函数是否需要被静态修饰呢？

  只要参考，该函数内是否访问了对象中的特有数据：

  如果有访问特有数据，那方法不能被静态修饰。

  如果没有访问过特有数据，那么这个方法需要被静态修饰。