[笔记]Java-6：类和对象

6 类和对象

6.1 面向对象编程（理解）

面向对象编程的概念

• 万物皆对象。
• 面向对象指以属性和行为的观点去分析现实生活中的事物。
• 面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程。
• 面向对象编程是软件产业化发展的需求。
• 理解面向对象的思想精髓(封装、继承、多态)，至少掌握一种编程语言。
  
  
  

6.2 类和对象及引用（重中之重）

类和对象的概念

• 对象主要指现实生活中客观存在的实体，在Java语言中对象体现为内存空间中的一块存储区域。（在堆区中申请了一块存储单元）
• 类简单来就是“分类”，是对具有相同特征和行为的多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性的成员变量以及描述行为的成员方法。
• 类是用于构建对象的模板，对象的数据结构由定义它的类来决定。（类比：类-想象为设计图，对象是根据设计图造出来的产品）
• 类是多个对象的统称，对象是具体某一个。
  
  

类的定义

class 类名 {
    类体;
} 

比如：

class Person {
    ...;
}

注意：通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写。

成员变量的定义

class 类名 {
    数据类型 成员变量名 = 初始值; 
}

比如：

class Person {
    String name;
}

注意：当成员变量由多个单词组成时，通常要求从第二个单词起每个单词的首字母大写。

对象的创建

new 类名();

比如：

new Person();

注意：
a.当一个类定义完毕后，可以使用new关键字来创建该类的对象，这个过程叫做类的实例化。（相当于创建了Person类的实体）
b.创建对象的本质就是在内存空间的堆区申请一块存储区域，用于存放该对象独有特征信息。
（new person()这种创建出来但又没命名的叫匿名对象）

引用的定义

基本概念
a.使用引用数据类型定义的变量叫做引用型变量，简称为"引用"。
(引用型变量：数组&类)
b.引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问。
• 语法格式

类名 引用变量名;
引用变量名.成员变量名;

比如：

Person p = new Person();  //p就是引用变量名，记录了person()的地址信息
p.name = "张飞";
System.out.println(p.name);

案例题目
编程实现Person类的定义和使用。

/*
    编程实现Person类的定义
 */
public class Person {

	// 1.描述Person类的两个特征：
	// 语法：数据类型 成员变量名 = 初始值;   - 其中[=初始值] 通常都省略不写
	String name; // 用于描述姓名的成员变量
	int age;     // 用于描述年龄的成员变量

	public static void main(String[] args){
		//2.声明Person类型的引用指向Person类型的对象
		//数据类型() 引用变量名 = new 类名();
		Person p = new Person(); //Person p是在栈区中申请内存，new Person是在堆区中申请存储空间，存储空间创造出来肯定有name和age两个属性
		
		//3.打印对象中的成员变量值
		// 引用变量名.成员变量名
		System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // null 0 (两个都是默认值)
		
		System.out.println("------------------------------------------------")
	
		//4.修改成员变量的数值
		p.name = "zhangfei";
		p.age = 30;
		
		//5.再次打印修改后的数值
		System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // zhangfei 30
	}
}

成员变量的初始值

对象创建后，其成员变量可以按照默认的方式初始化，具体规则如下：

关于Person类-程序的执行流程和内存分析

1.保存过的东西都保存在硬盘中，要读取需要进入内存，CPU再解析和执行
2.代码从硬盘中加载出来时，是先放在方法区内，是字节码文件
3.先找main方法，蓝框是在栈区中给main方法申请的一块区域
4.执行Person p，是在main中再划分一块区域给Person p（左边绿的区域）
5.执行new Person()，就是在堆区划一块区域给new Person()，并且按照类的属性划成两个区域name和age（右边绿色区域）
6.Person p = new Person()，相当于把等号右边赋值给等号左边，把地址信息赋值给左边区域中
7.用zhangfei将null覆盖，用30将0覆盖

案例题目
编程实现Point类的定义，特征有：横纵坐标(整数)，要求在main方法中声明Point类型的引用指向Point对象并打印特征，然后将横纵坐标修改为3和5后再次打印。

/*
    编程实现Point类的定义
 */
public class Point {
	
	int x; // 用于描述横坐标的成员变量
	int y; // 用于描述纵坐标的成员变量
	
	public static void main(String[] args){
		// 1.声明Point类型的引用指向Point类型的对象
		Point p = new Point();
		// 打印成员变量的数值
		System.out.println("横坐标是：" + p.x + "，纵坐标是：" + p.y);  // 0 0
	
		System.out.println("-----------------------------------------------");
	
		// 2.将横纵坐标修改为 3 和 5 后再次打印
		p.x = 3;
		p.y = 5;
		System.out.println("横坐标是：" + p.x + "，纵坐标是：" + p.y);   // 3 5
	}
}

6.3 成员方法（重中之重）

成员方法的定义

（成员方法：这一类事物的行为的描述）

class 类名 {
    返回值类型 成员方法名(形参列表) {
        成员方法体; 
    } 
}

比如：

class Person {
    void show() {
        System.out.println("没事秀一下！");
    }
}

