Java程序的变量大体可分为成员变量和局部变量。其中局部变量可分为如下3类。

• 形参：在方法签名中定义的局部变量，由方法调用者负责为其赋值，随方法的结束而消亡。
• 方法内的局部变量：在方法内定义的局部变量，必须在方法内对其进行显示初始化。这种类型的局部变量从初始化完成后开始生效，随方法的结束而消亡。
• 代码块的局部变量：在代码块内定义的局部变量，必须在代码块内对其进行显式初始化，这种类型的局部变量从初始化完成后开始生效，随代码的结束而消亡。

局部变量的作用时间很短暂，它们都被存储在方法的栈内存中。类体内定义的变量被称为成员变量（英文是Field）。如果定义该成员变量时没有使用static修饰，该成员变量又被称为非静态变量或实例变量；如果使用了static修饰，则该成员变量又可被称为静态变量或类变量

对于static关键字而言，从词义上来看，它是“静态”的意思。但从Java程序的角度来看，static的作用就是将实例成员变为类成员。static只能修饰在类里定义的成员部分，包括成员变量、方法、内部类、初始化块、内部枚举类。如果没有使用static修饰这里类里的成员，这里成员属于该类的实例；如果使用了static修饰，这些成员就属于类本身。从这个意义上看，static只能修饰类里的成员，不能修饰外部类，不能修改局部变量、局部内部类。

表明上看,Java类里定义成员变量时没有先后顺序,但实际上Java要求定义成员变量时必须采用合法的前后引用。示例如下

public class ErrorDef {
    int num1 = num2 + 5; //Cannot reference a field before it is defined
    int num2 = 20;
}

上面程序中定义num1成员变量的初始值时，需要根据num2变量的值进行计数，这就是“非法前后引用”。
类似地，两个类变量也不允许采用这样“非法前后引用”，示例如下。

public class ErrorDef {
    static int num1 = num2 + 5; //Cannot reference a field before it is defined
    static int num2 = 20;
}

但如果一个是实例变量，一个是类变量，则实例变量总是可以引用类变量，示例如下

public class RightDef {
    int num1 = num2 + 5;
    static int num2 = 20;
}

上面程序中num1是一个实例变量，而num2是一个类变量。虽然num2位于num1之后被定义，但nun1的初始值却可根据num2计算得到。这是因为，num2变量是一个类变量，num1是实例变量，而类变量的初始化时机总是处于实例变量的初始化时机之前。所以，虽然源代码中先定义了num1，再定义了num2，但num2的初始化时机总是位于num1之前，因此num1变量的初始化可根据num2的值计算得到

实例变量和类变量的属性

使用static修饰的成员变量是类变量，属于该类本身；没有使用static修饰的成员变量是实例变量，属于该类的实例。在同一个JVM内，每个类只对应一个Class对象，但每个类可以创建多个Java对象。

由于同一个JVM内每个类只对应一个Class对象，因此同一个JVM内的一个类的类变量只需一块内存空间；但对于实例变量而言，该类每创建一次实例，就需要为实例变量分配一块内存空间。也就是说，程序中有几个实例，实例变量就需要几块内存空间。

下面程序可以很好地表现出来实例变量属于对象，而类变量属于类的特性。

class Person {
    static int eyeNum;
    String name;
    int age;

    public void info() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}


public class FieldTest {
    public static void main(String[] args) {
        // 类变量属于该类本身，只要改类初始化完成，程序即可使用类变量
        Person.eyeNum = 2; // ①

        // 通过Person类访问 eyeNum类变量
        System.out.println("Person的eyeNum属性：" + Person.eyeNum);

        // 创建第一个Person对象
        Person p1 = new Person();
        p1.name = "zhangsan";
        p1.age = 22;

        System.out.println("通过p1变量访问eyeNum类变量：" + p1.eyeNum); // ②
        p1.info();

        // 创建第二个Person对象
        Person p2 = new Person();
        p2.name = "lisi";
        p2.age = 30;
        p2.info();

        // 通过p2修改Person类的eyeNum类变量
        p2.eyeNum = 4; // ③

        System.out.println("通过p1变量访问eyeNum类变量：" + p1.eyeNum);
        System.out.println("通过p2变量访问eyeNum类变量：" + p2.eyeNum);
        System.out.println("通过Person类访问eyeNum类变量：" + Person.eyeNum);
    }
}

