各位高手看一下，这个有点不明白：
package com.test1;

public class ExplicitStatic {

        /**
          * @param args
          */
         public static void main(String[] args) {
                 // TODO Auto-generated method stub
                 System.out.println("Inside in main()");
                 Cups.cup1.f1(99);
         }

}

class Cup
{
         Cup(int marker)
         {
                 System.out.println("Cup("+ marker+")");
         
        }
         void f1(int marker)
         {
                 System.out.println("f1("+ marker+ ")");
         }
}

class Cups
{
         static Cup cup1;
         static Cup cup2;
         static {
                 cup1=new Cup(1);
                 cup2=new Cup(2);
         }
         Cups(){
                 System.out.println("Cups()");
         }
}

/*output
Inside in main()
Cup(1)
Cup(2)
f1(99)

Cups这个对象的都没有创建，也就是没有用Cups cups=new Cups()；
怎么就可以使用Cups.cup1.f(99);
他具体是怎么调用的？
我不是很明白。
谢谢！

你的程序中定义了static Cup cup1;和  static Cup cup2;这两个静态变量随着类的加载而加载，意思就是Cups类加载的时候cup1和cup2也加载了，
这时对象还没加载。当调用Cups.cup1.f1(99);时，程序就直接找了Cups1.cup1。所以不需要新建对象的，画个图给你看看

如果用new Cup（）时，则是在堆内存中建立一个对象，其实是不需要的，内存中已经有了cup1，cup2对象了

因为cup1在cups里面是static修饰的

    static修饰属性（类变量）：

        那么这个属性就可以用" 类名.属性名 "来访问，也就是使这个属性成为本类的类变量，为本类对象所共享。

        类变量，会在加载时自动初始化，初始化规则和实例变量相同。

        注意：

            类中的实例变量是在创建对象时被初始化的

            static修饰的属性，是在类加载时被创建并进行初始化，类加载的过程只进行一次，也就是类变量只会被创建一次。

   

首先要对二个知识点搞清楚.
一,方法是如何调用?
方法调用方式存在两种,一是对象调用.二种类直接调用.
二,static修饰方法时,具有什么特点?
一旦方法被static所修饰,那么其又具有一种特性,可以被类直接打点调,当然,也可以被对象调.


package com.test1;

public class ExplicitStatic {

         /**
           * @param args
           */
          public static void main(String[] args) {
                  // TODO Auto-generated method stub
                  System.out.println("Inside in main()");
                  Cups.cup1.f1(99);
//从这个语句可以看出,这是调用了一个方法,那么想想方法只能要么对象调,在么类直接调,
所以你折分出来方法f1(99)和前面的调用者,那么这个方法的前面的调用者Cups.cup1,要么是类名,要么是对象
Cups.cup1显然不是类名,所以,它只能是对象.
再折分:Cups是一个类名 cup1是一个静态成员变量,那么显然,类直接调用了这个成员,那么调用这个成员得到什么,
就要看这个成员代表什么?
cup1在类加载时,就通过静态代码块给其初始化了创建了一个对象 cup1=new Cup(1);那么cup1就代表一个对象
所以,Cups.cup1也就是代表一个对象,且是Cup的对象.

          }

}

class Cup
{
          Cup(int marker)
          {
                  System.out.println("Cup("+ marker+")");
         
         }
          void f1(int marker)
          {
                  System.out.println("f1("+ marker+ ")");
          }
}

class Cups
{
          static Cup cup1;
          static Cup cup2;
          static {
                  cup1=new Cup(1);
                  cup2=new Cup(2);
          }
          Cups(){
                  System.out.println("Cups()");
          }
}

/*output
Inside in main()
Cup(1)
Cup(2)
f1(99)