第九章 对象的创建和使用

1 语法级别上怎么完成对象的创建

类名 变量名 = new 类名();
这样就完成了对象的创建

 

2 什么是实例变量?

对象又被称为实例。实例变量实际上就是:对象级别的变量。
public class 明星类{
double height;
}
身高这个属性所有的明星对象都有,但是每一个对象都有“自己的身高值”。
假设创建10个明星对象,height变量应该有10份。
所以这种变量被称为对象级别的变量。属于实例变量。

 

3 对象和引用的区别?

对象是通过new出来的,在堆内存中存储。
引用是:但凡是变量,并且该变量中保存了内存地址指向了堆内存当中的对象。

Studen2t.java

/*
学生类:
学号:int
姓名:String
年龄:int
性别:boolean
住址:String

变量必须先声明,再赋值才能访问。
注意:对于成员变量来说,没有手动赋值时,系统默认赋值。赋的值都是默认值,那么默认值是什么?

类型 默认值
-------------------
byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0
boolean false
char \u0000
引用数据类型 null

null是一个关键字,全部小写,表示空。是引用类型的默认值。

分析:对于成员变量来说,是不是应该一个对象有一份。
李四有李四的学号
张三有张三的学号
李四和张三的学号不一样,所以应该有两块不同的内存空间


*/

public class Student2{

// 属性(描述状态),在java程序中以“成员变量”的形式存在。
// 学号
// 一个对象一份。
int no;  

// 姓名
String name;

// 年龄
int age;

// 性别
boolean sex;

// 住址
String addr;
}

StudentTest2.java


public class StudentTest2{
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这个局部变量叫做引用
Student2 s1 = new Student2();
// 怎么访问实例变量?
// 语法:引用.实例变量名
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("---------------------");

// 创建学生对象2
// s2也是局部变量
// s2也叫做引用
Student2 s2 = new Student2();
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 = "xiaohong";
s1.age = 18;
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);

}

public static void method(){
// i, s1, s2都是main方法中的局部变量,在这里是无法访问的。
/*
System.out.println(i);
System.out.println(s1);
System.out.println(s2);
*/
}

}

 

 

 

4 内存图的重要性

1、画内存图的注意事项
第一:大写在内存图上不要体现出代码。内存上应该主要体现“数据”。
第二:大写画图的时候,图上的图形应该有先后顺序,先画什么,再画什么,必须是有顺序的,而不是想起来哪个画哪个。程序代码是有执行顺序的,程序执行到哪里你就画哪里就行了。

2、为什么要画内存图?
第一:有了内存图,程序不运行,我也知道结果。(可以推算出结果)
第二:有了内存图,有助于你调试程序。画内存图是对java运行机制的一种理解。不知道运行机制,以后复杂的程序出错之后你是不会调试的。

 

 

5 作业

5.1 作业1

User.java


/*
User类:用户类
*/

public class User{
// 用户id
// id的访问必须先造对象,然后对象有了,才能访问对象的id。
int id;  // 成员变量,实例变量(对象变量,一个对象一份)

// 用户名
String username;  // 成员变量可以不手动赋值,系统赋默认值。

// 密码
String password;
}

// byte, short, int, long, float, double, boolean, char,这样的默认值通常是0
// 引用类型:null

UserTest.java


// 第一步:类加载
// 第二步:调用UserTest类的main方法(方法调用要压栈)

public class UserTest{
public static void mian(String[] args){

// 方法体当中声明的变量叫做局部变量
User u1 = new User();
u1.id = 1111;
u1.username = "xiaohong";
u1.password = "123";
System.out.println(u1.id);
System.out.println(u1.username);
System.out.println(u1.password);

User u2 = new User();
u2.id = 2222;
u2.username = "jingxian";
u2.password = "456";
System.out.println(u2.id);
System.out.println(u2.username);
System.out.println(u2.password);
}
}

 

 

 

5.2 作业2

Address.java


