精华内容
下载资源
问答
  • JAVA静态变量

    千次阅读 2020-02-11 12:17:59
    1.Java 中的 static 使用之静态变量 Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问...

    1.Java 中的 static 使用之静态变量

    Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。当然,鉴于他作用的特殊性更推荐用类名访问~~
    使用 static 可以修饰变量、方法和代码块。
    本小节,我们先认识一下静态变量。
    例如,我们在类中定义了一个 静态变量 hobby ,操作代码如下所示:在这里插入图片描述
    运行结果:
    在这里插入图片描述
    要注意哦:静态成员属于整个类,当系统第一次使用该类时,就会为其分配内存空间直到该类被卸载才会进行资源回收!~~

    2.Java 中的 static 使用之静态方法

    方法:直接调用对应的方法即可
    与静态变量一样,我们也可以使用 static 修饰方法,称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用如:
    在这里插入图片描述
    运行结果:
    在这里插入图片描述
    需要注意:

    1、 静态方法中可以直接调用同类中的静态成员,但不能直接调用非静态成员。如:
    在这里插入图片描述

    如果希望在静态方法中调用非静态变量,可以通过创建类的对象,然后通过对象来访问非静态变量。如:
    在这里插入图片描述

    2、 在普通成员方法中,则可以直接访问同类的非静态变量和静态变量,如下所示:
    在这里插入图片描述

    3、 静态方法中不能直接调用非静态方法,需要通过对象来访问非静态方法。如:

    在这里插入图片描述

    3.Java 中的 static 使用之静态初始化块

    在类的声明中,可以包含多个初始化块,当创建类的实例时,就会依次执行这些代码块。如果使用 static 修饰初始化块,就称为静态初始化块。

    需要特别注意:静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。
    具体样例:
    在编辑器中,分别通过构造方法、初始化块和静态初始化块对变量进行初始化赋值:

    public class HelloWorld {
        
        String name; // 声明变量name
    	String sex; // 声明变量sex
    	static int age;// 声明静态变量age
        
        // 构造方法
    	public HelloWorld       () { 
    		System.out.println("通过构造方法初始化name");
    		name = "tom";
    	}
        
        // 初始化块
    	{ 
    		System.out.println("通过初始化块初始化sex");
    		sex = "男";
    	}
        
        // 静态初始化块
    	      static  { 
    		System.out.println("通过静态初始化块初始化age");
    		age = 20;
    	}
        
    	public void show() {
    		System.out.println("姓名:" + name + ",性别:" + sex + ",年龄:" + age);
    	}
        
    	public static void main(String[] args) {
            
            // 创建对象
    		HelloWorld hello = new HelloWorld();
    		// 调用对象的show方法
            hello.show();
    	}
    }
    

    在这里插入图片描述

    展开全文
  • JAVA 静态变量

    千次阅读 2011-05-05 15:05:00
    个人的总结 ...Java静态变量的初始化(static块的本质) 在网上看到了下面的一段代码:  1. public class Test {   2. static {   3. _i = 20;   4. }   5. pub

    个人的总结
    1 静态变量只有一份被类的所有实例共享
    2 静态变量的声明在编译时已经明确了内存的位置
    3 延迟初始化是改变静态变量的值

    引用


    Java静态变量的初始化(static块的本质)

    在网上看到了下面的一段代码:

       1. public class Test {  
       2.     static {  
       3.          _i = 20;  
       4.      }  
       5.     public static int _i = 10;  
       6.       
       7.     public static void main(String[] args) {  
       8.          System.out.println(_i);  
       9.      }  
      10. } 

    public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

    上述代码会打印出什么结果来呢?10还是20?本文将以此代码为引子,着重讨论一下静态变量的初始化问题。
    问题1:静态变量如何初始化

    Java类中可以定义一个static块,用于静态变量的初始化。如:

       1. public class Test {  
       2.     public static int _i;  
       3.     static {  
       4.          _i = 10;  
       5.      }  
       6. } 

    public class Test { public static int _i; static { _i = 10; } }

    当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如:

       1. public class Test {  
       2.     public static int _i = 10;  
       3. } 

    public class Test { public static int _i = 10; }

    那么上述两例在本质上有什么区别吗?回答是没有区别。两例代码编译之后的字节码完全一致,通过 “javap -c”查看到的字节码如下:

        public class Test extends java.lang.Object{
        public static int _i;

        public Test();
        Code:
        0: aload_0
        1: invokespecial #1; //Method java/lang/Object."<init>":()V
        4: return

        static {};
        Code:
        0: bipush 10
        2: putstatic #2; //Field _i:I
        5: return

        }

    通过字节码还可以看出,当类的定义中不含有static块时,编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前 提下。如果静态变量没有初始化操作,则编译器不会为之提供默认的static块。如:

       1. public class Test {  
       2.     public static int _i;  
       3. } 

    public class Test { public static int _i; }

    其字节码的表现形式为:

        public class Test extends java.lang.Object{
        public static int _i;

        public Test();
        Code:
        0: aload_0
        1: invokespecial #1; //Method java/lang/Object."<init>":()V
        4: return

        }

    由于静态变量是通过赋值操作进行初始化的,因此可以通过静态函数返回值的方式为其初始化。如:

       1. public class Test {  
       2.     public static int _i = init();  
       3.       
       4.     private static int init() {  
       5.         return 10;  
       6.      }  
       7. } 

    public class Test { public static int _i = init(); private static int init() { return 10; } }

    其本质与下面的代码相同:

       1. public class Test {  
       2.     public static int _i;  
       3.     static {  
       4.          _i = init();  
       5.      }  
       6.       
       7.     private static int init() {  
       8.         return 10;  
       9.      }  
      10. } 

    public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

    问题2:JDK如何处理static块

    类定义中可以存在多个static块吗?回答是可以。如:

       1. public class Test {  
       2.     public static int _i;  
       3.     static {  
       4.          _i = 10;  
       5.      }  
       6.       
       7.     public static void main(String[] args) {  
       8.      }  
       9.       
      10.     static {  
      11.          _i = 20;  
      12.      }  
      13. } 

    public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

    此类编译之后的字节码为:

        public class Test extends java.lang.Object{
        public static int _i;

        public Test();
        Code:
        0: aload_0
        1: invokespecial #1; //Method java/lang/Object."<init>":()V
        4: return

        public static void main(java.lang.String[]);
        Code:
        0: return

        static {};
        Code:
        0: bipush 10
        2: putstatic #2; //Field _i:I
        5: bipush 20
        7: putstatic #2; //Field _i:I
        10: return

        }

    观察static{}部分可以看出,上例的代码与下面的代码效果一致:

       1. public class Test {  
       2.     public static int _i;  
       3.       
       4.     public static void main(String[] args) {  
       5.      }  
       6.       
       7.     static {  
       8.          _i = 10;  
       9.          _i = 20;  
      10.      }  
      11. } 

    public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

    此例可以证明,不仅类定义中可以有多个static块,而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static 块。
    问题3:如何看待静态变量的声明

    静态变量存放在常量池之中。如何证明呢?如:

       1. public class Test {  
       2.     public static int _i = 10;  
       3. } 

    public class Test { public static int _i = 10; }

    使用“javap -c -verbose”查看其字节码的内容如下:

        public class Test extends java.lang.Object
        SourceFile: "Test.java"
        minor version: 0
        major version: 49
        Constant pool:
        const #1 = Method #4.#14; // java/lang/Object."<init>":()V
        const #2 = Field #3.#15; // Test._i:I
        const #3 = class #16; // Test
        const #4 = class #17; // java/lang/Object
        const #5 = Asciz _i;
        const #6 = Asciz I;
        const #7 = Asciz <init>;
        const #8 = Asciz ()V;
        const #9 = Asciz Code;
        const #10 = Asciz LineNumberTable;
        const #11 = Asciz <clinit>;
        const #12 = Asciz SourceFile;
        const #13 = Asciz Test.java;
        const #14 = NameAndType #7:#8;// "<init>":()V
        const #15 = NameAndType #5:#6;// _i:I
        const #16 = Asciz Test;
        const #17 = Asciz java/lang/Object;

        {
        public static int _i;


        public Test();
        Code:
        Stack=1, Locals=1, Args_size=1
        0: aload_0
        1: invokespecial #1; //Method java/lang/Object."<init>":()V
        4: return
        LineNumberTable:
        line 2: 0

        static {};
        Code:
        Stack=1, Locals=0, Args_size=0
        0: bipush 10
        2: putstatic #2; //Field _i:I
        5: return
        LineNumberTable:
        line 3: 0

        }

    我们看到,常量池中const #2指向的就是Test._i,也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是:

        * 静态变量的声明与初始化是两个不同的操作;
        * 静态变量的声明在编译时已经明确了内存的位置。

    如:


       1. public class Test {  
       2.     public static int _i = 10;  
       3. } 

    public class Test { public static int _i = 10; }


    上述代码的本质可以视为:


       1. public class Test {  
       2.     // 静态变量的声明  
       3.     public static int _i;  
       4.  
       5.     // 静态变量的初始化  
       6.     static {  
       7.          _i = 10;  
       8.      }  
       9. } 


    public class Test { // 静态变量的声明 public static int _i; // 静态变量的初始化 static { _i = 10; } }

    由于静态变量的声明在编译时已经明确,所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码,再编写声明代码。如:

       1. public class Test {  
       2.     // 静态变量的初始化  
       3.     static {  
       4.          _i = 10;  
       5.      }  
       6.       
       7.     // 静态变量的声明  
       8.     public static int _i;  
       9. } 


    public class Test { // 静态变量的初始化 static { _i = 10; } // 静态变量的声明 public static int _i; }

    对初始问题的解答

    解答了上述三个问题,让我们再来看看开篇提到的问题。代码如下:

       1. public class Test {  
       2.     static {  
       3.          _i = 20;  
       4.      }  
       5.     public static int _i = 10;  
       6.       
       7.     public static void main(String[] args) {  
       8.          System.out.println(_i);  
       9.      }  
      10. } 

    public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

    其本质可以用下面的代码表示:

       1. public class Test {  
       2.     static {  
       3.          _i = 20;  
       4.      }  
       5.     public static int _i;  
       6.     static {  
       7.          _i = 10;  
       8.      }  
       9.       
      10.     public static void main(String[] args) {  
      11.          System.out.println(_i);  
      12.      }  
      13. } 

    public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

    再简化一下,可以表示为:

       1. public class Test {  
       2.     public static int _i;  
       3.       
       4.     static {  
       5.          _i = 20;  
       6.          _i = 10;  
       7.      }  
       8.       
       9.     public static void main(String[] args) {  
      10.          System.out.println(_i);  
      11.      }  
      12. } 

    public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

    至此,代码已经明确告诉我们打印结果是什么了!

    展开全文
  • Java 静态变量,静态方法,静态常量 就是变量 ,方法,常量前面添加了static 关键字 为什么要使用静态的呢 有时候在处理问题时会需要两个类在同一个内存区域共享一个数据, 不如现在 Main 类中用到一个 NAME常量 而 有...

     

    Java 静态变量,静态方法,静态常量  就是变量 ,方法,常量前面添加了static 关键字

    为什么要使用静态的呢

    有时候在处理问题时会需要两个类在同一个内存区域共享一个数据, 不如现在 Main 类中用到一个 NAME常量 

    而 有一个Book类中也用到了NAME常量,这时就没有必要在2个类中都创建NAME常量了 为了解决这个问题 我们

    可以把这个NAME常量设置为static 相信这里就明白了为什么要使用了static了吧

    其语法:

             类名.静态类成员

    一个小案例 来更好的理解static 关键字

    package me;
    
    public  class Me {
        static String name; //静态变量
        static double PI = 3.14;//静态常量
    
        public static void Fine(){
         System.out.println("静态方法调用了额");
        }
    
        public void Method(){
            System.out.println(Me.name);
            System.out.println(Me.PI);
        }
    
        public static void main(String[] args) {
            Me.Fine(); //静态方法调用
            Me me = new Me();
            me.Method();// 等同于 new Me().Method();
    
        }
    }
    

           

     静态变量, 静态方法,静态常量 以上demo 都提到了.

    注意事项:

    1 静态方法不可以使用this关键字

    2 在静态方法中不可以直接调用非静态方法 

     

     

    展开全文
  • Java静态变量、静态常量、静态方法

    万次阅读 2016-11-17 17:24:17
    Java静态变量、静态常量、静态方法  静态变量和静态方法都属于静态对象。在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态...

    Java静态变量、静态常量、静态方法

           静态变量和静态方法都属于静态对象。在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。

    1、Java静态对象和非静态对象的区别

                                            静态对象                                                       非静态对象     
    拥有属性:               是类共同拥有的                                            是类各对象独立拥有的
    内存分配:              内存空间上是固定的                                      空间在各个附属类里面分配 
    分配顺序:              先分配静态对象的空间                    继而再对非静态对象分配空间,也就是        初始化顺序是先静态再非静态。

    2、Java静态对象的特点

    A,静态对象的数据在全局是唯一的,一改都改。如果你想要处理的东西是整个程序中唯一的,弄成静态是个好方法。非静态的东西你修改以后只是修改了他自己的数据,但是不会影响其他同类对象的数据。 
    B,引用方便。直接用类名.静态方法名  或者  类名.静态变量名就可引用并且直接可以修改其属性值,不用get和set方法。
    C,保持数据的唯一性。此数据全局都是唯一的,修改他的任何一处地方,在程序所有使用到的地方都将会体现到这些数据的修改。有效减少多余的浪费。

    D,static final用来修饰成员变量和成员方法,可简单理解为“全局常量”。对于变量,表示一旦给值就不可修改;对于方法,表示不可覆盖。

    3、静态变量、静态方法和静态块

           通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象(跟类是否有static修饰无关)。

           你可以将方法和变量都声明为static。static 成员的最常见的 例子是main( ) 。声明为static的方法有以下几条限制: ·

    A,它们仅能调用其他的static 方法

    B,它们只能访问static数据

    C,它们不能以任何方式引用this 或super(this涉及到对象,super 与继承有关)

           示例:Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块。

    1. public class TestNew {  
    2.     static int a = 3;  
    3.     static int b;  
    4.     static void meth(int x){  
    5.         System.out.println("x = "+x);  
    6.         System.out.println("a = "+a);  
    7.         System.out.println("b = "+b);  
    8.     }  
    9.     static {  
    10.         System.out.println("static block initialized");  
    11.         b = a*4;  
    12.     }  
    13.     public static void main(String[] args) {  
    14.         // TODO Auto-generated method stub  
    15.         meth(42);  
    16.     }  
    17. }  

           执行结果是:

    static blockinitialized
    x = 42
    a = 3
    b = 12

    上述classTestNew的执行顺序是:首先static 块执行(打印一条消息),a被设置为3,最后b被初始化为a*4 成12。然后调用main(),main () 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。

    4、外部使用静态变量或者静态方法

           在定义它们的类的外面,static方法和变量能独立于任何对象而被使用,你只要在类的名字后面加点号运算符即可。可以看到,这种格式与通过对象引用变量调用非static方法或者变量的格式类似。示例:

    1. class StaticDemo{  
    2.     static int a = 42;  
    3.     static int b = 99;  
    4.     static void callme(){  
    5.         System.out.println("a = "+a);  
    6.     }  
    7. }  
    8. public class TestNew {  
    9.     public static void main(String[] args) {  
    10.         // TODO Auto-generated method stub  
    11.         StaticDemo.callme();  
    12.         System.out.println("b = "+StaticDemo.b);  
    13.     }  
    14. }  

         执行结果:

    a = 42
    b = 99

    5、静态内部类

    静态内部类是指在一个类的内部,又定义了一个用static修饰的类。

    A,首先,用内部类是因为内部类与所在外部类有一定的关系,往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件存放这个类。

    B,静态方法、静态成员变量。它唯一的作用就是随着类的加载(而不是随着对象的产生)而产生,以致可以用类名+静态成员名直接获得。这样静态内部类就可以理解了,它可以直接被用外部类名+内部类名获得。

    publicclass Build {

          ..............

        public static class VERSION {

               ................

               public static final String RELEASE =getString("ro.build.version.release");

               ................

         }

         ................

    }

    在外部可以直接通过Build.VERSION.RELEASE来访问。

    6、静态常量

    静态常量不可变,可以直接被访问,如类名.静态常量名。例如:

    public class MathTest{

       public static final double PI= 3.1415926;

    }

    可以直接采用MathTest.PI的形式访问该PI常量。

     

     

    展开全文
  • Java静态变量,成员变量,局部变量的默认值 1.静态变量 public class GlobalVar { public static char aChar; public static int anInt; public static long aLong; public static float aFloat; public static...
  • Java静态变量使用实例

    万次阅读 2018-10-19 10:18:34
    前言 记住三点: 一、Java 中被 static 修饰的成员称为静态成员或类成员 二、它属于整个类所有,而...1.贴一个统计字符串的小程序,静态变量为int型 public class CalcStr { private static int num = 0; publi...
  • java静态变量和静态方法的区别 Java中的静态变量和静态代码块是在类加载的时候就执行的,实例化对象时,先声明并实例化变量再执行构造函数。如果子类继承父类,则先执行父类的静态变量和静态代码块,再执行子类的...
  • Java 静态变量生命周期

    千次阅读 2017-04-12 11:40:21
    Java 静态变量生命周期(类生命周期) Static: 加载:java虚拟机在加载类的过程中为静态变量分配内存。类变量:static变量在内存中只有一个,存放在方法区,属于类变量,被所有实例所共享销毁:类...
  • java静态变量与C静态变量的区别

    千次阅读 2011-12-25 20:49:46
    今天在复习以前问题的时候发现有一个问题是关于java静态变量的,就又思考了一下静态变量的作用,我无意间敲了以下代码。 public static void f1(){ static int a =1; }  我诧异的发现IDE居然报错。于是就...
  • java静态变量和静态方法优缺点

    千次阅读 2018-01-22 16:24:10
    java静态变量和静态方法会在程序初始化运行时候就加载到内存。优点:不需要在进行实例化。静态变量的值,直接赋新值即可,不需要参数传递,之后可以直接进行参数引用即可;静态方法可以直接通过"类名.方法"...
  • class string1 { String s1="pingguo"; String s2="xiangjiao"; String s3=new String("lizi"); String s4=new String("li"); public static void main(String args[]) ... System.out.println("s1==s2");...
  • java静态变量只能有1个? 一次产线异常,推翻了我的认知。 产线服务器solr应用内存异常,每个solr实例比平时多出3g内存使用。通过jvisual工具,发现一静态变量实例化了54次。 异常分析: solr实现了热加载,...
  • Java静态变量的初始化

    千次阅读 2019-06-28 01:12:53
    静态变量的初始化方式 在静态变量的声明时初始化 在静态代码块中初始化 静态变量的初始化时机 在类的生命周期内,静态变量只会被初始化一次。 静态变量的初始化时机需要分情况讨论 静态变量类型 初始化时机 ...
  • java静态变量用法

    千次阅读 2018-09-06 11:32:02
    static可以修饰方法、变量、内部类以及代码块。 static修饰类 只有内部类才可以用static修饰,普通类不能用static修饰...调用内部方法或变量:静态方法只能调用静态方法,只能访问静态变量,不能引用this或者super...
  • java 静态变量和静态块底层原理

    千次阅读 2013-11-04 15:57:29
    Java静态变量的初始化(static块的本质) 在网上看到了下面的一段代码: public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) {
  • java 静态变量解释

    千次阅读 2012-03-15 15:10:44
    用static修饰的变量叫静态变量静态变量不需要new出对象引用来调用,它可以直接用类名直接调用。当然用对象引用也能调它,只是不需要。非静态变量则必须用对象引用进行调用。静态变量在内存空间中只有一份,也永远...
  • 刚开时学Java时,总是喜欢使用静态方法和静态变量,因为自己对类的对象不清楚。今天看到书上对Java静态变量的解释,自己吓了一跳,如果是对多窗口的编程,那我的程序就不行了。下面是书上对静态变量的解释: 静态...
  • Java静态变量和静态方法

    千次阅读 2014-07-14 19:25:00
    静态成员包括静态数据成员和静态成员方法
  • 静态变量与实例变量 语法上的区别:静态变量定义前要加关键字static,而实例变量不用 实例变量:当创建一个类的对象时,该对象就会拥有一份属于自己的全部数据成员的副本,又称为实例变量,他们存储在相互独立的...
  • 网上有很多关于类变量存储位置的文章,比如... 运行报出java.lang.OutOfMemoryError: Java heap space说明是堆溢出了,难道静态变量又存储在堆中了? 关于这块很不解,求解释
  • JAVA静态变量的使用

    千次阅读 2018-04-14 22:04:28
    很多的地方建议把一个一个不变的变量使用static表明,然后所有的变量字母都是用大写来表示。这样的优点 是在读代码的时候我们知道这个字母代表什么, 当这个字母变化的时候,我们只需要修改一个地方就可以修改所有...
  • Java静态变量初始化时机

    千次阅读 2015-06-05 10:55:17
    静态变量初始化方式: 1.声明时初始化; 2.静态块中初始化; 测试: package com.skymr.learn; /** * 静态变量初始化顺序测试 * @author skymr * */ public class InstanceTest2 { static int b = 11; ...
  • Java 静态变量和实例变量的生命周期

    万次阅读 2012-08-20 16:38:30
    java类的成员变量有俩种:一种是被static关键字修饰的变量,叫类变量或者静态变量;另一种是实例变量,通常有new 关键字初始化。  在语法定义上的区别:静态变量前要加static关键字,而实例变量前则不加。  在...
  • java静态变量、常量和方法

    千次阅读 2015-12-17 21:54:49
    (1)提示:静态变量被类中的所有对象所共享,静态变量不能访问类中的实例成员。 (2)如果想让一个类的所有实例共享数据,就要使用静态变量(static variable),也成为类变量。静态变量将变量值储存在一个公共的...
  • java 静态变量注意事项

    千次阅读 2011-09-04 01:29:52
    前天写了一个java类,其中用到了一个静态数组,编译后部署到RESIN服务器,后来对该数组值进行了修改,重新编译部署,结果该数组值还是原值,并没有改变,修要重启resin服务器该值才能改变,静态变量使用一定要慎重,...
  • 浅谈:Java静态变量以及静态方法。

    千次阅读 2016-04-04 22:21:32
    关于Java中static对象和static方法的调用
  • Java静态变量和成员变量初始化顺序

    千次阅读 2018-08-01 19:22:49
    首先放一段代码,帮助我们分析变量初始化过程,大家可以先想一下他的输出,然后在看下面的运行结果: public class InitTest{ public static int k = 0; public static InitTest t1 = new InitTest("t1"...
  • JAVA 静态变量上使用@Value注解注入值

    千次阅读 2020-01-02 14:14:58
    正常我们使用@Value时只需要在变量上加上注解即可 ...但当我们尝试将@Value注解在静态变量上时会发现取不到值 解决方案: 在set方法上使用@Value注解 /** * 拒单后外部产品推送模板 */ public static Stri...
  • 实例变量是属于对象的属性,只有对象被实例化(new对象)之后才能分配内存空间;静态变量是属于整个类的,可以直接通过类名来引用,所以也叫类变量,在类加载的时候就被分配内存空间了!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 584,315
精华内容 233,726
关键字:

java静态变量

java 订阅