上面程序中①行代码直接对Person类的eyeNum类变量赋值。这没任何问题，因为eyeNum类变量是属于Person类的，当Person类初始化完成后，eyeNum类变量也随之初始化完成。因此，程序即可对该类变量赋值，也可访问该类变量的值。

执行①行代码之后，程序的内存分配如图所示。

一旦Person类初始化完成，程序即可通过Person类访问eyeNum类变量。除此之外，Java还允许通过Person类的任意实例来访问eyeNum类变量

虽然Java允许通过Person对象来访问Person类的eyeNum类变量，但由于Person对象本身并没有eyeNum类变量（只有实例变量才属于Person实例），因此程序通过Person对象来访问eyeNum类变量时，底层依然会转换为通过Person访问eyeNum类变量。也就是说，不管通过哪个Person对象来访问eyeNum类变量，都与通过Person类访问eyeNum类变量的效果完全相同。因此，在②行代码处通过p1来访问eyeNum变量将再次输出2.

执行完②行代码后，程序的内存分配如图

从图中可以看出，当程序创建Person对象时，系统不再为eyeNum类变量分配内存空间，执行初始化，而只为Person对象
的实例变量执行初始化 – 因为实例变量才属于Person实例，而类变量属于Person类本身。

当Person类初始化完成之后，类变量也随之初始化完成，以后不管程序创建多少个Person对象，系统不再为eyeNum类变量分配内存，但程序每创建一个Person对象，系统将再次为name、age实例变量分配内存，并执行初始化。

当程序执行完③行代码之后，内存中再次增加了一个Person对象。当程序通过p2对eyeNum类变量进行赋值时，实际上依然是对Person类的eyeNum类变量进行赋值。此时程序的内存分配如图所示。

当Person类的eyeNum类变量被改变之后，程序通过p1、p2、Person类访问eyeNum类变量都将输出4。这是由于，不管通过哪个Person对象来访问eyeNum类变量，底层都将转换为通过Person来访问eyeNum类变量。由于p1和p2两个变量指向不同的Java对象，当通过它们访问实例变量时，程序将输出不同的结果。

实例变量的初始化时机

对于实例变量而言，它属于Java对象本身，每次程序创建Java对象时都需要为实例变量分配内存空间，并执行初始化。
从程序运行的角度来看，每次创建Java对象都会为实例变量分配内存空间，并对实例变量执行初始化。
从语法角度来看，程序可以在3个地方对实例变量执行初始化：

• 定义实例变量时指定初始值
• 非静态初始化块中对实例变量指定初始值
• 构造器中对实例变量指定初始值

其中第1、2种方式(定义时指定的初始值和非静态初始化块中指定的初始值)比第3种方式（构造器中指定初始值）更早执行，但第1、2中方式的执行顺序与他们在源程序中的排列顺序相同。

class Cat {
    String name;
    int age;

    public Cat(String name, int age) {
        System.out.println("执行非静态初始化块");
        this.name = name;
        this.age = age;
    }

    {
        System.out.println("执行构造器");
        weight = 3.0;
    }

    double weight = 2.5;

    public String toString() {
        return "Name: " + name + ", Age: " + age + "Weight: " + weight;
    }
}


public class InitTst {
    public static void main(String[] args) {
        Cat cat1 = new Cat("tom", 3); // ①
        System.out.println(cat1);

        Cat cat2 = new Cat("jiafei", 2); // ②
        System.out.println(cat2);
    }
}

每当程序调用指定构造器来创建Java对象时，该构造器必然会获得执行的机会。除此之外，该类所包含的非静态初始化块将会获得执行的机会，而且总是在构造器执行之前获得执行。

当程序执行①行代码创建第一个Cat对象的时候，程序将会先执行Cat类的非静态初始化块，再调用该Cat类的构造器来初始化该Cat实例。执行完①行代码后的内存分配如图所示。

从图中可以看出，该Cat对象的weight实例变量的值为2.5，二不是初始化块中指定的。这是因为，初始化块中指定初始值，定义weight时指定初始值，都属于对该实例变量执行的初始化操作，他们的执行顺序与它们的顺序相同。在本程序中，初始化块中对weight的赋值位于定义weight语句之前，因此程序将先执行初始化块中的初始化操作，执行完成后weight实例变量的值为3.0，然后再执行定义weight时指定的初始值，执行完成后weight实例变量的值为2.5。 从这个意义上来看，初始化块中对weight所指定的初始化值每次都将被2.5所覆盖。

