java中static关键字用法

布满荆棘的人生 2022-08-18 02:19 326阅读 0赞

static关键字

一、用法

1、static关键字表示静态。能与属性，方法，代码块，内部类等一起使用。

2、static修饰属性和方法时，可以直接通过类名.属性或类名.方法来访问。

3、 静态变量：

• 一个类中，静态的变量只分配一块内存空间。多个实例对象共享该内存空间。

• 静态的变量在类加载的时候，被初始化。也就是说，只要类被加载，不管是否使用该静态变量，则都会自动的为其开辟空间，并初始化。

4、静态方法

• 在类加载时，加载到JVM。直接使用类名.方法名调用。

5、 静态代码块

• 是类的组成部分，在类第一次被加载的时候，执行一次。也就说，静态代码块在程序运行时，只能被执行一次。

• 用于初始化静态的属性。

下面来看示例一：

StaticDemo类

package com.jcxy.demo02;
    
    public class StaticDemo
    {
        //静态变量
        static int a = 10;
        static String str = "jack";
        //静态方法
        public static void show()
        {
            System.out.println("this is static demo！");
        }
    }

Test类

package com.jcxy.demo02;
    
    public class Test
    {
        
        /** 
         * 测试static关键字的用法
         * <功能详细描述>
         * @param args
         * @see [类、类#方法、类#成员]
         */
        public static void main(String[] args)
        {
            System.out.println(StaticDemo.a);
            System.out.println(StaticDemo.str);
            StaticDemo.show();
        }   
    }

打印输出：

10  
jack  
this is static demo！

示例二：静态代码块的用法

包含普通成员变量，静态成员变量，静态代码块，动态代码块以及构造函数的类

package com.jcxy.demo02;
    
    public class StaticDemo3
    {
        int age = 21;
        
        static String school = "清华";
        
        static
        {
    //        school = "北大";
            System.out.println("这是静态代码块");
        }
        
        {
            System.out.println("这是非静态代码块");
        }
        
        public StaticDemo3()
        {
            
            System.out.println("这是对象初始化的构造方法");
        }
    }

测试类Test

package com.jcxy.demo02;
    
    public class Test
    {
        
        /** 
         * 测试static关键字的用法
         * <功能详细描述>
         * @param args
         * @see [类、类#方法、类#成员]
         */
        public static void main(String[] args)
        {  
            StaticDemo3 sd = new StaticDemo3();
            System.out.println(StaticDemo3.school);
        }   
    }

打印结果：

这是静态代码块  
这是非静态代码块  
这是对象初始化的构造方法  
清华

通过打印结果，我们不难看到，

1、当我们new一个对象的时候，是静态变量最先开辟内存（在赋值的情况下），未赋值则跳过。

2、接下才静态代码块。

3、接着调用我们的构造方法，注意，调用构造方法的时候，在执行方法体之前。

4、先对普通成员变量进行初始化（当初赋值的情况下），如果没赋值则跳过。

5、接着才执行非静态方法。

6、最后才执行我们构造方法的方法体。

示例三：静态变量定义在静态代码块后与前的区别

看下面这种的输出结果

package com.jcxy.demo02;
    
    public class StaticDemo1
    {
        static
        {
            school = "aaa";
            //System.out.println(school);  编译错误。在定义前无法引用school
        }
        
        public static String school = "清华";
    }

Test：

package com.jcxy.demo02;
    
    public class Test
    {
        
        /** 
         * 测试static关键字的用法
         * <功能详细描述>
         * @param args
         * @see [类、类#方法、类#成员]
         */
        public static void main(String[] args)
        {
    //        System.out.println(StaticDemo.a);
    //        System.out.println(StaticDemo.str);
    //        StaticDemo.show();
            
            System.out.println(StaticDemo1.school);
        }   
    }

打印输出为：清华

为什么呢？

这种情况：

相当于以下代码:

public static String school;
        static{
             school = “aaa”;
             //System.out.println(school);报错
    	    }
        school = “清华”;

1- 类加载时，为静态属性分配内存空间，且以默认值填充；

2- 从上向下执行，先为school赋值aaa，再为school赋值清华

但此时要注意的是，声明语句在静态代码块下面，在静态代码块中的如果获得静态属性的值，则会报错。

看第二种情况：

package com.jcxy.demo02;
    
    public class StaticDemo1
    {  
        public static String school = "清华";
        static
        {
            school = "aaa";
            System.out.println(school);
        }
    }

Test：

package com.jcxy.demo02;
    
    public class Test
    {
        
        /** 
         * 测试static关键字的用法
         * <功能详细描述>
         * @param args
         * @see [类、类#方法、类#成员]
         */
        public static void main(String[] args)
        {       
            System.out.println(StaticDemo1.school);
        }   
    }

打印：

aaa

原因分析：

第二种情况：

1- 类加载时，为静态属性分配内存空间，且以默认值填充；

2- 将清华赋值给school

3- 执行静态代码块内容。

因为声明在获得school值之前，所以，可以System.out.println(school);

二、static特点：

1、static可以修饰属性，方法，代码块。此时属性，方法，代码块就成了类变量，静态方法，静态代码块。注意：静态不能修饰局部变量。

2、类变量，静态方法，静态代码块与具体某个对象无关，是属于类级别。如果访问权限允许，通过类名.方法名或类名.属性名访问。

3、静态变量，静态代码块都是在类加载时，执行并初始化。