当成员方法名由多个单词组成时，要求从第二个单词起每个单词的首字母大写。

返回值类型的详解

• 返回值主要指从方法体内返回到方法体外的数据内容。
  

• 返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型。

• 当返回的数据内容是66时，则返回值类型写 int 即可

• 在方法体中使用 return 关键字可以返回具体的数据内容并结束当前方法。（遇到return，方法体结束，把数据返回出去）

• 当返回的数据内容是66时，则方法体中写 return 66; 即可

• 当该方法不需要返回任何数据内容时，则返回值类型写 void 即可。
  
  

形参列表的详解

• 形式参数主要用于将方法体外的数据内容带入到方法体内部。
• 形式参数列表主要指多个形式参数组成的列表，语法格式如下：

数据类型 形参变量名1, 数据类型 形参变量名2, ... 

• 当带入的数据内容是"hello"时，则形参列表写 String s 即可
• 当带入的数据内容是66和"hello"时，则形参列表写 int i, String s 即可
• 若该方法不需要带入任何数据内容时，则形参列表位置啥也不写即可。
  
  

方法体的详解

• 成员方法体主要用于编写描述该方法功能的语句块。

成员方法可以实现代码的重用，简化代码。

方法的调用

引用变量名.成员方法名(实参列表);

• 实际参数列表主要用于对形式参数列表进行初始化操作，因此参数的个数、类型以及顺序都要完全一致。
• 实际参数可以传递直接量、变量、表达式、方法的调用等。

比如

p.show();

/*
    编程实现Person类内部重复代码的重用
 */
public class Person {

	String name; // 用于描述姓名的成员变量
	int age;

	// 自定义成员方法实现所有成员变量的打印，提高代码的复用性，简化代码量
	// 语法：返回值类型 方法名称 (形参列表) {方法体；}
	void show() {
		// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用.的前缀(不要p.name这种了)
		System.out.println("我是" + name + "，今年" + age + "岁了！");
	}

	public static void main(String[] args){
		//2.声明Person类型的引用指向Person类型的对象
		//数据类型() 引用变量名 = new 类名();
		Person p = new Person(); //Person p是在栈区中申请内存，new Person是在堆区中申请存储空间，存储空间创造出来肯定有name和age两个属性
		
		//3.打印对象中的成员变量值
		// 引用变量名.成员方法名(实参列表);
		// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
		p.show();   // null 0
				
		System.out.println("------------------------------------------------")
	
		//4.修改成员变量的数值
		p.name = "zhangfei";
		p.age = 30;
		
		//5.再次打印修改后的数值
		p.show();    // zhangfei 30
	}
}

案例：修改参数的值

/*
    有参数，无返回值的写法
 */
public class Person {

	String name;
	int age;

	void show() {
		
		System.out.println("我是" + name + "，今年" + age + "岁了！");
	}
	
	// 自定义成员方法实现将姓名修改为参数指定数值的行为（外部传入参数）
	void setName(String s) {  // setName,修改名字
		name = s;             // 修改名字
	} 
	// 自定义成员方法实现将年龄修改为参数指定数值的行为（外部传入参数）
	void setAge(int i) {      // setName,修改名字
		age = i;              // 修改年龄
	}

	public static void main(String[] args){
		Person p = new Person(); 
		p.show();      // null 0
		
		System.out.println("------------------------------------------------")
	
		p.name = "zhangfei";
		p.age = 30;
		
		p.show();      // zhangfei 30
	
		System.out.println("------------------------------------------------")
		
		// 通过成员方法的调用实现成员变量的修改
		p.setName("guanyu");
		p.setAge("35");
		
		p.show();      // guanyu 35
	}
}

/*
    同时修改姓名和年龄
 */
public class Person {

	String name;
	int age;

	void show() {
		
		System.out.println("我是" + name + "，今年" + age + "岁了！");
	}
	
	// 自定义成员方法实现将姓名和年龄修改为参数指定数值的行为（外部传入参数）
	void setNameAge(String s, int i) {
		name = s;
		age = i;
	}

	public static void main(String[] args){
		Person p = new Person(); 
		p.show();      // null 0
		
		System.out.println("------------------------------------------------")
	
		p.name = "zhangfei";
		p.age = 30;
		
		p.show();      // zhangfei 30
	
		System.out.println("------------------------------------------------")
		
		// 通过成员方法的调用同时修改姓名和年龄
		p.setNameAge("liubei", 40);
		p.show(); // liubei 40
	}
}

（这样写并不常用,，增加了耦合性）

可变长参数

返回值类型 方法名(参数的类型... 参数名) 

• 方法参数部分指定类型的参数个数是可以改变的，也就是0~n个 。 • 一个方法的形参列表中最多只能声明一个可变长形参 ，并且需要放到参数列表的末尾。

/*
    Person类可变长参数的使用
 */
public class Person {

	String name;
	int age;

	// 自定义成员方法实现可变长参数的使用（看做一位数组使用就行）
	void showArgument(int num, String... args) { // 参数类型不变，个数可以增加，0~n个
		System.out.println("num = " + num);
		for(int i = 0; i < args.length; i++) {
			System.out.println("第" + (i+1) + "个参数为：" + args[i]);
		}
	}
	
