面试官Q1：请说说static关键字，你在项目中是怎么使用的？

  • static 关键字可以用来修饰：属性、方法、内部类、代码块；

  • static 修饰的资源属于类级别，是全体对象实例共享的资源；

  • 使用 static 修饰的属性，静态属性是在类的加载期间初始化的，使用类名.属性访问

案例说明

①修饰成员变量

  1.  package com.ant.param;
  2.  public class StaticFieldDemo {
  3.      public static void main(String[] args) {
  4.          Foo f1 = new Foo();
  5.          Foo f2 = new Foo();
  6.          Foo f3 = new Foo();
  7.          System.out.println(f1.id + " " + f2.id + " " + f3.id );
  8.      }
  9.  }
  10. class Foo{
  11.     int id;
  12. }
  13. 运行结果如下：
  14. 0 0 0

上面的代码我们很熟悉，根据Foo构造出的每一个对象都是独立存在的，保存有自己独立的成员变量，相互不会影响，他们在内存中的示意如下:

从上图中可以看出，f1、f2和f3三个变量引用的对象分别存储在内存中堆区域的不同地址中，所以他们之间相互不会干扰。对象的成员属性都在这了，由每个对象自己保存。f1.id、f2.id、f3.id相当于“每个人一个水杯”。

我们对上面的代码，做如下修改：

  1. package com.ant.param;
  2.  public class StaticFieldDemo {
  3.      public static void main(String[] args) {
  4.          Foo f1 = new Foo();
  5.          Foo f2 = new Foo();
  6.          Foo f3 = new Foo();
  7.          System.out.println(f1.id + " " + f2.id + " " +
  8.          f3.id + " " + Foo.i);
  9.      }
  10. }
  11. class Foo{
  12.     int id;
  13.     static int i=0;
  14.     public Foo(){
  15.         id = i++;
  16.     }
  17. }
  18. 运行结果如下：
  19. 0 1 2 3

程序执行过程内存图如下所示：

第 1 步：加载类

static修饰的变量在类加载期间初始化，且在方法区中分配，属于线程共享区，所有的对象实例共享一份数据。

第 2步：继续加载类

第 3步：继续加载类

 

最终加载结果如上述三个步骤

 

②修饰成员方法

static的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的(方法区)。static修饰成员方法最大的作用，就是可以使用”类名.方法名”的方式操作方法，避免了先要new出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用：

  1.  package com.ant.param;
  2.  
  3.  public class StaticFieldDemo {
  4.      private static void print(){
  5.          System.out.println("hello");
  6.      }
  7.      public static void main(String[] args) {
  8.          StaticFieldDemo.print();
  9.      }
  10. }

③修饰静态代码块

静态代码块是在类加载期间运行的代码块，由于类只加载一次，所以静态代码块只执行一次！静态代码块用途很常见,一般用来在类加载以后初始化一些静态资源时候使用。如：加载配置文件等

  1. package com.ant.param;
  2.  
  3.  public class StaticBlockDemo {
  4.      public static void main(String[] args) {
  5.          Foo foo = new Foo();
  6.      }
  7.  }
  8.  
  9.  class Foo{
  10.     //代码块，在创建对象的时候执行，使用很少，和构造器差不多
  11.     {
  12.         System.out.println("创建对象了！");
  13.     }
  14.     //静态代码块，在类加载期间执行，用于加载配置文件或者其他信息等
  15.     static{
  16.         System.out.println("类加载了！");
  17.     }
  18.     public Foo(){
  19.         System.out.println("调用了构造器！");
  20.     }
  21. }

静态块用法：将多个类成员放在一起初始化，使得程序更加规整，对理解对象的初始化过程非常关键；

在我的印象中，这些问题一般初中级Java工程师会被问到，都是很常规的面试题，您会了吗？

　　

版权声明：本文为marsitman原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/marsitman/p/11192096.html