一、前言
static关键字是我们在编程中经常会使用到的，但有些可能只知其然而不知其所以然。下面介绍static关键字的作用再通过例子结合说明。
static关键字共有五种作用（先说明static所修饰的不会改变其(private、protected、default和public)作用域的范围）：
- 修饰成员变量（非局部变量）
- 修饰成员方法
- 修饰代码块
- 修饰内部类
- 静态导包
怎么会有五种呢，大部分初学者对前面两种或者加上第三种还是很熟悉的，第四种情况可能一开始的人就比较少知道了，第五种就更少人知道了。下面一一介绍：
二、修饰成员变量
- 说明及特点：static所修饰的变量也叫做静态变量，该变量在类初次加载时会被初始化，所以它在内存中只有一个副本，被所有对象所共享（前提也是public所修饰的），其实也叫做类变量，直接通过类可以调用。而非静态变量是在创建对象的时候被初始化，存在多个副本但各个副本互不影响，它也叫做实例化对象的变量。其中要注意的是static不能修饰局部变量（定义在函数内，语句内等，只在所属的区域有效）
- 好处：优先加载、内存利用率高(类初始化时加载且仅分配一次内存); 调用简单
- 案例解析:
package com.yuanfy.test.statics;
class Student {
//非静态变量
private String name;
int age;
//静态变量、全局变量
public static String schoolName = "清华大学";
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void say(){
static int count = 0;//编译报错，不能定义局部变量
}
public String getName() {
return name;
}
}
public class StaticTest {
public static void main(String[] args) {
Student s1 = new Student("张三", 18);
//1、只能通过实例对象调用
System.out.println("name: " + s1.getName() + ", age: " + s1.age);
//2、可以通过类直接调用，如果schoolName是public在其他包下也是可以直接通过类调用的，这样的变量也叫做全局变量
System.out.println("school:" + Student.schoolName);
//3、非静态变量只属于实例对象，所以对应成员变量的值互不影响。
Student s2 = new Student("李四", 19);
System.out.println("测试非静态变量是否会影响其他实例对象下的使用：");
System.out.println("name: " + s1.getName() + ", age: " + s1.age);//name: 张三, age: 18
System.out.println("name: " + s2.getName() + ", age: " + s2.age);//name: 李四, age: 19
//静态变量会影响使用。
System.out.println("静态变量会影响使用：");
s2.schoolName = "北京大学";
System.out.println("s2 school:" + s1.schoolName);//s1的学校名称肯定会改变成s2的学校名
}
}
output:
name: 张三, age: 18
school:清华大学
测试非静态变量是否会影响其他实例对象下的使用：
name: 张三, age: 18
name: 李四, age: 19
静态变量会影响使用：
s2 school:北京大学
三、修饰成员方法
- 说明：static所修饰的方法叫做静态方法，也称类方法。
- 特点：
1、跟静态变量一样，静态方法属于类而不属于对象，所以静态方法可以通过类直接调用，而不需要创建对象实例来调用。
2、由于静态方法是通过类直接调用的，所以静态方法中没有this对象。
3、静态方法可以调用静态变量或方法，但是不能调用非静态变量或方法
4、静态方法不能被覆盖。因为静态方法是编译时静态绑定的，而覆盖是基于运行时动态绑定的。
注意：构造方法不是静态方法，可以参考这里。
- 案例解析：
class Student {
//非静态变量
private String name;
int age;
//静态变量、全局变量
public static String schoolName = "清华大学";
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public static void say(){
//2、由于静态方法是通过类直接调用的，所以静态方法中没有this对象。
System.out.println("调用者:" + this);//编译失败
//3、静态方法可以调用静态变量或方法，但是不能调用非静态变量或方法
//Cannot make a static reference to the non-static
System.out.println("调用非静态变量name：" + name);//编译失败
//但是可以调用静态方法
System.out.println("调用静态变量schoolName:" + schoolName);
}
public void setName(){
//非静态方法可以使用this，知道是哪个实例对象在调用。
System.out.println("调用者：" + this);
}
}
class StudentDTO extends Student{
//编译报错； 4、静态方法不能被覆盖覆盖。因为静态方法是编译时静态绑定的，而覆盖是基于运行时动态绑定的。
31 @Override
32 public static void say(){
33
34 }
}
四、修饰代码块
- 说明：static修饰在代码块前用来形成静态代码块以优化程序性能。
- 特点：
1、在类初次被加载的时候在加载，只加载一次；
2、一个类可以有多个代码块，按代码块的顺序执行。
- 案例分析：
public class StaticTest {
static {
System.out.println("第一次加载静态代码块内容");
}
public static void main(String[] args) {
//不需要实例化对象，只要类加载就会执行static块内容。
// 与执行顺序与代码块的顺序一致。
}
static {
System.out.println("第二次加载静态代码块内容");
}
}
output:
第一次加载静态代码块内容
第二次加载静态代码块内容
五、修饰内部类
- 说明：static修饰的内部类成为静态内部类。
- 特点：
1、普通类不可以用static修饰，只有内部类才可以。（语法）
2、非静态内部类无法声明静态方法和静态变量，只有静态内部类才可以。原因很简单：当加载该类时，会自动解析类中static所修饰的所有变量、方法、代码块和内部类，而静态变量定义在非静态内部类，所以不会加载。而jvm虚拟机是要求静态变量必须是在类加载时初始化的。所以会编译报错，无法声明。
3、非静态内部类可以随意访问外部类的成员或方法，而静态内部类只能访问静态变量或方法。
4、调用静态内部类不需要持有外部内的引用可以直接调用，而非静态内部类就必须持有外部内的引用才能调用
- 案例分析：
public class StaticTest {
private static int startPrice = 10;//起步价
private static int kmPrice = 2;//每一公里2块钱
private int kmCount;//里程计时器
static class Car1{
//编译成功， 2、非静态内部类无法声明静态方法和静态变量，只有静态内部类才可以。
public static void start(){
11 //编译失败，3、非静态内部类可以随意访问外部类的成员或方法，而静态内部类只能访问静态变量或方法。
12 // kmCount = 0;
System.out.println("car1汽车启动，起步价是：" + startPrice);
}
}
class Car2{
17 //编译报错。 2、非静态内部类无法声明静态方法和静态变量，只有静态内部类才可以。
18 // public static void start(){
19 // System.out.println("开始启动");
20 // }
public void start2(){
//编译成功，3、非静态内部类可以随意访问外部类的成员或方法，而静态内部类只能访问静态变量或方法。
kmCount = 0;
System.out.println("car2汽车启动，起步价是：" + startPrice);
}
}
public static void main(String[] args) {
StaticTest.Car1.start();
30 //编译报错 4、调用静态内部类不需要持有外部内的引用可以直接调用，而非静态内部类就必须持有外部内的引用才能调用
31 // StaticTest.Car2.start();
//编译成功
StaticTest.Car2 car2 = new StaticTest().new Car2();
car2.start2();
}
}
output：
car1汽车启动，起步价是：10
car2汽车启动，起步价是：10
六、静态导包
- 说明：其实很简单，跟平常导包差不多，只是在import后面加上static，然后再在类后面引入所有成员（变量、方法、内部类等）用.*代替。格式如下：import static classPath.*;这个不是很常用，也不建议使用，请看下面特点及不足之处。
- 特点：
对于导入静态包可以直接使用其静态方法。
- 不足之处：
1、代码不直观：如果导入了多个静态包，不仔细看是不知道这个方法来源于哪个类 。
2、会存在方法冲突。
- 案列分析1：
package com.yuanfy.test;
/**
* @description 字符串工具类案例
* @author YuanFY
* @date 2017年12月10日 上午11:35:25
* @version 1.0
*/
public class StringUtil {
public static boolean isEmpty(String str){
return true;
}
}
package com.yuanfy.test.statics;
//导入静态包
import static com.yuanfy.test.StringUtil.*;
//import static com.yuanfy.test.scope2.StringUtil.*;
public class StaticTest2 { public static void main(String[] args) {
String str1 = "123";
String str2 = new String("123");
//方便之处直接使用静态方法，不直观
if (isEmpty(str1)){ }
}
}
- 案列分析2（导入多个静态包）：
package com.yuanfy.test.scope2;
//注意这是不同包下的工具类
public class StringUtil {
public static boolean isEmpty(String str){
return true;
}
}
package com.yuanfy.test.statics;
//导入多个静态包
import static com.yuanfy.test.StringUtil.*;
import static com.yuanfy.test.scope2.StringUtil.*;
public class StaticTest2 { public static void main(String[] args) {
String str1 = "123";
String str2 = new String("123");
//编译报错，The method isEmpty(String) is ambiguous for the type StaticTest2
if (isEmpty(str1)){ }
}
}
拓展（static所修饰加载的先后顺序）：静态代码块和静态变量无优先顺序，只跟其定义的前后顺序有关；静态代码块和变量优先静态方法。
class Test{
public Test(){
System.out.println("test()");
}
}
public class StaticTest3 {
static {
System.out.println("代码块1");
}
private static Test test = new Test();
static {
System.out.println("代码块2");
}
public static void test(){
System.out.println("StaticTest3 test()");
}
public static void main(String[] args) {
StaticTest3.test();
}
}
output:
代码块1
test()
代码块2
StaticTest3 test()
本篇文章分析到此结束，参考文献如下：