对象和内存分配

桃扇骨 2021-09-11 07:00 376阅读 0赞

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;
            }
    
        }