一文讲清楚static关键字

static能修饰的地方

• 静态变量
  
  
  
  • 静态变量: 又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它；静态变量在内存中只存在一份。
    
  • 实例变量: 每创建一个实例就会产生一个实例变量，它与该实例同生共死。
    
  
  
• 静态方法
  
  
  
  • 静态方法在类加载的时间就存在了，它不依赖于任何实例。以是静态方法必须有实现，也就是说它不能是抽象方法(abstract)。
    
  • 只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。
    
  
  
• 静态语句块
  
  
  
  • 静态语句块在类初始化时运行一次。
    
  
  
• 静态内部类
  
  
  
  • 非静态内部类依赖于外部类的实例，而静态内部类不需要。
    
  • 静态内部类不能访问外部类的非静态的变量和方法。
    
  
  
• 静态导包
  
  
  
  • 在使用静态变量和方法时不消再指明 ClassName，从而简化代码，但可读性大大低落。
    
  
  

初始化次序

• 静态属性，静态代码块。
  
• 普通属性，普通代码块。
  
• 构造方法。
  

1. public class InitOrder {
3.     // 静态属性
4.     private static String staticField = getStaticField();
6.     // 静态代码块
7.     static {
8.         System.out.println(staticField);
9.         System.out.println("静态代码块初始化");
10.     }
12.     // 普通属性
13.     private String field = getField();
15.     // 普通代码块
16.     {
17.         System.out.println(field);
18.         System.out.println("普通代码块初始化");
19.     }
21.     // 构造方法
22.     public InitOrder() {
23.         System.out.println("构造方法初始化");
24.     }
26.     // 静态方法
27.     public static String getStaticField() {
28.         String staticFiled = "静态属性初始化";
29.         return staticFiled;
30.     }
32.     // 普通方法
33.     public String getField() {
34.         String filed = "普通属性初始化";
35.         return filed;
36.     }
38.     public static void main(String[] argc) {
39.         new InitOrder();
40.     }
42.     /**
43.      *      静态属性初始化
44.      *      静态代码块初始化
45.      *      普通属性初始化
46.      *      普通代码块初始化
47.      *      构造方法初始化
48.      */
49. }

复制代码

静态方法和变量能否被继承

先说结论：能
父类A：

1. public class A {
2.     public static String staticStr = "A静态属性";
3.     public String nonStaticStr = "A非静态属性";
4.     public static void staticMethod(){
5.         System.out.println("A静态方法");
6.     }
7.     public void nonStaticMethod(){
8.         System.out.println("A非静态方法");
9.     }
10. }

复制代码

子类B：

1. public class B extends A{
3.     public static String staticStr = "B改写后的静态属性";
4.     public String nonStaticStr = "B改写后的非静态属性";
6.     public static void staticMethod(){
7.         System.out.println("B改写后的静态方法");
8.     }
10.     @Override
11.     public void nonStaticMethod() {
12.         System.out.println("B改写后的非静态方法");
13.     }
14. }

复制代码

子类C：

1. public class C extends A{
2. }

复制代码

测试：

1. public class Demo {
2.     public static void main(String[] args) {
3.         C c = new C();//C的引用指向C的对象
4.         System.out.println(c.nonStaticStr);//A非静态属性
5.         System.out.println(c.staticStr);//A静态属性
6.         c.nonStaticMethod();//A非静态方法
7.         c.staticMethod();//A静态方法
8.         //推出静态属性和静态方法可以被继承
10.         System.out.println("-------------------------------");
12.         A c1 = new C();//A的引用指向C的对象
13.         System.out.println(c1.nonStaticStr);//A非静态属性
14.         System.out.println(c1.staticStr);//A静态属性
15.         c1.nonStaticMethod();//A非静态方法
16.         c1.staticMethod();//A静态方法
17.         //推出静态属性和静态方法可以被继承
19.         System.out.println("-------------------------------");
20.         B b = new B();//B的引用指向B的对象
21.         System.out.println(b.nonStaticStr);//B改写后的非静态属性
22.         System.out.println(b.staticStr);//B改写后的静态属性
23.         b.nonStaticMethod();//B改写后的非静态方法
24.         b.staticMethod();//B改写后的静态方法
26.         System.out.println("-------------------------------");
27.         A b1 = new B();//A的引用指向B的对象
28.         System.out.println(b1.nonStaticStr);//A非静态属性
29.         System.out.println(b1.staticStr);//A静态属性
30.         b1.nonStaticMethod();//B改写后的非静态方法
31.         b1.staticMethod();//A静态方法
32.         //结果都是父类的静态方法，说明静态方法不可以被重写，不能实现多态
33.     }
34. }

复制代码

注意

静态变量尤其要注意并发问题。因为静态变量在Java中是类级别的变量，它们被所有类的实例共享。由于静态变量是共享资源，当多个线程同时访问和修改静态变量时，就会引发并发问题。
总结

• 子类会继承父类的静态方法和静态变量，但是无法对静态方法举行重写
  
• 子类中可以直接调用父类的静态方法和静态变量
  
• 子类可以直接修改（如果父类中没有将静态变量设为private）静态变量，但这是子类自己的静态变量。
  
• 子类可以拥有和父类同名的，同参数的静态方法，但是这并不是对父类静态方法的重写，是子类自己的静态方法，子类只是把父类的静态方法隐蔽了。
  
• 当父类的引用指向子类时，使用对象调用静态方法或者静态变量，是调用的父类中的静态方法或者变量（这比较好理解，因为静态方法或变量是属于类的，而引用指向的是一个对象，对象中并不会包含静态的方法和属性）。也就是说，失去了多态。
  
• 当子类的引用指向子类时，使用对象调用静态方法或者静态变量，就是调用的子类中自己的的静态方法或者变量了。
  

关于作者

来自一线程序员Seven的探索与实践，持续学习迭代中~
本文已收录于我的个人博客：https://www.seven97.top
公众号：seven97，欢迎关注~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。