class Student {   
               static String name;   
               public Student(){};   
               public Student(String name){   
                     this.name=name;   
               }   
               public static void study(){   
                     System.out.println(name+"is playing now!");   
               }   
            }   
            public class test03 {   
               public static void main(String [] args){   
               Student stu=new Student("张三");   
               Student st=new Student("李四");   
               Student.name="张三";   
               st.study();   
               stu.study();   
               }   
            }  
结果都是张三  如果没有Student.name="张三";结果都是李四 为什么呢   
class Student {   
        static String name;   
        public Student(){};   
        public Student(String name){   
              this.name=name;   
        }   
        public static void study(){   
              System.out.println(name+"is playing now!");   
        }   
     }   
     public class test03 {   
        public static void main(String [] args){   
        Student stu=new Student("张三");   
        Student st=new Student("李四");   
        //Student.name="张三";   
        Student.study();   
        stu.study();   
        }   
     }  
结果又都是李四  

name在学生类里面是静态变量，在学生类两次初始化的时候，最后一次初始化为了李四，因为static声明的属性是共享的，所以都是李四，而后面用学生类直接调用name再赋值张三，所以又变为了张三。关于内存的加载我也不是很清楚，看那个的话估计会更明了些。

static修饰的成员变量属于该类。
而且这个static修饰的变量是一个所有的对象都共享的变量，刚开始new张三时，那个static修饰的name，是张三，new李四的时候，将它修改成了
李四，所有最后都是李四了。如果没删Student.name="张三";   最后就是张三。

public class Student {

         static String name;   
     public Student(){};   
     public Student(String name){   
           this.name=name;   
     }   
     public static void study(){   
           System.out.println(name+"is playing now!");   
     }   
}


public class Test03 {

         public static void main(String [] args){   
                Student stu=new Student("张三");
                Student st=new Student("李四");   
                /*
                         因为name是静态的，执行完以上两条语句name="李四"，所以就是共享资源。
                 */
                Student.study();   
                stu.study();   
                }   

}

静态成员变量整个类只有一份
非静态的成员变量每个对象都有一份
Student stu=new Student("张三");   
所有name都为"张三"
Student st=new Student("李四");   
所有name都为"李四"
Student.name="张三";   
所有name都为"张三"

静态变量可以供类的所有对象使用，比如统计Student的数量

static 是一个特殊的关键字，用于修饰方法、属性等成员。static修饰的成员表明它属于这个类本身，而不属于该类的单个实例，被修饰的成员可以被类名直接调用。
你的第一个程序Student.name="张三";这相当于给Student类最终赋值张三。所以你之后调用只能是张三。
第二个情况类似，最后赋值是李四，所以打印结果为李四。
但是你的第二个程序如果将student的属性去掉static结果就会不一样。看下面的截图。

1. class Student {
   
2.         String name;   //姓名一般是不同的是不能用static修饰的，
   
3.         public Student(){};   
   
4.         public Student(String name){   
   
5.                 this.name=name;   
   
6.         }
   
7.         public void study(){   //同样，调用非static属性的时候，方法也不能是static的。
   
8.                 System.out.println(name+"is playing now!");   
   
9.         }   
   
10. }   
    
11. public class Test03 {   //类名首字母需大写
    
12.         public static void main(String [] args){
    
13.                 Student stu=new Student("张三");
    
14.                 Student st=new Student("李四");
    
15.                 //Student.name="张三";
    
16.                 st.study();
    
17.                 stu.study();
    
18.         }   
    
19. }  

复制代码

因为static是静态的，共享的，给它附上值之后，所有new出的对象的name值都是同一个name值。

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