// 住址类
public class Address{
// 城市
String city;  // 实例变量

// 街道
String street;

// 邮编
String zipcode;
}

User.java


public class User{

// 类 = 属性 + 方法

// 用户id
// int是一种基本数据类型
int id;  // 实例变量

// 用户名
// String是一种引用数据类型
String username;  // 实例变量

// 家庭住址
// Address是一种引用数据类型
Address addr;  // 实例变量
}

// 实例变量都存储在哪里?
// 实例变量都存储在堆内存的对象内部

Test.java


/*
引用和对象的区分?
“引用”是啥?是存储对象内存地址的一个变量
“对象”是啥?堆里new出来的。

通俗一点:
只要这个变量中保存的是一个对象的内存地址,那么这个变量就叫做“引用”。

思考:
引用一定是局部变量吗?
不一定

实例变量都存储在哪里?
实例变量都在堆内存的对象内部。

方法体外,类体内定义的变量叫做:成员变量。
*/

public class Test{
public static void main(String[] args){

/*
int i = 100;
int j = i; // 原理:会将i中保存的100复制一份,传给j变量
*/

// 家庭住址对象
Address a = new Address();
a.city = "楚雄";
a.street = "大兴区";
a.zipcode = "123123";

// 用户对象
User u = new User();
System.out.println(u.id);  // 0
System.out.println(u.username);  // null
System.out.println(u.addr);  // null

u.id = 111;
u.username = "xiaohong";
u.addr = new Address();
System.out.println(u.addr.city);
System.out.println(u.addr.street);
System.out.println(u.addr.zipcode);

// u.addr.city 这行代码可否拆分呢?u.addr.city 节省变量。
// 拆分成以下代码和以上效果完全相同,原理完全相同,不同的是以下代码多了两个变量
Address ad = u.addr;
String address = ad.city;


// --------------------------------------
int x = 100;
// = 代表赋值运算,“赋值”中有一个“值”
// x变量中的值是100,将100复制一份给y
// 表示:将x变量中保存的值100复制一份给y
int y = x;

// --------------------------------------
Address k = new Address();  // k中保存的是造出来的堆内存当中对象的内存地址
Address m = k;  // 表示把k变量中保存的对象中的内存地址复制一份给m
}
}

 

 

 

5.3 作业3

T.java


// 画出内存图

public class T{
A a;  // 成员变量中的实例变量。必须先创建对象,通过“引用”来访问

public static void main(String[] args){
D d = new D();
C c = new C();
B b = new B();
A a = new A();
T t = new T();

c.d = d;
b.c = c;
a.b = b;
t.a = a;

// 编写代码通过t来访问D中的i
System.out.println(t.a.b.c.d.i);
}

}

class A{
B b;
}

class B{
C c;
}

class C{
D d;
}

class D{
int i = 100;
}

 

 

6 程序出现空指针异常情况


/*
空指针异常

关于垃圾回收器:GC
在java语言中,垃圾回收器主要针对的是堆内存。
当一个java对象没有任何引用指向该对象的时候,
GC会考虑将该垃圾数据释放回收掉。

出现空指针异常的前提条件是?
“空引用”访问实例相关的数据时,都会出现空指针异常。
*/

