再议Java中的static关键字

时间 2019-11-05

标签再议 java static 关键字栏目 Java 繁體版

原文原文链接

再议Java中的static关键字

　　java中的static关键字在好久以前的一篇博文中已经讲到过了，感兴趣的朋友能够参考：《Java中的static关键字解析》。html

　　今天咱们再来谈一谈static关键字，此次咱们侧重讲述static关键字的一些使用场景和方式，如下是本文目录大纲：java

　　一.static关键字使用场景编程

　　二.static变量和普通成员变量区别设计模式

　　三.类的构造器究竟是不是static方法？多线程

　　如有不正之处，但愿谅解并欢迎批评指正。oracle

　　请尊重做者劳动成果，转载请标明原文连接：jvm

　　https://www.cnblogs.com/dolphin0520/p/10651845.htmlide

一.static关键字使用场景

　　static关键字主要有如下5个使用场景：工具

1）静态变量优化

　　把一个变量声明为静态变量一般基于如下三个目的：

做为共享变量使用
减小对象的建立
保留惟一副本

　　第一种比较容易理解，因为static变量在内存中只会存在一个副本，因此其能够做为共享变量使用，好比要定义一个全局配置、进行全局计数。如：

public class CarConstants {
　　// 全局配置,通常全局配置会和final一块儿配合使用, 做为共享变量
　　public static final int MAX_CAR_NUM = 10000;  
}

public class CarFactory {
　　// 计数器
　　private static int createCarNum = 0;
    
    public static Car createCar() {
      if (createCarNum > CarConstants.MAX_CAR_NUM) {
        throw new RuntimeException("超出最大可生产数量");
      }
      Car c = new Car();
      createCarNum++;
      return c;
    }
  
    public static getCreateCarNum() {
      return createCarNum;
    }
}

　　第二种虽然场景很少，可是基本在每一个工程里面都会使用到，好比声明Loggger变量：

private static final Logger LOGGER = LogFactory.getLoggger(MyClass.class);

　　实际上，若是把static去掉也是可行的，好比：

private final Logger LOGGER = LogFactory.getLoggger(MyClass.class);

　　这样一来，对于每一个MyClass的实例化对象都会拥有一个LOGGER，若是建立了1000个MyClass对象，则会多出1000个Logger对象，形成资源的浪费，所以一般会将Logger对象声明为static变量，这样一来，可以减小对内存资源的占用。

　　第三种最经典的场景莫过于单例模式了，单例模式因为必须全局只保留一个副本，因此自然和static的初衷是吻合的，用static来修饰再合适不过了。

public class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {}

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

2）静态方法

　　将一个方法声明为静态方法，一般是为了方便在不建立对象的状况下调用。这种使用方式很是地常见，好比jdk的Collections类中的一些方法、单例模式的getInstance方法、工厂模式的create/build方法、util工具类中的方法。

3）静态代码块

　　静态代码块一般来讲是为了对静态变量进行一些初始化操做，好比单例模式、定义枚举类：

单例模式

public class Singleton {
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

枚举类

public enum WeekDayEnum {
    MONDAY(1,"周一"),
    TUESDAY(2, "周二"),
    WEDNESDAY(3, "周三"),
    THURSDAY(4, "周四"),
    FRIDAY(5, "周五"),
    SATURDAY(6, "周六"),
    SUNDAY(7, "周日");

    private int code;
    private String desc;

