任务一:类和对象
面向对象编程的概念(理解)
以面向对象的思想进行分析,然后使用面向对象的编程语言进行表达。
类和对象以及引用(重中之重)
类和对象的概念
- 类:抽象的,Java中表现为引用数据类型,包含成员变量和成员方法。
- 对象:现实生活中客观存在的实体,在Java中体现为一块存储区域(堆区)。
类的定义
class 类名 {
类体;
}
// 通常情况下,当类名由多个单词组成时,要求每个单词首字母都要大写。(编程规范)
成员变量的定义
class 类名 {
数据类型 成员变量名 = 初始值;
}
// 当成员变量由多个单词组成时,通常要求从第二个单词起每个单词的首字母大写。(编程规范)
成员变量的初始值
对象创建后,其成员变量可以按照默认的方式初始化,具体规则如下:
成员变量的类型 | 默认初始值 |
---|---|
数值类型:byte、short、int、long、float、double、char | 0 |
boolean型 | false |
引用类型 | null |
对象的创建
new 类名();
-
当一个类定义完毕后,可以使用new关键字来创建该类的对象,这个过程叫做类的实例化。
-
创建对象的本质时在内存空间中的堆区申请一块存储区域,用于存放该对象独有的特征信息。
引用的定义
-
基本概念
- 使用引用数据类型定义的变量叫做引用型变量,简称为“引用”;
- 引用变量主要用于记录在堆区中的内存地址信息,便于下次访问。
-
语法格式
类名 引用变量名; 引用变量名.成员变量名;
案例题目——Person类的定义
编程实现Person类的定义与使用
/*
编程实现Person类的定义
*/
public class Person {
// 数据类型 成员变量名 = 初始值; 其中 =初始值 通常都省略不写
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
public static void main(String[] args) {
// 1.申明Person类型的引用指向Person类型的对象
// 数据类型(类名) 引用变量名 = new 类名();
Person p = new Person();
// 2.打印对象中的成员变量值
// 引用变量名.成员变量名
System.out.println("我是" + p.name + ",今年" + p.age + "岁了");
System.out.println("--------------------------------");
// 3.修改成员变量的数值
p.name = "张飞";
p.age = 30;
// 4.再次打印修改后的数值
System.out.println("我是" + p.name + ",今年" + p.age + "岁了");
}
}
案例题目——Point类的定义
编程实现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);
System.out.println("----------------------------");
// 2.将横纵坐标修改为3和5后再次打印
p.x = 3;
p.y = 5;
System.out.println("横坐标是:" + p.x + "纵坐标是:" + p.y);
}
}
成员方法(重中之重)
成员方法的定义
class 类名 {
返回值类型 成员方法名(形参列表) {
成员方法体;
}
}
// 当成员方法名由多个单词组成时,要求从第二个单词起每个单词的首字母大写。(编程规范)
返回值类型的详解
- 返回值类型主要指返回值的数据类型,可以是基本数据类型,也可以是引用数据类型;
- 在方法体中使用return关键字可以返回具体的数据内容并结束当前方法;
- 当该方法体不需要返回任何数据内容时,则返回值类型写void即可。
形参列表的详解
-
形式参数主要用于将方法体外的数据内容带入到方法体内部;
-
形式参数列表主要指多个形式参数组成的列表,语法格式如下:
数据类型 形参变量名1, 数据类型 形参变量名2, ...
-
若该方法不需要带入任何数据内容时,则形参列表位置不写即可。
方法体的详解
- 成员方法体主要用于编写描述该方法功能的语句块;
- 成员方法可以实现代码的重用,简化代码
方法的调用
-
引用变量名.成员方法名(实参列表);
-
实际参数列表主要用于对形式参数列表进行初始化操作,因此参数的个数,类型以及顺序都要完全一致;
-
实际参数可以传递直接量、变量、表达式、方法的调用等。
可变长参数
-
返回值类型 方法名(参数的类型... 参数名)
-
方法参数部分指定类型的参数个数是可以改变的,也就是0~n个
-
一个方法的形参列表中最多只能申明一个可变长形参,并且需要放到参数列表的末尾
案例题目——Person类中无参无返回值成员方法的使用
/*
编程实现Person类的定义
*/
public class Person {
// 数据类型 成员变量名 = 初始值; 其中 =初始值 通常都省略不写
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 方法名称(形参列表) { 方法体; }
void show() {
// 成员变量和成员方法都属于类内部的成员,因此可以直接访问成员变量不需要再加引用.的前缀
System.out.println("我是" + name + ",今年" + age + "岁了");
}
public static void main(String[] args) {
// 1.申明Person类型的引用指向Person类型的对象
// 数据类型(类名) 引用变量名 = new 类名();
Person p = new Person();
// 2.打印对象中的成员变量值
// 引用变量名.成员方法名(实参列表);
// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
p.show();
System.out.println("--------------------------------");
// 3.修改成员变量的数值
p.name = "张飞";
p.age = 30;
// 4.再次打印修改后的数值
p.show();
}
}
案例题目——Point类中无参无返回值成员方法的使用
/*
编程实现Point类的定义
*/
public class Point {
int x; // 用于描述横坐标的成员变量
int y; // 用于描述纵坐标的成员变量
// 自定义成员方法实现成员变量数值的打印
void show() {
System.out.println("横坐标是:" + x + "纵坐标是:" + y);
}
public static void main(String[] args) {
// 1.申明Point类型的引用指向Point类型的对象
Point p = new Point();
// 打印成员变量的数值
p.show();
System.out.println("----------------------------");
// 2.将横纵坐标修改为3和5后再次打印
p.x = 3;
p.y = 5;
p.show();
}
}
案例题目——Person类中有参无返回值成员方法的使用
/*
编程实现Person类的定义
*/
public class Person {
// 数据类型 成员变量名 = 初始值; 其中 =初始值 通常都省略不写
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 方法名称(形参列表) { 方法体; }
void show() {
// 成员变量和成员方法都属于类内部的成员,因此可以直接访问成员变量不需要再加引用.的前缀
System.out.println("我是" + name + ",今年" + age + "岁了");
}
// 自定义成员方法将姓名修改为参数指定数值的行为
void setName(String s) {
name = s;
}
// 自定义成员方法将年龄修改为参数指定数值的行为
void setAge(int i) {
age = i;
}
// 自定义成员方法实现将姓名和年龄修改为参数指定数值的行为,下面的方法不推荐使用
void setNameAge(String s, int i) {
name = s;
age = i;
}
public static void main(String[] args) {
// 1.申明Person类型的引用指向Person类型的对象
// 数据类型(类名) 引用变量名 = new 类名();
Person p = new Person();
// 2.打印对象中的成员变量值
// 引用变量名.成员方法名(实参列表);
// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
p.show();
System.out.println("--------------------------------");
// 3.修改成员变量的数值
p.name = "张飞";
p.age = 30;
// 4.再次打印修改后的数值
p.show();
System.out.println("--------------------------------");
// 5.通过成员方法的调用来实现成员变量的修改
p.setName("guanyu");
p.setAge(35);
p.show();
System.out.println("--------------------------------");
// 6.通过成员方法的调用来同时修改姓名和年龄
p.setNameAge("liubei",40);
p.show();
}
}
案例题目——Point类中有参无返回值成员方法的使用
/*
编程实现Point类的定义
*/
public class Point {
int x; // 用于描述横坐标的成员变量
int y; // 用于描述纵坐标的成员变量
// 自定义成员方法实现成员变量数值的打印
void show() {
System.out.println("横坐标是:" + x + ",纵坐标是:" + y);
}
// 自定义成员方法将横坐标修改为指定数值的行为
void setX(int i) {
x = i;
}
// 自定义成员方法将纵坐标修改为指定数值的行为
void setY(int j) {
y = j;
}
public static void main(String[] args) {
// 1.申明Point类型的引用指向Point类型的对象
Point p = new Point();
// 打印成员变量的数值
p.show();
System.out.println("----------------------------");
// 2.将横纵坐标修改为3和5后再次打印
p.x = 3;
p.y = 5;
p.show();
System.out.println("----------------------------");
// 3.通过调用成员方法实现横纵坐标的修改
p.setX(10);
p.setY(20);
p.show();
}
}
案例题目——Person类中可变长参数的使用
/*
编程实现Person类的定义
*/
public class Person {
// 数据类型 成员变量名 = 初始值; 其中 =初始值 通常都省略不写
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 方法名称(形参列表) { 方法体; }
void show() {
// 成员变量和成员方法都属于类内部的成员,因此可以直接访问成员变量不需要再加引用.的前缀
System.out.println("我是" + name + ",今年" + age + "岁了");
}
// 自定义成员方法将姓名修改为参数指定数值的行为
void setName(String s) {
name = 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]);
}
}
public static void main(String[] args) {
// 1.申明Person类型的引用指向Person类型的对象
// 数据类型(类名) 引用变量名 = new 类名();
Person p = new Person();
// 2.打印对象中的成员变量值
// 引用变量名.成员方法名(实参列表);
// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
p.show();
System.out.println("--------------------------------");
// 3.修改成员变量的数值
p.name = "张飞";
p.age = 30;
// 4.再次打印修改后的数值
p.show();
System.out.println("--------------------------------");
// 5.通过成员方法的调用来实现成员变量的修改
p.setName("guanyu");
p.setAge(35);
p.show();
System.out.println("--------------------------------");
// 6.通过成员方法的调用来同时修改姓名和年龄
p.setNameAge("liubei",40);
p.show();
System.out.println("--------------------------------");
// 7.通过成员方法的调用实现可变长参数的打印
p.showArgument(0);
System.out.println("++++++++++++++++++++++++++++++++");
p.showArgument(1, "参数1");
System.out.println("++++++++++++++++++++++++++++++++");
p.showArgument(2, "参数1", "参数2");
}
}
案例题目——Point类中可变长参数的使用
/*
编程实现Point类的定义
*/
public class Point {
int x; // 用于描述横坐标的成员变量
int y; // 用于描述纵坐标的成员变量
// 自定义成员方法实现成员变量数值的打印
void show() {
System.out.println("横坐标是:" + x + ",纵坐标是:" + y);
}
// 自定义成员方法将横坐标修改为指定数值的行为
void setX(int i) {
x = i;
}
// 自定义成员方法将纵坐标修改为指定数值的行为
void setY(int j) {
y = j;
}
// 自定义成员方法实现int类型的可变长参数使用
void showArgument(int... args) {
for(int i = 0; i < args.length; i++) {
System.out.println("下标为" + i + "的元素是:" + args[i]);
}
}
public static void main(String[] args) {
// 1.申明Point类型的引用指向Point类型的对象
Point p = new Point();
// 打印成员变量的数值
p.show();
System.out.println("----------------------------");
// 2.将横纵坐标修改为3和5后再次打印
p.x = 3;
p.y = 5;
p.show();
System.out.println("----------------------------");
// 3.通过调用成员方法实现横纵坐标的修改
p.setX(10);
p.setY(20);
p.show();
System.out.println("----------------------------");
// 4.通过成员方法的调用实现可变长参数的使用
p.showArgument(1,2,3,4,5);
}
}
案例题目——Person类中无参有返回值方法的使用
/*
编程实现Person类的定义
*/
public class Person {
// 数据类型 成员变量名 = 初始值; 其中 =初始值 通常都省略不写
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 自定义成员方法实现所有成员变量的打印
// 返回值类型 方法名称(形参列表) { 方法体; }
void show() {
// 成员变量和成员方法都属于类内部的成员,因此可以直接访问成员变量不需要再加引用.的前缀
System.out.println("我是" + name + ",今年" + age + "岁了");
}
// 自定义成员方法将姓名修改为参数指定数值的行为
void setName(String s) {
name = 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; // 返回数据并结束当前方法
}
// 自定义成员方法实现年龄数值的获取并返回的行为
int getAge() {
return age;
}
public static void main(String[] args) {
// 1.申明Person类型的引用指向Person类型的对象
// 数据类型(类名) 引用变量名 = new 类名();
Person p = new Person();
// 2.打印对象中的成员变量值
// 引用变量名.成员方法名(实参列表);
// 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
p.show();
System.out.println("--------------------------------");
// 3.修改成员变量的数值
p.name = "张飞";
p.age = 30;
// 4.再次打印修改后的数值
p.show();
System.out.println("--------------------------------");
// 5.通过成员方法的调用来实现成员变量的修改
p.setName("guanyu");
p.setAge(35);
p.show();
System.out.println("--------------------------------");
// 6.通过成员方法的调用来同时修改姓名和年龄
p.setNameAge("liubei",40);
p.show();
System.out.println("--------------------------------");
// 7.通过成员方法的调用实现可变长参数的打印
p.showArgument(0);
System.out.println("++++++++++++++++++++++++++++++++");
p.showArgument(1, "参数1");
System.out.println("++++++++++++++++++++++++++++++++");
p.showArgument(2, "参数1", "参数2");
System.out.println("--------------------------------");
// 8.通过成员方法的调用实现成员变量数值的获取并打印
String str1 = p.getName();
System.out.println("获取到的姓名是:" + str1);
int ib = p.getAge();
System.out.println("获取到的年龄是:" + ib);
}
}
案例题目——Point类中无参有返回值方法的使用
/*
编程实现Point类的定义
*/
public class Point {
int x; // 用于描述横坐标的成员变量
int y; // 用于描述纵坐标的成员变量
// 自定义成员方法实现成员变量数值的打印
void show() {
System.out.println("横坐标是:" + x + ",纵坐标是:" + y);
}
// 自定义成员方法将横坐标修改为指定数值的行为
void setX(int i) {
x = i;
}
// 自定义成员方法将纵坐标修改为指定数值的行为
void setY(int j) {
y = j;
}
// 自定义成员方法实现int类型的可变长参数使用
void showArgument(int... args) {
for(int i = 0; i < args.length; i++) {
System.out.println("下标为" + i + "的元素是:" + args[i]);
}
}
// 自定义成员方法实现获取横坐标数值并返回的行为
int getX() {
return x;
}
// 自定义成员方法实现获取纵坐标数值并返回的行为
int getY() {
return y;
}
public static void main(String[] args) {
// 1.申明Point类型的引用指向Point类型的对象
Point p = new Point();
// 打印成员变量的数值
p.show();
System.out.println("----------------------------");
// 2.将横纵坐标修改为3和5后再次打印
p.x = 3;
p.y = 5;
p.show();
System.out.println("----------------------------");
// 3.通过调用成员方法实现横纵坐标的修改
p.setX(10);
p.setY(20);
p.show();
System.out.println("----------------------------");
// 4.通过成员方法的调用实现可变长参数的使用
p.showArgument(1,2,3,4,5);
System.out.println("----------------------------");
// 5.通过成员方法的调用实现横纵坐标的获取
int ia = p.getX();
System.out.println("获取到的横坐标是" + ia);
int ib = p.getY();
System.out.println("获取到的纵坐标是" + ib);
}
}
方法的传参过程
int max(int a, int b) {
...
}
int a = 5;
int b = 6;
int res = m.max(a,b);
- 为main方法中的变量a,b,res分配空间并初始化
- 调用max方法,为max方法的形参变量ia,ib分配空间
- 将实参变量的数值赋值到形参变量的内存空间中
- max方法运行完毕后返回,形参变量空间释放
- main方法中的res变量得到max方法的返回值
- main方法结束后释放相关变量的内存空间
传参的相关概念
- 参数分为形参和实参,定义方法时的参数叫形参,调用方法时传递的参数叫实参
- 调用方法时采用值传递把实参传递给形参,方法内部其实是在使用形参
- 所谓值传递就是当参数是基本类型时,传递参数的值,比如传递i=10,真实传参时,是把10赋值给了形参。当参数是对象时,传递的是对象的值,也就是把对象的地址赋值给了形参。
参数传递的注意事项
- 基本数据类型的变量作为方法的参数传递时,形参变量数值的改变通常不会影响到实参变量的数值,因为两个变量有各自独立的内存空间;
- 引用数据类型的变量作为方法的参数传递时,形参变量指向内容的改变会影响到实参变量指向内容的数值,因为两个变量指向同一块内存空间;
- 当引用数据类型的变量作为方法的参数传递时,若形参变量改变指向后再改变指定的内容,则通常不会影响到实参变量指向内容的改变,因为两个变量指向不同的内存空间。
案例题目——编程实现参数传递的测试
/*
编程实现参数传递的测试
*/
public class ArgumentTest {
// 自定义成员方法打印参数传入的整数数据
void show1(int ia) {
ia = 200;
System.out.println("show方法中,ia = " + ia);
}
// 自定义成员方法打印参数传入的数组内容
void show2(int[] arr1) {
arr1 = new int[2]; // 加上该行代码后,相当于再堆区中又重新申请了一块内存空间
arr1[0] = 200;
System.out.println("show方法中,arr1[0] = " + arr1[0]); // 10 200 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);
System.out.println("--------------------------------");
// 3.调用show2方法进行测试
int[] arr2 = new int[]{10,20};
at.show2(arr2);
System.out.println("main方法中,arr2[0] = " + arr2[0]); // 10 200 10
}
}
内存结构之栈区
- 栈用于存放程序运行过程当中所有的局部变量,一个运行的Java程序从开始到结束会又多次方法的调用。
- JVM会为每一个方法的调用在栈中分配一个对应的空间,这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法,栈帧中存储了该方法的参数、局部变量等数据。