1. public class Static {
   
2.         static int i=0;
   
3.         int j=0;
   
4.         public static void main(String args[]){
   
5.                 Static s1=new Static();
   
6.                 Static s2=new Static();
   
7.                 s1.i++;
   
8.                 s1.j++;
   
9.                 s2.i++;
   
10.                 s2.j++;
    
11.                 System.out.println(s1.i);
    
12.                 System.out.println(s1.j);
    
13.                 System.out.println(s2.i);
    
14.                 System.out.println(s2.j);
    
15.         }
    
16.     }

复制代码

结果 2 1 2 1  这是为什么呢

i 是静态的，s1.i++; s2.i++;  这两个语句操作的都是公共的静态i   这两句后，i两次自+，当然就是2 最后 s1 s2输出的都是这个静态的i  =2

而j是s1  s2各自对象的  分别自+了一次   都成了1  

懂了吧

因为 i 是static 的啊，i 是 类 共享的数据，换句话说不管有多少个对象，i 都只有一个。
而 j 是 对象的属性，每个对象都有一个。

因为i是静态成员变量，在类加载时候加载，且只有一个，被所有对象共享。
而j是成员变量，是对象的属性，每个对象被创建后都有一个

1. package com.itheima;
   
2. 
   
3. public class Static
   
4. {
   
5.         static int i = 0;
   
6.         int j = 0;
   
7. 
   
8.         public static void main(String args[])
   
9.         {
   
10.                 Static s1 = new Static();
    
11.                 Static s2 = new Static();
    
12.                 s1.i++; // i是静态成员变量，被类中所有对象共享，执行这句后i=1
    
13.                 s1.j++; // j是成员变量，每个对象创建后都有一个，执行后s1的j=1
    
14.                 s2.i++; // 因为i被所有对象共享，所以执行这句话后i=2
    
15.                 s2.j++; // j是成员变量，每个对象创建后都有一个，执行后s2的j=1
    
16.                 System.out.println(s1.i);          //此时i=2
    
17.                 System.out.println(s1.j);
    
18.                 System.out.println(s2.i);
    
19.                 System.out.println(s2.j);
    
20.         }
    
21. }

复制代码

楼主：
1、用static修饰的成员变量是单独存在内存中静态区的，不依靠对象而存在，类的所有对象访问的都是一个static成员。直接的说就是，加载类的同时就加载了static修饰的成员；而非static成员，是在创建对象时加载的，它仅属于该对象，如果创建另一个对象，则又有一个属于那个对象的非static成员。
2、对于static成员，是唯一的，所有对象要访问，只能是访问这一个。
3、代码解析：
public class Static {
        static int i=0;//此时内存静态区中有static成员i，不依附于对象，且若所有对象要访问i，都是这个i。
        int j=0;//该成员只能是在创建对象时才创建，属于创建他的对象。
        public static void main(String args[]){
                Static s1=new Static();
                Static s2=new Static();
                s1.i++;//i初始值为0 ，经++ ，此时i=1，               
                s1.j++;//此时的j属于s1，初始值为0，经++，j=1
                s2.i++;//s1 s2访问的是同一个i，因此，经再次++， 此时i=2               
                s2.j++;//此j属于s2，初始值为0，经++，j=1
                System.out.println(s1.i);//打印i，与s1无关，值为2
                System.out.println(s1.j);//打印属于s1的j，值为1
                System.out.println(s2.i);//打印i，与s2无关，值为2
                System.out.println(s2.j);//打印属于s2的j，值为1
        }
    }
   
楼主可明白了？

i被static修饰，属于共享数据，注意是“数据”，可以理解成，是唯一的，不管有多少个对象，使用的都是这一个i（静态绑定，绑定类名）

所以经过两次i++后，这个共享数据变成了2，打印出来的也就是2

而j是成员变量，属于特有数据，不同对象中，就有一个不同的j，所以两次j++是分别操作两个对象中的j，打印的也分别是两个对象中的j