目录
知识框架
🏀对象的创建和使用
🥅创建对象对应的JVM内存结构
❤️Student类
学生类
学号：int
姓名：String
年龄：int
性别：boolean
住址：Stringpublic class Student{
// 属性（描述状态），在java程序中以“成员变量”的形式存在。
int no; // 这种“成员变量”又被称为“实例变量”。
// 姓名
String name;
// 年龄
int age;
// 性别
boolean sex;
// 住址
String addr;
}
❤️StudentTest类
public class StudentTest{
public static void main(String[] args){
1.//局部变量不初始化，不能直接访问，例如：
int k;
System.out.println(k); //错误: 可能尚未初始化变量k
//2.访问学生姓名no可以直接通过类名吗？
//学生姓名是一个实例变量。实例变量是对象级别的变量；不能通过“类名”来直接访问“实例变量”。
System.out.println(Student.name);//err,应该先new一个对象
//3.i属于局部变量吗？当然是；局部变量存储在栈内存当中。（栈主要存储局部变量。）
int i = 100;
//4.创建学生对象1
Student s1 = new Student();// s1属于局部变量；s1这个局部变量叫做引用
//怎么访问实例变量？语法：引用.实例变量名
System.out.println(s1.no);
System.out.println(s1.name);
System.out.println(s1.age);
System.out.println(s1.sex);
System.out.println(s1.addr);
System.out.println("-----------------------------");
//5. 程序执行到此处我可以修改s1这个学生的学号吗？
// 通过“=”赋值的方式将内存中实例变量的值修改一下。
s1.no = 110;
s1.name = "张三";
s1.age = 20;
s1.sex = true;
s1.addr = "深圳宝安区";
System.out.println("学号=" + s1.no);
System.out.println("姓名=" + s1.name);
System.out.println("年龄=" + s1.age);
System.out.println("性别=" + s1.sex);
System.out.println("住址=" + s1.addr);
}
}
❤️内存图
❤️例1
⭐️User类
public class User{
int id;
String username;
String password;
}
⭐️UserTest类
public class UserTest{
public static void main(String[] args){
//1.创建一个用户
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);
//2.创建另一个用户
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
⭐️Address
public class Address{
String city;
String street;
String zipcode;
}⭐️User
public class User{
int id; // 实例变量
String username; // 实例变量
Address addr; // Address是一种引用数据类型；addr是一个引用。
}
⭐️Test
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; //这相当于是建立了连接
System.out.println(u.username + "是"+u.addr.city+"城市的！");
}
}⭐️内存图
❤️例3
public class T{
A o1;
public static void main(String[] args){
A a = new A();
B b = new B();
C c = new C();
D d = new D();
T t = new T();
//这里不写代码会出现NullPointerException异常。（空指针异常。）
c.o4 = d; //这里全是相当于建立连接关系
b.o3 = c;
a.o2 = b;
t.o1 = a;
// 编写代码通过t来访问d中的i
//System.out.println(T.a); //错误的。
System.out.println(t.o1.o2.o3.o4.i);
}
}
class A{
B o2;
}
class B{
C o3;
}
class C{
D o4;
}
class D{
int i;
}🥅空指针异常
public class NullPointerTest{
public static void main(String[] args){
//1. 创建客户对象
Customer c = new Customer();//c指向内存地址
//2. 访问这个客户的id
System.out.println(c.id); // 0
//3. 重新给id赋值
c.id = 9521; // 终身代号
System.out.println("客户的id是=" + c.id);
//4.c赋值为空指针
c = null;
// NullPointerException
// 编译器没问题，因为编译器只检查语法，编译器发现c是Customer类型，
// Customer类型中有id属性，所以可以：c.id。语法过了。
// 但是运行的时候需要对象的存在，但是对象没了，尴尬了，就只能出现一个异常。
System.out.println(c.id);//err
//5.可以重新给c赋值，继续使用
c = new Customer();
}
}
class Customer{
// 客户id
int id; // 成员变量中的实例变量，应该先创建对象，然后通过“引用.”的方式访问。
}⭐️内存图1
⭐️内存图2
🥅方法调用时参数的传递问题
❤️例1
// x赋值给y，是怎么传递的？将x变量中保存的100这个值复制一份传给y；y的改变不贵改变x的值
//很类似于C语言中的传值调用
int x = 100;
int y = x; //将x的值复制一份传给y，所以y的改变不会影响xpublic class Test1{
public static void main(String[] args){
// 局部变量，域是main
int i = 10;
// 将i变量中保存的10复制一份，传给add方法；下面的i改变不会影响上面的i
add(i);
System.out.println("main ---> " + i); //10
}
public static void add(int i){ // i是局部变量，域是add
i++;
System.out.println("add ----> " + i); //11
}
}
⭐️内存图
❤️例2
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;
}
⭐️内存图
🥅构造方法
❤️例1
⭐️Student类
public class Student{
// 学号
int no;
// 姓名
String name
// 年龄
int age;
//1.当前的Student这个类当中并没有定义任何构造方法。
//但是系统实际上会自动给Student类提供一个无参数的构造方法。
//建议将无参数的构造方法（缺省构造器）写出来
public Student(){// 默认初始化为0 null 0
}
//2. 定义一个有参数的构造方法
public Student(int i){// 默认初始化为0 null 0
}
//3.编译器检测到该方法名“Studen”，发现这个名字和类名不一致，
//编译器会认为该方法是一个普通方法，普通方法应该有返回值，但是没有写返回值类型，所以报错了。
//错误: 方法声明无效; 需要返回类型
public Studen(String name){
}
// 第一种修改方式
//public void Studen(String name){//修改为普通方法
}
// 第二种修改方式
public Student(String name){//修改为构造方法
}
}⭐️ConstructorTest01类
public class ConstructorTest01{
public static void main(String[] args){
//1. 调用Student类的无参数构造方法
new Student();//没有用变量接收，调用完GC回收
//2. 调用下面的普通方法，在同一个类中，两种方法
ConstructorTest01.doSome();
doSome();
//3. 创建Student类型的对象
Student s1 = new Student();
//4. 输出“引用”；只要输出结果不是null，说明这个对象一定是创建完成了。
//输出结果大家目前是看不懂的，后期会讲。其实默认调用的是toString()方法
System.out.println(s1); //Student@54bedef2
//5. 这是调用另一个有参数的构造方法。
Student s3 = new Student(100);
System.out.println(s3); //Student@5caf905d
}
public static void doSome(){
System.out.println("do some!!!!");
}
}❤️例2：对于实例变量初始化，是在构造方法执行的过程中（创建对象）完成初始化的
⭐️User类
/*
1、id,name,age都有默认值
id的默认值是：0
name的默认值是：null
age的默认值是：0
2、思考：实例变量没有手动赋值的时候，实际上系统会默认赋值，那么这个默认赋值操作是在
什么时间进行的？是在类加载的时候给这些实例变量赋值吗？
答：不是，实例变量是在构造方法执行的过程中(创建对象时)完成初始化的，完成赋值的。
*/
public class User{
int id;
String name;
int age;
//3. 手动定义有参数的构造方法，无参数构造方法将消失；要想有必须手动写出来
public User(int a){
}
//4. 进行初始化
public User(){ //无参
// 这就表示不再采用系统默认值，手动赋值了。
id = 111;
name = "lisi";
age = 30;
}
}⭐️ConstructorTest02类
/*
1、构造方法对应的英语单词：Constructor【构造器】
2、构造方法作用：
创建对象，并且创建对象的过程中给属性赋值（初始化。）
*/
public class ConstructorTest02{
public static void main(String[] args){
//1. 调用无参的，进行手动初始化的
User u = new User();// 创建对象
System.out.println(u.id); //111
System.out.println(u.name); //lisi
System.out.println(u.age); //30
//2. 调用有参的，进行默认初始化的
User u2 = new User(1111111);// 创建对象
System.out.println(u2.id); //0
System.out.println(u2.name); // null
System.out.println(u2.age); // 0
}
}❤️例3：最终无参、有参构造方法的使用
⭐️Vip类
public class Vip{
long no;// 会员号
String name; // 会员姓名
String birth; // 生日
boolean sex; // 性别
//1. 无参数构造方法
public Vip(){
}
//---------------下面的代码我们学到this关键字还可以继续优化！
//2.有参数构造方法
public Vip(long huiYuanHao, String xingMing){
// 给实例变量赋值【初始化实例变量，初始化属性】
no = huiYuanHao;
name = xingMing;
// 实际上这里还有两行代码（没有手动赋值，系统都会默认赋值。）
//birth = null;
//sex = false;
}
//3. 有参数构造方法
public Vip(long huiYuanHao,String xingMing, String shengRi){
no = huiYuanHao;
name = xingMing;
birth = shengRi;
// 实际上这里有一行默认的代码
//sex = false;
}
//4. 有参数的构造方法
public Vip(long huiYuanHao,String xingMing,String shengRi,boolean xingBie){
no = huiYuanHao;
name = xingMing;
birth = shengRi;
sex = xingBie;
}
}⭐️ConstructorTest03类
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
}
}
