day05_java基础
课程目标
1. 【理解】什么是方法
2. 【掌握】方法的格式
3. 【理解】方法的执行流程
4. 【掌握】方法的案例
5. 【理解】方法的重载
6. 【理解】方法参数的传递
一.方法概述
什么是方法
方法(method)完成某一个特定功能的代码块
方法基本使用
将资料中给大家提供的打怪物发射炮弹重复的代码,把一些重复代码进行抽取(封闭)思想.
抽取代码
public static void fire() {
System.out.println("准备发射5发炮弹");
System.out.println("发射第1发炮弹* * * *");
System.out.println("发射第2发炮弹* * * *");
System.out.println("发射第3发炮弹* * * *");
System.out.println("发射第4发炮弹* * * *");
System.out.println("发射第5发炮弹* * * *");
System.out.println("发射5发炮弹结束");
}
在main方法中使用
public static void main(String[] args) {
System.out.println("游戏开始...");
System.out.println("看到了一个怪物...血牙野猪...");
//调用方法,发射炮弹
fire();
System.out.println("...血牙野猪被打倒...");
}
调用格式
方法名();
注意
方法必须先创建才可以使用,该过程成为方法定义
方法创建后并不是直接可以运行的,需要手动使用后,才执行,该过程成为方法调用
方法调用过程图解
定义方法格式
修饰符 返回值类型 方法名(参数列表){
//代码省略...
return 结果;
}
修饰符
: public static 目前固定写法
返回值类型
: 表示方法运行的结果的数据类型,方法执行后将结果返回到调用者
参数列表
: 方法在运算过程中的未知数据,调用者调用方法时传递
return
: 将方法执行后的结果带给调用者,方法执行到 return ,整体方法运行结束
小贴士:return 结束; 这里的结束在开发中,我们正确的叫法成为方法的返回值
二.方法类型
定义方法的两个明确
明确参数列表
该方法在完成一个功能时,需要的参数有几个,参数的类型是什么,需要在我们明确给出的。
明确返回值类型
方法的功能完成之后,是否有结果返回,如果有,使用return 将结果返回给调用者。没有返回值void
什么情况下,我们用return, 除了void以外的都要有return
案例一
需求
在控制台打印10次HelloWorld
分析
明确参数列表
方法中打印出 HelloWorld 即可,没有计算结果,返回值类型 void
明确返回值
打印几次已经明确规定10次,参数不需要定义
代码实现
public class MethodDemo01 {
public static void main(String[] args) {
//调用方法printHelloWorld打印10次HelloWorld
printHelloWorld();
}
public static void printHelloWorld() {
for (int i = 0; i < 10; i++) {
System.out.println("HelloWorld");
}
}
}
案例二
需求
实现不定次数打印HelloWorld
分析
明确参数列表
方法中打印出 HelloWorld 即可,没有计算结果,返回值类型 void
明确返回值
打印几次不清楚,参数定义一个整型参数
代码实现
public class MethodDemo02 {
public static void main(String[] args) {
//调用方法printHelloWorld,传递整数
printHelloWorld(10);
}
/*
定义打印HelloWorld方法
返回值类型,计算没有结果 void
参数:不确定打印几次
*/
public static void printHelloWorld(int n) {
for (int i = 0; i < n; i++) {
System.out.println("HelloWorld");
}
}
}
案例三
需求
定义方法实现两个整数的求和计算
分析
明确参数列表
计算哪两个整数的和,并不清楚,但可以确定是整数,参数列表可以定义两个int类型的
变量,由调用者调用方法时传递
明确返回值
方法计算的是整数的求和,结果也必然是个整数,返回值类型定义为int类型。
代码实现
public class MethodDemo03 {
public static void main(String[] args) {
// 调用方法getSum,传递两个整数,这里传递的实际数据又称为实际参数
// 并接收方法计算后的结果,返回值
int sum = getSum(5, 6);
System.out.println(sum);
}
/*
定义计算两个整数和的方法
返回值类型,计算结果是int
参数:不确定数据求和,定义int参数.参数又称为形式参数
*/
public static int getSum(int a, int b) {
return a + b;
}
}
流程图解
案例四
需求
定义方法实现比较两个整数是否相同
分析
明确参数列表
比较的两个整数不确定,所以默认定义两个int类型的参数。
明确返回值
比较整数,比较的结果只有两种可能,相同或不同,因此结果是布尔类型,比较的结果相
同为true。
代码实现
public class MethodDemo04 {
public static void main(String[] args) {
//调用方法compare,传递两个整数
//并接收方法计算后的结果,布尔值
boolean bool = compare(3, 8);
System.out.println(bool);
}
/*
定义比较两个整数是否相同的方法
返回值类型,比较的结果布尔类型
参数:不确定参与比较的两个整数
*/
public static boolean compare(int a, int b) {
if (a == b) {
return true;
} else {
return false;
}
}
}
案例五
需求
定义方法实现:计算1+2+3…+100的和
分析
明确参数列表
需求中已知到计算的数据,没有未知的数据,不定义参数
明确返回值
1~100的求和,计算后必然还是整数,返回值类型是int
代码实现
public class MethodDemo05 {
public static void main(String[] args) {
//调用方法getSum
//并接收方法计算后的结果,整数
int sum = getSum();
System.out.println(sum);
}
/*
定义计算1~100的求和方法
返回值类型,计算结果整数int
参数:没有不确定数据
*/
public static int getSum() {
//定义变量保存求和
int sum = 0;
//从1开始循环,到100结束
for (int i = 1; i <= 100; i++) {
sum = sum + i;
}
return sum;
}
}
TODO: 无参无返回值的方法 无参有返回值的方法
有参无返回值的方法 有参有返回值的方法
试着去写返回值类型各种情况, 试着去写参数列表的各种数据类型
三.方法小结
定义方法注意事项
定义位置:类中方法外,不能嵌套定义
方法必须先定义,再使用
void表示无返回值,可以省略return,也可以单独的书写return
不能在return后面写代码,return意味着方法结束,所有后面的代码记永远都不会执行,属于无效代码
定义方法时()中的参数,我们称之为:形式参数,在调用该方法时传递的参数,我们称之为:实际参数
- 你可以不接收返回的值,但你必须给出参数
调用方法三种形式
直接调用:直接写方法名调用
public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("方法被调用");
}
赋值调用:调用方法,在方法前面定义变量,接收方法返回值
public static void main(String[] args) {
int sum = getSum(5,6);
System.out.println(sum);
}
public static int getSum(int a,int b) {
return a + b;
}
输出语句调用:在输出语句中调用方法
public static void main(String[] args) {
System.out.println(getSum(5,6));
}
public static int getSum(int a,int b) {
return a + b;
}
注意事项
不能用输出语句调用void无返回值类型的方法。因为方法执行后没有结果,也就打印不出任何内容
public static void main(String[] args) {
// 错误,不能输出语句调用void类型方法
System.out.println(printHello());
}
public static void printHello() {
System.out.println("Hello");
}
四.重载
4.1方法重载概述
在同一个类中,具有相同的方法名, 参数列表不同(参数的个数及类型不同),与返回值无关
参数列表:个数不同,数据类型不同,顺序不同。
重载方法调用:JVM通过方法的参数列表,调用不同的方法。
注意事项
* 重载仅对应方法的定义,与方法的调用无关,调用方式参照标准格式
* 重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关,换句话说不能通过返回值来判定两个方法是否相互构成重载
4.2重载案例
案例一
需求
使用方法重载的思想,设计比较两个整数是否相同的方法,兼容全整数类型(byte,short,int,long)
思路
①定义比较两个数字的是否相同的方法compare()方法,参数选择两个int型参数
②定义对应的重载方法,变更对应的参数类型,参数变更为两个long型参数
③定义所有的重载方法,两个byte类型与两个short类型参数
④完成方法的调用,测试运行结果
代码实现
public class MethodTest1 {
public static void main(String[] args) {
//调用方法
System.out.println(compare(10, 20));
System.out.println(compare((byte) 10, (byte) 20));
System.out.println(compare((short) 10, (short) 20));
System.out.println(compare(10L, 20L));
}
//int
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
//byte
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
//short
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
//long
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
案例二
判断哪些方法是重载关系
public static void open(){}
public static void open(int a){}
public static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}
案例三
需求
模拟输出语句中的println方法的效果,传递什么类型的数据就输出什么类型的数据,只允许定义一个方法名println
代码实现
public class MethodTest2 {
public static void println(byte a) {
System.out.println(a);
}
public static void println(short a) {
System.out.println(a);
}
public static void println(int a) {
System.out.println(a);
}
public static void println(long a) {
System.out.println(a);
}
public static void println(float a) {
System.out.println(a);
}
public static void println(double a) {
System.out.println(a);
}
public static void println(char a) {
System.out.println(a);
}
public static void println(boolean a) {
System.out.println(a);
}
public static void println(String a) {
System.out.println(a);
}
}
五.参数传递
方法参数传递基本类型
测试代码:
public class ArgsDemo01 {
public static void main(String[] args) {
//实际参数
int number = 100;
System.out.println("调用change方法前:" + number);
//调用方法
change(number);
System.out.println("调用change方法后:" + number);
}
//形式参数
public static void change(int number) {
number = 200;
}
}
结论:
基本数据类型的参数,形式参数的改变,不影响实际参数
结论依据:
每个方法在栈内存中,都会有独立的栈空间,方法运行结束后就会弹栈消失
方法参数传递引用类型
测试代码
public class ArgsDemo02 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前:" + arr[1]);//20
change(arr);
System.out.println("调用change方法后:" + arr[1]);//200
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
结论
对于引用类型的参数,形式参数的改变,影响实际参数的值
结论依据
引用数据类型的传参,传入的是地址值,内存中会造成两个引用指向同一个内存的效果,所以即使方法弹栈,堆内存中的数据也已经是改变后的结果
数组遍历
需求
设计一个方法用于数组遍历,要求遍历的结果是在一行上的。例如:[11, 22, 33, 44, 55]
思路
- 因为要求结果在一行上输出,所以这里需要在学习一个新的输出语句System.out.print(“内容”);
System.out.println(“内容”); 输出内容并换行
System.out.print(“内容”); 输出内容不换行
System.out.println(); 起到换行的作用 - 定义一个数组,用静态初始化完成数组元素初始化
- 定义一个方法,用数组遍历通用格式对数组进行遍历
- 用新的输出语句修改遍历操作
- 调用遍历方法
代码实现
public class MethodTest3 {
public static void main(String[] args) {
//定义一个数组,用静态初始化完成数组元素初始化
int[] arr = {11, 22, 33, 44, 55};
//调用方法
printArray(arr);
}
// 定义一个方法,用数组遍历通用格式对数组进行遍历
/*
两个明确:
返回值类型:void
参数:int[] arr
*/
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x]+", ");
}
}
System.out.println("]");
}
}
数组最大值
需求
设计一个方法用于获取数组中元素的最大值
思路
① 定义一个数组,用静态初始化完成数组元素初始化
② 定义一个方法,用来获取数组中的最大值,最值的认知和讲解我们在数组中已经讲解过了
③ 调用获取最大值方法,用变量接收返回结果
④ 把结果输出在控制台
代码实现
public class MethodTest02 {
public static void main(String[] args) {
//定义一个数组,用静态初始化完成数组元素初始化
int[] arr = {12, 45, 98, 73, 60};
//调用获取最大值方法,用变量接收返回结果
int number = getMax(arr);
//把结果输出在控制台
System.out.println("number:" + number);
}
//定义一个方法,用来获取数组中的最大值
/*
两个明确:
返回值类型:int
参数:int[] arr
*/
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}
}
六.递归
什么是递归
指在当前方法内调用自己的这种现象。
从前有座山,山里有座庙,庙里有一个老和尚和一个小和尚。。。。。。
你为什么要放羊,为了娶媳妇,娶媳妇干什么,为了生娃娃。。。。。。
递归的分类
递归分为两种,直接递归 和 间接递归。
直接递归:称为方法自身调用自己。A方法调用B方法B方法调用A方法…
间接递归:可以A方法调用B方法,B方法调用C方法,C方法调用A方法。
递归的注意事项
递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出。
在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。
构造方法,禁止递归
package cn.yanqi_02;
public class Demo01DiGui {
/*
* 3.构造方法,禁止递归
* 编译报错:构造方法是创建对象使用的,不能让对象一直创建下去
*/
public Demo01DiGui() {
//Demo01DiGui();
}
public static void main(String[] args) {
show1();
// show2(1);
}
/*
* 2.在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。
* 4993
* Exception in thread "main" java.lang.StackOverflowError
*/
private static void show2(int i) {
System.out.println(i);
//添加一个递归结束的条件,i==5000的时候结束
if(i==5000){
return;//结束方法
}
show2(++i);
}
/*
* 1.递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出。 Exception in thread "main"
* java.lang.StackOverflowError
*/
private static void show1() {
System.out.println("a方法");
show1();
}
}
递归累加求和
需求
计算1 ~ n的和
分析
num的累和 = num + (num-1)的累和,所以可以把累和的操作定义成一个方法,递归调用。
代码实现
public class DiGuiDemo {
public static void main(String[] args) {
//计算1~num的和,使用递归完成
int num = 5;
// 调用求和的方法
int sum = getSum(num);
// 输出结果
System.out.println(sum);
}
/*
通过递归算法实现.
参数列表:int
返回值类型: int
*/
public static int getSum(int num) {
/*
num为1时,方法返回1,
相当于是方法的出口,num总有是1的情况
*/
if(num == 1){
return 1;
}
/*
num不为1时,方法返回 num +(num-1)的累和
递归调用getSum方法
*/
int gs = getSum(num-1);
return num + gs;
}
}
递归求阶乘
什么是阶乘
所有小于及等于该数的正整数的积。
使用递归求5的阶乘
5! = 5 * 4 * 3 * 2 * 1 5! = 5 * 4! 4! = 4 * 3! 3! = 3 * 2! 2! = 2 * 1! 1! = 1 求n的阶乘 n * (n - 1)!
求N阶乘公式
n! = n * (n-1) … 3 * 2 * 1
分析
这与累和类似,只不过换成了乘法运算,学员可以自己练习,需要注意阶乘值符合int类型的范围。
推理得出:n! = n * (n-1)!
代码实现
public class DiGuiDemo {
//计算n的阶乘,使用递归完成
public static void main(String[] args) {
int n = 3;
// 调用求阶乘的方法
int value = getValue(n);
// 输出结果
System.out.println("阶乘为:"+ value);
}
/*
通过递归算法实现.
参数列表:int
返回值类型: int
*/
public static int getValue(int n) {
// 1的阶乘为1
if (n == 1) {
return 1;
}
/*
n不为1时,方法返回 n! = n*(n-1)!
递归调用getValue方法
*/
return n * getValue(n - 1);
}
}
1!
1! = 1
求n的阶乘
n * (n - 1)!
求N阶乘公式
n! = n * (n-1) … 3 * 2 * 1
分析
这与累和类似,只不过换成了乘法运算,学员可以自己练习,需要注意阶乘值符合int类型的范围。
推理得出:n! = n * (n-1)!
代码实现
public class DiGuiDemo {
//计算n的阶乘,使用递归完成
public static void main(String[] args) {
int n = 3;
// 调用求阶乘的方法
int value = getValue(n);
// 输出结果
System.out.println("阶乘为:"+ value);
}
/*
通过递归算法实现.
参数列表:int
返回值类型: int
*/
public static int getValue(int n) {
// 1的阶乘为1
if (n == 1) {
return 1;
}
/*
n不为1时,方法返回 n! = n*(n-1)!
递归调用getValue方法
*/
return n * getValue(n - 1);
}
}