25_类和面向对象的概念
面向对象编程的概念
- 是JavaSE最重要的
- 万物皆对象-------------先找对象
- 面向对象指以属性（比如身高、体重，又称特征）和行为的观点去分析现实生活中的事物。------------分析行为特征
- 面向对象编程指先以面向对象的思想对对象进行分析，有什么特征、什么行为，分析完然后使用面向对象的编程语言进行表达（翻译）的过程。
- C：面向过程；C++：既面向过程，又面向对象；Java：纯粹面向对象编程语言
- 面向过程：安排第一步干什么，第二步干什么，规定了什么时候干什么，关注的是整个过程
- 面向对象：先看是不是一个对象，再分析特征和行为，不规定什么时候干什么，关注的是对象能否完成任务，具不具备特征行为，能不能干
- 面向对象编程是软件产业化发展的需求。
- 理解面向对象的思想精髓（封装、继承、多态），至少掌握一种编程语言
类和对象的概念
- 对象就是现实生活中客观存在的事物，万物皆对象
- 对象主要指现实生活中客观存在的实体，在Java语言中对象体现为内存空间中的一块存储区域。只要我们创建了一个对象，在Java中本质上就是在堆区中申请了一块存储单元。
- 类简单来说就是"分类"，是对具有相同特征和行为的多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性的成员变量以及描述行为的成员方法。
- 类是用于构建对象的模板，对象的数据结构由定义它的类来决定。
类的定义
-
class 类名 { 类体; } // 所有只要带名的都要遵循之前讲的标识符的命名法则 class Person { } -
注意：
- 通常情况下，当类名由多个单词组成时，要求每个单词首字母都要大写。
成员变量的定义
-
class 类名 { 数据类型 成员变量名 = 初始值; // 本质上还是变量 } class Person { String name; // 声明字符串类型的名字作为Person类的一个特征 } -
注意：
- 当成员变量由多个单词组成时，通常要求从第二个单词起每个单词首字母大写。第一个单词首字母小写。
对象的创建
- new 类名();=>new Person();=>像这种只是创建出来没有名字的对象，我们称之为匿名对象。
- 注意：
- 当一个类定义完毕后，可以使用 new 关键字来创建该类的对象，这个过程叫做类的实例化。
- 创建对象的本质就是在内存空间的堆区申请一块存储区域，用于存放该对象独有特征信息。
引用的定义
-
基本概念
-
使用引用数据类型定义的变量叫做引用型变量，简称为"引用"。
-
引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问。--------------->详情看数组的内存结构分析
-
语法格式：
类名 引用变量名; 引用变量名.成员变量名; 只要带名的都要遵循标识符的命名法则 Person p = new Person(); p.name = "张飞"; System.out.println(p.name);
-
案例：编程实现Person类的定义和使用
/*
编程实现Person类的定义
main 方法是整个程序的入口,大门
*/
public class Person {
// 特征：成员变量，语法格式：数据类型 成员变量名 = 初始值; - 其中 = 初始值 通常都省略不写，局部变量不省略
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 行为：成员方法
public static void main(String[] args) {
// 1、声明 Person 类型的引用指向Person类型的对象
// 创建类的实体（对象）------------类的实例化
Person p = new Person(); // 数据类型（类名） 引用变量名 = new 类名(); 声明什么样的引用，指向什么样的对象
// 2、打印对象中的成员变量值
// 引用变量名.成员变量名
System.out.println("name: " + p.name + ", age: " + p.age); // name : null , age : 0
System.out.println("-------------------------------------------------");
// 3、修改成员变量的数值
p.name = "西凉锦马超";
p.age = 30;
// 4、再次打印修改后的数值
System.out.println("name: " + p.name + ", age: " + p.age); // name : 西凉锦马超 , age : 30
}
}
成员变量的初始值
Person类代码的执行流程和内存分析
执行时底层内存结构过程（Person类的执行流程和内存分析）：
-
Person.java写完之后在计算机的硬盘保存（保存后的数据都在硬盘中存放），CPU不能直接访问硬盘中的数据，要想访问得先加载到内存中才能访问。这段代码要想让Java虚拟机解析执行，还要将其加载（读）到内存中。
-
代码写完之后得javac先编译生成一个.class字节码文件。但只要是文件就在硬盘上，java Person的时候就是启动Java虚拟机对Person这段代码解释和执行。当在 cmd java Person 回车的时候才会把这段代码加载到内存中，然后让CPU解析和执行。
-
-
当这段代码一旦回车加载到内存中的时候，这段代码就会被放到一个叫方法区的地方。无论是栈区、堆区、方法区都只是我们人为命名的一个名字而已，不要想得太复杂。加载到方法区中的严格来说是字节码文件，这里写成源码是为了看起来更清晰一些。
-
加载进方法区中就该开始运行了，main方法是程序的入口，所以首先要找main方法，一旦找main方法的时候，就要在栈区中给main方法这个方法申请一块地盘（蓝色方框）。因为在一个方法中我们可能会声明很多局部变量，而局部变量都在栈区，且局部变量都隶属于这个方法，所以要为这个方法开辟一块栈区内存空间。
-
执行Person p 本质上就是在栈区分配给main方法的这块内存空间中划分出来一个小格子、一小块给它，接下来执行 = 右边的 new Person()，之前讲的只要是new的无论是对象还是数组都会在堆区中申请一块内存空间。因为Person类中有两个特征：name 和 age。所以创建出来对象也会包含两部分内容：name 和 age。new 对象的时候并没有给这个对象的成员变量给初始值，所以它里面存放的是默认值------------null 和 0（上方绿色区域）。
-
= 的作用是赋值，相当于是把 = 右边的值赋给 = 左边。而 = 右边实际上是一块堆区空间，也就是把堆区空间所在的内存地址，此处是0x10赋值到Person p 的这块小格子里边，于是Person p 的小格子里边这块地址指向的就是这块堆区空间（红色箭头）。
-
建立了关联之后紧接着做的事情就是打印，p.name p.age 就是根据 变量 p 里边记录的内存地址找到堆区空间，然后在堆区空间中再去找 name -------> null 和 age--------> 0，然后再把 null 和 0 打印出来。紧接着又通过 p.name 和 p.age 给了个 zhangfei 和 30，就相当于把 zhangfei 这个字符串放到了 p.name 这个小格子里边，相当于这个效果，暂时不做详细区分。给 p.age 赋值 30，相当于把拿着 30 把 p.age 的0给覆盖了。也就是拿着 zhangfei 过来把 null 给覆盖掉了，拿着 30 过来把 0 覆盖掉了，此处我们保留原始数据让大家看得更清晰，只是用 红色字体 把它凸显出来了。然后打印的是现在 p 指向的堆区空间的 name 和 age，此时已经变成了 zhangfei 和 30。
案例
-
编程实现 Point 类的定义，特征有：横纵坐标（整数），要求在 main 方法中声明 Point 类型的引用指向 Point 对象并打印特征，然后将横纵坐标修改为 3 和 5 再次打印
/* 编程实现Point类的定义 */ public class Point { int xPoint; // 用于描述横轴坐标的成员变量 int yPoint; // 用于描述纵轴坐标的成员变量 public static void main(String[] args) { // 1、 声明 Point 类型的引用指向 Point 对象并打印特征 Point p = new Point(); // 打印成员变量的数值 System.out.println("横坐标是：" + p.xPoint + ", 轴坐标是：" + p.yPoint); System.out.println("--------------------------------------------------------"); // 2、将横纵坐标修改为 3 和 5 再次打印 p.xPoint = 3; p.yPoint = 5; System.out.println("横坐标是：" + p.xPoint + ", 轴坐标是：" + p.yPoint); } }
成员方法的定义
-
对这一类行为的描述，
-
语法格式：
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 即可
- 若该方法不需要带入任何数据内容时，则形参列表位置啥也不写即可。
方法体的详解
- 成员方法体主要用于编写描述该方法功能的语句块。
- 成员方法可以实现代码的重用，简化代码。实现同一段代码只要写一遍却可以多次使用的效果。
Person 类中无参无返回值成员方法的定义
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 成员方法名(形参列表) { 方法体; }
// 成员方法的目的：实现代码的重用，简化代码。实现同一段代码只要写一遍却可以多次使用的效果。
void show() {
// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用 . 的前缀
System.out.println("name: " + name + ", age: " + age);
}
方法的调用
- 语法规则：引用变量名.成员方法名(实参列表);----------------->p.show()
- 实际参数列表主要用于对形式参数列表进行初始化操作，因此参数的个数、类型以及顺序都要完全一致。
- 实际参数可以传递直接量、变量、表达式、方法的调用等。
Person 类中无参无返回值成员方法的调用
/*
编程实现Person类的定义
main 方法是整个程序的入口,大门
*/
public class Person {
// 特征：成员变量，语法格式：数据类型 成员变量名 = 初始值; - 其中 = 初始值 通常都省略不写，局部变量不省略
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 行为：成员方法 方法与方法之间不可以嵌套，方法不能写方法内部
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 成员方法名(形参列表) { 方法体; }
void show() {
// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用 . 的前缀
System.out.println("name: " + name + ", age: " + age);
}
public static void main(String[] args) {
// 1、声明 Person 类型的引用指向Person类型的对象
// 创建类的实体（对象）------------类的实例化
Person p = new Person(); // 数据类型（类名） 引用变量名 = new 类名(); 声明什么样的引用，指向什么样的对象
// 2、打印对象中的成员变量值
// 引用变量名.成员变量名
// System.out.println("name: " + p.name + ", age: " + p.age); // name : null , age : 0
// 引用变量名.成员方法名(实参列表);
// 调用方法的本质就是根据方法名跳转过去，执行方法体后再跳转回这个位置
p.show();
System.out.println("-------------------------------------------------");
// 3、修改成员变量的数值
p.name = "西凉锦马超";
p.age = 30;
// 4、再次打印修改后的数值
// System.out.println("name: " + p.name + ", age: " + p.age); // name : 西凉锦马超 , age : 30
p.show(); // 代码复用
}
}
Point 类中无参无返回值成员方法的定义
/*
编程实现Point类的定义
*/
public class Point {
int xPoint; // 用于描述横轴坐标的成员变量
int yPoint; // 用于描述纵轴坐标的成员变量
// 自定义成员方法实现成员变量数值的打印,需求中如果有返回值要求，就说明该方法有返回值，否则没有返回值;需求中如果有参数要求，就说明该方法有参数，否则没有参数
void show() {
System.out.println("横坐标是：" + xPoint + ", 轴坐标是：" + yPoint);
}
public static void main(String[] args) {
// 1、 声明 Point 类型的引用指向 Point 对象并打印特征
Point p = new Point();
// 打印成员变量的数值
// System.out.println("横坐标是：" + p.xPoint + ", 轴坐标是：" + p.yPoint);
p.show();
System.out.println("--------------------------------------------------------");
// 2、将横纵坐标修改为 3 和 5 再次打印
p.xPoint = 3;
p.yPoint = 5;
// System.out.println("横坐标是：" + p.xPoint + ", 轴坐标是：" + p.yPoint);
p.show();
}
}
Person 类中有参无返回值成员方法使用
// 需求：自定义成员方法实现将姓名修改为参数指定数值的行为
// 相当于 String s = "东方耀";
void setName(String s) {
name = s; // s 的值暂时不知道，形参的值取决于实参传入的值
}
// 需求：自定义成员方法实现将年龄修改为参数指定数值的行为
void setAge(int i) {
age = i;
}
// main 方法中
System.out.println("-------------------------------------------------");
// 5、通过成员方法的调用来实现成员变量的修改
p.setName("东方耀"); // 实参是给形参赋值的
p.setAge(18);
p.show(); // name: 东方耀, age: 18
Person 类中多个形参成员方法的使用
// 自定义成员方法实现姓名和年龄修改为参数指定数值的行为 下面的方法不推荐使用 上面方法推荐使用，想改什么就改什么===> 降低了功能之间的耦合性
// 此处只是为了告诉我们可以传多个形参，当然，传多个形参就得传多个实参
// 不推荐使用的根本原因：一旦改姓名，就得改年；一旦改年龄，就得改姓名
// 局部变量的特点：从声明开始，一直到右花括号结束，出了右花括号了就不好使了
void setNameAge(String s, int i) {
name = s;
age = i;
}
// 6、通过成员方法同时修改姓名和年龄
// p.setNameAge("孙悟空", 99999);
int ia = 99999;
p.setNameAge("孙" + "悟空", ia); // 表达式，变量，直接量
p.show(); // 孙悟空 99999
Point 类中有参无返回值成员方法的使用
// 自定义成员方法实现将横坐标修改为参数指定数值的行为
void setXPoint(int x) {
xPoint = x;
}
// 自定义成员方法实现将纵坐标修改为参数指定数值的行为
void setYPoint(int y) {
yPoint = y;
}
// 3、通过成员方法的调用来实现横纵坐标的修改
p.setXPoint(20);
p.setYPoint(15);
p.show(); // 20 15
可变长参数
- 语法规则：返回值类型 方法名(参数的类型 … 参数名) // … 相当于汉语中的省略号意思是这里的参数个数有很多（不确定），我们使用 … 来省略，所以称为可变长参数
- 方法参数部分指定类型的参数个数是可以改变的，也就是 0 ~ n个。在表示我们在使用可变长参数的方法的时候可以不传，也可以传无数个。
- 一个方法的形参列表中最多只能声明一个可变长形参，并且需要放在参数列表的末尾。
- 如果有这样两个方法void abc(int i, int j, int k); void abc(int … args);如果在main方法中调用：abc(1, 2, 3);它会先在方法区中找看有无对应参数的方法，如有先调用其，此处调用的就是abc(int i, int j, int k); 如果没有找到才调用可变参数的方法。
Person类中可变长参数的使用
// 自定义成员方法实现可变长参数的使用 看作一维数组使用即可
// 类型相同的多个数据内容叫做一维数组
void showArgument(int num, String ... args) {
System.out.println("num = " + num);
for(int i = 0; i < args.length; i ++) {
System.out.println("第" + (i + 1) + "个参数为：" + args[i]);
}
}
System.out.println("-------------------------------------------------");
// 7、通过成员方法实现可变长参数的打印
// 当我们在开发中，不确定实参的个数时，或者说，希望实参的个数0 ~ n 的时候，就可以使用可变长参数
p.showArgument(0); // 此时num 代表参数个数
System.out.println("-------------------------------------------------");
p.showArgument(1, "参数1");
System.out.println("-------------------------------------------------");
p.showArgument(2, "canshu1", "canshu2"); // 多个参数之间使用 , 隔开
Point类中可变长参数的使用
// 可变长参数除了是String类型，还可以是基本数据类型
// 自定义成员方法实现 int 类型的可变长参数的使用
// 方法跟方法之间一定都是平行关系
// void showArgument(int ... args, int num) { // 错误: varargs(var 变量) 参数必须是最后一个参数
void showArgument(int ... args) {
// length 是数组的属性
for(int i = 0; i < args.length; i ++) {
System.out.println("下标为" + i + "的元素是：" + args[i]);
}
}
// 4、通过成员方法实现可变长参数的使用
p.showArgument(1, 2, 3, 4, 5);
执行结果：
--------------------------------------------------------
下标为0的元素是：1
下标为1的元素是：2
下标为2的元素是：3
下标为3的元素是：4
下标为4的元素是：5
成员变量和局部变量的区别：
- 成员变量都是写在类体的类中，方法体的外部，不属于任何方法体。
- 局部变量，要么在小括号中，要么在大括号中。局部变量是隶属于写在方法体内部的。
- 二者第一个区别在于声明的位置不同。
- 局部变量的作用域，作用范围是从声明开始一直到方法结束。而成员变量是在类体中声明，它的作用域、作用范围是从声明开始，一直到整个类结束。二者第二个区别是作用范围不同。
- 区别二者：只要关注它到底是在类体中声明的还是在方法体中声明的即可。
Person类中无参有返回值方法的使用
// 自定义成员方法实现姓名数值的获取并返回的行为
String getName() {
return name; // 返回数据并结束当前方法
// ... return 后面还有代码，这些代码是执行不到的。
}
// 自定义成员方法实现年龄数值的获取并返回的行为
int getAge() {
return age;
}
// 8、通过成员方法的调用实现成员变量数值的获取并打印
// 返回值需要定义一个与返回值类型相同的变量接收
String str = p.getName(); // 调用方法的本质就是根据方法名跳转过去执行，getName方法没有形式参数，意味着我们调用的时候不需要给实际参数
int i = p.getAge();
System.out.println("我的姓名是：" + str); // 孙悟空
System.out.println("我的年龄是：" + i); // 99999
运行结果：
-------------------------------------------------
我的姓名是：孙悟空
我的年龄是：99999
Point类中无参有返回值方法的使用
// 自定义成员方法实现获取横坐标并返回的行为
int getXPoint() {
return xPoint;
}
// 自定义成员方法实现获取纵坐标并返回的行为
int getYPoint() {
return yPoint;
}
// 5、通过成员方法调用实现横纵坐标的获取
int x = p.getXPoint(); // 就是跳过去拿到返回值放到局部变量的内存空间中
System.out.println("获取到的横坐标是：" + x); // 20
int y = p.getYPoint();
System.out.println("获取到的纵坐标是：" + y); // 15
执行结果：
--------------------------------------------------------
获取到的横坐标是：20
获取到的纵坐标是：15
方法的传参过程
- int max(int ia, int ib) {… … } int a = 5; int b = 6; int res = m.max(a, b);--------------------> 既有返回值又有参数的方法
-
为main方法中的变量 a、b、res 分配内存空间并初始化。
-
调用max方法，为max方法的形参变量ia、ib分配空间。--------->为max方法在栈区中分配一块空间
-
将实参变量的数值赋值到形参变量的内存空间中。
-
max方法执行完毕后返回，形参变量空间释放。
-
main方法中的res变量得到max方法的返回值。
-
main方法结束后释放相关变量的内存空间。
-
参数传递的注意事项
-
基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；相当于我这里有一本高等数学的复习资料，你找我借，我把这个复习资料复印了一份给你，你把你的复习资料随便怎么搞，甚至是撕了，跟我的都没有关系，因为我只是复制了一份给了你，你对你的资料怎么操作，对我的都没有影响。------------------------->形参的改变不会影响到实参，除非是基本数据类型。
/* 编程实现参数传递的测试------------这个很重要 无论是在笔试、面试，自己写代码的时候也是很容易犯的错误 */ public class ArgumentTest { // 自定义成员方法打印参数传入的整数数据 void show1(int ia) { ia = 200; System.out.println("show1 方法中：ia = " + ia); // show1 方法中：ia = 200 } public static void main(String[] args) { // 1、声明一个ArgumentTest类型的引用指向该类型的变量 ArgumentTest at = new ArgumentTest(); // 2、使用引用变量调用show方法进行测试 int ib = 10; at.show1(ib); System.out.println("main 方法中： ib = " + ib); // main 方法中： ib = 10 } }
-
引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间。arr2 在内存空间中的值是一个内存地址，arr2给 arr1赋值的时候，实际上赋给的是内存地址，所以两个变量同时指向了堆区空间中的一块存储空间。这就好比我有一本复习资料在桌子上，你来找我借，我直接把我复习资料的地址告诉你了，你根据我给的地址在我的桌子上找到了我的复习资料，然后你把它撕了，我回来一看我的复习资料被撕了。
// 自定义成员方法打印参数传入的数组内容 void show2(int[] arr1) { arr1[0] = 200; System.out.println("show2方法中：arr1[0] = " + arr1[0]); // show2方法中：arr1[0] = 200 } main 方法中------------------- // 3、调用show2方法进行测试 int[] arr2 = new int[]{10, 20}; at.show2(arr2); System.out.println("main 方法中： arr2[0] = " + arr2[0]); // main 方法中： arr2[0] = 200
-
引用数据类型的数值能影响到实参，基本数据类型的数值无法影响到实参 。 实际在于：引用数据类型存放的是地址，指向同一块堆区内存空间之后，指向同一块，当然改变了。而基本数据类型没有改变是因为：基本数据类型里面放的直接是值，并不是地址。所以，一定要注意这个坑。
-
当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间。就好比我有一本高等数学复习资料，你来找我借，我告诉了你我的复习资料的地址，你去我给的地址去找，然后你一抬头你发现远方还有一本复习资料，你便奔着那本复习资料去了，然后你在那本复习资料上乱写乱画对我的复习资料没有丝毫影响。
// 自定义成员方法打印参数传入的数组内容 void show2(int[] arr1) { arr1 = new int[2]; // 加上该行代码后，当于在堆区中又重新申请一块内存空间。arr1又指向了新的内存空间。 arr1[0] = 200; System.out.println("show2方法中：arr1[0] = " + arr1[0]); // show2方法中：arr1[0] = 200 } mian方法中------------------ int[] arr2 = new int[]{10, 20}; at.show2(arr2); System.out.println("main 方法中： arr2[0] = " + arr2[0]); // main 方法中： arr2[0] = 10
内存结构之栈区
- 栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次方法的调用。
- JVM为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。
- 当某一个方法调用完成后，其对应的栈帧将被清除。
传参的相关概念
- 参数分为形参和实参，定义方法时的参数叫形参。调用方法时传递的参数叫实参。
- 调用方法时采用值传递把实参传递给形参，方法的内部其实是在使用形参。
- 所谓值传递就是当参数是基本类型时，传递参数的值，比如传递 i = 10，真实传参时，把 10 赋值给了形参。当参数是对象时，传递的是对象的值，也就是把对象的地址赋值给形参。
总结
1、面向对象编程的概念（理解）
- 对象、面向对象（根据特征、行为去分析现实世界中事物的方式）、面向对象编程（先分析清楚了之后再根据面向对象的编程语言(Java)进行翻译）、面向对象实际上就是把任务派个对象，面向过程就是我们关注这个过程，去执行整个过程的流程。
2、类和对象以及引用（重中之重）
- 类和对象、类的定义、成员变量的定义、对象的创建（类的实例化）、引用的定义等
3、成员方法（重中之重）
- 语法格式、详解、调用格式、传参的过程等
Person 类全部代码
/*
编程实现Person类的定义
main 方法是整个程序的入口,大门
*/
public class Person {
// 特征：成员变量，语法格式：数据类型 成员变量名 = 初始值; - 其中 = 初始值 通常都省略不写，局部变量不省略
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 行为：成员方法 方法与方法之间不可以嵌套，方法不能写方法内部
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 成员方法名(形参列表) { 方法体; }
void show() {
// 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用 . 的前缀
System.out.println("name: " + name + ", age: " + age);
}
// 需求：自定义成员方法实现将姓名修改为参数指定数值的行为
// 相当于 String s = "东方耀";
void setName(String s) {
name = s; // s 的值暂时不知道，形参的值取决于实参传入的值
}
// 需求：自定义成员方法实现将年龄修改为参数指定数值的行为
void setAge(int i) {
age = i;
}
// 自定义成员方法实现姓名和年龄修改为参数指定数值的行为 下面的方法不推荐使用 上面方法推荐使用，想改什么就改什么===> 降低了功能之间的耦合性
// 此处只是为了告诉我们可以传多个形参，当然，传多个形参就得传多个实参
// 不推荐使用的根本原因：一旦改姓名，就得改年；一旦改年龄，就得改姓名
// 局部变量的特点：从声明开始，一直到右花括号结束，出了右花括号了就不好使了
void setNameAge(String s, int i) {
name = s;
age = i;
}
// 自定义成员方法实现可变长参数的使用 看作一维数组使用即可
// 类型相同的多个数据内容叫做一维数组
void showArgument(int num, String ... args) {
System.out.println("num = " + num);
for(int i = 0; i < args.length; i ++) {
System.out.println("第" + (i + 1) + "个参数为：" + args[i]);
}
}
// 自定义成员方法实现姓名数值的获取并返回的行为
String getName() {
return name; // 返回数据并结束当前方法
// ... return 后面还有代码，这些代码是执行不到的。
}
// 自定义成员方法实现年龄数值的获取并返回的行为
int getAge() {
return age;
}
public static void main(String[] args) {
// 1、声明 Person 类型的引用指向Person类型的对象
// 创建类的实体（对象）------------类的实例化
Person p = new Person(); // 数据类型（类名） 引用变量名 = new 类名(); 声明什么样的引用，指向什么样的对象
// 2、打印对象中的成员变量值
// 引用变量名.成员变量名
// System.out.println("name: " + p.name + ", age: " + p.age); // name : null , age : 0
// 引用变量名.成员方法名(实参列表);
// 调用方法的本质就是根据方法名跳转过去，执行方法体后再跳转回这个位置
p.show();
System.out.println("-------------------------------------------------");
// 3、修改成员变量的数值
p.name = "西凉锦马超";
p.age = 30;
// 4、再次打印修改后的数值
// System.out.println("name: " + p.name + ", age: " + p.age); // name : 西凉锦马超 , age : 30
p.show(); // 代码复用
System.out.println("-------------------------------------------------");
// 5、通过成员方法的调用来实现成员变量的修改
p.setName("东方耀"); // 实参是给形参赋值的
p.setAge(18);
p.show(); // name: 东方耀, age: 18
System.out.println("-------------------------------------------------");
// 6、通过成员方法同时修改姓名和年龄
// p.setNameAge("孙悟空", 99999);
int ia = 99999;
p.setNameAge("孙" + "悟空", ia); // 表达式，变量，直接量
p.show(); // 孙悟空 99999
System.out.println("-------------------------------------------------");
// 7、通过成员方法实现可变长参数的打印
// 当我们在开发中，不确定实参的个数时，或者说，希望实参的个数0 ~ n 的时候，就可以使用可变长参数
p.showArgument(0); // 此时num 代表参数个数
System.out.println("-------------------------------------------------");
p.showArgument(1, "参数1");
System.out.println("-------------------------------------------------");
p.showArgument(2, "canshu1", "canshu2"); // 多个参数之间使用 , 隔开
System.out.println("-------------------------------------------------");
// 8、通过成员方法的调用实现成员变量数值的获取并打印
String str = p.getName(); // 调用方法的本质就是根据方法名跳转过去执行，getName方法没有形式参数，意味着我们调用的时候不需要给实际参数
int i = p.getAge();
System.out.println("我的姓名是：" + str); // 孙悟空
System.out.println("我的年龄是：" + i); // 99999
}
}
Point类全部代码
/*
编程实现Point类的定义
*/
public class Point {
int xPoint; // 用于描述横轴坐标的成员变量
int yPoint; // 用于描述纵轴坐标的成员变量
// 自定义成员方法实现成员变量数值的打印,需求中如果有返回值要求，就说明该方法有返回值，否则没有返回值;需求中如果有参数要求，就说明该方法有参数，否则没有参数
void show() {
System.out.println("横坐标是：" + xPoint + ", 轴坐标是：" + yPoint);
}
// 自定义成员方法实现将横坐标修改为参数指定数值的行为
void setXPoint(int x) {
xPoint = x;
}
// 自定义成员方法实现将纵坐标修改为参数指定数值的行为
void setYPoint(int y) {
yPoint = y;
}
// 可变长参数除了是String类型，还可以是基本数据类型
// 自定义成员方法实现 int 类型的可变长参数的使用
// 方法跟方法之间一定都是平行关系
// void showArgument(int ... args, int num) { // 错误: varargs(var 变量) 参数必须是最后一个参数
void showArgument(int ... args) {
// length 是数组的属性
for(int i = 0; i < args.length; i ++) {
System.out.println("下标为" + i + "的元素是：" + args[i]);
}
}
// 自定义成员方法实现获取横坐标并返回的行为
int getXPoint() {
return xPoint;
}
// 自定义成员方法实现获取纵坐标并返回的行为
int getYPoint() {
return yPoint;
}
public static void main(String[] args) {
// 1、 声明 Point 类型的引用指向 Point 对象并打印特征
Point p = new Point();
// 打印成员变量的数值
// System.out.println("横坐标是：" + p.xPoint + ", 轴坐标是：" + p.yPoint);
p.show();
System.out.println("--------------------------------------------------------");
// 2、将横纵坐标修改为 3 和 5 再次打印
p.xPoint = 3;
p.yPoint = 5;
// System.out.println("横坐标是：" + p.xPoint + ", 轴坐标是：" + p.yPoint);
p.show();
System.out.println("--------------------------------------------------------");
// 3、通过成员方法的调用来实现横纵坐标的修改
p.setXPoint(20);
p.setYPoint(15);
p.show(); // 20 15
System.out.println("--------------------------------------------------------");
// 4、通过成员方法实现可变长参数的使用
p.showArgument(1, 2, 3, 4, 5);
System.out.println("--------------------------------------------------------");
// 5、通过成员方法调用实现横纵坐标的获取
int x = p.getXPoint(); // 就是跳过去拿到返回值放到局部变量的内存空间中
System.out.println("获取到的横坐标是：" + x); // 20
int y = p.getYPoint();
System.out.println("获取到的纵坐标是：" + y); // 15
}
}
ArgumentTest全部源码
/*
编程实现参数传递的测试------------这个很重要
无论是在笔试、面试，自己写代码的时候也是很容易犯的错误
*/
public class ArgumentTest {
// 自定义成员方法打印参数传入的整数数据
void show1(int ia) {
ia = 200;
System.out.println("show1 方法中：ia = " + ia); // show1 方法中：ia = 200
}
// 自定义成员方法打印参数传入的数组内容
void show2(int[] arr1) {
arr1 = new int[2]; // 加上该行代码后，当于在堆区中又重新申请一块内存空间。arr1又指向了新的内存空间。
arr1[0] = 200;
System.out.println("show2方法中：arr1[0] = " + arr1[0]); // show2方法中：arr1[0] = 200
}
public static void main(String[] args) {
// 1、声明一个ArgumentTest类型的引用指向该类型的变量
ArgumentTest at = new ArgumentTest();
// 2、使用引用变量调用show方法进行测试
int ib = 10;
at.show1(ib);
System.out.println("main 方法中： ib = " + ib); // main 方法中： ib = 10
System.out.println("-----------------------------------------------------");
// 3、调用show2方法进行测试
int[] arr2 = new int[]{10, 20};
at.show2(arr2);
System.out.println("main 方法中： arr2[0] = " + arr2[0]); // main 方法中： arr2[0] = 200 10
}
}
3318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