	public static void main(String[] args){
		Person p = new person();
		// 打印可变长参数
		p.showArgument();
		p.showArgument(1, "参数1");
		p.showArgument(2, "参数1", "参数2");
	}
}

案例：获取姓名和年龄并且返回（无参数有返回值）

/*
    无参数，有返回值的写法
 */
public class Person {

	String name; 
	int age;     

	// 自定义成员方法实现姓名数值的获取并且返回的行为
	String getName() {
		return name;     // return之后的代码是执行不到的，在这终止了
	}

	// 自定义成员方法实现年龄数值的获取并且返回的行为
	int getAge() {
		return age;
	}

	public static void main(String[] args){
		Person p = new Person(); 
		p.name = zhangfei;
		p.age = 30;
		
		// 调用成员方法实现成员变量数值的获取并打印
		String str1 = p.getName();      // 注意怎么接返回值
		System.out.println("获取到的姓名是：" + str1);   // zhangfei
		int str2 = p.getAge();
		System.out.println("获取到的年龄是：" + str2);   // 30
	}
}

方法的传参过程

案例分析：
这边有一个max方法（有参数有返回值），他是怎么运行的？

int max(int ia, int ib) { … … … }      

int a = 5; 
int b=6; 
int res = m.max(a,b);   // main中的方法，res用来接返回值的

步骤：

1. 为main方法中的变量a、b、res分配空间并初始化。
2. 调用max方法，为max方法的形参变量ia、ib分配空间。
3. 将实参变量的数值赋值到形参变量的内存空间中。
4. max方法运行完毕后返回，形参变量空间释放。
5. main方法中的res变量得到max方法的返回值。
6. main方法结束后释放相关变量的内存空间

参数传递的注意事项

总结：

• 1.基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；

/*
    编程实现参数传递的测试 (注意事项1)
 */
public class ArgumentTest {
	
	// 自定义成员方法打印参数传入的整数数据
	// int ia = ib = 10;
	void show1(int ia) {    // 这时候传过来的ib = 10，赋值给了ia
		ia = 200;           // ia = 200又把10给覆盖了
		System.out.println("show方法中：ia = " + ia); // 200
	}
	
	public static void main(String[] args) {
		
		// 1.声明ArgumentTest类型的引用指向该类型的对象
		ArgumentTest at = new ArgumentTest();
		
		// 2.使用引用变量调用show1方法进行测试
		int ib = 10;
		at.show1(ib);    // 变量可以传直接量，也可以传变量
		System.out.println("main方法中：ib = " + ib); // ib = 10 
	}
}

• 2.引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间 （引用数据类型是有堆区栈区的）

/*
    编程实现参数传递的测试 
 */
public class ArgumentTest {
	
	// 自定义成员方法打印参数传入的数组内容
	void show2(int[] arr1) {
		arr1[0] = 200;    // ★★arr1先获取了arr2的地址，地址不变的情况下赋值，所以arr2的数值也发生变化了
		System.out.println("show方法中：arr1[0] = " + arr1[0]); // 200
	}
	
	public static void main(String[] args) {
		
		// 1.声明ArgumentTest类型的引用指向该类型的对象
		ArgumentTest at = new ArgumentTest();
		
		// 2.调用show2方法进行测试
		int[] arr2 = new int[]{10, 20};
		at.show2(arr2);      // arr2中里面放的是地址，赋值给了arr1
		System.out.println("main方法中：arr2[0] = " + arr2[0]); // 200
	}
}

• 3.当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间。

/*
    编程实现参数传递的测试 
 */
public class ArgumentTest {
	
	// 自定义成员方法打印参数传入的数组内容
	void show2(int[] arr1) {
		arr1 = new int[2];  // ★★加上该行代码后，相当于在堆区中又重新申请一块内存空间
		arr1[0] = 200;
		System.out.println("show方法中：arr1[0] = " + arr1[0]); // 200
	}
	
	public static void main(String[] args) {
		
		// 1.声明ArgumentTest类型的引用指向该类型的对象
		ArgumentTest at = new ArgumentTest();
		
		// 2.调用show2方法进行测试
		int[] arr2 = new int[]{10, 20};
		at.show2(arr2);      // arr2中里面放的是地址，赋值给了arr1
		System.out.println("main方法中：arr2[0] = " + arr2[0]); // 10
	}
}

内存结构之栈区

• 栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次方法的调用。
• JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。
• 当某一个方法调用完成后，其对应的栈帧将被清除。
  
  

传参的相关概念

• 参数分为形参和实参，定义方法时的参数叫形参，调用方法时传递的参数叫实参。
• 调用方法时采用值传递把实参传递给形参，方法内部其实是在使用形参。
• ★★所谓值传递就是当参数是基本类型时，是传递参数的值，比如传递i=10，真实传参时，把10赋值给了形参。当参数是**对象（引用数据类型）**时，传递的是对象的值，也就是把对象的地址赋值给形参。

本章总结