当执行②行代码再次创建一个Cat对象时，程序将再一次调用非静态初始化块、相应的构造器来初始化Cat对象。

执行完②行代码后，程序的内存分配如图所示。

类变量的初始化时机

实例变量属于Java类本身，只有当程序初始化该Java类时才会为该类的类变量分配内存空间，并执行初始化。
从程序运行的角度来看，每JVM对一个Java类只初始化一次，因此Java程序每运行一次，系统只为类变量分配一次内存空间，执行一次初始化。
从语法角度来看，程序可以在2个地方对类变量执行初始化：

• 定义类变量时指定初始值
• 静态初始化块中对类变量指定初始值。

这两种方式的执行顺序与它们在源程序中的排列顺序相同。

public class StaticInitTest {
    // 定义count类变量，定义时指定初始值
    static int count = 2;

    // 通过静态初始化块为name类变量指定初始值
    static {
        System.out.println("StaticInitTest的静态初始化块");
        name = "hello";
    }

    // 定义name类变量时指定初始值
    static String name = "itmyhome";

    public static void main(String[] args) {
        System.out.println("count类变量的值" + StaticInitTest.count);
        System.out.println("name类变量的值" + StaticInitTest.name);
    }
}

静态初始化块中为类变量指定初始值，每次运行该程序，系统将会对StaticInitTest类执行初始化：先为所有类变量分配内存空间，再按源代码中的排序执行静态初始化块中所指定的初始值和定义类变量时所指定的初始值.

对于本例程序而已，静态初始化夸中对name变量的指定初始值位于定义name变量时指定初始值之前，因此系统先将name类变量赋值为“hello”，然后再将该name类变量赋值为“itmyhome”。每运行该程序一次，这个初始化过程只执行一次，因此运行上面程序将看到输出name类变量的值为“itmyhome”.

下面程序更清楚地表现了类变量的初始化过程。首先定义了Price类，该Price类里有一个静态的initPrice变量，用于代表初始价格。每次创建Price实例时，系统会以initPrice为基础，减去当前打折价格(由discount参数代表)即得到该Price的currentPrice变量值

class Price {
    // 类成员是Price实例
    final static Price INSTANCE = new Price(2.8);

    // 再定义一个类变量
    static double initPrice = 20;

    // 定义该Price的currentPrice实例变量
    double currentPrice;

    public Price(double distinct) {
        // 根据静态变量计算实例变量
        currentPrice = initPrice - distinct;
    }
}


public class PriceTest {
    public static void main(String[] args) {
        // 通过Price的INSTANCE访问currentPrice实例变量
        System.out.println(Price.INSTANCE.currentPrice); // ①

        // 创建Price实例
        Price p = new Price(2.8);
        // 通过创建的Price实例访问currentPrice实例变量
        System.out.println(p.currentPrice); // ②
    }
}

上面程序中①、②行代码都访问Price实例的currentPrice实例变量，而且程序都是通过new Price(2.8)来创建Price实例的。表面上看，程序输出两个Price的currentPrice都应该返回17.2(由20减去2.8得到)，但实际上运行程序并没有输出两个17.2，而是输出-2.8和17.2

如果仅仅停留在代码表面来看这个问题，往往很难得到正确的结果，下面从内存角度来分析这个程序。第一次用到Price类时，程序开始对Price类进行初始化，初始化分成以下2个阶段。

• (1)系统为Price的两个类变量分配内存空间。
• (2)按初始化代码(定义时指定初始化值和初始化块中执行初始值)的排列顺序对类变量执行初始化。

初始化第一阶段，系统先为INSTANCE、initPrice两个类变量分配内存空间，此时INSTANCE、initPrice的默认值null和0.0。截止初始化进入第二个阶段，程序按顺序依次为INSTANCE、initPrice进行复制。对INSTANCE赋值时要调用Price(2.8)，创建Price实例，此时立即执行程序中③代码为currentPrice进行赋值，此时initPrice类变量的值为0，因此赋值的结果是currentPrice等于-2.8。接着，程序再次将initPrice赋为20，但此时对INSTANCE的currentPrice实例变量以及不起作用了。

