Java中static修饰符详解【静态变量与成员变量的区别】

桃扇骨 2022-05-19 02:08 230阅读 0赞

#### static静态变量 ####

在程序中任何变量或者代码都是在编译时，是由系统自动分配内存来存储的，而所谓静态就是指在编译后分配的内存会一直存在，直到程序退出时才会释放内存空间。

static是静态修饰符。被static修饰后的成员，在编译时由系统分配一块内存空间，直到程序停止运行才会释放。那么就是说该类的所有对象都会共享这块内存空间。

#### 静态变量与成员变量的区别 ####

##### 所属不同： #####

静态变量属于类，也称为类变量。  
成员变量属于对象，也称为实例变量（对象变量）

##### 内存中位置不同： #####

静态变量存储于方法的静态区。  
成员变量存储于堆内存。

##### 生命周期不同： #####

静态变量是随着类的加载而加载的，随着类的消失而消失。  
成员变量随着对象的创建而存在，随着对象的消失而消失。

##### 调用不同： #####

静态变量可以通过类名调用 ，也可以通过对象调用。  
成员变量只能通过对象名调用

需要注意的是：  
1、在静态方法中没有this关键字，因为静态是随着类的加载而加载的，this是随着对象的创建而存在的，静态比对象先存在。  
2、静态方法只能访问静态的成员变量和静态的成员方法。  
例如：

public class Main{
        int a;
        public static void main(String[] args){
            System.out.println(this.a);//会报错
            System.out.println(a);//这种也会报错，这里的a相当于this.a
        }
    }

根据静态变量的第一点特性，就导致了在main方法上边定义成员变量会出现报错：

Exception in thread "main" java.lang.Error: 无法解析的编译问题：
        不能在静态上下文中使用 this

根据第二点，不难得出解决办法是将成员变量也定义为静态变量

public class Main{
        static int a = 10;//将a定义为静态变量
        public static void main(String[] args){
            System.out.println(a);
        }
    }

下面是在类中对static的应用：

import java.util.*;
    
    public class Main{
        public static void main(String[] args){
            //创建phone类型的对象s
            phone s = new phone();
            //创建phone类型的对象s1
            phone s1 = new phone();
    
            //对s对象中volues赋值
            s.volues = 10;
            //对s1对象中volues赋值
            s1.volues = 20;
            //输出s和s1中volues的值进行对比
            System.out.println("s.volues="+s.volues);
            System.out.println("s1.volues="+s1.volues);
    
            //先对s中静态成员变量volues1进行赋值并输出
            s.volues1 = 999;
            System.out.println("s.volues1="+s.volues1);
    
            //对s1中静态成员变量volues1进行赋值
            s1.volues1 = 1000;
    
            //输出s和s1中静态成员变量volues1的值进行对比
            System.out.println("s.volues1="+s.volues1);
            System.out.println("s1.volues1="+s1.volues1);
    
            //静态变量可以通过类名进行调用
            System.out.println("通过类名调用："+phone.volues1);
        }
    }
    //创建一个phone类
    class phone{
        private String color, brand;
        //创建普通成员变量volues
        int volues;
        //创建静态成员变量volues1
        static int volues1;
    
    }

输出结果：

//s和s1中普通成员变量volues的值不会相互干扰
    s.volues=10
    s1.volues=20
    s.volues1=999
    //对s1中静态成员变量volues1赋值后s.volues1的值也随之改变
    s.volues1=1000
    s1.volues1=1000
    通过类名调用：1000

因为静态方法只能访问静态的成员变量和静态的成员方法，所以我们平常定义方法时将方法也定义为静态的

public class Main{
        public static void main(String[] args){
            int[] a = {
       15,21,65,9};
            printArray(a);
        }
        public static void printArray(int[] arr){
            for(int i = 0; i < arr.length-1; i++)
                System.out.print(arr[i]+" ");
            System.out.println(arr[arr.length-1]);
        }
    }

那如果我们把方法定义为非静态的就无法调用，这时该怎么办呢？看看下边的代码你就知道了

public class Main{
        public static void main(String[] args){
            int[] a = {
       15,21,65,9};
            Main s = new Main();//创建一个自身类的对象，然后调用
            s.printArray(a);
        }
        public void printArray(int[] arr){
            for(int i = 0; i < arr.length-1; i++)
                System.out.print(arr[i]+" ");
            System.out.println(arr[arr.length-1]);
        }
    }

但是一般不会这样用，因为对同一种类型操作都会创建一个与之相关的类，通过这个类来调用方法，这也是Java的封装思想的体现。

那么如果我不用构造方法，调用类中的方法该怎么办呢？本文讲的就是static修饰符，当然是用静态啦。

正常情况下我们的代码应该是这样的：

public class Main{
        public static void main(String[] args){
            int[] a = {
       15,21,65,9};
            Arr s = new Arr();//创建对象
            s.printArray(a);//调用方法
        }
    
    }
    
    class Arr{
        public void printArray(int[] arr){
            for(int i = 0; i < arr.length-1; i++)
                System.out.print(arr[i]+" ");
            System.out.println(arr[arr.length-1]);
        }
    }

如果用静态的方法应该是这样的：

public class Main{
        public static void main(String[] args){
            int[] a = {
       15,21,65,9};
            //Arr s = new Arr();//将构造方法私有后外界无法创建对象
            Arr.printArray(a);//与静态变量一样，直接用类名调用就可以了
        }
    
    }
    
    class Arr{
        private Arr(){}//先讲构造方法设为私有，上一个代码没有写是因为你如果没有写的话jvm会自动给你生成一个默认权限的构造方法。
        public static void printArray(int[] arr){
            for(int i = 0; i < arr.length-1; i++)
                System.out.print(arr[i]+" ");
            System.out.println(arr[arr.length-1]);
        }
    }