JAVA中的static

 

• static修饰的成员字段：static修饰的成员字段也叫类字段或全局字段，在类被加载时static修饰的成员字段被初始化，与类关联，只要类存在，static字段就存在。一个static字段单独划分一块存储空间，不与具体的对象绑定在一起，该存储空间被类的各个对象所共享。也就是说当声明一个对象时，并不产生static字段的拷贝，而是该类所有的实例对象共用同一个static字段。static修饰的成员字段能在创建任何实例对象之前被访问，而不必引用任何对象，也就是说不管创建多少对象，static修饰的字段只占有一块内存。
    class StaticTest
    {
      static int i=47;
    }
  Static :对于类的属性来说，对于不同的对象 StaticTest st1=new StaticTest();StaticTest st2=new StaticTest();都只有一个共享的存储空间。
• 引用Static字段有两种方法：可以用一个对象去定位它；也可以用其类名直接调用（最好通过类名，这样不至于让看程序的人感到疑惑）。如果一个成员被声明为static，它就能够在它的类的对象被创建之前被访问，不必引用任何对象。最常见的例子是main()方法，static定义的字段会优先于任何其它非static字段，不论其出现的顺序如何。
• Java字段在类这个级别分两种，类字段（static）和实例字段，而在静态的方法中不能够直接访问实例字段，实例字段需要初始化成一个类的实例后(对象）才可以用。静态的之所以有这种区分是为了区别对待类和对象的成员。如果某个字段或者方法被声明为static，意味着在类初始化时就必须分配内存空间。静态字段属于类，为该类所有对象所共享,在程序开始执行前就分配内存空间，如果前面加上final，功能类似全局常量,不可以修改其值，比如圆周率。静态方法中不能定义静态字段。 
• Java语言可以使用static关键字修饰类的成员字段和成员方法。被static修饰的成员字段，成员方法一般被称为静态（或者全局）字段（static field），静态方法（static method）。有别于一般的字段和方法，静态字段，静态方法的作用域是类的所有对象。也就是说，当运行时，在程序空间中，类的所有对象访问到的静态字段都是同一个值，当其中一个对象改变了静态字段的值，其它对象都将受到影响。正因为这样，静态字段，静态方法可以（建议）通过类名.静态字段/类名.静态方法直接存取：1、对象.字段/方法：没有使用static修饰的成员字段、成员方法是作用于对象域的，通常被称作实例字段(instance field)，对象方法(instance method)。当某个对象被创建时，它们才真正地存在于内存空间之中，而且对象本身对它们的改变，不会影响到其它对象。就好像 Person的一个对象zhangsan，zhangsan的改变不会影响到其它Person对象一样。2、类.字段/方法：使用static修饰的成员字段、成员方法可以看作类的固有的，它作用于类的全体对象。当类的所有对象需要共享同一值时，可以使用static来定义。如：PI=3.1415926，这时可以使用static来定义PI字段。当然，通常这种不希望改变static字段的情况，一般使用static final来修饰。
• 如果需要通过计算来初始化的static字段，可以声明为一个static块，Static 块仅在该类被加载时执行一次。
• 声明为static的字段实质上就是全局字段。当声明一个对象时，并不产生static字段的拷贝，而是该类所有的实例字段共用同一个static字段。声明为static的方法有以下几条限制：
• • 它们仅能调用其它的static 方法。
  • 它们只能访问static数据。
  • 它们不能以任何方式引用this或super
• 声明为static的字段在定义的地方被初始化，并且只能初始化一次。也就是说如果你在一个方法里定义了一个static字段，当你第二次调用该方法时，该字段不被再次初始化。
• 静态方法：不向对象施加操作的方法，静态方法可以看成是没有this参数的方法。既可以使用类名也可以通过对象来调用静态方法，建议使用类名。this是个隐式参数，代表被构造的对象。

• public class ExplicitStatic
  {
      public static void main(String[] args)
      {
          System.out.println("Inside main()");
          Cups.c1.f(99);
      }
      static Cups x=new Cups();
      static Cups y=new Cups();
  }
  class Cup
  {
      Cup(int marker)
      {
          System.out.println("Cup("+marker+")");
      }
      void f(int marker)
      {
          System.out.println("f("+marker+")");
      }
  }
  class Cups
     {
      static Cup c1=new Cup(11);
      static Cup c2;
      Cup c3=new Cup(33);
      Cup c4;
      {
          c3=new Cup(3);
          c4=new Cup(4);
      }
      static
      {
          c1=new Cup(1);
          c2=new Cup(2);
      }
      Cups()
      {
          System.out.println("Cups()");
      }
  }

输出：

程序详解：

首先初始化的是static，顺序是代码顺序up-to-down，然后在是自己调用的方法。

上面的执行顺序是：

1：static Cups x=new Cups(); 转入 Cups对象

2：static Cup c1=new Cup(11); 转入 Cup对象

3：执行Cup的输出 Cup(11);

4：cups对象里的 static Cup c2；

5：static

{

   c1=new Cup(1);转入Cup对象 输出 Cup(1)

   c2=new Cup(2);转入Cup对象 输出 Cup(2)

}

6：cups对象里的 Cup c3=new Cup(33); 输出 Cup(33)

7：c3=new Cup(3); 输出 Cup(3)

   c4=new Cup(4); 输出 Cup(4)

8：Cups()

{

System.out.println("Cups()"); 输出 Cups()

}

9：static Cups y=new Cups();

注意Cups里的static成员已经初始化 所以

static Cup c1=new Cup(11);

static Cup c2;

static{

   c1=new Cup(1);

   c2=new Cup(2);

}

不再执行！

下面的就和上面一样了！