Java之static关键字

动力节点学习笔记

  
 
 

 
   
  
  

/*  
   
  
  
    static修饰的方法叫做静态方法  
   
  
  
          
   
  
  
        一般情况下工具类中的方法大部分都是静态方法。  
   
  
  
          
   
  
  
        静态方法不用创建对象也能直接访问该方法。  
   
  
  
          
   
  
  
*/ 
   
  
  

public class StaticTest03{  

   
  
  
      
   
  
  

    //成员方法  

   
  
  

    //成员方法必须使用“引用.”调用  

   
  
  

    public void m1(){  

   
  
  
          
   
  
  
    }  
   
  
  
      
   
  
  

    //静态方法  

   
  
  

    //可以使用“类名.”方式调用.也可以用“引用.”，即使用的是“引用.”，底层还是用的“类名.”  

   
  
  

    //静态方法中不能直接访问非静态数据.  

   
  
  

    //静态方法中不能使用this  

   
  
  

    public static void m2(){  

   
  
  

        System.out.println("m2....");  

   
  
  
    }  
   
  
  
      
   
  
  

    //入口  

   
  
  

    public static void main(String[] args){  

   
  
  
          
   
  
  

        StaticTest03 st = new StaticTest03();  

   
  
  
        st.m1();  
   
  
  
          
   
  
  
        m2();  
   
  
  
          
   
  
  

        //静态的方法按照正规的方式访问：“类名.”  

   
  
  

        //静态的方法也能用“引用.”访问  

   
  
  

        st.m2(); //编译阶段检查出st是StaticTest03类型，编译通过，运行的时候，仍然使用 "StaticTest03."的方式访问。  

   
  
  

                    //该方法执行不需要对象。  

   
  
  
          
   
  
  
          
   
  
  

        //空的引用去访问成员的时候会出现空指针异常。  

   
  
  

        //m2方法不是“成员”而是静态的。  

   
  
  

        //所以即使引用是空的，也不会报空指针异常。  

   
  
  

        StaticTest03 s = null;  

   
  
  
        s.m2();   
   
  
  
          
   
  
  
    }  
   
  
  
      
   
  
  
}  
   
  
  
 
  
 
 

 

 

  
 
 

/*  
   
  
  
    static关键字：  
   
  
  
        1.static修饰的变量叫做“静态变量”.  
   
  
  
        2.static修饰的方法叫做“静态方法”.  
   
  
  
        3.static还可以定义静态语句块.  
   
  
  
      
   
  
  
    以下例子演示：static定义静态语句块  
   
  
  
      
   
  
  
    static定义的静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行。  
   
  
  
*/ 
   
  
  

public class StaticTest01{  

   
  
  
      
   
  
  

    //静态语句块  

   
  
  

    static{  

   
  
  

        System.out.println("1");  

   
  
  
    }  
   
  
  
      
   
  
  

    static{  

   
  
  

        System.out.println("2");  

   
  
  
    }  
   
  
  
      
   
  
  

    static{  

   
  
  

        System.out.println("3");  

   
  
  
    }  
   
  
  
      
   
  
  

    static{  

   
  
  

        System.out.println("4");  

   
  
  
    }  
   
  
  
      
   
  
  

    //入口  

   
  
  

    public static void main(String[] args){  

   
  
  

        System.out.println("main execute!  1");  

   
  
  

        System.out.println("main execute!  2");  

   
  
  
    }  
   
  
  
      
   
  
  
}  
  
 
 

 

  
 
 

/*  
   
  
  
    关于实例语句块  
   
  
  
        每一次调用构造方法之前会执行一次。  
   
  
  
        实例语句块执行顺序也是自上而下。  
   
  
  
*/ 
   
  
  
 
   
  
  

public class StaticTest02{  

   
  
  
 
   
  
  

    //静态语句块  

   
  
  

    static{  

   
  
  

        System.out.println("A");  

   
  
  
    }  
   
  
  
      
   
  
  

    //实例语句块  

   
  
  
    {  
   
  
  

        System.out.println("1");  

   
  
  
    }  
   
  
  
      
   
  
  
      
   
  
  
    {  
   
  
  

        System.out.println("2");  

   
  
  
    }  
   
  
  
      
   
  
  
      
   
  
  
    {  
   
  
  

        System.out.println("3");  

   
  
  
    }  
   
  
  
      
   
  
  

    //构造方法  

   
  
  
    StaticTest02(){  
   
  
  

        System.out.println("StaticTest02无参数的构造执行！");  

   
  
  
    }  
   
  
  
      
   
  
  

    //入口  

   
  
  

