1. 
   
2. public class Problems {
   
3.         public static void main(String[] args) {
   
4.                 System.out.println(Price.INSTANCE.currentPrice);
   
5.                 Price price=new Price(2.8);
   
6.                 System.out.println(price.currentPrice);
   
7.         }
   
8. 
   
9. }
   
10. 
    
11. class Price{
    
12.         static Price INSTANCE = new Price(2.8);
    
13.         static double initPrice = 20;
    
14.         double currentPrice;
    
15.         public Price(double discount){
    
16.                  currentPrice = initPrice - discount;
    
17.         }
    
18. }
    
19. /*运行结果：-2.8
    
20. *                    17.2
    
21. */
    

复制代码

从结果来看，静态成员在内存中是先分配其内存地址，然后在进行初始化赋值。
当这句时：System.out.println(Price.INSTANCE.currentPrice);内存中只对initPrice分配内存，内存默认值为0，还没有进行初始化就被调用，所以输出为-2.8  。
当这句时：System.out.println(price.currentPrice);对象已经执行完对initPrice的赋值语句，所以再次调用就输出了17.2.

这是我的理解，就是从这些现象中推测内存中的变化。

我只想说静态不要乱用，静态优先加载 等 这句加载完毕后才会加载        static double initPrice = 20;
所以static Price INSTANCE = new Price(2.8);初始化的时候内存中还没有为initPrice 赋值
所以public Price(double discount){
            currentPrice = initPrice - discount;//相当于currentPrice =0-initPrice ；
                                             }
static一般修饰成员变量 成员函数 修饰局部变量的时候，局部变量所在函数也得静态修饰

      

执行Price.INSTANCE.currentPrice这个时内存中只对initPrice分配内存，还没有进行初始化，initPrice为0，因为static Price INSTANCE = new Price(2.8);在 static double initPrice = 20;之前执行，而 Price price=new Price(2.8);已经完成了对象的所有初始化操作。

帖子已重新分类。若还没理解的，可继续提问~