ToB企服应用市场:ToB评测及商务社交产业平台

标题: 一文讲清楚static关键字 [打印本页]
作者: 农民    时间: 2024-8-23 19:49
标题: 一文讲清楚static关键字
static能修饰的地方

初始化次序

  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中是类级别的变量，它们被所有类的实例共享。由于静态变量是共享资源，当多个线程同时访问和修改静态变量时，就会引发并发问题。
总结

关于作者

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

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



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4