这篇博客详细介绍了Java面向对象编程的核心内容，包括类和对象、方法和封装、static关键字、继承、多态等关键概念。讲解了构造方法、方法重载、this关键字的使用，以及递归、封装的实现流程。此外，还探讨了static关键字的作用，如静态代码块、单例设计模式，以及继承的特点和方法重写原则。最后，讨论了多态的概念和实际应用，抽象类和接口的区别，以及内部类、枚举、注解等特殊类的使用。
数据来源：拉勾教育Java就业急训营
一. 类和对象
1.程序执行流程与内存分析
• 栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次方法的调用。
• JVM会为每一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据。
• 当某一个方法调用完成后，其对应的栈帧将被清除。
2.可变长参数
• 返回值类型 方法名(参数的类型… 参数名)
• 方法参数部分指定类型的参数个数是可以改变的，也就是0~n个 。
• 一个方法的形参列表中最多只能声明一个可变长形参，并且需要放到参数列表的末尾。
public class Person {
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 自定义成员方法实现可变长参数的使用 看作一维数组使用即可 0 ~ n个
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) {
// 通过成员方法实现可变长参数的打印
p.showArgument(0);
System.out.println("-----------------------------------------------------");
p.showArgument(1, "参数1");
System.out.println("-----------------------------------------------------");
p.showArgument(2, "参数1", "参数2");
}
}
3.方法的传参过程
3.1传参的相关概念
• 参数分为形参和实参，定义方法时的参数叫形参，调用方法时传递的参数叫实参。
• 调用方法时采用值传递把实参传递给形参，方法内部其实是在使用形参。
• 所谓值传递就是当参数是基本类型时，传递参数的值，比如传递 i=10，真实传参时，把10赋值给了形参。当参数是对象时，传递的是对象的值，也就是把对象的地址赋值给形参。
int max(int ia, int ib) {
… … …
}
public static void main(String[] args) {
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方法结束后释放相关变量的内存空间。
3.2参数传递的注意事项
• 基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间；
public class ArgumentTest {
// 形参ia，实参ib
void show1(int ia) {
ia = 200;
System.out.println("show方法中：ia = " + 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
}
• 引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间
public class ArgumentTest {
// 形参arr1，实参arr2
void show2(int[] arr1) {
arr1[0] = 200;
System.out.println("show方法中：arr1[0] = " + 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);
System.out.println("main方法中：arr2[0] = " + arr2[0]); // arr2[0] = 200
}
• 当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间。
public class ArgumentTest {
// 形参arr1，实参arr2
void show2(int[] arr1) {
arr1 = new int[2]; // 加上改行代码后，相当于在堆区中又重新申请一块内存空间
arr1[0] = 200;
System.out.println("show方法中：arr1[0] = " + 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);
System.out.println("main方法中：arr2[0] = " + arr2[0]); // arr2[0] = 10
}
二. 方法和封装
1.构造方法
1.1 语法格式
class 类名 {
类名(形参列表) {
构造方法体;
}
}
构造方法名与类名完全相同并且没有返回值类型，连void都不许有。
1.2 默认构造方法
• 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造构造方法，叫做默认/缺省构造方法，如：Person(){}
• 若类中出现了构造方法，则编译器不再提供任何形式的构造方法。
1.3 作用
• 使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。
2.方法重载
2.1 概念
• 若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)。
2.2 重载的体现形式
• 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同。
• 判断方法能否构成重载的核心：调用方法时能否加以区分。
2.3 实际意义
方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本，来实现各种不同的功能。
3.this关键字
3.1 this的基本概念
• 若在构造方法中出现了this关键字，则代表当前正在构造的对象。
• 若在成员方法中出现了this关键字，则代表当前正在调用的对象。
• this关键字本质上就是当前类类型的引用变量。
3.2 工作原理
在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于汉语中"我的"，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。
3.3 使用方式
• 当局部变量名与成员变量名相同时，在方法体中会优先使用局部变量(就近原则)，若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量是成员变量（重中之重）。
public class Person {
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
// 就近原则 懒人原则
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
• this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值（重点）。
public class Person {
String name; // 用于描述姓名的成员变量
int age; // 用于描述年龄的成员变量
Person getPerson() {
// 返回当前调用对象本身 Person tp = new Person(); return tp;
return this;
}
}
• 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法（了解）。
3.4 注意事项
• 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。
• 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生
NullPointerException 异常（空指针异常）。
4.递归
4.1 基本概念
递归本质就是指在方法体的内部直接或间接调用当前方法自身的形式。
4.2 注意事项
• 使用递归必须有递归的规律以及退出条件。
• 使用递归必须使得问题简单化而不是复杂化。
• 若递归影响到程序的执行性能，则使用递推取代之。
4.3 实例
4.3.1 阶乘
编程实现参数n的阶乘并返回，所谓阶乘就是从1累乘到n的结果。
/*
编程实现累乘积的计算并打印
*/
public class JieChengTest {
// 自定义成员方法实现将参数n的阶乘计算出来并返回
// 1! = 1; 2! = 1*2; 3! = 1*2*3; ... n! = 1*2*3*...*n;
int show(int n) {
// int n=5; int n = 4; int n = 3; int n = 2; int n = 1;
// 递推的方式
/*
int num = 1;
for(int i = 1; i <= n; i++) {
num *= i;
}
return num;
*/
/*
5! = 5 * 4 * 3 * 2 * 1;
4! = 4 * 3 * 2 * 1;
3! = 3 * 2 * 1;
2! = 2 * 1;
1! = 1;
5! = 5 * 4!;
4! = 4 * 3!;
3! = 3 * 2!;
2! = 2 * 1!;
1! = 1;
n! = n * (n-1)!;
*/
// 递归的方式
// 当n的数值为1时，则阶乘的结果就是1
/*
if(1 == n) {
return 1;
}
*/
if(1 == n) return 1;
// 否则阶乘的结果就是 n*(n-1)!
return n*show(n-1);
// show(5) => return 5*show(4); => 120
// show(4) => return 4*show(3); => 24
// show(3) => return 3*show(2); => 6
// show(2) => return 2*show(1); => 2
// show(1) => return 1; => 1
}
public static void main(String[] args) {
// 1.声明JieChengTest类型的引用指向该类型的对象
JieChengTest jct = new JieChengTest();
// 2.调用方法进行计算并打印
int res = jct.show(5);
System.out.println("最终的计算结果是：" + res); // 120
}
}
4.3.2 费式数列
编程实现费式数列中第n项的数值并返回。
费式数列： 1 1 2 3 5 8 13 21 ……
A. 递归方法
public class FeeTest {
// 自定义成员方法实现费氏数列中第n项数值的计算并返回，n由参数指定
// 1 1 2 3 5 8 13 21 ....
int show(int n) {
// 使用递归的方式进行计算
// 当n=1或者n=2时，结果是1
if(1 == n || 2 == n) {
return 1;
}
// 否则结果是前两项的和
return show(n-1) + show(n-2);
}
public static void main(String[] args) {
// 1.声明FeeTest类型的引用指向该类型的对象
Fee ft = new Fee();
// 2.调用方法计算并打印
int res = ft.show(55);
System.out.println("计算的结果是：" + res);
}
}
B. 递推方法
public class FeeTest {
// 自定义成员方法实现费氏数列中第n项数值的计算并返回，n由参数指定
// 1 1 2 3 5 8 13 21 ....
最低0.47元/天 解锁文章
扫一扫
610
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
