对象的创建和使用-内存分析

理论

Java是面向对象语言，要想创建对象，必须先定义类

一个类包含包括状态信息和动作信息【属性+方法】

属性通常用变量来表示，既然是变量，那么变量肯定有数据类型
【数据类型包括：基本数据类型 + 引用数据类型】

定义类的语法：

[修饰符列表] class 类名{
	属性;
	方法;
}

数据类型包括基本数据类型和引用数据类型

String是引用数据类型，String是SUN公司提供的类，Student是自定义的类，也是引用数据类型

【在Java中，所有的 .class 都属于引用数据类型】

public class Student{
	类体
}

下面的学生类是一个模板，代表所有的学生对象，描述所有对象的共同特征。当前的学生类只描述学生的状态信息【属性】

类体中，方法体之外定义的变量称为成员变量，成员变量没有赋值，系统默认赋值

所有学生都有学号信息，但是每个学生的学号都是不同的。

所以，要访问这个学号必须先创建对象，通过对象去访问学号信息

学号信息不能直接通过“类”去访问，所以这种成员变量又被叫做 实例变量

对象又被称为实例，对象变量又被称为实例变量。「对象级别的变量」

不创建对象，这个no变量的内存空间是不存在的。只有创建了对象，这个no变量的内存空间才会创建。

public class Student{
  int age;
  int no;
  String name;
  String address;
}

对象的创建

通过一个类，可以实例化N个对象。实例化对象的语法

new 类名();

new是Java语言中的一个运算符

new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间

public class Student{
  int age;
  int no;
  String name;
  String address;
}

int 是基本数据类型，i是一个变量名， 10 是一个 int 类型的字面值

Student是一个类，是一个引用数据类型，s 是一个变量名，是引用，new Student() 是一个学生对象，是实例对象

public static class Test{
	public static void main(String[] args){
		int i = 10;
		
		Student s = new Student();
	}
}

成员变量没有手动赋值的话，系统赋默认值

数据类型	默认值
byte,short ,int ,long	0
float,double	0.0
char	\u0000
引用数据类型	null （是空值）

使用new时，JVM内存图如何表示

public static class Test{
	public static void main(String[] args){
		int i = 10;
		Student s = new Student();
	}
	class Student{
		int age;
		int no;
		String name;
		String address;
	}
}

Student是一个引用数据类型

s是一个变量名

new student ()是一个学生对象

s 是一个局部变量【在栈内在中存储】

new是 Java 语言当中的一个运算符，new运算符的作用是创建对象，在 JVM 堆内存当中开辟新的内存空间

方法区内存：在类加载的时候，.class字节码代码片段被加载到该内存空间当中。

栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈

堆内存：new的对象在堆内存中存储，成员变量中的实例变量在堆内存里的对象中存储

1. 什么是对象？new 运算符在堆内存中开辟的内存空间称为对象。
2. 什么是引用？引用是一个变量，由于这个变量保存了另一个Java对象的内存地址，所以我们称之为引用
3. 在Java中，不能直接操作堆内存，Java中没有指针，如果想要访问堆内存中的数据，必须使用引用的方式去访问。
4. 局部变量在栈内存中存储。
5. 成员变量中的实例变量在堆内存的Java对象内部存储。

访问实例变量

语法格式：

读取数据：引用 . 变量名
修改数据：引用 . 变量名 = 值;

public static class Test{
	public static void main(String[] args){
		int i = 10;
		Student s = new Student();
		
		//读取数据
		int a = s.age;
		System.out.println( a );        //0
		
		System.out.println(s.name);    //null
		
		//修改数据
		s.age = 10;
		s.name = "草莓";
		System.out.println(s.age);      //10
		System.out.println(s.name);     //草莓
	}
	class Student{
		int age;
		int no;
		String name;
		String address;
	}
}

内存图体现如下：

成员变量在栈内存中存储
成员变量中的实例变量在堆内存的 Java 对象内部存储

再创建一个对象

public static class Test{
	public static void main(String[] args){
		int i = 10;
		Student s = new Student();
		
		//读取数据
		int a = s.age;
		System.out.println( a );        //0
		System.out.println(s.name);    //null
		
		//修改数据
		s.age = 10;
		s.name = "草莓";
		System.out.println(s.age);      //10
		System.out.println(s.name);     //草莓

		Student t = new Student();
	}
	class Student{
		int age;
		int no;
		String name;
		String address;
	}
}

内存图体现如下：

实例变量是 1 个对象 1 份，100 个对象 100 份

类中创建自定义类的类型的变量

String 是一种引用数据类型，city 是一个变量名，是一个实例变量

city是一个引用，保存内存地址指向 String 对象

//地址类
class Address{
    //城市
    String city;
    //街道
    String street;
}

int 是基本数据类型 ，no 是一个实例变量

String 是引用数据类型，name 是一个实例变量，是一个引用

Address 是引用数据类型，addr 是一个实例变量，是一个引用

