一、何谓方法
——何谓方法？
- System.out.println(),表示调用系统 类 里面的标准输出 对象 out中的方法 println()方法
- Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合。
- 方法包含于类或对象中。
- 方法在程序中被创建，在其他地方被引用。
- 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样有利于我们后期的扩展。
二、方法的定义及调用
——方法的定义
- Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
- **方法包含一个方法头和一个方法体。**下面是一个方法的所有部分：
- 修饰符： 修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型： 方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，没有返回值，在这种情况下，returnValueType 是关键字 void。（如果方法存在返回值，则返回值一定要通过return关键词返回，如果是void(空)没有返回值，则不需要return ）
- 方法名： 是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型： 参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用时用于接收外界输入的数据。
- 实参：调用方法时实际传给方法的数据。
- 方法体： 方法体包含具体的语句，定义该方法的功能。
修饰符 返回值类型 方法名（参数类型 参数名）{
...
方法体
...
return 返回值；
}public class Demo02 {
public static void main(String[] args) {
double max = max(20, 20);//实际参数，实际调用传递给它的参数
System.out.println(max);
}
// void，空返回值
//前两个为修饰符 返回值类型 方法名（比大小方法）
public static double max(double a,double b){//形式参数，用来定义作用的
double result=0;
if (a==b){
System.out.println("a==b");
}else {
if (a>b){
result = a;
}else {
result = b;
}
}
return result;
}
}——方法调用
- 调用方法：对象名.方法名(实参对象)
- Java 支持两种调用方法的方式，根据方法是否返回值来选择。
- 当方法返回一个值的时候，方法调用通常被当做一个值。例如：
int larger = max(30,40);- 如果方法返回值是void，方法调用一定是一条语句。
System.out.println("Helllo World!")- 课后拓展了解：值传递（Java是值传递） 和 引用传递
三、方法重载
——方法重载
- 重载就是在一个类中，有相同的函数名称，但形参不同的函数。
- 方法的重载的规则：
- 方法名称必须相同。
- 参数列表必须不同（参数个数不同、参数类型不同、参数排列顺序不同…）。
- 参数个数不同
public class Demo001 {
public static void main(String[] args) {
int x = add(10, 22);
System.out.println(x);
int y = add(11, 22, 33);
System.out.println(y);
}
public static int add(int a,int b){//2个参数
return a+b;
}
public static int add(int a,int b,int c){//3个参数
return a+b+c ;
}
}- 参数类型不同
public class Demo001 {
public static void main(String[] args) {
int x = add(10, 22);
System.out.println(x)
double z = add(11.1, 22.2);//如果实际参数全是int ，则运行的方法是下面第一个int方法，再把值转化为double；而不是直接应用下面第二种double方法
System.out.println(z);
double j = add(10.1, 10);//如果实际参数全是int ，则运行的方法是下面第一个int方法，再把值转化为double；而不是直接应用下面第三种多种类型方法
System.out.println(j);
}
public static int add(int a,int b){//全int类型
return a+b;
}
public static double add(double a,double b){//全double类型
return a+b;
}
public static double add(double a,int b){//多种类型
return a+b;
}
}- 参数排列顺序不同
public class Demo001 {
public static void main(String[] args) {
double z = add(11, 22.2);//如果参数全是int ，则运行的方法是下面第一个int方法，再把值转化为double；而不是直接应用下面第2种double方法
System.out.println(z);
double j = add(10.1, 10);//如果参数全是int ，则运行的方法是下面第一个int方法，再把值转化为double；而不是直接应用下面第3种double方法
System.out.println(j);
}
public static int add(int a,int b){//全int
return a+b;
}
public static double add(int b,double a){//int在前
return a+b;
}
public static double add(double a,int b){//double在前
return a+b;
}
}- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载。
- 实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
四、命令行传参
—— 命令行传参
- 有时候你希望运行一个程序的时候再传递给它消息。这要靠传递命令行参数给 main()函数实现。
public class Demo03 {
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i <args.length ; i++) {
System.out.println("args[" + i + "]:" + args[i]);
}
}
}五、可变参数
——可变参数（不定项参数）
- JDK 1.5 开始，Java支持传递同类型的可变参数（不定项参数）给一个方法。
- 在方法声明中，在指定参数类型后加一个省略号（…）。
- 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声明。
public class Demo04 {
public static void main(String[] args) {
//调用可变参数的方法
printMax(22,33,455,12313,493222,423131);//随便输入多个double类型的数组number
printMax(new double[]{22,33,55,21});//自定义一个double类型的数组
}
//打印出最大值
public static void printMax(double... number){//不确定有多少个元素（参数），则在元素（参数）的类型后面加...
if (number.length==0){//先判断number数组是否有元素（参数）
System.out.println("No argument passed");
return;
}
double result = number[0];//定义一个元素（number[0]代表number数组的第一个元素（参数））
//比大小
for (int i=1;i<number.length;i++){//从第二个元素（参数）开始遍历
if (number[i]>result){
result=number[i];//如果number[i]比result大，则把number[i]赋值给result
}
}
System.out.println("最大值是："+result);
}
}public class Test1 {
/*
* ... 可变参数
* 当 ... 作为形参时 传入的实参是可变的
* 在方法体内部 仍然将可变参数当成数组使用
* 如果传入的实参是多个单独的变量 程序会自动将多个单独的变量放入数组
*
* 可变参数的好处
* 1 传入数组OK
* 2 传入多个单独的变量OK
* 3 传入的多个单独的变量的数量没有要求 可以变化的
* */
// 定义一个方法 遍历一个整数数组
public static void showArray(int... arr){
System.out.println("showArray 方法执行了");
for (int i = 0; i <arr.length ; i++) {
System.out.println(arr[i]);
}
}
public static void main(String[] args) {
int[] arr={1,2,3,4,5,6,7,8,9};
int a=11;
int b=22;
int c=33;
int d=44;
int e=55;
int f=66;
int g=77;
showArray(a,b,c,d);
showArray(arr);
}
}——可变参数的使用的注意事项
六、递归
——递归(方法（栈）不能无限加，否则会溢出造成内存崩溃)
- A方法调用B方法，我们很容易理解！（例：main()方法调用其他方法）
- 递归就是：A方法调用A方法！就是自己调用自己
- 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
- 递归结构包括两个部分：
- 递归头： 什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体： 什么时候需要调用自身方法。
- 边界条件：边界（当执行到最后一个要求时，终止（例：f(1)==1）如下代码）
- 前阶段：当代码不符合边界条件时，会不停的调用自身，直到符合边界条件，终止并依次返回结果
- 返回阶段：重复返回 n*f(n-1) 直到f(1)
public class Demo05 {
//阶乘 1！=1，2！=2*1，3！=3*2*1，4！=4*3*2*1
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个阶乘数：");
int i = scanner.nextInt();
System.out.println(f(i));//应用输出方法
}
//1！=1
//2！=2*1
//3！=3*2*1
public static int f(int i){//创建一个方法
if (i==1){//如果i==1，则输出i并终止
System.out.println(i);
return i;
}else {//否则 结束输出i*f（i-1），f（i-1）套用f（i）方法直到i==1，结束
System.out.print(i+"*");
return i*f(i-1);
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
