方法(四)


方法(四)

方法:封装某种功能,提高代码的复用性和可维护性,方法是程序中最小的执行单元。
面向过程中,称方法为函数;在面向对象中,称为方法。
方法定义:将一些代码打包在一起,该过程为方法定义
方法调用:方法定义后不是直接运行的,需要手动调用才能执行,该过程名为方法调用
平时用的main也是一个方法,main方法可以被jvm识别。
格式

1
2
3
4
权限修饰符 其他修饰符 返回值类型 方法名(参数列表){
方法体;
return 返回值;
}

返回值类型

void表无返回值,有返回值则使用数据类型(基本数据类型+引用数据类型)。
return关键字

  • 方法无返回值:return可以省略不写,如果要写return,后面不能跟具体数据,表示结束方法。
  • 方法有返回值:必须要写return,表结束方法和返回结果

无返回值的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test{
public static void p(){
System.out.println("方法");
}
public static void main(String[] args){//void表示无返回值
//第一次调用方法
p();
//第二次调用方法
p();
}
}
/*
方法
方法
*/

有返回值的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//调用方法,返回1-10的总和
public class Test{
public static int s(){//返回值为整型
int sum=0;
for(int i=1;i<=10;i++){
sum+=i;
}
return sum;
}
public static void main(String[] args){
//直接打印
System.out.println(s());
//也可以将方法返回值用整型变量接收
//例如:
int i=s();
System.out.println(i);
}
}
/*
55
55
*/

参数列表

参数

  • 实际参数:实际参加运算的值。基本数据类型是值,引用数据类型是地址值。
  • 形式参数:定义方法时,参数列表的参数

例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//调用方法计算两个值的和,并返回
public class Test{
//x,y为形参,实际调用方时传入的值为方法的实参
public static int sum(int x,int y){
return x+y;
}
public static void main(String[] args){
int s1=sum(10,30);
System.out.println("传入的两个数值和为:"+s1);
int s2=sum(30,40);
System.out.println("传入的两个数值和为:"+s2);
}

}
/*
传入的两个数值和为:40
传入的两个数值和为:70
*/

方法的调用

调用格式:
方法名(实参列表);
实参列表的注意事项:实参列表的参数个数,类型,顺序需与形参完全相同。
:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test{
public static int s1(int x,int y){
return x+y;
}
public static String s2(int x,String s){
return x+s;
}
public static void main(String[] args){
System.out.println(s1(10,20));//调用s1
System.out.println(s2(10,"ljsblog"));//调用s2
}
}
/*
30
10ljsblog
*/

方法的重载

定义:同一个类中出现多个方法名相同,参数列表不同的多个方法,这种现象称为方法重载(overloading)
参数列表:

  • 参数个数不同
  • 参数类型不同
  • 不同类型的参数顺序不同(不建议)

:方法的重载与访问权限修饰符和返回值类型无关。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Test {
public static int add(int a) {
return a;
}

//参数个数不同
public static int add(int a, int b) {
return a + b;
}

//参数类型不同
public static int add(double a, int b) {
return (int) a + b;
}
//不同类型参数顺序不同

public static int add(int a, double b) {
return a + (int) b;
}

public static void main(String[] args) {
System.out.println(add(10));//调用add(int a)
System.out.println(add(10, 20));//调用add(int a,int b)
System.out.println(add(20.5, 30));//调用add(double a,int b)
System.out.println(add(30, 15.5));//调用add(int a,double b)
}
}
/*
10
30
50
45
*/

方法的递归

方法调用自身称为递归,使用递归时要设置终止条件。
递归条件:存在限制条件,当满足这个限制条件时,递归不再继续,每次递归调用后越来越接近这个限制条件。
:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Scanner;
//输入一个数,计算其阶乘
public class Test{
public static int f(int num){
if(num==1){
return 1;
}
return num*f(num-1);
}
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
System.out.println(n+"的阶乘为"+f(n));
}
}
/*
5
5的阶乘为120
*/

方法范例

求数组最大值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test{
public static void main(String[] args){
int[] arr={45,47,57,16,44,78};
int max=getMax(arr);
System.out.println("最大值为"+max);
}
public static int getMax(int[] arr){
int max=arr[0];
for(int i=1;i<arr.length;i++){
if(n<arr[i]){
n=arr[i];
}
}
return max;
}
}

判断是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//定义一个方法判断数组中某个数是否存在
public class Test{
public static void main(String[] args){
int[] arr={45,47,57,16,44,78};
boolean flag=f(arr,57);
if(flag==true){
System.out.println("存在");
}else{
System.out.println("不存在");
}
}
public static boolean f(int[] arr,int num){
for(int i=0;i<arr.length;i++){
if(arr[i]==num){
return true;
}
}
return false;
}
}
/*
存在
*/

拷贝数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//将数组下标from到to(不包括to)的数据拷贝到arr2,并返回打印
public class Test{
public static void main(String[] args){
int[] arr1={1,2,3,4,5,6,7,8,9,10};
int[] arr2=copy(arr1,2,5);
for(int i=0;i<arr2.length;i++){
System.out.println(arr2[i]);
}
}
public static int[] copy(int[] arr1,int from,int to){
int[] arr2=new int[to-from];
for(int i=from,j=0;i<to;i++,j++){
arr2[j]=arr1[i];
}
return arr2;
}
}
/*
3
4
5
*/

方法的内存

方法被调用后就会进栈执行,先进后出。

  • 基本数据类型
    • 数据值存储在自己的空间中,赋值给其他变量,赋的真实的值。
    • 方法传递基本数据类型时,传递的是真实的数据,形参改变不影响实际参数的值
  • 引用数据类型
    • 数据值存储在其他的空间中,自己空间存储的是地址值,赋值给其他变量,赋的是地址值
    • 方法传递引用数据类型时,传递的是地址值,形参改变,影响实际参数的值

Author: ljs
Reprint policy: All articles in this blog are used except for special statements CC BY 4.0 reprint polocy. If reproduced, please indicate source ljs !
评论
  TOC