//用户类
class User{
    //编号
    int no;
    //用户名
    String name;
    //家庭住址
    Address addr;
}

创建一个 User 对象，读取用户的数据，并修改用户的数据

//测试类
public class  Test {
    public static void main(String[] args) {
        User u = new User();
        //输出数据
        System.out.println(u.name);
        System.out.println(u.no);
        System.out.println(u.addr);
        //改变数据
        u.name = "caomei";
        u.no = 2;
        u.addr = new Address();
    }
}

内存图表示如下：

实例变量 addr 中保存的是 Address 对象的内存地址

读取用户家庭住址的城市和街道信息

//测试类
public class  Test {
    public static void main(String[] args) {
        User u = new User();
        u.addr = new Address();

        //修改和读取城市和街道信息
        System.out.println(u.addr.city);     //null
        System.out.println(u.addr.street);   //null

        u.addr.city = "ad";
        u.addr.street = "123";

        System.out.println(u.addr.city);     //ad
        System.out.println(u.addr.street);   //123
    }
}

直接将现有的引用内存地址赋值给实例变量

	u.addr = new Address();

上面的代码可以换成下面这种写法

	Address a = new Address();
	u.addr = a;

内存图体现如下：

此时引用 a 内中指向的对象和 addr 指向的对象是同一个，所以有一下代码

	System.out.println(u.addr.city);   //null
	a.city = "123";
	System.out.println(u.addr.city);   //123

妻子类和丈夫类，互相引用对方

代码如下：

//测试类
public class  Test {
    public static void main(String[] args) {
        //创建丈夫对象
        Husband a = new Husband();
        a.name = "caomei";

        //创建妻子对象
        Wife b = new Wife();
        b.name = "xigua";

        //可以通过任意一方找到另一方
        b.h = a;
        a.w = b;

        //输出 caomei 妻子的名字
        System.out.println( a.w.name );
    }
}
//丈夫类
class Husband{

    //姓名
    String name;

    //含有妻子的引用
    Wife w;
}
class Wife{

    //姓名
    String name;

    //丈夫的引用
    Husband h;
}

内存图体现如下：

空指针异常

例如有如下程序：

public class test1{
  public static void main(String[] args){
    test2 t = new test2();
    System.out.println(t.name);
    t = null;
    System.out.println(t.name);
  }
}

class test2{
  public String name = "UpYou";
}

以上程序编译可以通过，运行出现异常，对象索引断裂，发生错误：java.lang.NUllPointerException

代码第三行时，拿到了test2对象的内存地址

当代码走到第5行时，t的值不再是test2的内存地址。当值改变后，意味着索引断裂。断裂之后test2对象会被垃圾回收，这时无论如何都无法访问到该对象。空引用无法访问实例相关的数据。

“实例”相关的数据：这个数据访问的时候必须有对象的参与。这种数据就是实例相关的数据

对象的参数传递

试想以下代码的执行结果

public class Tset{
	public static void main(String[] args){
		//创建对象
		User u = new User(22);
		add(u);
		System.out.println("main中" + u.age);    //23
	}
	public static void add(User u){
		u.age ++;
		System.out.println("add中" + u.age);    //23
	}
}
class User{
	int age;
	public User(){}
	public User(int a){
		age = a;
	}
}

执行结果：

内存图显示如下

结论：

涉及到参数的传递，传递的都是保存的值

int i= 10； int j = i ；传递的是 10 这个字面值

User u = new User()； User p = u ；实际传递的是保存对象的内存地址 0x1234，指向同一个对象

总结

1. JVM（Java虚拟机）主要包括三块内存空间，分别是：栈内存、堆内存、方法区内存
2. 堆内存和方法区内存个有一个，一个线程一个栈内存
3. 方法调用的时候，该方法所需要的内存空间在栈内存中分配，称为压栈。方法执行结束之后，该方法所属的内存空间释放，称为弹栈。
4. 栈中主要存储的是方法体当中的局部变量。
5. 方法的代码片段以及整个类的代码片段都被存储到方法区当中，在类加载的时候这些代码片段会载入。
6. 在程序执行过程中使用new运算符创建的Java对象，存储在堆内存当中。对象内部有实例变量，所以实例变量存储在堆内存当中。
7. 变量分类：
   1. 局部变量「方法体中声明」
   2. 成员变量「方法体外声明」
      1. 实例变量「前边修饰符没有static」
      2. 静态变量「前边修饰符中有static」
8. 静态变量存储在方法区内存当中
9. 三块内存当中，变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器主要针对的是堆内存。
10. 垃圾回收器「自动垃圾回收、GC机制」什么时候会考虑将某个Java对象的内存回收呢？
    1. 当随内存当中的Java对象成为垃圾数据的时候，会被垃圾回收器回收。
    2. 当堆内存中的Java对象没有更多的引用指向它的时候就会被当成垃圾。当它被回收的时候，这个对象无法被访问，因为访问对象只能通过引用的方式访问。