    WeekDayEnum(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    private static final Map<Integer, WeekDayEnum> WEEK_ENUM_MAP = new HashMap<Integer, WeekDayEnum>();

    // 对map进行初始化
    static {
        for (WeekDayEnum weekDay : WeekDayEnum.values()) {
            WEEK_ENUM_MAP.put(weekDay.getCode(), weekDay);
        }
    }

    public static WeekDayEnum findByCode(int code) {
        return WEEK_ENUM_MAP.get(code);
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

4）静态内部类

　　关于内部类的使用场景可参考以前写的这篇文章 http://www.javashuo.com/article/p-hdzvhjxq-ed.html

　　内部类通常状况下使用不是特别多，若是须要在外部类里面定义一个内部类，一般是基于外部类和内部类有很强关联的前提下才去这么使用。

　　在说静态内部类的使用场景以前，咱们先来看一下静态内部类和非静态内部类的区别：

　　非静态内部类对象持有外部类对象的引用（编译器会隐式地将外部类对象的引用做为内部类的构造器参数）；而静态内部类对象不会持有外部类对象的引用

　　因为非静态内部类的实例建立须要有外部类对象的引用，因此非静态内部类对象的建立必须依托于外部类的实例；而静态内部类的实例建立只需依托外部类；

　　而且因为非静态内部类对象持有了外部类对象的引用，所以非静态内部类能够访问外部类的非静态成员；而静态内部类只能访问外部类的静态成员；

　　二者的根本性区别其实也决定了用static去修饰内部类的真正意图：

内部类须要脱离外部类对象来建立实例
避免内部类使用过程当中出现内存溢出

　　第一种是目前静态内部类使用比较多的场景，好比JDK集合中的Entry、builder设计模式。

　　HashMap Entry：

　　builder设计模式：

public class Person {
    private String name;
    private int age;

    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    public static class Builder {

        private String name;
        private int age;

        public Builder() {
        }

        public Builder name(String name) {
            this.name = name;
            return this;
        }
        public Builder age(int age) {
            this.age=age;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// 在须要建立Person对象的时候
Person person = new Person.Builder().name("张三").age(17).build();

　　第二种状况通常出如今多线程场景下，非静态内部类可能会引起内存溢出的问题，好比下面的例子：

public class Task {

    public void onCreate() {
        // 匿名内部类, 会持有Task实例的引用
        new Thread() {
            public void run() {
                //...耗时操做
            };
        }.start();    
    }
}

　　上面这段代码中的：

new Thread() {
  public void run() {
  //...耗时操做
  };
}.start();

　　声明并建立了一个匿名内部类对象，该对象持有外部类Task实例的引用，若是在在run方法中作的是耗时操做，将会致使外部类Task的实例迟迟不能被回收，若是Task对象建立过多，会引起内存溢出。

　　优化方式：

public class Task {

    public void onCreate() {
        SubTask subTask = new SubTask();
        subTask.start();
    }
    
    static class SubTask extends Thread {
        @Override
        public void run() {
            //...耗时操做    
        }
        
    }
}

5）静态导入

静态导入其实就是import static，用来导入某个类或者某个包中的静态方法或者静态变量。以下面这段代码所示：

import static java.lang.Math.PI; 
 
    public  class MathUtils { 

    public static double calCircleArea(double r) {
        // 能够直接用 Math类中的静态变量PI
        return PI * r * r; 
    } 
}

　　这样在书写代码的时候确实能省一点代码，可是会影响代码可读性，因此通常状况下不建议这么使用。

2.static变量和普通成员变量区别

　　static变量和普通成员变量主要有如下4点区别：

区别1：所属不一样。static变量属于类，不单属于任何对象；普通成员变量属于某个对象
区别2：存储区域不一样。static变量位于方法区；普通成员变量位于堆区。
区别3：生命周期不一样。static变量生命周期与类的生命周期相同；普通成员变量和其所属的对象的生命周期相同。
区别4：在对象序列化时（Serializable），static变量会被排除在外（由于static变量是属于类的，不属于对象）

3.类的构造器究竟是不是static方法？

　　关于类的构造器是不是static方法有不少争议，在《java编程思想》一书中提到“类的构造器虽然没有用static修饰，可是其实是static方法”，我的认为这种说法有点欠妥，缘由以下：

　　1）在类的构造器中，实际上有一个隐藏的参数this引用，this是跟对象绑定的，也就是说在调用构造器以前，这个对象已经建立完毕了才能出现this引用。而构造器的做用是干什么的呢？它负责在建立一个实例对象的时候对实例进行初始化操做，即jvm在堆上为实例对象分配了相应的存储空间后，须要调用构造器对实例对象的成员变量进行初始化赋值操做。

　　2）咱们再来看static方法，因为static不依赖于任何对象就能够进行访问，也就是说和this是没有任何关联的。从这一层面去讲，类的构造器不是static方法

　　3）从JVM指令层面去看，类的构造器不是static方法，咱们先看一下下面这段代码：

class Person {
  private String name;
  
  public Person(String name) {
    this.name = name;
  }
  
  public static void create() {
    
  }
}


public class Main {
  public static void main(String[] args) {
    Person.create();
    Person p = new Person("Jack");
  }
}

　　这段代码反编译以后的字节码以下：

　　从上面能够看出，在调用static方法是调用的是invokestatic指令，而在调用类的构造器时实际上执行的是invokespecial指令，而这2个指令在JVM规范中的解释以下：

　　https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokestatic

　　能够看出，这2个指令的用途是彻底不一样的，invokestatic定义很清楚，就是用来调用执行static方法，而invokespecial用来调用实例方法，用来特殊调用父类方法、private方法和类的构造器。