方法
1、概述
方法：若干代码组织在一起，实现了一个功能。【function】(c语言) 【method】(java)
方法有什么好处：1）提高代码的复用性，2）减少代码的冗余。
2、格式
-
无参无返回值方法的定义
public static void 方法名(){ //方法体 }无返回值：返回值类型固定为void
无参：参数列表为空： ()
注意:方法写在类中方法外【方法不能嵌套】
方法的调用
方法定义好后，不会自己运行，需要调用才能执行。主方法被JVM调用的 调用格式：方法名（）;代码运行流程
1.jvm调用main方法 2.执行main方法里的方法【由上至下执行】 3.由main方法里的方法名找到对应的方法并执行 4.执行完毕后返回方法调用处 5.程序结束练习
package com.demo; public class ArrayPrintEven { public static void main(String[] args) { printEven(); } public static void printEven() { int[] arr = {1,2,3,4,5,6}; for (int i = 0; i < arr.length; i++) { int num = arr[i]; if (num%2==0) { System.out.println(num + "是偶数"); } } } }- 定义方法的三个明确说明
- 返回值类型：方法运行后是否有结果返回到方法调用处，如果没有固定为void。如果有这个返回值类型就是返回结果的类型。
- 方法名：见名知意，小驼峰。
- 参数列表：方法运行后，需要从方法外部传入的数据，可以通过参数进行传递。
-
带有参数方法的定义
【定义格式】有参无返回值方法 public static void 方法名(参数列表){ }参数列表：方法运行后，需要从方法外部传入的数据，可以通过参数进行传递。
- 不需要外部传入数据：无参 ()
- 需要从外部传入数据：有参 (参数类型 参数1，参数类型 参数2，…)
- 参数就是定义在括号中的变量
- 如果需要定义参数列表，需要知道参数列表：几个参数？各个参数的类型？
练习： 定义一个方法，接收两个int数据，方法内部将这两个数据求和并打印出来
1：返回值类型 void
2：方法名 printSum
3：参数列表 (int a,int b)
public static void printSum(int a,int b){
int sum = a+b;
System.out.println(sum);
}
带有参数方法的调用方式及流程图解
【有参方法调用】 方法名(实参);
有参方法调用时，一定要传入和形参对应类型，对应个数的实参。
/*
有参方法调用：
方法名(实参);
实参：实际参数，方法调用时中【实参可以是常量，可以是变量，表达式】
形参：形式参数，在方法参数列表中
注意：有参方法调用时，一定要传入和形参对应类型，对应个数的实参。
实参给形参赋值
*/
public class Demo01 {
public static void main(String[] args) {
printSum(100,200); // 100,200 实参
//printSum(3.14, 6.28); //类型不一致
//printSum(100 ); //个数不一致
}
public static void printSum(int a,int b) { // a,b 形参
int sum = a + b;
System.out.println("sum = " + sum);
}
}
练习
/*
定义一个方法，该方法接收一个int整数参数，方法内部打印是输出该数据是否是偶数
1）返回值类型：void
2）方法名:printOuShu
3）参数列表: (int num)
*/
public class Demo03Practice {
public static void main(String[] args) {
printOuShu(100); // 常量
int a = 111;
printOuShu(a); // 变量
printOuShu(a+1); //表达式
}
public static void printOuShu(int num) {
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
}
}
/*
定义一个方法用于打印两个int整数中的较大数，数据来自于方法参数
1）返回值类型：void
2）方法名：printMax
3）参数列表：(int a,int b)
*/
public class Demo04Practice {
public static void main(String[] args) {
printMax(100,20 );
}
public static void printMax(int a, int b) {
int max = a > b ? a : b;
System.out.println("max = " + max);
}
}
- 带返回值的方法定义
方法的返回值：方法运行后返回的结果。
返回值类型：方法运行后返回的结果的类型。
【格式】有返回值
public static 返回值类型 方法名(参数列表){
//如果有返回值，一定需要有一个return语句返回结果
return 值；
//如果返回值类型为void，可以不用return。也可用
return ;
}
返回值类型：方法运行后返回的结果的类型
- 没有返回值：固定为void
- 有返回值：值得类型即返回值类型。例如:定义一个方法对两个int数据求和，并返回结果。 返回值类型即int
如果有返回值，必须使用return语句在方法体中返回结果。
有返回值
public static 返回值类型 方法名(参数列表){
//如果有返回值，一定需要有一个return语句返回结果
return 值；
}
return 值；含义:1）表示返回值 2）表示方法运行结束
如果没有返回值，也可以有return
public static void 方法名(参数列表){
//如果返回值类型为void，可以不用return。也可用
return ;
}
return ; 含义：表示方法运行结束
【例如】定义一个方法对两个int数据求和，并返回结果。 返回值类型即int
public static int getSum(int a,int b){
return a+b;
}
带返回值的方法调用及流程图解
方法得调用：
1）直接调用:适合没有返回值得方法
2）打印调用：System.out.println(方法调用()); 【只能用于有返回值得方法】
3）赋值调用：先定义变量保存方法返回得结果。 【只能用于有返回值得方法】
变量类型 变量 = 方法调用();
注意：变量类型要和返回值类型一致。
注意：
1）没有返回值得方法，不能使用 打印调用，赋值调用，只能使用直接调用。
2）如果有返回值：建议使用 赋值，打印调用，【可以直接调用，但是无法处理方法返回得结果。】
public class Demo01 {
public static void main(String[] args) {
//1）直接调用
getSum(100, 200);
System.out.println("==========");
//2）打印调用：System.out.println(方法调用());
System.out.println(getSum(100, 200));
System.out.println("==========");
//3）赋值调用：先定义变量保存方法返回得结果。
//String sum = getSum(100, 200);
//String sum2 = 300;
int sum = getSum(1000, 2000);
System.out.println(sum);
System.out.println("=====");
//没有返回值得方法，不能使用 打印调用，赋值调用，只能使用直接调用。
test();// 直接调用
//System.out.println(test()); //打印调用
//void a = test(); //赋值调用
//如果有返回值：建议使用 赋值，打印调用，可以直接调用，但是无法处理方法返回得结果。
getSum(111, 222);
}
public static int getSum(int a, int b) {
return a+b;
}
public static void test(){}
}
【练习】
/*
定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
1）返回值类型：boolean
2）方法名：isOuShu
3）参数列表：一个int (int a)
*/
public class Demo03Practice {
public static void main(String[] args) {
System.out.println(isOuShu(100)); //true
System.out.println(isOuShu(101)); //false
}
public static boolean isOuShu(int a) {
return a % 2 == 0;
/*
System.out.println("Hello World");
if (a % 2 == 0) {
return true;
} else {
return false;
}*/
}
}
/*
设计一个方法可以获取两个数的较大值，数据来自于参数
1）返回值类型： int
2）方法名: getMax
3）参数列表: 2 个int (int a,int b)
*/
public class Demo04Practice {
public static void main(String[] args) {
System.out.println(getMax(100,200 )); //200
System.out.println(getMax(1000,200 )); //1000
}
public static int getMax(int a, int b) {
int max = a > b ? a : b;
return max;
}
}
- 定义方法的注意事项
-
方法不能嵌套定义
-
返回值类型，必须要和
return语句返回的结果类型相同，否则编译失败 。 -
不能在
return后面写代码，return意味着方法结束，所有后面的代码永远不会执行，属于无效代码。 -
void表示无返回值，可以省略return，也可以单独的书写
return;，后面不加数据
方法重载的的概述
-
什么是重载？同一个类中，存在同名不同参的方法。这些方法就互为重载。
-
调用方法是通过方法名调用的，调用重载方法不会混乱么？
【方法名】+【参数列表】 共同选择一个最适合的方法执行。
/*
定义方法，打印两个数的和。
重载方法的好处：能够方便调用方法
如何选择重载方法的调用？【方法名】+【参数列表】 共同选择一个最适合的方法执行。
*/
public class Demo01 {
public static void main(String[] args) {
//两个int
printSum(100, 200);
//两个double
//printSum(3.14, 1.414);
printSum2(3.14, 1.414);
printSum(1.414, 1.732);
//两个字符串
printSum3("Hello", "World");
byte b1 = 111, b2 = 100;
printSum(b1, b2); //printSum(int ,int)
//printSum(3.14, "Hello"); //printSum(double , String) 找不到匹配的方法
printSum("Hello",3.14 ); //printSum(String ,double)
}
public static void printSum(int a, int b) {
System.out.println(a+b);
}
public static void printSum(String a, double b) { //重载
System.out.println(a+b);
}
public static void printSum(double a, double b) {//重载
System.out.println(a+b);
}
public static void printSum2(double a, double b) {//不是重载
System.out.println(a+b);
}
public static void printSum3(String a, String b) {//不是重载
System.out.println(a+b);
}
}
重载：同名不同参的方法
-
同名：方法名相同
-
不同参：参数列表不同
- 个数不同
- 个数相同，类型不同
- 个数相同，类型相同，参数列表顺序不同
和参数名，返回值类型，和修饰符没有关系。
方法重载练习
- 需求1：使用方法重载的思想，设计比较两个数据是否相等的方法，兼容全整数类型byte,short,int,long）
/*
使用方法重载的思想，设计比较两个数据是否相等的方法，兼容全整数类型byte,short,int,long）
*/
public class Demo02Practice {
public static void main(String[] args) {
byte a1 = 10, b1 = 20;
short a2 = 10, b2 = 10;
int a3 = 10, b3 = 20;
long a4 = 20, b4 = 20;
compare(a1, b1); //compare(byte a, byte b)
compare(a2, b2); //compare(short a, short b)
compare(a3, b3); // compare(int a, int b)
compare(a4, b4); //compare(long a, long b)
}
//两个byte
public static void compare(byte a, byte b) {
System.out.println(a==b);
}
//两个short
public static void compare(short a, short b) {
System.out.println(a==b);
}
//两个int
public static void compare(int a, int b) {
System.out.println(a==b);
}
//两个long
public static void compare(long a, long b) {
System.out.println(a==b);
}
}
判断哪些方法是重载关系
【同名不同参】
public static void open(){}
public static void open(int a){}
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){} //x 和5同名参数相同
public static void OPEN(){} //x 不同名
public static void open(int i,int j){} //x 和3同参
方法的练习
-
需求1：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
System.out.println("Hello1"); //打印Hello并换行 System.out.print("Hello2"); //打印Hello不换行 System.out.print("Hello3"); //打印Hello不换行/* 设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55] */ public class Demo01 { public static void main(String[] args) { //System.out.println("Hello1"); //打印Hello并换行 //System.out.print("Hello2"); //打印Hello不换行 //System.out.print("Hello3"); //打印Hello不换行 int[] arr = {11, 22, 33, 44, 55}; printArray(arr); } public static void printArray(int[] arr) { //[11, 22, 33, 44, 55] //1)先打印一个: [ System.out.print("["); //2)遍历数组，取出元素打印：元素后面加逗号，最后一个加] for (int i = 0; i < arr.length; i++) { //元素后面加逗号，最后一个加] if (i == arr.length - 1) { System.out.println(arr[i] + "]"); } else { System.out.print(arr[i]+", "); } } } }设计一个方法用于获取数组中元素的最大值
public class Demo02 { public static void main(String[] args) { int[] arr={5,15,2000,10000,100,4000}; System.out.println(getMax(arr)); //10000 } //功能实现:获取数组的最大值 public static int getMax(int[] arr) { int max = arr[0]; for (int i = 0; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } return max; } }
方法参数传递概述
形参：方法参数列表中参数。
实参：调用方法时传入的数据。
调用一个有参的方法时，有一个参数传递的过程，本质上就是实参给形参赋值。
方法的参数类型可以是任意的类型：
- 基本数据类型
- 引用数据类型
基本数据类型作为参数传递特点【形参变，实参不变】
基本数据类型作为形参的特点：形参如果改变了值，实参不会发生改变
/*
基本数据类型作为形参的特点：形参如果改变了值，实参不会发生改变
*/
public class Demo01 {
public static void main(String[] args) {
int score = 50;
System.out.println("main1 = " + score); // 50
change(score);
System.out.println("main2 = " + score); // 50
}
public static void change(int num) {
System.out.println("change:1 " + num); // 50
num = 100;
System.out.println("change:2 " + num); //100
}
}
基本数据类型作为参数传递图解
如果需要改变值，可以使用方法的返回值返回数据，然后赋值给实参。
引用数据类型作为参数传递特点
特点：形参地址不变的情况下，形参内容发生改变，实参内容也会改变。
/*
特点：形参地址不变的情况下，形参内容发生改变，实参内容也会改变。
*/
public class Demo01 {
public static void main(String[] args) {
int[] brr = {10, 20, 30};
System.out.println("main1 = " + brr[0]); //10
change(brr);
System.out.println("main2 = " + brr[0]); //100
}
public static void change(int[] arr) {
System.out.println("change1 = " + arr[0]);//10
arr[0] = 100;
System.out.println("change2 = " + arr[0]);//100
}
}
引用数据类型作为参数传递特点
特点：形参地址不变的情况下，形参内容发生改变，实参内容也会改变。
/*
特点：形参地址不变的情况下，形参内容发生改变，实参内容也会改变。
*/
public class Demo01 {
public static void main(String[] args) {
int[] brr = {10, 20, 30};
System.out.println("main1 = " + brr[0]); //10
change(brr);
System.out.println("main2 = " + brr[0]); //100
}
public static void change(int[] arr) {
System.out.println("change1 = " + arr[0]);//10
arr[0] = 100;
System.out.println("change2 = " + arr[0]);//100
}
}
引用数据类型作为参数传递图解
811
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
