《Java编程秘籍：深入解析static关键字的多面用法与实例剖析》

1. 解释什么是static关键字，并列举至少3种用法：

   • static 关键字用于声明类的成员，而不是实例成员。使用 static 声明的变量和方法属于类本身，而不是某个特定的实例。

   • 三种用法：

     1. 静态变量：在类中声明的 static 变量，所有实例共享同一个变量。例如：

        public class Example {
            public static int staticVar = 0;
        }
        

     2. 静态方法：在类中声明的 static 方法，可以在不创建实例的情况下调用。例如：

        public class Example {
            public static void staticMethod() {
                System.out.println("Static method called");
            }
        }
        

     3. 静态代码块：在类加载时执行的代码块，用于初始化类的静态变量。例如：

        public class Example {
            static {
                System.out.println("Static block executed");
            }
        }
        

2. 静态成员变量和非静态成员变量的区别：

   1. 存储位置：静态成员变量存储在方法区中，非静态成员变量存储在堆内存中。
   2. 生命周期：静态成员变量在类加载时初始化，直到程序结束；非静态成员变量在对象创建时初始化，随着对象被回收而销毁。
   3. 出现顺序：静态成员变量优先于非静态成员变量初始化。
   4. 调用方式：静态成员变量可以通过类名调用，非静态成员变量通过对象实例调用。
   5. 初始化时机：静态成员变量在类加载时初始化，非静态成员变量在对象创建时初始化。
   6. 内存占用：静态成员变量内存位置固定，非静态成员变量每个对象实例都有独立的内存空间。
   7. 共享：静态成员变量被类的所有实例共享，非静态成员变量各实例独立。

3. static方法和非static方法的区别：

   • static方法：属于类本身，可以不创建实例而调用，不能访问非静态成员。
   • 非static方法：属于类的实例，需要创建实例后调用，可以访问类的所有成员。
   • 使用场景：当方法不依赖于实例变量时，使用 static 方法。例如工具类中的方法，如 Math 类的 sqrt 方法。

4. 匿名代码块和静态代码块的作用：

   • 匿名代码块：在对象创建时执行，用于初始化实例变量。

     {
         // 匿名代码块
         System.out.println("Anonymous block executed");
     }
     

   • 静态代码块：在类加载时执行，用于初始化类的静态变量。

     static {
         // 静态代码块
         System.out.println("Static block executed");
     }
     

5. 在Java中，能否继承static成员变量或方法：

   • 在Java中，static 成员变量和方法不能被继承，但是可以被访问。如果子类中定义了同名的 static 成员变量或方法，它们会隐藏父类的同名成员，但不会覆盖它们。

6. 程序分析：

   • 案例一：

     class Test {
         public Test() {
             System.out.println("构造器");
         }
     
         public void info() {
             System.out.println("info");
         }
     
         static {
             System.out.println("test static 1");
         }
     
         public static void main(String[] args) {
             new Test().info();
         }
     
         {
             System.out.println("代码块");
         }
     
         static {
             System.out.println("test static 2");
         }
     }
     

     输出：

     test static 1
     test static 2
     代码块
     构造器
     info
     

   • 案例二：

     public class Test06 {
         public static void main(String[] args) {
             Child child = new Child();
         }
     }
     
     class Parent {
         static {
             System.out.println("静态代码块Parent");
         }
     
         {
             System.out.println("构造代码块Parent");
         }
     
         public Parent() {
             System.out.println("构造方法Parent");
         }
     }
     
     class Child extends Parent {
         static {
             System.out.println("静态代码块Child");
         }
     
         {
             System.out.println("构造代码块Child");
         }
     
         public Child() {
             System.out.println("构造方法Child");
         }
     }
     

     输出：

     静态代码块Parent
     静态代码块Child
     构造代码块Parent
     构造方法Parent
     构造代码块Child
     构造方法Child
     

   • 案例三：

     class B {
         public static B b = new B();
         public static B b2 = new B();
     
         {
             System.out.println("构造块");
         }
     
         static {
             System.out.println("静态块");
         }
     }
     public class Test06 {
         public static void main(String[] args) {
             B b = new B();
         }
     }
     

     输出：

     静态块
     构造块
     构造块
     构造块
     

7. 单例模式：

   • 定义：单例模式确保一个类只有一个实例，并提供一个全局访问点。

   • 示例：

     public class Singleton {
         private static Singleton instance;
     
         private Singleton() {}
     
         public static Singleton getInstance() {
             if (instance == null) {
                 instance = new Singleton();
             }
             return instance;
         }
     }
     

8. 统计次数：

   • 示例：

     public class InstanceCounter {
         private static int count = 0;
     
         public InstanceCounter() {
             count++;
         }
     
         public static int getCount() {
             return count;
         }
     
         public static void main(String[] args) {
             new InstanceCounter();
             new InstanceCounter();
             System.out.println("Instance count: " + InstanceCounter.getCount());
         }
     }
     

`