    public static void main(String[] args){  

   
  
  
          
   
  
  

        //调用构造方法  

   
  
  

        new StaticTest02();  

   
  
  
          
   
  
  

        new StaticTest02();  

   
  
  
          
   
  
  

        new StaticTest02();  

   
  
  
    }  
   
  
  
}  
  
 
 

 

  
 
 

/*  
   
  
  
    static修饰的变量叫做“静态变量”  
   
  
  
          
   
  
  
        变量分类：  
   
  
  
            1.局部变量  
   
  
  
            2.成员变量(实例变量，非静态变量)  
   
  
  
            3.静态变量(方法区)  
   
  
  
          
   
  
  
        什么时候变量声明成静态变量？  
   
  
  
            如果这个属性所有的对象都有，并且这个属性的值是相同的，则该属性声明成  
   
  
  
            静态的属性。  
   
  
  
          
   
  
  
          
   
  
  
        成员变量：创建java对象的时候初始化。  
   
  
  
        静态变量：在类加载阶段赋值，并且只赋值一次。  
   
  
  
*/ 
   
  
  

public class StaticTest04{  

   
  
  
      
   
  
  

    public static void main(String[] args){  

   
  
  
          
   
  
  

        Animal a1 = new Animal("AAA",10);  

   
  
  

        Animal a2 = new Animal("BBB",11);  

   
  
  
          
   
  
  

        //如何访问(类名.)  

   
  
  
        System.out.println(Animal.type);  
   
  
  
          
   
  
  

        //也可以使用 引用.  

   
  
  
        System.out.println(a1.type);  
   
  
  
          
   
  
  
          
   
  
  

        Animal a3 = null;  

   
  
  

        System.out.println(a3.type); //静态变量底层访问的时候一定使用的  类名. 和对象无关，不会出现空指针异常。  

   
  
  
          
   
  
  
    }  
   
  
  
}  
   
  
  
 
   
  
  
 
   
  
  

//抽象现实世界中的“陆生”动物  

   
  
  

class Animal{  

   
  
  
      
   
  
  

    //Field  

   
  
  

    //成员变量(一个对象一份.)  

   
  
  

    //成员变量在创建对象的时候初始化，并且存储在堆中的每一个对象中。  

   
  
  
    String name;  
   
  
  

    int age;  

   
  
  
      
   
  
  

    //静态变量，被存储在方法区.  

   
  
  

    //所有的java对象共享这一份。  

   
  
  

    //所以静态变量是类级别的，使用“类名.”的方式访问.  

   
  
  

    static String type = "陆生";  

   
  
  
      
   
  
  

    //Constructor  

   
  
  

    Animal(String name,int age){  

   
  
  

        this.name = name;  

   
  
  

        this.age = age;  

   
  
  
    }  
   
  
  
} 
  
 
 

 

  
 
 

 
   
  
  

/*  
   
  
  
    关于代码的顺序  
   
  
  
*/ 
   
  
  

public class StaticTest05{  

   
  
  
      
   
  
  

    //编译通过  

   
  
  

    static int i = 100;  

   
  
  
      
   
  
  

    static{  

   
  
  
        System.out.println(i);  
   
  
  
    }  
   
  
  
      
   
  
  
      
   
  
  
      
   
  
  

    //非法向前引用  

   
  
  

    /*  
   
  
  
    static{  
   
  
  
        System.out.println(i);  
   
  
  
    }  
   
  
  
      
   
  
  
    static int i = 100;  
   
  
  
    */ 
   
  
  
      
   
  
  
}  
  
 
 

 

  
 
 

/*  
   
  
  
 
   
  
  
    类{  
   
  
  
          
   
  
  
        //可以通过“类名.”，也可以通过“引用.”，即使使用“引用.”底层也是“类名.”  
   
  
  
        //1.静态变量  
   
  
  
        //2.静态方法  
   
  
  
          
   
  
  
        //必须对象存在才可以访问，采用“引用.”  
   
  
  
        //3.成员变量  
   
  
  
        //4.成员方法  
   
  
  
          
   
  
  
        //创建对象,给成员变量赋值  
   
  
  
        //5.构造方法  
   
  
  
          
   
  
  
        //类加载时只执行一次。  
   
  
  
        //6.静态语句块  
   
  
  
          
   
  
  
        //构造方法没调用之前执行一次。  
   
  
  
        //7.实例语句块  
   
  
  
          
   
  
  
        //用在成员方法和构造方法中。  
   
  
  
        //8.this  
   
  
  
    }  
   
  
  
      
   
  
  
    空指针异常：空引用访问成员  
   
  
  
      
   
  
  
*/