对static的理解

发表于 | 分类于 |
字数统计: 639 | 阅读时长 ≈ 3

[TOC]

能否被重写

语法上子类允许出现和父类只有方法体不一样其他都一模一样的static方法，但是在父类引用指向子类对象时，通过父类引用调用的依然是父类的static方法，而不是子类的static方法。
即：语法上static支持重写，但是运行效果上达不到多态目的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Base{  
        static void a( ){System.out.println("A");  }  
                 void b( ){System.out.println("B"); }  
}  
public class  Inherit extends Base{  
          static void a( ){System.out.println("C");  }  
                  void b( ){System.out.println("D"); }  
           public static void main(String args[]){  
                    Base b=new Base();  
                    Base  c=new Inherit();  
                    b.a();  
                    b.b();  
                    c.a();  
                    c.b();  
         }  
}

修饰

​ 1.静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来
访问它。静态变量在内存中只存在一份。

1
2
3
4
5
6
7
8
9
10
public class A {
  private int x; // 实例变量
  private static int y; // 静态变量
  public static void main(String[] args) {
  // int x = A.x; // Non-static field 'x' cannot be referenced from a static context
  A a = new A();
  int x = a.x;
  int y = A.y;
 }
}

  1. 静态方法
    静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

    1
    2
    3
    4
    5
    6
    public abstract class A {
    public static void func1(){
    }
    // public abstract static void func2(); // Illegal combination of modifiers: 'abstract'
    and 'static'
    }

  1. 静态语句块
    静态语句块在类初始化时运行一次。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class A {
    static {
    System.out.println("123");
    }
      public static void main(String[] args) {
      A a1 = new A();
      A a2 = new A();
     }
    }
    1
    123

  2. 静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
public class OuterClass {
  class InnerClass {
  }
  static class StaticInnerClass {
 }
  public static void main(String[] args) {
// InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be
   referenced from a static context
  OuterClass outerClass = new OuterClass();
  InnerClass innerClass = outerClass.new InnerClass();
  StaticInnerClass staticInnerClass = new StaticInnerClass();
 }
}

5.初始化顺序

静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺
序

1
2
3
4
5
6
7
8
public static String staticField = "静态变量";
  static {
  System.out.println("静态语句块");
}
  public String field = "实例变量";
 {
  System.out.println("普通语句块");
 }

最后才是构造函数的初始化。

1
2
3
public InitialOrderTest() {
  System.out.println("构造函数");
}