目录
一、不带返回值方法的定义和调用
二、带返回值方法的定义和调用
三、形参和实参
四、方法的调用
五、带返回值方法的调用
六、方法重载
七、练习
一、不带返回值方法的定义和调用
1、方法概述
方法：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
2、方法的两个注意
A : 方法必须创建才可以使用，该过程称之为（方法定义）
B：方法创建后不能直接运行，需要手动调用，才可以执行，该过程称之为（方法调用）
方法：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
定义格式：
public static void 方法名 ( ) {
//方法体
}
调用格式：
方法名();
方法的调用
方法定义格式：public static void 方法名( ) { 方法体; }
方法调用格式：方法名();
方法名：panDuanJiOu
方法体：定义int类型变量，if判断是否是偶数
public class FangFaDemo {
public static void main(String[] args) {
//调用方法
isEvenNumber();
}
//需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
public static void panDuanJiOu() {
//定义变量
int number = 10;
//判断是否为偶数
if (number % 2 == 0) {
System.out.println(true);
} else {
System.out.println(false);
}
}
}
1、main方法与自定义方法的执行顺序
main方法先执行
2、方法调用的过程
main方法先被调用，随后执行main方法中的逻辑代码，当遇到了调用自定义方法的语句，执行自定义方法内部的逻辑代码，自定义方法执行完毕之后，继续回到main方法中执行。
需求：
设计一个方法用于打印两个数中的较大数，数据来自于方法参数
思路：
1:定义一个方法，用于打印两个数字中的较大数
2:为方法定义两个参数，用于接收两个数字
3:使用分支语句分两种情况对两个数字的大小关系进行处理
4:在main()方法中调用定义好的方法（使用常量）
5:在main()方法中调用定义好的方法（使用变量）
public class ZuiDaZhi {
public static void main(String[] args) {
//在main()方法中调用定好的方法
getMax(10, 20);
//调用方法的时候，人家要几个就给几个，要什么类型就给什么类型、
int a = 10;
int b = 20;
getMax(a, b);
}
public static void getMax(int a, int b) {
if (a > b) {
System.out.println(a);
} else {
System.out.println(b);
}
}
}
二、带返回值方法的定义和调用
带返回值方法的定义和调用
1、带参方法的定义格式
public static void 方法名(参数1, 参数2, 参数…){
方法体 ;
}
参数的定义：数据类型 变量名，数据类型 变量名…
注意：方法的参数，可以是一个，也可以是多个，如果是多个，中间需要以逗号分隔
2、带参方法的调用格式
在main方法中，通过方法名调用，并传入对应类型的参数
方法名(参数);
3、调用带参方法注意事项
调用带参方法，传入的参数，无论是类型还是数量，都需要跟定义的参数类型匹配
传入的参数可以是变量，也可以是常量
public class FanhuiZhiDemo {
public static void main(String[] args) {
// isEvennumber(10);
boolean flag = isEvennumber(10);
System.out.println(flag);
}
//需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
public static boolean isEvennumber(int number) {
if (number % 2 == 0) {
return true;
} else {
return false;
}
}
}
方法注意事项：
方法的参数可以是多种类型
方法不能嵌套定义
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
public class FanHuiZhi01 {
public static void main(String[] args) {
boolean flag = OuShu(10);
System.out.println(flag);
String jeishou = Zifuchun(5);
System.out.println(jeishou);
double jeishou01 = XiaoShu(21);
System.out.println(jeishou01);
}
public static boolean OuShu(int shuzi) {
if (shuzi % 2 == 0) {
return true;
} else {
return false;
}
}
public static String Zifuchun(int a) {
if (a > 1 && a < 10) {
return "我要吃饭";
} else {
return "我不饿";
}
}
public static double XiaoShu(int b) {
if (b > 0 && b < 20) {
return 3.1415;
} else {
return 2.111;
}
}
}
三、形参和实参
1、形参
全称叫做形式参数，指的是定义方法的时候，方法小括号中定义的参数
例如：public static void method(int num){}
当中的 int num
2、实参
全程为实际参数，指的是调用方法的时候，传入的具体数值。
例如：method(10);
四、方法的调用
1.直接调用
2.赋值调用
3.输出调用
public class FangFaDiaoYong01 {
public static double XiaoShuHe(double a, double b) {
return a + b;
}
public static void main(String[] args) {
//直接
System.out.println(XiaoShuHe(2.1, 3.1));
System.out.println("-------------");
//赋值
double a = 2.1;
double b = 3.5;
double he1 = XiaoShuHe(a, b);
System.out.println(he1);
System.out.println("------------");
//输出
System.out.println(XiaoShuHe(a, b));
System.out.println("=============");
XiaoShuHe01(3.1, 5.2);
}
public static void XiaoShuHe01(double a, double b) {
System.out.println(a + b);
}
}
五、带返回值方法的调用
1、方法的返回值类型，和返回值的关系
对应关系，方法的返回值类型，必须跟返回值的类型对应，否则引发编译错误
2、返回值的接收
带有返回值的方法调用之后，会产生一个运算后的结果，这个结果没有接收被使用的话，将毫无意义。
3、return关键字的作用
return关键字用于将方法运算的结果，返还给调用处。
需求：
设计一个方法可以获取两个数的较大值，数据来自于参数
思路：
1:定义一个方法，用于获取两个数字中的较大数
2:使用分支语句分两种情况对两个数字的大小关系进行处理
3:根据题设分别设置两种情况下对应的返回结果
4:在main()方法中调用定义好的方法并使用变量保存
5:在main()方法中调用定义好的方法并直接打印结果
public class FanHuiZhiDom01 {
public static void main(String[] args) {
int shuju = getMax(10, 20);
System.out.println(shuju);
System.out.println(getMain(10,20));
System.out.println(getXiaoShu(2.5,6.4));
}
public static int getMax(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
public static int getMain(int a, int b ){
if (a>b){
return b;
}else {
return a;
}
}
private static double getXiaoShu(double a, double b){
if (a>b){
return a;
}else {
return b;
}
}
}
定义方法前，要思考明确
1. 明确返回值类型：知晓方法运行结束后是否有数据返回，没有写void，有的话则书写具体类型
2. 明确参数：明确参数的类型和数量
调用方法
1. void类型的方法，直接调用即可
2. 非void类型的方法，推荐使用变量接收调用
六、方法重载
方法重载：
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同
public class FangFaChongZaiDom1 {
public static void main(String[] args) {
//需求1：求两个int类型数据和的方法
int result = sum(10, 20);
System.out.println(result);
//需求2：求两个double类型数据和的方法
double result2 = sum(1.2, 4.6);
System.out.println(result2);
//需求3：求三个int类型数据和的方法
int result3 = sum(2, 8, 16);
System.out.println(result3);
}
public static int sum(int a, int b) {
return a + b;
}
public static double sum(double a, double b) {
return a + b;
}
public static int sum(int a, int b, int c) {
return a + b + c;
}
}
需求：
使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
思路：
1:定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
2:定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
3:定义所有的重载方法，两个byte类型与两个short类型参数
4:完成方法的调用，测试运行结果
public class FangFaChongZaiDom2 {
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));
}
public static boolean compare(int a, int b) {
return a == b;
}
public static boolean compare(byte a, byte b) {
return a == b;
}
public static boolean compare(short a, short b) {
return a == b;
}
public static boolean compare(long a, long b) {
return a == b;
}
}
对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
public class FangFaChongZaiDom3 {
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 FangFaChongZaiDom5 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前：" + arr[1]);
change(arr);
System.out.println("调用change方法后：" + arr[1]);
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
七、练习
练习 01数组遍历
需求：
设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如： [5, 9, 12, 87, 64]
思路：
1:因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
System.out.println(“内容”); 输出内容并换行
System.out.print(“内容”); 输出内容不换行
System.out.println(); 起到换行的作用
2:定义一个数组，用静态初始化完成数组元素初始化
3:定义一个方法，用数组遍历通用格式对数组进行遍历
4:用新的输出语句修改遍历操作
5:调用遍历方法
public class LianXi01{
public static void main(String[] args) {
int arr[] = {5, 9, 12, 87, 64};
shuZhu(arr);
}
public static void shuZhu(int arr[]) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ",");
}
}
System.out.println("]");
}
}
联系 02 数组最大值
需求：
设计一个方法用于获取数组中元素的最大值，调用方法并输出结果
思路：
1:定义一个数组，用静态初始化完成数组元素初始化
2:定义一个方法，用来获取数组中的最大值
3:调用获取最大值方法，用变量接收返回结果
4:把结果输出在控制台
public class LianXi01 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素初始化
int[] arr = {12, 45, 98, 73, 60};
System.out.println(zuiDaZhi(arr));
}
public static int zuiDaZhi(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
}
练习 03
分析以下需求，并用代码实现(每个小需求都需要封装成方法)
1.求两个整数之和
2.求两个小数之和
3.判断两个整数是否相等
4.判断两个小数是否相等
5.获取两个整数中较大的值
6.获取两个小数中较大的值
7.获取两个整数中较小的值
8.获取两个小数中较小的值
9.用一个方法获取两个整数中较大的值或较小的值
public class LianXi03 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数");
int a = sc.nextInt();
System.out.println("请输入第一个整数");
int b = sc.nextInt();
//int a = 1;//可直接使用固定数值，这里我使用了从键盘中获取数据
//int b = 2;
System.out.println("请输入如第一个小数");
double c = sc.nextDouble();
System.out.println("请输入如第二个小数");
double d = sc.nextDouble();
//double c =2.5;
// double d = 5.8;
int he = qiuhe(a, b);
System.out.println("两个整数之和" + he);
double he1 = qiuhe(c, d);
System.out.println("两个小数之和" + he1);
boolean panduan = xiangde(a, b);
System.out.println("判断两个整数是否相等" + panduan);
boolean panduan1 = xingdneg1(c, d);
System.out.println("判断两个小数是否相等" + panduan1);
int zhengmax = zengshuda(a, b);
System.out.println("两个整数中较大的值" + zhengmax);
int zhengmin = zengshuxiao(a, b);
System.out.println("两个整数中较小的值" + zhengmin);
double xiaoshumax = xiaoshuda(c, d);
System.out.println("两个小数中较大的值" + xiaoshumax);
double xiaosjimin = xiaoshuxiao(c, d);
System.out.println("两个小数中较小的值" + xiaosjimin);
System.out.println("您要求最大值还是最小值:(大:小)");
String dj = sc.next();
int daxiao = dahuoxiao(a, b, dj);
System.out.println("您要求的最" + dj + "值是" + daxiao);
}
public static int qiuhe(int a, int b) {
return a + b;
}
public static double qiuhe(double a, double b) {
return a + b;
}
public static boolean xiangde(int a, int b) {
if (a == b) {
return true;
} else {
return false;
}
}
public static boolean xingdneg1(double c, double d) {
if (c == d) {
return true;
} else {
return false;
}
}
public static int zengshuda(int a, int b) {
return a > b ? a : b;
}
public static int zengshuxiao(int a, int b) {
return a < b ? a : b;
}
public static double xiaoshuda(double c, double d) {
return c > d ? c : d;
}
public static double xiaoshuxiao(double c, double d) {
return c < d ? c : d;
}
public static int dahuoxiao(int a, int b, String dj) {
switch (dj) {
case "大":
//求两个小数的最大值
return a > b ? a : b;
case "小":
//求两个小数的最小值
return a < b ? a : b;
default:
System.out.println("客官不可以...");
return -1;// -1.0表示不合法.没有进行任何计算
}
}
}
文章有不对之处，欢迎同学们指出修改，谢谢。
2543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
