Java的static关键字

Java关键字是什么？

摘自百度百科

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。

常用的关键字如下图

Java关键字.png

针对于上述关键字，我们抽出几个比较重要的来唠唠

修饰字符类型关键字

static

在Java中，static表示“静态的”，它也是一种修饰符，可以修饰属性、方法、代码块和内部类。
一般情况下，static修饰的变量，方法，代码块。都跟随类的生命周期，它们所属的JVM内存也都是处于共享内存

变量：

静态变量（或称为类变量），指被 static 修饰的成员变量；类的静态变量在内存中只有一个，Java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被类的所有实例共享。静态变量可以直接通过类名被访问。静态变量的生命周期取决于类的生命周期，当加载类的时候，静态变量被创建并分配内存，当卸载类的时候，静态变量被销毁并撤销内存。
实例变量，指没有被 static 修饰的成员变量；类的每个实例都有相应的实例变量。每创建一个类的实例，Java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中。实例变量的生命周期取决于实例的生命周期，当创建实例的时候，实例变量被创建并分配内存，当销毁实例的时候，实例变量被销毁并撤销内存。
局部变量，指的是在一个方法的内部或者方法的一个代码块中声明的变量，前者的作用域就是整个方法，后者的作用域则是这个代码块（代码块就是{}以内的代码）

class Person() {
  private String name; // 实例变量
  private Integer age; // 实例变量
  private static String country = "China"; // 静态变量

  public person(String name, Integer age) {
    this.name = name;
    this.age = age;
  }
}

当我们使用这个类创建实例的时候

  public static void main(String[] args) {
    Person p1 = new Person("zhangfei", 30);
    Person p2 = new Person("guanyu", 35);
    
    System.out.println(p1.name);
    System.out.println(Person.country);
  }

内存分配如下：

Java_static内存分配.jpg

方法：

• 静态方法是使用 static 关键字修饰的成员方法，它属于类，而不是类的实例。
• 静态方法可以直接通过类名来调用，也可以通过类的对象来调用，但一般推荐使用类名来调用。
• 静态方法只能访问类的静态变量和静态方法，不能访问类的实例变量和实例方法，也不能使用 this 关键字。
• 静态方法通常是一些工具方法，不需要依赖于对象的状态，例如 Collections 类、Math 类等都包含了很多静态方法。

# 接上面的Person类
class Person() {
  ……

  public String printName() {
    System.out.println(this.name);
  }

  public static printCountry() {
    System.out.println(Person.country);
  }
  
}

实际调用

  public static void main(String[] args) {
    Person p1 = new Person("zhangfei", 30);
    Person p2 = new Person("guanyu", 35);
    
    p1.printName();
    Person.printCountry(); // 使用类名调用
    p1.printName(); // 使用对象调用，推荐使用类名调用
  }

代码块：

静态代码块，在Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。
当类被加载时，静态代码块会执行，由于类只加载一次，所以静态代码块只会执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化

# 接上面的Person类
class Person() {
  static{
    System.out.println("开始加载类，执行静态代码块");
  }
}

构造代码块
java类中使用{}声明的代码块(和静态代码块的区别是少了static关键字)

# 接上面的Person类
class Person() {
  {
    System.out.println("开始加载类，执行构造代码块");
  }
}

这里要梳理清楚执行顺序

静态代码块>构造代码块>构造函数>普通代码块

我们可以实际模拟运行一下

public class codeBlock {
    static {
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
    public codeBlock(){
        System.out.println("无参构造函数");
    }
    public void sayHello(){
        System.out.println("普通代码块");
    }

    public static void main(String[] args) {
        System.out.println("执行了main方法");
        new codeBlock().sayHello();
        System.out.println("---------------------------");
    }
}

执行结果如下：

静态代码块
执行了main方法
构造代码块
无参构造函数
普通代码块
---------------------------

嵌套类

嵌套类又成为内部类，内部类就是一个定义在一个类里面的类，里面的类可以理解为（寄生），外部类可以理解成（宿主）
分为静态内部类和非静态内部类；

• 静态内部类是指被声明为static的内部类，
• 非静态内部类是指没有被声明为static的内部类

实例化：静态内部类的实例化不依赖于外部类的实例，可以直接通过类名访问；而非静态内部类的实例化必须依赖于外部类的实例，只能在外部类的实例方法中创建。
关系：静态内部类与外部类没有任何联系，只是被包含在外部类中；而非静态内部类可以访问外部类的成员和方法，并且可以使用外部类的引用来访问外部类的成员。

静态内部类不需要依赖外部类的实例而可以被实例化。静态内部类通常用于封装与外部类紧密相关的一组静态方法或常量

public class OuterClass {
    public static class InnerClass {
        // 静态内部类中可以定义一组静态方法或常量
        public static final int MAX_VALUE = 100;
        public static int add(int x, int y) {
            return x + y;
        }
    }
}

public class OuterClass {
    private int outerVar;
    
    public OuterClass(int outerVar) {
        this.outerVar = outerVar;
    }
    
    public void outerMethod() {
        int localVar = 10;
        // 非静态内部类
        class InnerClass {
            public void innerMethod() {
                System.out.println(outerVar); // 访问外部类的实例变量
                System.out.println(localVar); // 访问局部变量
            }
        }
        
        InnerClass inner = new InnerClass();
        inner.innerMethod();
        
        // 静态内部类
        static class StaticInnerClass {
            public static final int MAX_VALUE = 100;
            public static void staticInnerMethod() {
                System.out.println("This is a static inner class.");
            }
        }
        
        StaticInnerClass staticInner = new StaticInnerClass();
        staticInner.staticInnerMethod();
    }
}

非静态内部类：InnerClass可以访问外部类的实例变量outerVar和局部变量localVar，因此适合在需要访问外部类实例的情况下使用**，例如实现一个事件监听器。

Outer.Inner in = new Outer().new.Inner()

静态内部类：StaticInnerClass没有访问外部类实例的需求，只需要实现一些独立的功能，因此适合在不需要访问外部类实例的情况下使用，例如实现一个工具类。同时，静态内部类的实例化不依赖于外部类的实例，可以直接通过类名访问，使用起来更加方便。和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已

Outer.Inner in = new Outer.Inner();

一道有意思的面试题

class People() {
  private int heartbeat = 150;
  public class Heart {
    private int heartbeat = 110;
    public void show() {
      int heartbeat = 80;
      System.out.println(heartbeat);//80
      System.out.println(this.heartbeat);//110
      System.out.println(People.this.heartbeat);//150
    }
  }

  public static void main(String[] args) {
    new People().new Heart().show();
  }
}

输出结果

80
110
150

匿名内部类(重要)
匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。
匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。

为什么在Java中需要内部类?
我们先看一下不使用匿名内部类来实现抽象方法的时候

abstract class Person {
    public abstract void eat();
}
 
class Child extends Person {
    public void eat() {
        System.out.println("eat something");
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Child();
        p.eat();
    }
}

用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用
但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？
这个时候就引入了匿名内部类

引入匿名内部类之后

abstract class Person {
    public abstract void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

可以看到，我们直接将抽象类Person中的方法在大括号中实现了
这样便可以省略一个类的书写，并且，匿名内部类还能用于接口上

interface Person {
    public void eat();
}
 
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现
最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

Thread类的匿名内部类实现

public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

Runnable接口的匿名内部类实现

public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}

这篇文章介绍匿名内部类使用场景，比较通俗易懂。java匿名内部类总结

匿名内部类总结：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。