public class NullPointerTest{
public static void main(String[] args){
// 创建客户对象
Customer c = new Customer();
// 访问这个客户的id
System.out.println(c.id);

// 重新给id赋值
c.id = 9511;
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;  // 成员变量中的实例变量,应该先创建对象,然后通过“引用.”的方式访问。
}

 

 

 

 

7 方法调用时方法传递

7.1 方法调用传参1


/*
分析程序的输出结果
java中规定:参数传递的时候,和类型无关,不管是基本数据类型还是引用数据类型统一都是将盒子中保存的那个“值”复制一份,传递下去。
java中只有一个规定:参数传递的时候,一定是将“盒子”中保存的东西复制一份传递过去。

内存地址也是值,也是盒子中保存的一个东西。
*/

public class Test1{

int x = 100;
int y = x;  // x赋值给y,是怎么传递的?将x变量中保存的100这个值复制一份传给y

public static void main(String[] args){
// 局部变量,域是main
int i = 10;
// 将i变量中保存的10复制一份,传给add方法。
add(i);
System.out.println("main ---> " + i);  // 10
}

public static void add(int i){  // i是局部变量,域是add域
i++;
System.out.println("add ---> " + i)  // 11
}
}

 

 

 

7.2 方法调用传参2


/*
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);
}

// 关于方法的形式参数可以是基本数据类型,也可以是引用数据类型,只要是合法的数据类型就可以了。
public static void add(Person p){  // p是add方法的局部变量
p.age++;
System.out.println("add --> " + p.age);
}
}

class Person{
// 年龄属性,成员变量中的实例变量
int age;
}

 

 

 

 

8 构造方法

8.1 构造方法语法结构

Student.java


public class Student{
// 学号
int no;

// 姓名
String name;

// 年龄
int age;

// 当前的Student这个类当中并没有定义任何构造方法。
// 但是系统实际上会自动给Student类提供一个无参数的构造方法。
// 将无参数的构造方法(缺省构造器)写出来
public Student(){
System.out.println("无参数的构造方法执行了!");
}

// 定义一个有参数的构造方法
public Student(int i){

}

// 没有返回值类型,编译器会判定该方法是构造方法
// 于是编译器会检测方法名是否和类名一致,结果发现不一致
// 编译器报错
/*
编译器检测到该方法名“Studen”,发现这个名字和类名不一致,编译器会认为该方法是一个普通方法,普通方法应该有返回值,但是没有写返回值类型,所以报错了。
错误:方法声明无效; 需要返回值类型
*/
/*

public Studen(String[] name){

}
*/

// 第一种修改方式
public void Studen(Stirng[] args){}

// 第二种修改方式
public Student(String[] args){}

}

ConstructorTest01.java

    构造方法
1、什么是构造方法,有什么用?
构造方法一个比较特殊的方法,通过构造方法可以完成对象的创建,以及实例变量的初始化
构造方法是用来创建对象,并且同时给对象的属性赋值的。
注意:实例变量没有手动赋值的时候,系统会赋默认值。

2、重点:当一个类没有提供任何构造方法,系统会默认提供一个无参数的构造方法。(这个构造方法被称为缺省构造器)

3、调用构造方法怎么调用呢?
使用哪个运算符呢?
使用new运算符来调用构造方法。
语法格式:
new 构造方法名(实际参数列表);

4、构造方法的语法结构是?
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
// 通常在构造方法体中给属性赋值,完成属性的初始化。
}
注意:
修饰符列表目前统一写:public,不要写public static
构造方法名和类名必须一致
构造方法不需要指定返回值类型,也不能写void,写上void表示普通方法

普通方法的语法结构是?
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}

5
当一类中没有提供任何构造方法,系统默认提供一个无参数的构造方法。这个无参数的构造方法叫做缺省构造器。
当一个类中手动的提供了构造方法,那么系统将不再默认提供无参数的构造方法。
无参数构造方法和有参数的构造方法都可以调用。
Student x = new Student();
Student y = new Studnet(123);
构造方法支持方法重载吗?
构造方法是支持方法重载的。
在一个类当中构造方法可以有多个。
并且所有构造方法名字都是一样的。
方法重载的特点:
在同一个类中,方法名相同,参数列表不同。
对于实例变量来说,只要你在构造方法中没有手动给它赋值,统一都会采用默认赋值,默认赋系统值。



public class ConstructorTest01{
public static void main(String[] args){

// 调用Student类的无参数构造方法
new Student();

// 调用普通方法
ConstructorTest01.doSome();
doSome();

// 创建Student类型的对象
Student s1 = new Student();

// 输出“引用”
// 只要输出结果不是null,说明这个对象一定创建完成了。
System.out.println(s1);  // Student@4517d9a3

Student s3 = new Student(100);
System.out.println(s3);

}

public static void doSome(){
System.out.println("do Some!!!");
}

}

 

