java 定义方法的参数_Java方法的定义及其递归和参数传递（重点！！！）

一、方法

​1、方法的概念

​将一个功能抽取出来，放在类中的大括号中，形参一个独立的功能，当需要使用它时，直接调用它，这样可以增强代码的复用性(重复利用)，并解决代码冗余现象。

Java方法是语句的集合，它们在一起执行一个功能

方法是解决一类问题的步骤的有序组合

方法包含于类或对象中

方法在程序中被创建，在其他地方被引用

2、设计方法的原则

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展

3、方法的语法

​【访问修饰符】返回值类型 方法名(【参数类型 参数名1，参数类型 参数名2.....】){

​方法体

​}

详解：

​访问修饰符：用于修饰这个方法的调用范文 目前默认public static

​返回值类型：无返回值就写void 或者 方法执行后返回的结果的数据类型，方法执行完之后会将结果返回

​方法名：给方法起名，遵循标识符的规则

​参数类型、参数名：它们是同时定义，方法在执行时未知的数据，需要在调用方法时进行传递值，参数类型表示这个参数的数据类型，参数名就是这个参数的名称，这个参数名称可以在方法体中使用

​方法体：这个方法具有的功能(代码块)

定义一个方法

public static int add(int num1，int num2){

return num1+num2；

}

4、方法的分类

​根据方法的参数不同，返回值不同，可以将方法分为四类：

1、无参无返回值方法

语法

public static void 方法名(){

方法体

}

2、无参有返回值方法

语法

public static void 返回值类型 方法名(){

方法体

}

/**

* 定义无参有返回值，需要先指定 这个返回值的数据类型

* 生成一个100以内的随机整数

*/

public static int getRandomNum(){

System.out.println("生成随机数");

int num = (int)(Math.random()*100);

return num; //注意 返回值类型 必须与定义的数据类型一致

}

public static void main(String[] args) {

//调用有返回值类型

//(返回值可以接受，也可以不接受，一般建议接受)

int n=getRandomNum();

System.out.println(n);

}

//结果在n中

3、有参无返回值方法

语法：

public static void 方法名(参数列表){

方法体

}

情况一：当参数中是基本数据类型，将实参的值赋值给形参

public static void add(itn num){

num++;

System.out.println("方法中num的值："+num);

}

调用方法：num的改变不会改变n的值，因为是两个独立的内存

int n = 10;

System.out.println(n);

add(n);

System.out.println("方法外面 实参的值："+n)；

结果输出：

​方法中num的值：11

​方法外面实参的值：10

情况二：当参数的数据类型是引用数据类型

例如：数组

//方法的比对 参数的数组

public static void add(int [] arr){

arr[0]++;

System.out.println("方法中aar[0]="+aar[0]);

}

调用：

int [] array = {10,20};

add(array);//会调用 参数是数组的add方法

System.out.println("方法外面的arr【0】"+array[0]);

结果：

​方法中arr[0]=11

​方法外面的arr[0]=11

例如：类的调用

public static void addAge(Stdent studen){

//将学生的年龄 获取 自加

int age = student.age;

age++;

// 在重新赋值

student.age=age;

}

调用：

Student student = new Student(); //age默认为 18

System.out.println("方法调用之前："+student.age);//18

addAge(student);// 传送的地址

System.out.println("方法外面 学生的年龄："+student.age);

结果输出：方法调用之前： 18

​方法外面 学生的年龄：19

/**

* 以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，

* 也就是说 参数再传递时，将引用类型的地址赋值给 方法的形参

* 对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变

* 不会影响实参的值

* 原因： 引用数据类型在参数传递时 是地址 (JVM对于堆内存的大小不可控)

* 基本数据类型在参数传递时 是值

*

*/

情况三：当参数是String类型时，String是引用数据类型，但是在参数传递时，与基本类型一样

public static void main(String[] args){

//参数是字符串

String uname = “李四”；

sayHello(uname)；

System.out.println("我最后对："+uname+"sayHello");

}

public static void sayHello(String name){

name= "张三"；

System.out.println("我对"+name+"sayHello")；

}

结果：我对张三sayHello

​我最后对李四sayHello

4、有参有返回值方法

语法：

public static 返回值类型 方法名(参数列表){

方法体

}

例如：

public static String sayHello(String name){

name="张三";

System.out.println("我对"+name+"sayHello");

return name ;

}

调用：

public static void main(String[] args) {

// 参数是字符串

String uname ="李四";

// 将返回值接收 ，这是 uname 才被改变 ，如果不接受，则不改变

uname = sayHello(uname);

System.out.println("我最后对"+uname+"sayHello");

}

