欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

荐 JavaSe 基础 - 第九章 对象的创建和使用

程序员文章站 2022-05-08 08:30:27
JavaSe 基础 - 第九章 对象的创建和使用1、怎样创建对象?2、什么是实例变量?3、对象和引用的区别?4、画内存图注意事项  为什么要画内存图(非常重要)?5、程序在什么情况下会出现空指针异常呢?6、方法在调用的时候参数是如何传递的?7、构造方法【拓展】java 虚拟机内存管理(理解)传送门1、怎样创建对象?   语法格式:类名 变量名 = new 类名() ;   类是模板,通过一个类,是可以创建N多个对象的。   new是一个运算符。专门负责对象的创建。对于 XueSheng s...

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

荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用

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

   方法体外声明的变量叫做 成员变量。(成员变量可以不手动赋值,系统赋默认值)
   方法体当中声明的变量叫做 局部变量
荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用
【画内存图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变量。

	}
}

荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用

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

荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用

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
*/

荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用
【实例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
*/

荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用

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 虚拟机是如何管理它的内存的,请看下图:
荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用

① 程序计数器:
	1) 概念:可以看做当前线程所执行的字节码的行号指示器。
	2) 特点:线程私有的内存

② java 虚拟机栈(重点):
	1) 概念:描述的是 java 方法执行的内存模型。(每个方法在执行的时候会创建一个
		栈帧,用于存储 局部变量表,操作数栈,动态链接,方法出口等信息。每个方法
		从调用直至完成的过程,就对应一个栈帧从入栈到出栈的过程。)
	2) 特点:线程私有,生命周期和线程相同。这个区域会出现两种异常:
		*Error 异常:若线程请求的深度大于虚拟机所允许的深度。
		OutOfMemoryError 异常:若虚拟机可以动态扩展,如果扩展是无法申请到足够的内存。

③ 本地方法栈:
	1) 概念:它与虚拟机栈所发挥的作用是相似的,区别是 java 虚拟机栈为执行 java 方法服务,
		而本地方法栈是为本地方法服务。
	2) 特点:线程私有,也会抛出两类异常:*Error 和 OutOfMemoryError。

④ java 堆(重点):
	1) 概念:是被所有线程共享的一块区域,在虚拟机启动时创建。
	2) 特点:线程共享,存放的是 对象实例(所有的对象实例和数组),GC 管理的主要区域。
		可以处于物理上不连续的内存空间。

⑤ 方法区(重点):
	1) 概念:存储已被虚拟机加载的类 类 信息、常量、静态变量,即时编译器编译后的代码等数据。
	2) 特点:线程共享的区域,抛出异常 OutOfMemory 异常:当方法区无法满足内存分配需求的时候。

    以上所描述内容,有看得懂的,也有看不懂的,例如:线程、本地方法等,这个需要大家
在学习后面内容之后,返回来再看一看,那个时候你就全部明白了。针对于目前来说,大家必
须要知道 java 虚拟机有三块主要的内存空间,分别是“虚拟机栈(后面简称栈)”、“方法
区”、“堆区”,方法区存储类的信息,栈中存储方法执行时的栈帧以及局部变量,堆区中主
要存储 new 出来的对象,以及对象内部的实例变量。其中垃圾回收器主要针对的是堆内存,
方法区中最先有数据,因为程序执行之前会先进行类加载。栈内存活动最频繁,因为方法不断
的执行并结束,不断的进行压栈弹栈操作。

将目前阶段需要掌握的内存空间使用一张简单的图表示出来,这个图是大家需要掌握的:
荐
                                                        JavaSe 基础 - 第九章 对象的创建和使用
                         java 虚拟机内存管理-简图

传送门

上一章:JavaSe 基础 - 第八章 认识面向对象
下一章:JavaSe 基础 - 第十章 封装

本文地址:https://blog.csdn.net/W1324926684/article/details/107371299

相关标签: JavaSe基础 java