JavaSE 基础 - 第九章 对象的创建和使用
JavaSE 基础 - 第九章 对象的创建和使用
- 1、怎样创建对象？
- 2、什么是实例变量？
- 3、对象和引用的区别？
- 4、画内存图注意事项
- 为什么要画内存图（非常重要）？
- 5、程序在什么情况下会出现空指针异常呢？
- 6、方法在调用的时候参数是如何传递的？
- 7、构造方法
- 【拓展】java 虚拟机内存管理（理解）
- 传送门
1、怎样创建对象？
语法格式：
类名 变量名 = new 类名() ;
类是模板，通过一个类，是可以创建N多个对象的。
new是一个运算符。专门负责对象的创建。
对于 XueSheng s1 = new XueSheng(); 和 int i = 100; 的区别：
i是变量名
int是变量的数据类型
100是具体的数据。
s1是变量名（s1不能叫做对象。s1只是一个变量名字。）
XueSheng是变量s1的数据类型（引用数据类型）
new XueSheng() 这是一个对象。（学生类创建出来的学生对象。）
数据类型包括两种：
基本数据类型：byte 、short、 int 、long、 float 、double 、boolean 、char
引用数据类型：String、XueSheng…
java中所有的“类”都属于引用数据类型。
变量必须先声明，再赋值才能访问。
注意：对于成员变量（在方法体以外的变量）来说，没有手动赋值时，系统默认赋值。赋的值都是默认值，那么默认值是什么？
| 类型 | 默认值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0F |
| double | 0.0 |
| boolean | false |
| char | \u0000 |
| 引用数据类型 | null |
null是一个java关键字，全部小写，表示空。是引用类型的默认值。
2、什么是实例变量？
对象又被称为实例。
实例变量实际上就是：对象级别的变量。
public class 明星类{
double height;
}
// 身高这个属性所有的明星对象都有，但是每一个对象都有“自己的身高值”。
// 假设创建10个明星对象，height变量应该有10份。
// 所以这种变量被称为对象级别的变量。属于实例变量。
// 实例变量在访问的时候，是不是必须先创建对象？
3、对象和引用的区别？
对象：是通过new出来的，在堆内存中存储。
引用：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的。
public class Student{
// 属性（描述状态），在java程序中以“成员变量”的形式存在。
// 学号-----》一个对象一份。
int no; // 这种成员变量又被称为“实例变量”。
// 姓名
String name;
// 年龄
int age;
// 性别
boolean sex;
// 住址
String addr;
}
/*
对象的创建和使用。
*/
public class StudentTest{
public static void main(String[] args){
//局部变量
//错误: 可能尚未初始化变量k
/*
int k;
System.out.println(k);
*/
//访问学生姓名可以直接通过类名吗？
// 学生姓名是一个实例变量。实例变量是对象级别的变量。
// 是不是应该先有对象才能说姓名的事儿。
// 不能通过“类名”来直接访问“实例变量”。
//System.out.println(Student.name);
// i属于局部变量吗？当然是。
// 局部变量存储在栈内存当中。（栈主要存储局部变量。）
//int i = 100;
// 创建学生对象1
// s1属于局部变量吗？当然是。
// s1这个局部变量叫做引用
Student s1 = new Student();
// 怎么访问实例变量？
// 语法：引用.实例变量名
System.out.println(s1.no); // 0
System.out.println(s1.name); // null
System.out.println(s1.age); //0
System.out.println(s1.sex); //false
System.out.println(s1.addr); //null
System.out.println("-----------------------------");
// 创建学生对象2
// s2也是局部变量。
// s2也叫做引用。
Student s2 = new Student();
System.out.println(s2.no);
System.out.println(s2.name);
System.out.println(s2.age);
System.out.println(s2.sex);
System.out.println(s2.addr);
// 程序执行到此处我可以修改s1这个学生的学号吗？
// 通过“=”赋值的方式将内存中实例变量的值修改一下。
s1.no = 110;
s1.name = "张三";
s1.age = 20;
s1.sex = true;
s1.addr = "深圳宝安区";
System.out.println("学号=" + s1.no); // 学号=110
System.out.println("姓名=" + s1.name); //姓名=张三
System.out.println("年龄=" + s1.age); //年龄=20
System.out.println("性别=" + s1.sex); //性别=true
System.out.println("住址=" + s1.addr); //住址=深圳宝安区
// 再次赋值
s1.addr = "北京大兴区";
System.out.println("住址：" + s1.addr); //住址：北京大兴区
}
public static void method(){
// i s1 s2都是main方法中的局部变量，在这里是无法访问的。
/*
System.out.println(i);
System.out.println(s1);
System.out.println(s2);
*/
}
}
4、画内存图注意事项
第一：大家在内存图上不要体现出代码。内存上应该主要体现“数据”。
第二：大家画图的时候，图上的图形应该有先后顺序，先画什么，再画什么，必须是有顺序的，而不是想起来这个画这个，
想起来那个画那个。程序代码是有执行顺序的，程序执行到哪里你就画哪里就行了。
为什么要画内存图（非常重要）？
第一：有了内存图，程序不运行，我也知道结果。（可以推算出结果）
第二：有了内存图，有助于你调试程序。
画内存图是对Java运行机制的一种理解。不知道运行机制，以后复杂的程序出现错误之后你是不会调试的，调不明白。
【画内存图1】：User.java 、UserTest.java
/*
User类：用户类
*/
public class User{
// 用户id
// 访问id不能这样：User.id （这是错误的，实例变量不能用类名访问。）
// id的访问必须先造对象，然后对象有了，才能访问对象的id
int id; //成员变量，实例变量（对象变量，一个对象一份。）
// 用户名
String username; // 成员变量可以不手动赋值，系统赋默认值。
// 密码
String password;
}
// 第一步：类加载
// 第二步：调用UserTest类的main方法（方法调用要压栈。）
public class UserTest{
// 方法体外声明的变量叫做成员变量。
//User u1; //成员变量。（实例变量）
public static void main(String[] args){
//int i = 100;
// 方法体当中声明的变量叫做局部变量
User u1 = new User();
// 实例变量怎么访问（属性怎么访问）？
// 语法是：“引用.属性名”
System.out.println(u1.id); //0
System.out.println(u1.username); //null
System.out.println(u1.password); //null
u1.id = 11111;
u1.username = "zhangsan";
u1.password = "123";
System.out.println(u1.id);
System.out.println(u1.username);
System.out.println(u1.password);
User u2 = new User();
u2.id = 22222;
u2.username = "lisi";
u2.password = "456";
System.out.println(u2.id);
System.out.println(u2.username);
System.out.println(u2.password);
}
}
方法体外声明的变量叫做 成员变量。（成员变量可以不手动赋值，系统赋默认值）
方法体当中声明的变量叫做 局部变量。
【画内存图2】：难度较大 / User.java 、Address.java 、Test.java "课堂画图"文件夹012
public class User{
// 类=属性+方法
// 以下3个都是属性，都是实例变量。（对象变量。）
// 用户id
// int是一种基本数据类型
int id; // 实例变量
// 用户名
// String是一种引用数据类型
String username; // 实例变量
// 家庭住址
// Address是一种引用数据类型
// addr是成员变量并且还是一个实例变量
// addr是否是一个引用呢？是。addr是一个引用。
Address addr;
}
// 实例变量都存储在哪里？ 实例变量都在堆内存的对象内部。
// 方法体外，类体内定义的变量叫做：成员变量。
// 住址类
public class Address{
// 一个家庭住址有3个属性。
// 城市
String city; // 实例变量
// 街道
String street;
// 邮编
String zipcode;
}
/*
到目前为止，如果什么也没听懂，怎么写代码？
记住一个知识点就行，可以后期慢慢学习画图。
记住一句话：里面有什么就能“点”什么。
所有的实例变量（属性）都是通过“引用.”来访问的。
引用和对象怎么区分？
“引用”是啥？是存储对象内存地址的一个变量。
“对象”是啥？堆里new出来的。
通俗一点：
只要这个变量中保存的是一个对象的内存地址，那么这个变量就叫做“引用”。
思考：
引用一定是局部变量吗？
不一定。
*/
public class Test{
public static void main(String[] args){
// 家庭住址对象
Address a = new Address();
a.city = "北京";
a.street = "大兴区";
a.zipcode = "121221";
// 用户对象
User u = new User();
System.out.println(u.id); // 0
System.out.println(u.username); // null
System.out.println(u.addr); // null
u.id = 11111;
u.username = "zhangsan";
u.addr = a;
// 思考一个问题：
// 我想知道zhangsan他是哪个城市的，代码应该怎么写？
System.out.println(u.username + "是"+u.addr.city+"城市的！");
// u.addr.city 这行代码可否拆分呢？u.addr.city 节省变量。
// 拆分成以下代码和以上效果完全相同，原理完全相同，不同的是以下代码多了两个变量。
Address ad = u.addr;
String zhuZhi = ad.city;
System.out.println(zhuZhi);
//-----------------------是否理解以下代码---------------------------
int x = 100;
// = 代表赋值运算，“赋值”中有一个“值”
// x变量中的值是100. 将100复制一份给y
// 表示：将x变量中保存的值100复制一份给y
int y = x;
//-----------------------是否理解以下代码---------------------------
Address k = new Address(); // Address k = 0x1111;
Address m = k; // 这里表示将k变量中保存的0x1111复制了一份传给了m变量。
}
}
5、程序在什么情况下会出现空指针异常呢？
空引用 访问 "对象相关"的数据时，会出现空指针异常（NullPointerException）。
垃圾回收器（GC）主要针对堆内存。
【程序实例：】 NullPointerTest.java
/*
空指针异常。（NullPointerException）
关于垃圾回收器：GC
在java语言中，垃圾回收器主要针对的是堆内存。
当一个java对象没有任何引用指向该对象的时候，
GC会考虑将该垃圾数据释放回收掉。
出现空指针异常的前提条件是？
"空引用"访问实例【对象相关】相关的数据时，都会出现空指针异常。
*/
public class NullPointerTest{
public static void main(String[] args){
// 创建客户对象
Customer c = new Customer();
// 访问这个客户的id
System.out.println(c.id); // 0
// 重新给id赋值
c.id = 9521; // 终身代号
System.out.println("客户的id是=" + c.id);
c = null;
// NullPointerException
// 编译器没问题，因为编译器只检查语法，编译器发现c是Customer类型，
// Customer类型中有id属性，所以可以：c.id。语法过了。
// 但是运行的时候需要对象的存在，但是对象没了，尴尬了，就只能出现一个异常。
System.out.println(c.id);
}
}
class Customer{
// 客户id
int id; // 成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问。
}
6、方法在调用的时候参数是如何传递的？
实际上，在java语言中，方法调用时参数传递，和类型无关，都是将变量中保存的那个“值”传过去，
这个“值”可能是一个数字100，也可能是一个java对象的内存地址：0x1234
记住这句话：不管是哪一种数据类型的传递，都是将“变量中保存的那个值复制一份传递过去。”
（1）传递的是基本数据类型—不会改变变量的值
（2）传递的是引用（内存地址）—会改变值
【实例1】 --传的数字 10 —不会改变i本身的值
// 分析程序的输出结果。
// java中规定：参数传递的时候，和类型无关，不管是基本数据类型还是引用数据类型
// 统一都是将盒子中保存的那个“值”复制一份，传递下去。
// java中只有一个规定：参数传递的时候，一定是将“盒子”中的东西复制一份传递过去。
// 内存地址也是值，也是盒子中保存的一个东西。
public class Test1{
public static void main(String[] args){
int x = 100;
int y = x; // x赋值给y，是怎么传递的？将x变量中保存的100这个值复制一份传给y
// 局部变量，域是main
int i = 10;
// 将i变量中保存的10复制一份，传给add方法。并不是把i直接传过去再带回来
add(i);
System.out.println("main ---> " + i); //10
}
/*
public static void add(int i){ // i是局部变量，域是add
i++; //这个i和上面的i不是同一个
System.out.println("add ----> " + i); // add ----> 11
}
*/
public static void add(int k){
k++;
System.out.println("add ----> " + k); // add ----> 11
}
}
/* 运行结果
add ----> 11
main ---> 10
*/
【实例2】 --传的对象p的内存地址 ----会改变p的值
/* java中关于方法调用时参数传递实际上只有一个规则：
不管你是基本数据类型，还是引用数据类型，实际上在传递的时候都是将变量中保存的那个“值”复制一份，传过去。
int x = 1;
int y = x; 把x中保存1复制一份传给y
x和y都是两个局部变量。
Person p1 = 0x1234;
Person p2 = p1; 把p1中保存的0x1234复制一份传给p2
p1和p2都是两个局部变量。
你和你媳妇，都有你家大门上的钥匙，钥匙是两把。但是都可以打开你家的大门。
*/
public class Test2{
public static void main(String[] args){
Person p = new Person();
p.age = 10;
add(p);
System.out.println("main--->" + p.age); //11
}
// 方法的参数可以是基本数据类型，也可以是引用数据类型，只要是合法的数据类型就行。
public static void add(Person p){ // p是add方法的局部变量。
p.age++;
System.out.println("add--->" + p.age); //11
}
}
class Person{
// 年龄属性，成员变量中的实例变量。
int age;
}
/*运行结果
add--->11
main--->11
*/
7、构造方法
7.0、构造方法
1、什么是构造方法，有什么用？
构造方法是一个比较特殊的方法，通过构造方法可以完成对象的创建，
以及实例变量的初始化。
换句话说：【构造方法是用来创建对象，并且同时给对象的属性赋值】
（注意：实例变量没有手动赋值的时候，系统会赋默认值。）
2、重点（需要记忆）：当一个类没有提供任何构造方法，系统会默认提供
一个无参数的构造方法。（而这个构造方法被称为缺省构造器。系统会默认赋值。）
3、调用构造方法怎么调用呢？
使用哪个运算符呢？
使用new运算符来调用构造方法。
语法格式：
new 构造方法名(实际参数列表);
4、构造方法的语法结构是？
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
通常在构造方法体当中给属性赋值，完成属性的初始化。
}
注意：
第一：修饰符列表目前统一写：public。千万不要写public static。
第二：构造方法名和类名必须一致。
第三：构造方法不需要指定返回值类型，也不能写void，写上void
表示普通方法，就不是构造方法了。
普通方法的语法结构是？
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
普通方法的调用：
类名.方法名(实际参数列表);
7.1、当一个类中没有提供任何构造方法，系统默认提供一个无参数的构造方法。
这个无参数的构造方法叫做 缺省构造器。
（这个时候，无参构造器里面就会对 没有手动赋值的实例变量，赋默认值。）
7.2、当一个类中手动的提供了构造方法，那么系统将不再默认提供无参数构造方法。
建议将无参数构造方法手动的写出来，这样一定不会出问题。
7.3、无参数构造方法和有参数的构造方法都可以调用。
Student x = new Student();
Student y = new Student(123);
7.4、构造方法支持方法重载吗？
构造方法是支持方法重载的。
在一个类当中构造方法可以有多个。
并且所有的构造方法名字都是一样的。
方法重载特点：
在同一个类中，方法名相同，参数列表不同。
7.5、对于实例变量来说，只要你在构造方法中没有手动给它赋值，统一都会默认赋值。默认赋系统值。
public class Vip{
// 会员号
long no;
// 会员姓名
String name;
// 生日
String birth;
// 性别
boolean sex;
//无参数构造方法
public Vip(){
//这里实际上有4行代码你看不见。
// 无参数构造方法体当中虽然什么代码都没写，
// 但是实际上是在这个方法体里面进行的实例变量默认值初始化
// 当然，如果你在这个方法里面给他们赋值了，系统就不会默认赋值了
/*
no = 0;
name = null;
birth = null;
sex = false;
*/
}
//有参数构造方法
public Vip(long huiYuanHao, String xingMing){
// 给实例变量赋值【初始化实例变量，初始化属性】
no = huiYuanHao;
name = xingMing;
// 实际上这里还有两行代码（没有手动赋值，系统都会默认赋值。）
//birth = null;
//sex = false;
}
//有参数构造方法
public Vip(long huiYuanHao,String xingMing, String shengRi){
no = huiYuanHao;
name = xingMing;
birth = shengRi;
// 实际上这里有一行默认的代码
//sex = false;
}
//有参数的构造方法
public Vip(long huiYuanHao,String xingMing,String shengRi,boolean xingBie){
no = huiYuanHao;
name = xingMing;
birth = shengRi;
sex = xingBie;
}
}
public class ConstructorTest03{
public static void main(String[] args){
//调用不同的构造方法创建对象
Vip v1 = new Vip();
System.out.println(v1.no); //0
System.out.println(v1.name); // null
System.out.println(v1.birth); // null
System.out.println(v1.sex); // false
Vip v2 = new Vip(11111L, "大灰狼");
System.out.println(v2.no); // 11111L
System.out.println(v2.name); // "大灰狼"
System.out.println(v2.birth); // null
System.out.println(v2.sex); // false
Vip v3 = new Vip(22222L, "小绵羊", "2000-10-10");
System.out.println(v3.no); // 22222L
System.out.println(v3.name); //"小绵羊"
System.out.println(v3.birth); // "2000-10-10"
System.out.println(v3.sex); // false
Vip v4 = new Vip(33333L, "钢铁侠", "1980-10-11", true);
System.out.println(v4.no); // 33333L
System.out.println(v4.name); //"钢铁侠"
System.out.println(v4.birth); //"1980-10-11"
System.out.println(v4.sex); //true
}
}
构造方法需要掌握的知识点：
1. 构造方法有什么作用？
2 .构造方法怎么定义，语法是什么？
3. 构造方法怎么调用，使用哪个运算符？
4. 什么是缺省构造器？
5. 怎么防止缺省构造器丢失？ 建议将无参数构造方法手动的写出来，这样一定不会出问题。
6. 实例变量在类加载是初始化吗？实例变量在什么时候初始化？
实例变量是在构造方法执行的过程中完成初始化的，完成赋值的。
【拓展】java 虚拟机内存管理（理解）
了更好的理解上面的程序，来看看java 虚拟机是如何管理它的内存的，请看下图：
① 程序计数器：
1) 概念：可以看做当前线程所执行的字节码的行号指示器。
2) 特点：线程私有的内存
② java 虚拟机栈（重点）：
1) 概念：描述的是 java 方法执行的内存模型。（每个方法在执行的时候会创建一个
栈帧，用于存储 局部变量表，操作数栈，动态链接，方法出口等信息。每个方法
从调用直至完成的过程，就对应一个栈帧从入栈到出栈的过程。）
2) 特点：线程私有，生命周期和线程相同。这个区域会出现两种异常：
StackOverflowError 异常：若线程请求的深度大于虚拟机所允许的深度。
OutOfMemoryError 异常：若虚拟机可以动态扩展，如果扩展是无法申请到足够的内存。
③ 本地方法栈：
1) 概念：它与虚拟机栈所发挥的作用是相似的，区别是 java 虚拟机栈为执行 java 方法服务，
而本地方法栈是为本地方法服务。
2) 特点：线程私有，也会抛出两类异常：StackOverflowError 和 OutOfMemoryError。
④ java 堆（重点）：
1) 概念：是被所有线程共享的一块区域，在虚拟机启动时创建。
2) 特点：线程共享，存放的是 对象实例（所有的对象实例和数组），GC 管理的主要区域。
可以处于物理上不连续的内存空间。
⑤ 方法区（重点）：
1) 概念：存储已被虚拟机加载的类 类 信息、常量、静态变量，即时编译器编译后的代码等数据。
2) 特点：线程共享的区域，抛出异常 OutOfMemory 异常：当方法区无法满足内存分配需求的时候。
以上所描述内容，有看得懂的，也有看不懂的，例如：线程、本地方法等，这个需要大家
在学习后面内容之后，返回来再看一看，那个时候你就全部明白了。针对于目前来说，大家必
须要知道 java 虚拟机有三块主要的内存空间，分别是“虚拟机栈（后面简称栈）”、“方法
区”、“堆区”，方法区存储类的信息，栈中存储方法执行时的栈帧以及局部变量，堆区中主
要存储 new 出来的对象，以及对象内部的实例变量。其中垃圾回收器主要针对的是堆内存，
方法区中最先有数据，因为程序执行之前会先进行类加载。栈内存活动最频繁，因为方法不断
的执行并结束，不断的进行压栈弹栈操作。
将目前阶段需要掌握的内存空间使用一张简单的图表示出来，这个图是大家需要掌握的：
java 虚拟机内存管理-简图
传送门
上一章：JavaSE 基础 - 第八章 认识面向对象
下一章：JavaSE 基础 - 第十章 封装