方法的概述
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可
简单来说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义 , 函数在Java中被称为方法
方法定义
案例代码-方法定义格式
package Function;
/*
* 方法：就是完成特定功能的代码块。
*
* 定义格式：
* 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
* 方法体;
* return 返回值;
* }
* 格式解释：
* A:修饰符 目前记住public
* B:返回值类型 用于限定返回值的数据类型
* C:方法名 一个名字，为了方便我们调用方法
* D:参数类型 用于接收调用方法时传入的数据的类型
* E:参数名 用于接收调用方法时传入的数据的变量
* F:方法体 完成功能的代码
* G:return 结束方法，把返回值带给调用者
*
* 方法的两个明确：
* A:返回值类型 明确功能结果的数据类型
* B:参数列表 明确有几个参数，以及参数的类型
*
* 案例：
* 求两个数和的案例。
*/
public class FunctionDemo {
/*
* 写一个方法，用于求和。
* 两个明确： 返回值类型 int 参数列表 int a,int b
*/
public static int sum(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int a = 1, b = 1;
System.out.println(sum(a, b));
}
}
案例代码-两个数字比大小
package Function;
/*
* 需求：键盘录入两个数据，返回两个数中的较大值
*
* 两个明确：
* 返回值类型：int
* 参数列表：int a,int b
* 需求：返回两个数中的较大值
*
* 两个明确：
* 返回值类型：int
* 参数列表：int a,int b
*/
public class FunctionDemo2 {
public static int max(int a, int b) {
return (a > b ? a : b);
}
public static void main(String[] args) {
int a = 1;
int b = 2;
int max = max(a, b);
System.out.println("最大值为:" + max);
}
}
案例代码-两个数字是否相等
package Function;
public class FunctionDemo3 {
public static int equal(int a, int b) {
if (a == b) {
return 1;
} else {
return 0;
}
}
public static void main(String[] args) {
int a = 2;
int b = 3;
if (equal(a, b) == 1) {
System.out.println("两个数字相等");
} else {
System.out.println("两个数字不相等");
}
}
}
案例代码-获取三个数最大值
package Function;
/*
* 需求：返回三个数中的最大值
*
* 两个明确：
* 返回值类型：int
* 参数列表：int a,int b,int c
*/
public class FunctionDemo4 {
public static int max(int a, int b, int c) {
return a > b ? (a > c ? a : c) : (b > c ? b : c);
}
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = 3;
int max = max(a, b, c);
System.out.println("最大值为:" + max);
}
}
案例代码-void修饰的方法的调用
package Function;
/*
* 需求：写一个方法，在控制台输出10次HelloWorld案例。
*
* 两个明确：
* 返回值类型：void
* 参数列表：无参数
*
* 如果一个方法没有明确的返回值类型，java提供了void进行修饰。
*
* void修饰的方法的调用：
* A:单独调用
*/
public class FunctionDemo5 {
public static void hello() {
for (int i = 1; i <= 10; i++) {
System.out.println("Hello World!");
}
}
public static void main(String[] args) {
hello();
}
}
案例代码-打印1到n之间的数据
package Function;
/*
* 需求：写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
*
* 两个明确：
* 返回值类型：void
* 参数列表：int n
*/
public class FunctionDemo6 {
public static void print(int a) {
for (int i = 1; i <= a; i++) {
System.out.println(i);
}
}
public static void main(String[] args) {
int a = 5;
print(a);
}
}
案例代码-打印所有的水仙花数
package Function;
/*
* 写一个方法，把所有的水仙花数打印在控制台
*
* 两个明确：
* 返回值类型：void
* 参数列表：无参数
*/
public class FunctionDemo7 {
public static void printFlower() {
for (int x = 100; x < 1000; x++) {
int ge = x % 10;
int shi = x / 10 % 10;
int bai = x / 10 / 10 % 10;
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == x) {
System.out.println(x);
}
}
}
public static void main(String[] args) {
printFlower();
}
}
方法的重载
方法重载概述
案例代理-方法重载
package Overload;
/*
* 方法重载：在同一个类中，出现了方法名相同的方法，这就是方法重载。
* 方法重载特点：
* 方法名相同，参数列表不同。与返回值无关。
* 参数列表不同：
* 参数的个数不同。
* 参数对应的类型不同。
* 注意：
* 在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。
*/
public class OverloadDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int result = sum(a, b); // 求和
System.out.println("result:" + result);
int c = 30;
result = sum(a, b, c);
System.out.println("result:" + result);
}
// 两个float类型的数据求和
public static float sum(float a, float b) {
return a + b;
}
// 三个整数的求和
public static int sum(int a, int b, int c) {
return a + b + c;
}
// 两个整数的求和
public static int sum(int a, int b) {
return a + b;
}
}
案例代码-比较数据是否相等
package Overload;
/*
* 需求：比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
* 在main方法中进行测试
*/
public class OverloadDemo2 {
public static boolean equal(byte a, byte b) {
System.out.println("byte");
if (a == b) {
return true;
} else {
return false;
}
}
public static boolean equal(short a, short b) {
System.out.println("short");
if (a == b) {
return true;
} else {
return false;
}
}
public static boolean equal(int a, int b) {
System.out.println("int");
if (a == b) {
return true;
} else {
return false;
}
}
public static boolean equal(long a, long b) {
System.out.println("long");
if (a == b) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
// 调用
System.out.println(equal(10, 20));
System.out.println("-------------");
System.out.println(equal((byte) 10, (byte) 20));
System.out.println("-------------");
System.out.println(equal((short) 10, (short) 20));
System.out.println("-------------");
System.out.println(equal(10L, 20L));
}
}
方法参数传递
方法的参数是基本类型的时候
- 形式参数的改变不影响实际参数。
- 形式参数:用于接收实际数据的变量
- 实际参数:实际参与运算的变量
代码案例-参数传递
package Transfer;
public class TransferDemo {
public static void main(String[] args) {
// 定义变量
int a = 10;
int b = 20;
System.out.println("方法外改变前");
System.out.println("a:" + a + ",b:" + b); // a:10,b:20
System.out.println("方法内改变前");
change(a, b);
System.out.println("方法内改变后");
System.out.println("a:" + a + ",b:" + b);
// a:10,b:20
}
public static void change(int a, int b) { // a=10,b=20
System.out.println("a:" + a + ",b:" + b); // a:10,b:20
a = b; // a=20;
b = a + b; // b=40;
System.out.println("a:" + a + ",b:" + b); // a:20,b:40
}
}
案例代码-形参为引用类型
package Transfer;
/*
* 方法的参数是引用类型：
* 形式参数的改变直接影响实际参数
*/
public class TransferDemo2 {
public static void main(String[] args) {
// 定义数组
int[] arr = {1, 2, 3, 4, 5};
// 遍历数组
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("----------------");
change(arr);
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
// 如果元素是偶数，值就变为以前的2倍
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
方法递归调用
指的是一个方法自己调用自己的情况,一般需要考虑如下几点问题
- 一定要设置递归调用的结束条件
- 每一次调用的过程中一定要修改传递的参数条件
案例代码-递归
package Recursive;
public class RecursiveDemo {
public static void main(String[] args) {
System.out.println(sum(100));
}
public static int sum(int num) {
if (num == 1) {
return 1;
}
return num + sum(num - 1);
}
}
案例代码-阶乘
package Recursive;
public class RecursiveDemo2 {
public static void main(String[] args) {
System.out.println(factorial(3));
}
public static double factorial(double num) {
if (num == 1) {
return 1;
}
return num * factorial(num - 1);
}
}
Comments | NOTHING