第31集：面向对象（04）程序执行过程的内存分析_01

1. 栈：

   1. 每个线程私有，不能实现线程间的共享！

   2. 局部变量放置于栈中。

   3. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！

2. 堆：

   1. 放置new出来的对象！

   2. 堆是一个不连续的内存空间，分配灵活，速度慢！

   3. 方法区(也是堆)：

      1. 被所有线程共享！

      2. 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

3. 属性（field，或者叫成员变量）

   1. 属性用于定义该类或该类对象包含的数据或者说静态属性。

   2. 属性作用范围是整个类体。

   3. 属性的默认初始化：在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值：0【整数】,0.0【浮点数】char:u0000,  boolean:false,  所有引用类型:null)

   4. 属性定义格式：

      [修饰符]  属性类型  属性名 = [默认值] 

4. java中，除了基本数据类型之外的其他类型称之为引用类型。

5. java中的对象是通过引用(reference)来操作的,说白了，引用指的就是对象的地址！

6. 所有引用的值都是4个字节

7. 类的方法

   1. 方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序有一个个函数调用组成；面向对象中，整个程序的基本单位是类，方法是从属于类或对象的。

   2. 方法定义格式：

      [修饰符]  方法返回值类型  方法名(形参列表) {
      // n条语句
      }

8. 内存分析图

   1. 针对下列代码进行内存分析

      public class Student{//静态数据String name;int id;int age;String gender;int weight;//动态行为public void study(){System.out.println(name+"在学习");}public void sayHello(String sname){System.out.println(name+"向"+sname+"说：你好！");}public static void main(String[] args){Student s1 = new Student();s1.name = "高琪";s1.study();s1.sayHello("马士兵");Student s2 = new Student();s2.age = 18;s2.name = "老高";}}

   2. 基本执行步骤简述：

      1. 类加载器去方法区寻找Student类，找到直接用，找不到则去Classpath（类路径）里去找class字节码文件，还找不到就报错

      2. 找到Student类的字节码文件后，通过类加载器（Class Loader）加载Student类的信息到方法区。

      3. 方法区中放置：

         1. 代码

            1. 实例变量（属性）

            2. 方法

         2. static变量

         3. 常量池（例如字符串常量...）（"在学习"、"高琪"、" 老高"、"马士兵"....））。

      4. 运行 Student s1 = new Student();中的Student s1时，将s1这个局部变量放在了栈里。

      5. 运行new Student()时，新建了一个对象放在了堆里，此时它的属性被初始化为默认值，方法获得指向方法区里方法的地址。

      6. 运行=时，新建对象的引用地址被赋值给了s1。

      7. 运行s1.name = "高琪";时，其实是通过name里存的指向常量“高琪”的地址，找到方法区里常量池里的“高琪”。

   3. 内存分析图示（重要！）

   

   提示：图例中的地址是瞎写的，莫当真。

第32集：面向对象（05）程序执行过程的内存分析_02

1. 常量池所有常量会被共享

2. 内存分析图示

   1. 针对下列代码进行分析

      package com.test031_032;public class Computer {String brand;int cpuSpeed;
      }
      

      package com.test031_032;public class Student {//静态数据String name;int id;int age;String gender;int weight;Computer computer;//动态行为public void study(){System.out.println(name+"在学习");}public void sayHello(String sname){System.out.println(name+"向"+sname+"说：你好！");}
      }
      

      package com.test031_032;public class Test2 {public static void main(String[] args){Student s1 = new Student();s1.name = "高琪";s1.age = 18;Computer c = new Computer();c.brand = "联想";c.cpuSpeed = 100;s1.computer = c;c.brand = "戴尔";System.out.println(s1.computer.brand);}
      }
      

   2. 内存图分析
      

第33集：面向对象_06_虚拟机内存管理、垃圾回收机制、c++和java的比较

1. 垃圾回收机制(Garbage Collection)

   JAVA的内存管理实际上指的就是对象的管理，其中包括对象空间的分配和释放。

2. 对象空间的分配

   使用new关键字创建对象即可。

3. 对象空间的释放

   将对象赋值null，即该对象没有引用指向时。垃圾回收器将负责回收所有”不可达”对象的内存空间。

4. 要点

   1. 程序员无权调用垃圾回收器。

   2. 程序员可以通过System.gc()。通知GC运行，但是JAVA规范并不能保证立刻运行。

   3. finalize方法，是JAVA提供给程序员用来释放对象或资源的方法，但是尽量少用。

第34集：面向对象_07_构造方法

1. 构造器(constructor，或者叫构造方法)

2. 构造器作用

   构造器用于构造该类的实例。

3. 构造器调用

   Java通过new关键字来调用构造器，从而返回该类的实例。

4. 构造器定义的格式：

   [修饰符] 类名(形参列表){//n条语句
   }

5. 构造器使用要点

   1. 通过new关键字调用。

   2. 构造器虽然有返回值（返回该类的对象），但是不能定义返回类型 (返回值的类型肯定是本类)，不能在构造器里调用return。

   3. 如果我们没有定义构造器，则系统会自动定义一个无参的构造函数。如果已定义则编译器不会添加。

   4. 构造器的方法名必须和类名一致。

   package com.test034;public class Test034_TestConstructor {
   int speed;
   public Test034_TestConstructor() {System.out.println("构造一个车！");
   }public static void main(String[] args){Test034_TestConstructor a = new Test034_TestConstructor();}
   }
   

   package com.test034;public class Point {private int x;private int y;private int z;public Point(int x,int y,int z){this.x = x;this.y = y;this.z = z;}public void setX(int x){this.x = x;}public void setY(int y){this.y = y;}public void setZ(int z){this.z = z;}public double distance(int x,int y,int z){return Math.sqrt((this.x - x)*(this.x - x)+(this.y - y)*(this.y - y)+(this.z - z)*(this.z - z));}public static void main(String[] args){Point p1 = new Point(3,4,5);p1.setX(10);System.out.println(p1.x);System.out.print(p1.distance(20, 30, 40));}
   }

第35集：面向对象_08方法重载构造方法重载

1. 方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。 调用时，会根据不同的参数表选择对应的方法。

2. 方法调用时，匹配离得最近的类型。

3. 不同的含义：类型，个数，顺序不同。

4. 只有返回值不同不构成方法的重载（int a (int i){}, void a（int i）{},  调用：a(1)，谁能告诉我是调哪个方法?）

5. 只有形参的名称不同，不构成方法的重载

6. 与普通方法一样，构造方法也可以重载

package com.test035;public class TestOverload {public static void main(String[] args){MyMath m = new MyMath(2,2);int result = m.add(4,8);System.out.println(result);System.out.println(m.a+m.b);}
}class MyMath{int a;int b;public MyMath(){}public MyMath(int a){this.a = a;}public MyMath(int a,int b){this.a = a;this.b = b;}public int add(int a,int b){return a+b;}}

第36集：面向对象09_static变量和方法内存分析static

1. 在类中，用static声明的成员变量为静态成员变量。

2. 它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。

3. 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享。

4. 可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”。

5. 用static声明的方法为静态方法。

6. 不需要对象，就可以调用(类名.方法名)。

7. 在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。【static方法从属于类的，不能调用从属于对象的非static属性与方法，非static方法从属于对象，可以直接调用从属于类的static属性与方法】

8. 可以通过对象引用或类名（不需要实例化）访问静态成员。

9. 内存分析图（重要！）
   

package com.test036;public class Student {String name;int id;static int ss;public static void printSS(){System.out.println(ss);}public void study(){printSS();System.out.println(name+"在学习");}public void sayHello(String sname){System.out.println(name+"向"+sname+"说：你好！");}
}    

package com.test036;public class TestStatic {public static void main(String[] args){Student.ss = 323;Student.printSS();Student s1 = new Student();}
}