8.2 构造方法的使用

User.java


/*
1、id, name, age都有默认值对吗?
对。

2、
id的默认值是:0
name的默认值是:null
age的默认值是:0

3、思考:
实例变量没有手动赋值的时候,系统会默认赋值,那么这个默认赋值操作是在什么时候进行的呢?
是在类加载的时候给这些实例变量赋值吗?
不是,实例变量是在构造方法执行的过程中完成初始化的。
*/

public class User{
// 3个属性,3个实例变量【对象变量】
// 用户id
int id;

// 用户名
String name;

// 年龄
int age;

// 手动定义有参数的构造方法,无参数的构造方法将消失
public User(int a){

}

public User(){
// 这里实际上有三行代码你看不见
// 无参数构造方法体当中虽然什么代码都没写,但是实际上是在这个方法体里面进行的实例变量默认值初始化
/*
id = 0;
name = null;
age = 0;
*/

// 这就表示不在采用系统默认值,手动赋值了。
id = 111;
name = "xiaohong";
age = 30;
}

}

ConstructorTest02.java


/*
1、构造方法对应的英语单词:Constructor【构造器】
2、构造方法作用:
创建对象,并且创建对象的过程中给属性赋值(初始化)
*/

public class ConstuctorTest02{

}

Vip.java


/*
1、id, name, age都有默认值对吗?
对。

2、
id的默认值是:0
name的默认值是:null
age的默认值是:0

3、思考:
实例变量没有手动赋值的时候,系统会默认赋值,那么这个默认赋值操作是在什么时候进行的呢?
是在类加载的时候给这些实例变量赋值吗?
不是,实例变量是在构造方法执行的过程中完成初始化的。
*/

public class User{
// 3个属性,3个实例变量【对象变量】
// 用户id
int id;

// 用户名
String name;

// 年龄
int age;

// 手动定义有参数的构造方法,无参数的构造方法将消失
public User(int a){

}

public User(){
// 这里实际上有三行代码你看不见
// 无参数构造方法体当中虽然什么代码都没写,但是实际上是在这个方法体里面进行的实例变量默认值初始化
/*
id = 0;
name = null;
age = 0;
*/

// 这就表示不在采用系统默认值,手动赋值了。
id = 111;
name = "xiaohong";
age = 30;
}

}

ConstructorTest03.java


public class ConstructorTest03{
public static void main(String[] args){
// 调用不同的构造方法创建对象
Vip v1 = new Vip();
System.out.pirntln(v1.no);  // 0
System.out.pirntln(v1.name);  // null
System.out.pirntln(v1.birth);  // null
System.out.pirntln(v1.sex);  // false

Vip v2 = new Vip(11111, "大狼");  
System.out.pirntln(v2.no);  // 11111
System.out.pirntln(v2.name);  // "大狼"
System.out.pirntln(v2.birth);  // null
System.out.pirntln(v2.sex);  // false

Vip v3 = new Vip(22222, "小绵羊", "2000-03-25");
System.out.pirntln(v3.no);  // 22222
System.out.pirntln(v3.name);  // "小绵羊"
System.out.pirntln(v3.birth);  // "2000-03-25"
System.out.pirntln(v3.sex);  // false

Vip v4 = new Vip(33333, "小狗", "2022-02-22", true);
System.out.pirntln(v4.no);  // 33333
System.out.pirntln(v4.name);  // "小狗"
System.out.pirntln(v4.birth);  // "2022-02-22"
System.out.pirntln(v4.sex);  // true

}
}
 

 

 
posted @   路走  阅读(163)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布:重大改进与新特性概览!
· AI与.NET技术实操系列(二):开始使用ML.NET
· 单线程的Redis速度为什么快?
点击右上角即可分享
微信分享提示