Java基础(二)-static关键字分析

一、前言

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()

本篇文章分析到此结束，参考文献如下：

http://rednaxelafx.iteye.com/blog/652719

https://www.cnblogs.com/dolphin0520/p/3799052.html