java中的static修饰符笔记

你的名字 2023-09-23 20:39 65阅读 0赞

### 文章目录 ###

*  static静态
 *  static final常量

# static静态 #

static：静态的

*  静态变量：
    
     *  由static修饰
     *  属于类，存储在方法区中，只有一份
     *  常常通过类名点来访问
     *  何时用：所有对象所共享的数据(图片、音频、视频等)

class Loo{
        
       int a;
        static int b;
        Loo(){
        
            a++;
            b++;
        }
        void show(){
        
            System.out.println("a="+a+"，b="+b);
        }
    }
    public class StaticDemo {
        
        public static void main(String[] args) {
        
            Loo o1 = new Loo();
            o1.show();
            Loo o2 = new Loo();
            o2.show();
            Loo o3 = new Loo();
            o3.show();
            System.out.println(Loo.b); //常常通过类名点来访问
        }
    }

*  静态方法：
    
     *  由static修饰
     *  属于类，存储在方法区中，只有一份
     *  常常通过类名点来访问
     *  静态方法中没有隐式this传递，所以不能直接访问实例成员
     *  何时用：方法的操作与对象无关

//演示静态方法
    class Moo{
        
         int a; //实例变量(对象来访问)
         static int b; //静态变量(类名点来访问)
         void show(){
         //有this
             System.out.println(this.a);
             System.out.println(Moo.b);
         }
         static void test(){
         //没有this
             //静态方法中没有隐式this传递，
             //没有this就意味着没有对象，
             //而实例变量a是必须通过对象点来访问的
             //所以如下语句发生编译错误
             //System.out.println(a); //编译错误
             System.out.println(Moo.b);
         }
     }
     
     //演示静态方法何时用
     class Noo{
        
         int a; //实例变量----是属于对象的，描述对象的属性
         //在show()中需要访问对象的属性a，说明此方法与对象有关，不能设计为静态方法
         void show(){
        
             System.out.println(a);
         }
         //在plus()中并没有访问对象的属性或行为，说明此方法与对象无关，可以设计为静态方法
         static int plus(int num1,int num2){
        
             int num = num1+num2;
             return num;
         }
     }
     
     public class StaticDemo {
        
         public static void main(String[] args) {
        
             Moo.test(); //常常通过类名点来访问
         }
     }

*  静态块：
    
     *  由static修饰
     *  属于类，在类被加载期间自动执行，因为一个类只被加载一次，所以静态块也只执行一次
     *  何时用：加载/初始化静态资源(图片、音频、视频等)

//演示静态块
    class Poo{
        
        static{
        
            System.out.println("静态块");
        }
        Poo(){
        
            System.out.println("构造方法");
        }
    }
    public class StaticDemo {
        
        public static void main(String[] args) {
        
            Poo o4 = new Poo();
            Poo o5 = new Poo();
            Poo o6 = new Poo();
        }
    }

成员变量分两种：实例变量和静态变量

*  实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份  
    通过引用打点来访问
 *  静态变量：由static修饰，属于类的，存储在方法区中，只有一份  
    通过类名点来访

![在这里插入图片描述][e6798fbef2b54994bf8ff8c43bcf4f17.png]

一般情况下：凡是静态的成员，都是公开的

# static final常量 #

static final常量：应用率高

*  必须声明同时初始化
 *  常常由类名点来访问，不能被改变
 *  建议：常量所有字母都大写，多个单词用\_分隔
 *  编译器在编译时会将常量直接替换为具体的值，效率高
 *  何时用：数据永远不变，并且经常使用

public class StaticFinalDemo {
        
        public static void main(String[] args) {
        
            System.out.println(Aoo.PI); //常常通过类名点来访问
            //Aoo.PI = 3.1415926; //编译错误，常量不能被改变
    
    
            //1)加载Boo.class到方法区中
            //2)静态变量num一并存储在方法区中
            //3)到方法区中获取num的值并输出
            System.out.println(Boo.num);
    
            //编译器在编译时会将常量直接替换为具体的值，效率高
            //相当于System.out.println(5);
            System.out.println(Boo.COUNT);
    
        }
    }
    
    class Boo{
        
        public static int num = 5; //静态变量
        public static final int COUNT = 5; //常量
    }
    
    class Aoo{
        
        public static final double PI = 3.14159;
        //public static final int NUM; //编译错误，常量必须声明同时初始化
    }

[e6798fbef2b54994bf8ff8c43bcf4f17.png]: https://img-blog.csdnimg.cn/e6798fbef2b54994bf8ff8c43bcf4f17.png