当Price类初始化完成后，INSTANCE类变量引用到一个currentPrice为-2.8的Price实例，而initPrice类变量的值为20.0。当再次创建Price实例时，该Price实例的currentPrice实例变量的值才等于20.0

一、实例变量

也叫成员变量、全局变量。

• 定义在类中、方法外，有默认初始值。
• 通过对象的引用来访问实例变量。
• 随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

二、类变量

也叫静态变量。

• 定义在类中、方法外，有关键字 static 修饰，有默认初始值。
• 可以通过对象调用，也可以通过类名调用。
• 生命周期与类共存亡。
• 对象的引用存放在方法区，如果用关键字 new 为引用类型的静态变量分配对象，该对象在堆中的地址也会存放在方法区。！但是对象本身仍在堆内存中。

三、局部变量

• 定义在方法中，或者方法的形参，没有初始化值。
• 生命周期与方法共存亡。
• 存放在栈中。局部的对象的引用所指对象在堆中的地址在存储在了栈中。

举例：

public class StaticObjTest {
    static class Test {
        static ObjectHolder staticObj = new ObjectHolder();//静态变量、类变量
        ObjectHolder instanceObj = new ObjectHolder();//实例变量、成员变量
        void foo() {
            ObjectHolder localObj = new ObjectHolder();//局部变量
            System.out.println("done");
        }
    }
}

• 静态变量staticObj 随着Test的类型信息存放在方法区
• 成员变量instance0bj 随着Test的对象实例存放在Java堆
• 局部变量localobj则是存放在foo() 方法栈帧的局部变量表中。
• 三个对象的数据在内存中的地址都落在Eden区范围内，所以结论：只要是对象实例 即new() 必然会在Java堆中分配。

再举个例子：

public class  PersonDemo
{
    public static void main(String[] args) 
    {   //局部变量p和形参args都在main方法的栈帧中
        //new Person()对象在堆中分配空间
        Person p = new Person();
        //sum在栈中，new int[10]在堆中分配空间
        int[] sum = new int[10];
    }
}
class Person
{   //实例变量name和age在堆(Heap)中分配空间
    private String name;
    private int age;
    //类变量(引用类型)name1和"cn"都在方法区(Method Area)
    private static String name1 = "cn";
    //类变量(引用类型)name2在方法区(Method Area)
    //new String("cn")对象在堆(Heap)中分配空间
    private static String name2 = new String("cn");
    //num在堆中，new int[10]也在堆中
    private int[] num = new int[10];
    Person(String name,int age)
    {   
        //this及形参name、age在构造方法被调用时
        //会在构造方法的栈帧中开辟空间
        this.name = name;
        this.age = age;
    }
    //setName()方法在方法区中
    public void setName(String name)
    {
        this.name = name;
    }
    //speak()方法在方法区中
    public void speak()
    {
        System.out.println(this.name+"..."+this.age);
    }
    //showCountry()方法在方法区中
    public static void  showCountry()
    {
        System.out.println("country="+country);
    }
}

变量名首写字母使用小写，如果由多个单词组成，从第2个单词开始的其他单词的首写字母使用大写。

如果局部变量的名字和成员变量的名字相同， 要想在该方法中使用成员变量，必须使用关键字this

输出结果：

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

       成员变量：

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

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

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

      局部变量：

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

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

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

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

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

成员变量和类变量的区别

由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

输出结果：

成员变量和类变量的区别：

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

      成员变量随着对象的创建而存在，随着对象的回收而释放。

      静态变量随着类的加载而存在，随着类的消失而消失。

   2、调用方式不同

      成员变量只能被对象调用。

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

   3、别名不同

      成员变量也称为实例变量。

      静态变量也称为类变量。

   4、数据存储位置不同

      成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

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

   特点：

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

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

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

 

弊端：

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

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

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

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

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

 

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

成员分两种：

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

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

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

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

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

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

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

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

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

成员变量和静态变量的区别：

   1、成员变量所属于对象。所以也称为实例变量。

      静态变量所属于类。所以也称为类变量。

   2、成员变量存在于堆内存中。

      静态变量存在于方法区中。

   3、成员变量随着对象创建而存在。随着对象被回收而消失。

      静态变量随着类的加载而存在。随着类的消失而消失。

   4、成员变量只能被对象所调用 。

      静态变量可以被对象调用，也可以被类名调用。

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