对象和内存分配

package six;

import oo.Car;

public class duixiang2 {
    public static void main(String[] args) {
        
        // 内存管理分为内存分配、内存
        // 内存分配:java创建对象时jvm为该对象在堆内存中所分配的内存空间
        // 内存回收：java失去对象引用，变成垃圾时，jvm的垃圾回收机制自动清理该对象

        /*
         * 实例变量和类变量
         *
         * java变量分为 - 局部变量 - 形参：在方法中定义的局部变量，由方法调用者为其赋值，方法结束而消亡 -
         * 方法内的局部变量：在方法内定义局部变量，必须显示在方法内对其显示的初始化。初始化而生，方法结束而亡 -
         * 代码块内的局部变量：在代码块内定义的局部变量，显示初始化，初始化而生，代码块结束而亡 局部变量的作用短暂，他们都被存储在方法的栈内存中 -
         * 成员变量Field - static 修饰的为静态的变量或类变量 - 没有static修饰的称为非静态变量或实例变量
         *
         * static 只能修饰在类里定义的成员部分，包括 成员变量、方法、内部类、初始化代码块、内部枚举类
         *
         * 静态变量的初始化在实例变量之前
         *
         * 实例变量和静态（类）变量的属性 static修饰的变量为静态变量，属于该类本身。
         * 没有static修饰的成员变量是实例变量，属于该类的实例。
         *
         * 同一个jvm中，每个类只对应一个class对象，因此同一个jvm内的一个类的类变量只需要一块内存空间 但每个类可以创建多个java对象
         *
         * 实例变量，该类每次创建一次实例，就需要为实例变量分配一块内存空间，程序中有几个实例，就需要几块内存空间
         *
         */
        Person.eyeNum = 2;
        System.out.println(Person.eyeNum + "eyeNum");
        Person person1 = new Person();
        person1.name = "me";
        person1.age = 123;
        System.out.println(person1.eyeNum);
        person1.info();

        Person person2 = new Person();
        person2.eyeNum = 3;
        System.out.println(person2.eyeNum);
        System.out.println("-----");
        Person.eyeNum = 4;
        System.out.println(Person.eyeNum);
        System.out.println(person1.eyeNum);
        System.out.println(person2.eyeNum);

        /*
         * 从一个角度看，类也是对象，所有的类都是class 的实例，每个类初始化完成后，系统都会为该类创建一个对应的class实例
         */

        /*
         * 实例变量初始化时间40，每次java程序创建java对象时都需要为实例变量分配内存 - 定义实例变量时指定的初始化值 -
         * 非静态初始化块中对实例变量指定初始值 - 构造器对实例变量指定初始值
         *
         * 定义变量时指定的初始化值和初始化化中指定的初始值，与他们的在源程序中的排列顺序相同
         *
         */
        System.out.println("实例对象2017年2月10日09:29:30");

        Cat cat = new Cat("a", 1);
        System.out.println("cat ------- " +cat);
        Cat cat2 = new Cat("b", 2);
        System.out.println("cat2 ------" + cat2);
        Cat cat3  = new Cat();
        System.out.println("cat3 ---------" + cat3);
        
        /*
         * javap -c   
         * 可以看到
         * 定义实例变量是指定的初始化值
         * 初始化块中为实例变量指定的初始化值
         * 构造器中为实例变量指定的初始值
         * 三者作用类似，对应的赋值语句都被合并到构造器中，位于构造器的所有语句之前，赋值语句的顺序保持它们在源代码中的顺序
         *
         *
         * */
        
        /*
         * 类变量初始化时机
         *
         * 初始化java类时才会该类的类变量分配内存空间，并初始化
         * jvm对一个类只初始化一次，java程序每运行一次，系统只为类变量分配一次内存空间，执行一次初始化
         * 定义类变量时指定初始化值
         * 静态初始化块中对类变量指定初始值
         * */
    }
}

     class Person {
         String name;
         int age;
         static int eyeNum;

         void info() {
        System.out.println(this.name + "  " + this.age);
         }
     }
    class Cat {
        String name;
        int age;
        
        public Cat() {
            // TODO 自动生成的构造函数存根
            System.out.println("无参构造器");
        }
        public Cat(String name, int age) {
            // TODO 自动生成的构造函数存根
            System.out.println("带参构造器2"); // 每当程序调用构造器来创建java对象时，该构造器必然获得执行的机会，该类的非静态代码块也会执行，且优先于构造器
            this.name = name;
            this.age = age;
        }

        
        {
            int i = 1 ;
            i ++;
            int count  ;
            count =+ i ;
            System.out.println("非静态代码块执行多次" + count ); //非静态代码块优先于构造器
            int we = 2; // 定义实例变量时指定的初始值、初始化块中为实例变量指定初始值的语句都是地位平等的， 处理后将被提取到构造器中
            System.out.println(" we "+ " = "+ we);
        }
        static {
            System.out.println("静态代码块只执行一次");
        }

        double we = 3;
        // 等于
        // double we 创建对象时为该对象分配内存
        // we = 3  这句将会被提取到java类的构造器中执行
        @Override
        public String toString() {
            // TODO 自动生成的方法存根
            return "cat name = " + this.name + " age = " + this.age + " we = " + we;
        }

    }