关于static

static是静态的意思；

static修饰的成员变量，在内存中存在于方法区中，只有一份，非静态的成员变量在堆中，每个对象中都有一份

public class Demo1 {
    public static void main(String[] args) {
        
        Test t1 = new Test();
        t1.classNo = "12";
        t1.id = 12;
        Test t2 = new Test();
        t2.classNo = "25";
        t2.id = 25;
        System.out.println("t1的id： "+t1.id+"  t1的classNo："+t1.classNo +"  t2的id： "+t2.id+"  t2的classNo： "+ t2.classNo);
    }
}

class Test{
    int id;
    String name;
    static String classNo;
    
}

如上代码控制台会输出 " t1的id： 12 t1的classNo25 t2的id： 25 t2的classNo： 25 " ，静态成员变量存在于方法区内且只有一份，非静态的成员变量在堆中，每个对象中都有一份

静态成员变量的访问方式：

   1：通过对象访问
          格式：对象.成员变量

      2：通过类名访问
          格式：类名.静态的成员变量

public class Demo1 {
    public static void main(String[] args) {
        
        Test.classNo = "12";
        // Test.id = 12; 会报错，不是静态不可以直接通过类名调用
        
    }
}

class Test{
    int id;
    String name;
    static String classNo;
    
}

如果有数据需要被共享出去，就可以使用static修饰

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

　　1：存储位置
        静态成员变量：在方法区
           非静态成员变量：堆中

       2：数量
           静态成员变量:在内存中只有一份
          非静态成员变量：有多少对象就有多少份

        3：访问方式
            静态成员变量：可以通过对象访问，也可以通过类名访问
            非静态成员变量：只能通过对象访问

        4：生命周期：
            静态成员变量：随着类文件的加载而存在，跟着类文件的消失而消失
            非静态成员变量：随着对象的创建而存在，对象被垃圾回收器回收时消失

        5:作用
           静态成员变量：共享一个数据给所有对象使用
           非静态成员变量：描述一类事物的公共属性

当一个类被主动使用时，Java虚拟就会对其初始化（加载这个类,初始化为加载的最后一步），如下六种情况为主动使用：

    1、当创建某个类的新实例时（如通过new或者反射，克隆，反序列化等）
2、当调用某个类的静态方法时
    3、当使用某个类或接口的静态字段时
    4、当调用Java API中的某些反射方法时，比如类Class中的方法，或者java.lang.reflect中的类的方法时
    5、当初始化某个子类时
    6、当虚拟机启动某个被标明为启动类的类（即包含main方法的那个类）

　static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态代码块执行等工作。

     static修饰方法：
   　　 访问方式：
       　　　1：通过对象访问
      　　　 2：通过类名访问

　　　　静态方法被调用时执行

　　　静态方法注意点：
　　　　    1：静态方法可以直接访问静态成员(变量，方法)，不能直接访问非静态成员, 可以通过对象访问非静态成员
　　　　   2：非静态方法可以直接访问静态成员和非静态成员
   　　　　 3: 静态方法中不能出现this关键字和super关键字
      　　　　 4：静态方法可以通过类名或者对象调用，非静态方法只能通过对象调用

public class Demo {

    /**
     * @param args
     */
    public static void main(String[] args) {
           
        Person3.study();  // 通过类名调用静态方法
        
        new Person3("aa",20).study(); // 通过对象调用静态方法
        
          System.out.println(Person3.classNo);  // 通过类名访问静态成员变量
    }

}

class Person3{
    String name;
    int age;
    static String classNo = "52";
    
    static{
        
        System.out.println("静态代码块");
    }
    
    public Person3() {
         
    }
    
    public Person3(String name, int age) {
         
        this.name = name;
        this.age = age;
    }
    
    public static void study(){
//        System.out.println("学习"+classNo);
        
//        System.out.println("姓名："+new Person3().name); // 静态的方法不能直接访问非静态的成员变量
         
//        compare(new Person3());  // 静态的方法不能直接访问非静态的方法
        eat();  // 静态的方法可以直接访问静态的方法
    }
    
    public static void eat(){
        System.out.println("eat..."+classNo); // 静态的方法可以直接访问静态的成员变量
    }

    public void compare(Person3 p){
        eat();   // 非静态的方法可以直接访问静态的方法
        
        if(this.age > p.age){
            System.out.println(this.name+"比"+p.name+"大");
        }else if(this.age < p.age){
            System.out.println(this.name+"比"+p.name+"小");
        } else {
            System.out.println(this.name+"和"+p.name+"一样");
        }
    }
    
    public String toString() {
        return "Person3 [name=" + name + ", age=" + age + ", classNo="
                + classNo + "]";
    }
    
    
}