static关键字详解

最新推荐文章于 2021-06-15 13:50:30 发布

Charles Yan

最新推荐文章于 2021-06-15 13:50:30 发布

阅读量463

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_42586723/article/details/104159204

版权

Java 专栏收录该内容

47 篇文章 2 订阅

订阅专栏

static关键字详解

static关键字介绍
static关键字误区
static关键字常见面试题

static关键字介绍

参考链接

https://blog.csdn.net/kuangay/article/details/81485324

定义

《Java编程思想》P86页：static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

作用

static修饰类的成员变量
Java类提供了两种类型的变量：用static关键字修饰的静态变量和不用static关键字修饰的实例变量。

静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间。对静态变量的引用有两种方式，分别是"类.静态变量"和"对象.静态变量"

实例变量属于对象，只有对象被创建后，实例变量才会被分配内存空间，才能被使用。它在内存中存在多个复制，只有用"对象.实例变量"的方式来引用
static修饰类的成员方法
static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用时，这个类的对象可能还没被创建，即使已经被创建了，也无法确定调用哪个对象的方法。同理，static方法也不能访问非static类型的变量。

单例设计模式
```
  class Singleton{

    private static Singleton instance=null;

    private Singleton(){}

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

static修饰类的代码块
构造方法用于对象的初始化。静态代码块，用于类的初始化操作。
合理使用静态代码块以优化程序性能：

    class Person{
        private Date birthDate;

        public Person(Date birthDate) {
            this.birthDate = birthDate;
        }


        boolean isBornBoomer() {
            Date startDate = Date.valueOf("1946");
            Date endDate = Date.valueOf("2020");
            return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
        }
    }

isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：

    class Person{
        private Date birthDate;
        private static Date startDate,endDate;
        static{
            startDate = parseDateStr("1946");
            endDate = parseDateStr("2020");

        }

        //将日期字符串转换为Date类型
        public static Date parseDateStr(String dateStr) {
            Date year = null;
            try {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
                year = sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return year;
        }

        public Person(Date birthDate) {
            this.birthDate = birthDate;
        }

        boolean isBornBoomer() {
            return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
        }

        public static void main(String[] args) {
            Date currentDate = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            System.err.println("当前时间：" + sdf.format(currentDate));

            //获取当前年月日
    //        LocalDate localDate = LocalDate.now();
    //        int year = localDate.getYear();
    //        System.err.println("当前时间：" + year);

            Person person = new Person(currentDate);
            boolean boomer = person.isBornBoomer();
            System.err.println("是否在给定范围内：" + boomer);

        }
    }

注意事项
很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行：

静态初始化块可以置于类中的任何地方，类中可以有多个静态初始化块。
在类初次被加载时，会按照静态初始化块的顺序来执行每个块，并且只会执行一次。

特点

static优先于对象存在，因为static的成员随着类的加载就已经存在
static修饰的成员多了一种调用方式，可以直接被类名所调用（类名.静态成员）
static修饰的方法（静态方法）不能调用非静态成员，编译会报错
static成员变量的初始化顺序按照定义的顺序进行初始化

区别

生命周期的不同
1. 成员变量随着对象的创建而存在随着对象的回收而释放。
2. 静态变量随着类的加载而存在随着类的消失而消失。
调用方式不同
1. 成员变量只能被对象调用。
2. 静态变量可以被对象调用，也可以用类名调用。（推荐用类名调用）
别名不同
1. 成员变量也称为实例变量。
2. 静态变量称为类变量。
数据存储位置不同
1. 成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
2. 静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

其他

static与final结合
1. 对于变量，若使用static final修饰，表示一旦赋值不能修改，并且通过类名可以访问。
2. 对于方法，若使用static final修饰，表示该方法不可被覆盖，并且可以通过类名直接访问。

案例代码

  public class PersonTest {

  public static double i = Math.random();

  public final double j = Math.random();

  public static void main(String[] args) {

      PersonTest personTest1 = new PersonTest();
      PersonTest personTest2 = new PersonTest();
      System.err.println("static修饰：" + (personTest1.i == personTest2.i));
      System.err.println("final修饰：" + (personTest1.j == personTest2.j));
  }
}

输出结果


  static修饰：true
  final修饰：false

代码执行过程分析

static关键字修饰变量时，会使该变量在类加载时就会被初始化，不会因为对象的创建再次被加载，当变量被static 修饰时就代表该变量只会被初始化一次

static关键字误区

不能改变变量和方法的访问权限

Java中能够影响到访问权限的只有private、public、protected这几个关键字。

能通过this访问静态成员变量

测试代码

静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）

  public class Main {　　
      static int value = 33;

      public static void main(String[] args) throws Exception{
          new Main().printValue();
      }

      private void printValue(){
          int value = 3;
          System.out.println(this.value);
      }
  }

  //输出结果为：33

不能作用于局部变量

Java语法规定

static关键字常见面试题

测试题1

案例代码

    public class Test extends Base{

        static{
            System.out.println("test static");
        }

        public Test(){
            System.out.println("test constructor");
        }

        public static void main(String[] args) {
            new Test();
        }
    }

    class Base{

        static{
            System.out.println("base static");
        }

        public Base(){
            System.out.println("base constructor");
        }
    }

输出结果


    base static
    test static
    base constructor
    test constructor

代码执行过程分析
1. 找到main方法入口，main方法是程序入口，但在执行main方法之前，要先加载Test类
2. 加载Test类的时候，发现Test类继承Base类，于是先去加载Base类
3. 加载Base类的时候，发现Base类有static块，而是先执行static块，输出base static结果
4. Base类加载完成后，再去加载Test类，发现Test类也有static块，而是执行Test类中的static块，输出test static结果
5. Base类和Test类加载完成后，然后执行main方法中的new Test()，调用子类构造器之前会先调用父类构造器
6. 调用父类构造器，输出base constructor结果
7. 然后再调用子类构造器，输出test constructor结果

测试题2

案例代码


    public class Test {
        Person person = new Person("Test");
        static{
            System.out.println("test static");
        }

        public Test() {
            System.out.println("test constructor");
        }

        public static void main(String[] args) {
            new MyClass();
        }
    }

    class Person{
        static{
            System.out.println("person static");
        }
        public Person(String str) {
            System.out.println("person "+str);
        }
    }


    class MyClass extends Test {
        Person person = new Person("MyClass");
        static{
            System.out.println("myclass static");
        }

        public MyClass() {
            System.out.println("myclass constructor");
        }
    }

输出结果


    test static
    myclass static
    person static
    person Test
    test constructor
    person MyClass
    myclass constructor

代码执行过程分析
1. 找到main方法入口，main方法是程序入口，但在执行main方法之前，要先加载Test类
2. 加载Test类的时候，发现Test类有static块，而是先执行static块，输出test static结果
3. 然后执行new MyClass(),执行此代码之前，先加载MyClass类，发现MyClass类继承Test类，而是要先加载Test类，Test类之前已加载
4. 加载MyClass类，发现MyClass类有static块，而是先执行static块，输出myclass static结果
5. 然后调用MyClass类的构造器生成对象，在生成对象前，需要先初始化父类Test的成员变量，而是执行Person person = new Person(“Test”)代码，发现Person类没有加载
6. 加载Person类，发现Person类有static块，而是先执行static块，输出person static结果
7. 接着执行Person构造器，输出person Test结果
8. 然后调用父类Test构造器，输出test constructor结果，这样就完成了父类Test的初始化了
9. 再初始化MyClass类成员变量，执行Person构造器，输出person MyClass结果
10. 最后调用MyClass类构造器，输出myclass constructor结果，这样就完成了MyClass类的初始化了

测试题3

案例代码

  public class Test {

      static{
          System.out.println("test static 1");
      }
      public static void main(String[] args) {

      }

      static{
          System.out.println("test static 2");
      }
  }

输出结果
```
  test static 1
  test static 2
```
代码执行过程分析
1. 虽然在main方法中没有任何语句，但是还是会输出，原因上面已经讲述过了。
2. 另外，static块可以出现类中的任何地方（只要不是方法内部，记住，任何方法内部都不行），并且执行是按照static块的顺序执行的。

测试题4

案例代码


  public class Test{

    public static int testStatic(){
      static final int i=0;
      System.out.println(i++);
      
    }

    public static void main(String[] args){
      Test test=new Test();
      test.testStatic();
    }
  }