Java学习笔记：static关键字

矫情吗；* 2022-04-23 08:12 157阅读 0赞

java提供的关键字有50个，保留字2个  
保留字：`goto` 、 `const`  
这次学习static

## static关键字 ##

#### 使用场景： ####

*  修饰普通方法
    
     *  主函数
     *  除构造函数外的方法
    
        /**
         * 主函数
         * @param args
         */
        public static void main(String[] args){
              
        	
        }
        /**
         * 静态方法
         */
        public static void keywork(){
              
        	System.out.println("keyword!");
        	
        }
 *  修饰属性
    
     *  直接修饰
     *  通过类名访问

/**
        * 静态成员
        */
       static int i=10;

主函数使用静态成员的方法：

System.out.println(Keyword.i);

*  修饰内部类
    
     *  在一个类中的类
    
        public class Keyword {
              
         	/**
        	 * 内部类
        	 * @author mo
        	 *
        	 */
        	static class key{
              
        		public key(){
              
        			System.out.println("内部类!");
        		}
        	} 
        }
 *  修饰静态块
    
        /**
         * 静态块
         */
        static{
              
        	System.out.println("静态块!");
        	
        }

#### 特点作用 ####

1.  所有使用static修饰的内容，都存在静态内存中
2.  外部调用的时候地址不变
3.  可以通过类名直接访问
4.  所有使用static修饰的内容都会最先执行
5.  在静态方法或者静态块中不能使用非静态的属性、方法、内部类，如图报错  
    ![在这里插入图片描述][20190129154531439.png]

#### 举例代码 ####

package com.TestKeyword;
    
    public class Keyword {
        
       /**
        * 主函数
        * @param args
        */
       public static void main(String [] args){
        
       	//第一次用到keyword这个类
       	System.out.println(Keyword.i);
       	Keyword.keywork();
       	Keyword.key k=new Keyword.key();
       	Keyword kw1=new Keyword();
       	Keyword kw3=new Keyword();
       	Keyword kw2=new Keyword();
       	/**
       	 * 多次对i操作，查看i的值
       	 * 若i是静态成员，那么i每次修改之后的值都会被保存
       	 * 若i不是静态成员，那么i每次修改的值只在那个对象中有效
       	 */
       	kw1.print();
       	kw2.print();
       	kw3.print();
       }
       /**
        * 静态成员
        */
       static int i=10;
       /**
        * 静态方法
        */
       public static void keywork(){
        
       	System.out.println("keyword!");
       	
       }
       /**
        * 内部类
        * @author mo
        *
        */
       static class key{
        
       	public key(){
        
       		System.out.println("内部类!");
       	}
       } 
       /**
        * 静态块
        */
       static{
        
       	System.out.println("静态块!");
       }
       /**
        * 普通方法，需要创建对象才能调用
        */
       public void print(){
        
       	i++;
       	System.out.println("i = "+i);
       }
    }

输出：

静态块!
    10
    keyword!
    内部类!
    i = 11
    i = 12
    i = 13

*  根据输出结果可以发现静态块的内容最先执行！
 *  若以上代码的 i 修改为私有成员，不用static修饰则用不同的类打印时，发现i的值都是11

//修改主函数 
    public static void main(String [] args){
        
       	//第一次用到keyword这个类
       //	System.out.println(Keyword.i);
       	Keyword.keywork();
       	Keyword.key k=new Keyword.key();
       	Keyword kw1=new Keyword();
       	Keyword kw3=new Keyword();
       	Keyword kw2=new Keyword();
       	/**
       	 * 多次对i操作，查看i的值
       	 * 若i是静态成员，那么i每次修改之后的值都会被保存
       	 * 若i不是静态成员，那么i每次修改的值只在那个对象中有效
       	 */
       	kw1.print();
       	kw2.print();
       	kw3.print();
       }

//修改成员i
    private int i=10;

运行结果：

静态块!
    keyword!
    内部类!
    i = 11
    i = 11
    i = 11

说明非静态成员只保留该对象的成员

[20190129154531439.png]: /images/20220322/1f9bb12802bd40e8a0d2744c8a476f23.png