Java static关键字|极客教程

Java 静态类，块，方法和变量，static关键字可以与类，变量，方法和块一起使用。静态成员属于类而不是特定实例，这意味着如果您将成员设为静态，则可以在不使用对象的情况下访问它。我们举一个例子来理解这个：

这里我们有一个静态方法myMethod()，我们可以在没有任何对象的情况下调用这个方法，因为当我们将一个成员静态化时它就变成了类级别。如果我们删除static关键字并使其成为非静态关键字，那么我们必须创建一个类的对象才能调用它。

静态成员对于类的所有实例（对象）是通用的，但非静态成员对于每个类实例是独立的。

class SimpleStaticExample
{
    // This is a static method
    static void myMethod()
    {
        System.out.println("myMethod");
    }

    public static void main(String[] args)
    {
          /* You can see that we are calling this
           * method without creating any object. 
           */
           myMethod();
    }
}

输出：

myMethod

静态块

静态块用于初始化静态变量。当在内存中加载类时，将执行此块。一个类可以有多个静态块，它们将按照它们写入程序的相同顺序执行。

示例 1：单个静态块

正如您所看到的，在我们在main方法中访问它们之前，两个静态变量都已初始化。

class JavaExample{
   static int num;
   static String mystr;
   static{
      num = 97;
      mystr = "Static keyword in Java";
   }
   public static void main(String args[])
   {
      System.out.println("Value of num: "+num);
      System.out.println("Value of mystr: "+mystr);
   }
}

输出：

Value of num: 97
Value of mystr: Static keyword in Java

示例 2：多个静态块

让我们看看多个静态块如何在 Java 中工作。它们以给定的顺序执行，这意味着第一个静态块在第二个静态块之前执行。这就是原因，第一个块初始化的值被第二个块覆盖。

class JavaExample2{
   static int num;
   static String mystr;
   //First Static block
   static{
      System.out.println("Static Block 1");
      num = 68;
      mystr = "Block1";
  } 
  //Second static block
  static{
      System.out.println("Static Block 2");
      num = 98;
      mystr = "Block2";
  }
  public static void main(String args[])
  {
      System.out.println("Value of num: "+num);
      System.out.println("Value of mystr: "+mystr);
   }
}

输出：

Static Block 1
Static Block 2
Value of num: 98
Value of mystr: Block2

Java 静态变量

静态变量对于类的所有实例（或对象）是通用的，因为它是类级变量。换句话说，您可以说只创建了一个静态变量副本，并在该类的所有实例之间共享。这些变量的内存分配仅在类加载到内存中时才会发生一次。
几点重点：

静态变量也称为类变量。
与非静态变量不同，这些变量可以直接在静态和非静态方法中访问。

示例 1：可以在静态方法中直接访问静态变量

这里我们有一个静态方法disp()和两个静态变量var1和var2。这两个变量都可以在静态方法中直接访问。

class JavaExample3{
  static int var1;
  static String var2;
  //This is a Static Method
  static void disp(){
      System.out.println("Var1 is: "+var1);
      System.out.println("Var2 is: "+var2);
  }
  public static void main(String args[]) 
  {
      disp();
  }
}

输出：

Var1 is: 0
Var2 is: null

示例 2：静态变量在类的所有实例之间共享

在此示例中，字符串变量是非静态的，整数变量是静态的。正如您在输出中看到的那样，两个对象的非静态变量是不同的，但静态变量在它们之间共享，这就是对象ob2对静态变量所做的更改在两个对象中反映的原因。

class JavaExample{
   //Static integer variable
   static int var1=77; 
   //non-static string variable
   String var2;

   public static void main(String args[])
   {
    JavaExample ob1 = new JavaExample();
    JavaExample ob2 = new JavaExample();
    /* static variables can be accessed directly without
     * any instances. Just to demonstrate that static variables
     * are shared, I am accessing them using objects so that 
     * we can check that the changes made to static variables
     * by one object, reflects when we access them using other
     * objects
     */
        //Assigning the value to static variable using object ob1
    ob1.var1=88;
    ob1.var2="I'm Object1";
        /* This will overwrite the value of var1 because var1 has a single 
         * copy shared among both the objects.
         */
        ob2.var1=99;
    ob2.var2="I'm Object2";
    System.out.println("ob1 integer:"+ob1.var1);
    System.out.println("ob1 String:"+ob1.var2);
    System.out.println("ob2 integer:"+ob2.var1);
    System.out.println("ob2 STring:"+ob2.var2);
   }
}

输出：

ob1 integer:99
ob1 String:I'm Object1
ob2 integer:99
ob2 STring:I'm Object2

Java 静态方法

静态方法可以在不使用类的对象（实例）的情况下访问类变量（静态变量），但是只能使用对象访问非静态方法和非静态变量。

可以在静态和非静态方法中直接访问静态方法。

语法：

静态关键字后跟返回类型，后跟方法名称。

static return_type method_name();

示例 1：静态方法`main`访问没有对象的静态变量

class JavaExample{
   static int i = 10;
   static String s = "Beginnersbook";
   //This is a static method
   public static void main(String args[]) 
   {
       System.out.println("i:"+i);
       System.out.println("s:"+s);
   }
}

输出：

i:10
s:Beginnersbook

示例 2：直接在静态和非静态方法中访问的静态方法

class JavaExample{
  static int i = 100;
  static String s = "geek-docs.com";
  //Static method
  static void display()
  {
     System.out.println("i:"+i);
     System.out.println("i:"+s);
  }

  //non-static method
  void funcn()
  {
      //Static method called in non-static method
      display();
  }
  //static method
  public static void main(String args[])
  {
      JavaExample obj = new JavaExample();
      //You need to have object to call this non-static method
      obj.funcn();

      //Static method called in another static method
      display();
   }
}

输出：

i:100
i:geek-docs.com
i:100
i:geek-docs.com

静态类

只有当它是嵌套类时，才能使静态成为类。

嵌套的静态类不需要引用外类
静态类无法访问外部类的非静态成员

我们将在一个例子的帮助下看到这两点：

静态类示例

class JavaExample{
   private static String str = "geek-docs.com";

   //Static class
   static class MyNestedClass{
    //non-static method
    public void disp() {

       /* If you make the str variable of outer class
        * non-static then you will get compilation error
        * because: a nested static class cannot access non-
        * static members of the outer class.
        */
       System.out.println(str); 
    }

   }
   public static void main(String args[])
   {
       /* To create instance of nested class we didn't need the outer
    * class instance but for a regular nested class you would need 
    * to create an instance of outer class first
        */
    JavaExample.MyNestedClass obj = new JavaExample.MyNestedClass();
    obj.disp();
   }
}