面向对象（static关键字）

static关键字：用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

   随着类的加载而加载

   优先于对象存在

   被所有的对象共享

   可以直接被类名调用

使用注意：

   静态方法只能访问静态成员

   静态方法中不可以写this，super关键字

   主函数是静态的

 static关键：

  1、被static修饰的成员变量，被所有的对象所共享

  2、静态随着类的加载而加载，随着类的消失而消失

  3、优先于对象的存在

  4、静态成员可以直接被类名所调用

static的使用注意事项：

   1、静态方法只能调用静态成员，不能调用非静态成员，非静态方法可以调用静态成员也可以调用非静态成员

   2、在静态方法中不允许出现this super关键字，this代表对象，而静态方法执行时还没有对象呢

   3.主函数是静态的

   4、静态是有访问局限性的，只能访问静态的内容

静态成员变量和非静态成员变量的区别：

    1、非静态成员变量又称为实例变量，静态成员变量又称为类变量

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

    3、非静态变量存在于对象堆内存中，静态成员变量存在于方法区中

    4、非静态变量只能被对象所调用，而静态变量可以被类名调用也可以被对象调用。

静态什么时候用：

    1、成员变量是否需要static修饰呢？该成员变量的值如果每一个对象都相同的话就用static来修 饰，如果不是的话就不用static来修饰了，让这些不相同的存储到每个对象中。

    2、成员函数是否需要被静态修饰呢？

  当函数中访问到了对象中的特有属性时，该函数不能被静态修饰，如果函数中没有访问到对象的特有属性，就可以被静态修饰。如果方法没有访问过特有属性那么可以直接被静态化。简单的说，如果函数中访问了成员变量（实例变量），不能静态，否则可以静态，直接被类名所调用。如果一个类中定义的方法都是静态的，说明这个类是不需要对象的。

静态代码块：

     随着类的加载而执行，而且只执行一次

优先于主函数执行

package com_package2;

public class StaticCode
{
     private String name;
     private static String country;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static String getCountry() {
        return country;
    }
    public static void setCountry(String country) {
        StaticCode.country = country;
    }
     public void show()
     {
         System.out.println("name="+name);
         System.out.println("country="+country);
         
     }
    
}

package com_package2;

public class StaticCodeDemo {
    
    public static void main(String[]args)
    {
        StaticCode p = new StaticCode();
        p.setName("hejinjin");
        p.setCountry("cn");
        //StaticCode p1 = new StaticCode();
        //p1.setCountry(country)
        p.show();
    }
}

package com_package2;

public class StaticCode
{
     private String name;
     private static String country="cn";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static String getCountry() {
        return country;
    }
    public static void setCountry(String country) {
        StaticCode.country = country;
    }
     public void show()
     {
         System.out.println("name="+name);
         System.out.println("country="+country);
         
     }
    
}

package com_package2;

public class StaticCodeDemo {
    
    public static void main(String[]args)
    {
        //StaticCode p = new StaticCode();
        //p.setName("hejinjin");
        //p.setCountry("cn");
        //StaticCode p1 = new StaticCode();
        //p1.setCountry(country)
        //p.show();
        System.out.println(StaticCode.getCountry());没有创建对象就可以调用静态的对象，由此可以看出，静态成员变量随着类的加载而存在。
        
    }
}

package com_package2;

public class StaticCode
{
     private String name;
     private static String country="cn";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static String getCountry() {
        return country;
    }
    public static void setCountry(String country) {
        StaticCode.country = country;
    }
     public static void show()
     {
         System.out.println("name="+name);//这样是不对的因为静态方法无法访问非静态变量
         System.out.println("country="+country);
         
     }
    
}

package com_package2;

public class StaticCode
{
     private String name="kakaka";
     private static String country="cn";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public static String getCountry() {
        return country;
    }
    public static void setCountry(String country) {
        StaticCode.country = country;
    }
     public  void show()
     {
         System.out.println("name="+name);
         System.out.println("country="+country);
         
     }
     public static void function()
     {
         
         System.out.println("kokokookokok");
     }
     public static void guojia()
     {
         System.out.println("country"+country);
         
     }
     
    
}

package com_package2;

public class StaticCodeDemo {
    
    public static void main(String[]args)
    {
        //StaticCode p = new StaticCode();
        //p.setName("hejinjin");
        //p.setCountry("cn");
        //StaticCode p1 = new StaticCode();
        //p1.setCountry(country)
        //p.show();
        System.out.println(StaticCode.getCountry());
        speak();
        
    }
    public static void speak()
    {
        
        StaticCode p = new StaticCode();
        p.setName("hejinjinhaha");
        System.out.println(p.getName());
        StaticCode.function();//这两个方法没有访问到静态成员变量，所以直接静态化
        StaticCode.guojia();//这两个方法没有访问到静态成员变量，所以直接静态化
    }
}

静态代码块

package com_package2;

public class StaticCode
{
    static
    {
        System.out.println("A");
        
    }
    public void show()
    {
        System.out.println("run");
        
    }
}

package com_package2;

public class StaticCodeDemo {
    static 
    {
        System.out.println("B");
        
        
    }
    public static void main(String[]args)
    {
        StaticCode p = new StaticCode();
        p.show();
        
    }
    static 
    {
        
        System.out.println("C");
    }
    
}

B
C
A
run

注意执行顺序，先从带主函数的类进入，由于静态代码块随着类的创建而创建，所以优先于主函数执行，然后再执行主函数，在执行主函数的时候用到了StaticCode类，StaticCode类中也有静态代码块，而这个静态代码块也是随着类的建立而存在，所以比show（）要执行的早。
静态代码块的特点就是：随着类的加载而执行并且只执行一次，优先于主函数执行