1. 　　public class VariantTest
   
2. 　　{
   
3. 　　                public static int staticVar = 0;
   
4. 　　                public int instanceVar = 0;
   
5. 　　                public VariantTest()
   
6. 　　                {
   
7. 　　                        staticVar++;
   
8. 　　                        instanceVar++;
   
9. 　　                        System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
   
10. 　　                }

复制代码

这段代码在主函数上要怎样才能运行，看到打印结果

1. 　　public class VariantTest
   
2. 　　{
   
3. 　　                public static int staticVar = 0; //静态成员变量随类的加载存在；可以VariantTest.staicVar访问
   
4. 　　                public int instanceVar = 0; //成员变量存在对象中，要先有对象才能访问。
   
5. 　　                public VariantTest()//对对象的初始化。
   
6. 　　                {
   
7. 　　                        staticVar++;
   
8. 　　                        instanceVar++;
   
9. 　　                        System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
   
10. 　　                }

复制代码

1. package InterviewQA;
   
2. 
   
3. 
   
4. public class VariantTest
   
5. {
   
6. public static int staticVar = 0;
   
7. public int instanceVar = 0;
   
8. public VariantTest()//你已经在构造函数里打印了你定义的这两个变量，所以new 一个对象时执行到这里，控制台自然就会看到输出
   
9. {
   
10. staticVar++;
    
11. instanceVar++;
    
12. System.out.println("staticVar=" + staticVar +",instanceVar=" + instanceVar);
    
13. }
    
14.    }
    
15.    class Demo
    
16.   {
    
17.       public static void main(String[] args)
    
18.              {
    
19.                       VariantTest test=new VariantTest( );//new 一个对象，调用构造函数进行初始化操作
    
20.               }
    
21.   }

复制代码

1. class AA
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. new VariantTest();
   
6. }
   
7. }
   
8. class VariantTest
   
9. {
   
10. public static int staticVar = 0;
    
11. public int instanceVar = 0;
    
12. public VariantTest()
    
13. {
    
14. staticVar++;
    
15. instanceVar++;
    
16. System.out.println("staticVar=" + staticVar + ",instanceVar=" + instanceVar);
    
17. }
    
18. }

复制代码

实例变量和类变量（静态变量）的区别：
1.存放位置：类变量（静态变量）随类加载存在于方法区中，实例变量随对象建立存在于堆内存中
2生命周期：类变量（静态变量）随类的加载而加载，随类的消失而消失，生命周期最长。
                由于静态先存在，对象后存在。所以生命周期最长

1. class demo
   
2. {
   
3.         public static int staticVar=0; //静态变量
   
4.         public int instanceVar =0;
   
5.         public void VariantTest()     //别忘了，函数返回值类型为void
   
6.         {
   
7.                 staticVar++;
   
8.                 instanceVar++;
   
9.                 System.out.println("staticVar="+staticVar+",instanceVar="+instanceVar);
   
10.         }
    
11. }
    
12. class ceshi
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 demo ce =new demo();        //初始化对象
    
17.                 ce.VariantTest();      //通过对象调用类中的函数
    
18.         }
    
19. }

复制代码

这样就可以运行了。
楼主要注意函数前面写上返回值类型，你前面的有些格式错误。
只要在主函数中建立对象，并调用函数，就可以实现了
只要调用一次函数就会实现两个数各+1一次

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

1. 
   
2. 　　public class VariantTest
   
3. 　　{
   
4. 　　 public static int staticVar = 0;
   
5. 　　 public int instanceVar = 0;
   
6. 　　 public VariantTest()//你已经在构造函数里打印了你定义的这两个变量，所以new 一个对象时执行到这里，控制台自然就会看到输出
   
7. 　　 {
   
8. 　　 staticVar++;
   
9. 　　 instanceVar++;
   
10. 　　 System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
    
11. 　　 }
    
12.      }
    
13.      class Demo
    
14.     {
    
15.         public static void main(String[] args)
    
16.                {
    
17.                         VariantTest test=new VariantTest( );//new 一个对象，调用构造函数进行初始化操作
    
18.                 }
    
19.     }

复制代码

(0)

  

摘要：



在语法定义上的区别：静态变量前要加

static

关键字，而实例变量前则不加。





在语法定义上的区别：静态变量前要加

static

关键字，而实例变量前则不加。



在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的

实例变量才会被分配空间，

才能使用这个实例变量。

静态变量不属于某个实例对象，

而是属

于类，

所以也称为类变量，只要程序加载了类的字节码，

不用创建任何实例对象，

静态变量

就会被分配空间，

静态变量就可以被使用了。

总之，

实例变量必须创建对象后才可以通过这

个对象来使用，静态变量则可以直接使用类名来引用。

  

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个

staticVar

变

量，并且每创建一个实例对象，这个

staticVar

就会加

1

；但是，每创建一个实例对象，就

会分配一个

instanceVar

，即可能分配多个

instanceVar

，并且每个

instanceVar

的值都只自

加了

1

次。

  

public

class

VariantTest

{  

         

public

static

int

staticVar

=

0;

         

public

int

instanceVar

=

0;

         

public

VariantTest()

         

{  

                  

staticVar++;

                  

instanceVar++;