结果：

我对张三sayHello

我最后对张三sayHello

5、方法的调用

​如果方法体中需要一些位置的数据作为执行条件，那么这些数据可以作为参数

​如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型

​方法调用两种方式：

对象名 方法名(参数)

直接写方法名调用，但必须是static修饰的

//获取这个字符串的第一个字符

public void method1(String str){

//返回字符串的第一个字符

return str。charAt(0)；

}

//调用方法

对象名.method1()

//调用静态方法 (static修饰的)

String s = "abc";

char c = method1(s) //s将赋值给方法的形参 str 那么方法执行时str有值

//c就是方法调用后的返回值0

6、方法参数传递

1、方法的参数是基本数据类型，它传递的是值

//计算一个属的平方

public int pow(int a){

a = a + 2；

return a * a；

}

main:

int num = 4;

int sum = pow(num);//赋值给a

System.out.println(num);//4

System.out.println(sum);//36

2、方法的参数是引用数据类型，它传递的是地址(除了String类型除外)

//参数 是数组类型

public static int pow(int [] arr){

arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;

return arr[0]*arr[0]; // 4*4

}

调用

// 调用另一个pow

int [] array = {2,3};

int sum2 = pow(array) ; // array中存放数组的地址 ，将地址赋值给 arr形参

System.out.println(array[0]);// 4

System.out.println(sum2 ); // 16

7、方法的重载

​在一个类中，存在相同的方法名的两个级以上的方法，且它们的参数列表不同(参数类型不通风，参数个数不同，参数顺序不同)，不考虑参数名，不考虑返回值类型

​一个类中不能存在完全相同的方法，它们是重复的方法。JVM编译不通过

例如：

public int add(int a,int b){

return a+b;

}

//重载

public int add(long a,long b){

return (int)(a+b);

}

//与前两个 不重载

public void add(int c,int d){

}

// 能与 方法1 ，2 构成重载

public void add(int a){

}

// 能与 方法1 ，2 构成重载

public void add(int a ,long b){

}

// 能与 方法1 ，2 构成重载

public void add(long a ,int b){

}

注意：方法名是否相同，参数列表是否相同(数据类型，参数个数，参数顺序)

方法重载的规则

方法名称必须相同

参数列表不同(类型，个数，顺序等)

方法的返回类型可以相同也可以不相同

仅仅返回类型不同不足以成为方法的重载

实现理论:

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

在一个方法中可以调用另外一个方法

//在一个方法中可以调用另外一个方法，它们的执行顺序是这样的

public static void main(String[] args) {

System.out.println("这是main方法 的开始语句块");

method1();

System.out.println("这是main方法 的结束语句块");

}

public static void method1(){

System.out.println("这是method1 的开始语句块");

//在一个方法中可以调用另外一个方法，它们的执行顺序是这样的

method2();

System.out.println("这是method1 的结束语句块");

}

public static void method2(){

System.out.println("这是method2 的开始语句块");

method3();

System.out.println("这是method2 的结束语句块");

}

public static void method3(){

System.out.println("这是method3 的开始语句块");

System.out.println("这是method3 的结束语句块");

}

8、方法的递归调用

1、定义

​在一个方法中，运行方法自身调用，这样的调用称为方法的递归调用，为了避免出现方法调用时出现死循环，递归调用中必须定义 方法结束调用的条件。

​方法递归调用执行流程

public static void m3(int i){

if(i==5){

return ;

}

System.out.println("这是m3方法开始i :"+ i);

i++;

m3(i);

System.out.println("m3方法的结束 i:"+ i );

}

public static void main(String[] args) {

m3(0); //

}

例题：用户输入一个数字使用递归计算出这个数的阶乘

//使用递归输入一个数计算它的阶乘

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个数");

int num=sc.nextInt();

int sum=f(num);

System.out.println(sum);

}

public static int f(int n){

if (n==1)

return 1;

return n*f(n-1);

}

以下是递归的练习题，有兴趣的可以做做

练习1 ： 一组序列 1 ，1, 2，3, 8...13,21,34,55,89,144 n， 第12个数 为多少？

练习2： 1， 3， 5， 7， 9， 11 . 问前10个数的和

练习3 ：前5个阶乘之和 例如 5!+4!+3!+...1!

练习4：定义一个函数，函数有一个整型参数n，

如果参数n为偶数时，调用函数求1/2+1/4+...+1/n,

如果参数n为奇数时，调用函数1/1+1/3+...+1/n

练习5、 1/1+1/2+2/3+3/5+5/8.。。。前8个数之和。