1. package Day09_面向对象;
   
2. 
   
3. public class L01_Static {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 A.sop();
   
7.         }
   
8. }
   
9. class A
   
10. {
    
11.         int a = 4;   //非静态成员
    
12.         static void sop()   //静态方法
    
13.         {
    
14.                 System.out.println(new A().a+",,,"+new B().b);
    
15.         }
    
16. }
    
17. class B
    
18. {
    
19.         int b = 5;   
    
20. //非静态成员
    
21. }

复制代码

非静态成员属于对象,调用时需要先实例对象，然后对象.非静态成员。静态成员属于类，调用时直接类名.静态方法。

视频里说的是静态方法不能“直接”访问非静态成员，这是因为静态方法是“类方法”，优先于对象的存在，所以不能直接访问对象的属性（没有对象，怎么会有对象的属性），而你代码中访问变量x是通过A的对象new A()来访问的，new A()创建了A的对象，当然就能访问自己内部的非private属性了。

静态方法先于对象存在，非静态的成员是在对象建立后才存在的，所以他不能调用非静态成员，

1. public class L01_Static {
   
2.         public static void main(String[] args)
   
3.         {
   
4.                 A.sop();
   
5.         }
   
6. }
   
7. class A
   
8. {
   
9.         int a = 4;   //非静态成员
   
10.         static void sop()   //静态方法
    
11.         {
    
12.                 System.out.println(new A().a+",,,"+new B().b);//你这个是在建立静态方法时就建立了对象，所以能调用非静态的成员，如果你将new B(),new A()放在静态方法的外面就不对了，
    
13.         }
    
14. }
    
15. class B
    
16. {
    
17.         int b = 5;   
    
18. //非静态成员
    
19. }

复制代码

，，，这个是我个人的理解

毕老师说的，不能访问的是这种，而不是New建立实例后的对象吧？
我也不太懂，写一点给你参考一下！

1. class A
   
2. {
   
3. int x;
   
4. static int y;
   
5. static int F()
   
6. {
   
7. x = 1;   //错误 不允许访问
   
8. y = 2   //正确 允许访问
   
9. }
   
10. }

复制代码

静态方法只能访问类中的静态成员
作为非静态成员，在类的每个实例中都占有一个存储，或者说具有一个副本，而静态方法是类所共享的，它无法判断出当前的x属于哪个类的实例，所以不知道应该到内存的哪个地址去读取当前x的值；而y是静态成员所有类的实例都公用一个副本，静态方法F使用它就不存在什么问题。

PS：
静态方法规：
静态方法只能访问类的静态成员，不能访问类的非静态成员；
非静态方法可以访问类的静态成员，也可以访问类的非静态成员；
静态方法既可以用实例来调用，也可以用类名来调用。