java方法学习

java 方法

在Java中，方法是类（或对象）的行为或功能的实现。（一起实现一个功能）java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段。

• 方法是解决一类问题步骤的有序结合。

• 方法包含于类或对象中。

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

  设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。设计方法时，最好保持方法的原子性。（就是一个方法只完成一个功能，有利于后期的拓展）

package com.jianstudy.method;
public class Demo01 {public static void main(String[] args) {//如果是实例方法要先创建类的实例:类名 声明的变量的名称 =new 类名() --- new 类的名称()是创建一个类的名称类型新对象的表达式。Demo01 demo01 = new Demo01();//创建一个Demo01类的demo01实例int result = demo01.add1(1, 2);//调用实例demo01里的add1方法System.out.println(result);//如果方法是静态的static修饰符int result1 =add(2,2);//实际参数：实际调用时，传递给他的参数System.out.println(result1);}/*方法的定义修饰符 返回类型 方法名(参数列表) {方法体}*///定义一个加法方法//静态方法             ↓形式参数，用来定义作用的参数。（接收外界输入的数据）public static int add(int a, int b) {return a+b ;}public  int add1(int a, int b) {return a+b ;}
}

package com.jianstudy.method;public class Demo02 {public static void main(String[] args) {Demo02 demo02 = new Demo02();int max =demo02.max(6,6);System.out.println(max);}//比大小方法 显示对比结果，返回大的数// 如果不需要返回值直接使用void类型//public void max(int a, int b){}public int max(int a, int b) {int result=0;if(a==b){System.out.println("a==b");return 0;}if(a>b){System.out.println("a>b");result = a;}else{System.out.println("a<b");result = b;}return result ;}
}

不需要返回值的话 0 5 4 就不会显示了

方法的定义

在Java中，方法的定义是指声明一个具有特定名称、参数列表（可能为空）、返回类型（可能为void表示不返回任何值）以及方法体（包含执行语句的块）的代码段。

[修饰符] 返回的数据类型 方法名([参数列表]) {

方法体 …

执行语句 …

return 返回值; // 如果返回类型不是void，则需要有返回语句

}

1. 修饰符（可选）：这是方法的访问控制符或其他修饰符，如public、private、protected、static、final等。它们定义了方法的可见性、是否可以被继承、是否是静态的等特性。

2. 返回类型：这是方法执行完毕后返回的数据类型*。如果方法不返回任何值，则使用void关键字。

3. 方法名：这是方法的标识符，用于在代码中引用该方法。方法名应该是描述性的，以便清楚地表明方法的功能。（命名要见名知义）

4. 参数列表（可选）：这是一组由逗号分隔的变量声明，它们定义了方法接收的输入。如果方法不接受任何参数，则参数列表为空，但仍需要保留圆括号()。

   每个参数都包括类型和变量名。参数像是一个占位符，当方法被调用时，传递值给参数。这个值被称为实参（实际参数）或变量。

   • 形式参数：在方法被调用时，用于接收外界输入的数据。
   • 实参：调用方法时，实际传递给的方法的数据。

5. 方法体：这是包含方法执行语句的代码块。方法体由大括号{}包围，并且包含了实现方法功能的Java语句。（实现功能的代码）

6. 返回语句（可选）：如果方法有一个非void的返回类型，则必须包含一个return语句来返回相应类型的值。return语句也可以用于提前退出方法或返回特定的值。

方法的调用

在Java中，方法的调用是指通过方法名以及必要的参数来执行该方法的过程。调用方法时，程序会跳转到方法定义中的方法体，并执行其中的代码。方法调用可以在同一个类中、子类中、或者不同类（通过对象实例或类名）之间进行。

以下是一些方法调用的基本形式：

1. 同一类中的方法调用
   在类的内部，可以直接通过方法名来调用该类中定义的其他方法。
2. 通过对象实例调用方法
   当方法不是静态的（即不是用static关键字修饰的）时，需要通过类的对象实例来调用该方法。格式：类名 声明的变量的名称 =new 类名()
3. 通过类名调用静态方法
   静态方法属于类本身，而不是类的某个实例。因此，可以通过类名直接调用静态方法，而无需创建类的对象。

在方法调用时，需要注意以下几点：

• 确保方法的存在性：调用的方法必须在类中被定义，否则会导致编译错误。
• 参数匹配：传递给方法的参数类型、数量和顺序必须与方法定义中的参数列表相匹配。
• 访问权限：调用方法时，必须遵守Java的访问控制规则。例如，私有方法（private）只能在定义它们的类内部被调用。
• 静态上下文：在静态方法或静态初始化块中，只能直接调用静态方法或访问静态字段。要调用非静态方法或访问非静态字段，需要先创建类的对象实例

方法的重载

在Java中，方法的重载（Overloading）是一种允许在同一个类中定义多个同名方法的技术，只要它们的参数列表不同即可。参数列表的不同可以体现在参数的类型、数量或顺序上。方法重载的主要目的是提高代码的可读性和易用性，使得程序员可以用一种更自然的方式来表示相同的功能。

方法重载的关键点

1. 方法名相同：重载的方法必须具有相同的名称。
2. 参数列表不同：重载的方法参数列表必须不同，这可以通过改变参数的类型、数量或顺序来实现。
3. 返回类型可以相同也可以不同：方法的返回类型不是重载的考虑因素。即使两个方法具有相同的名称和不同的返回类型，但如果它们的参数列表相同，那么它们就不是重载方法。
4. 访问修饰符和异常声明可以不同：访问修饰符（如public、private等）和抛出的异常类型也不会影响方法的重载。

方法重载的原理

方法重载的实现依赖于编译器（jvm）。当编译器遇到一个方法调用时，它会根据传递给方法的参数类型和数量来选择合适的方法进行调用。如果有多个同名方法，编译器会根据参数列表的不同来进行匹配。

需要注意的是，虽然方法重载可以提高代码的可读性和灵活性，但过度使用也可能会导致代码的可读性下降。因此，在使用方法重载时，应该遵循一定的命名和规范，以确保代码的可维护性。

package com.jianstudy.method;
public class Demo03 {public static void main(String[] args) {Demo03 demo03 = new Demo03();int result1 = demo03.add(5,4);int result2 = demo03.add(1,2,3);double result3 =add(10.1,5.5)  ;//静态的方法可以直接调用double result4 =demo03.add(10,5,5.5)  ;System.out.println(result1);        System.out.println(result2);        System.out.println(result3);System.out.println(result4);}//方法的重载/*方法名相同，参数列表必须不同，返回值类型可以相同，也可以不同，访问修饰符和异常声明可以不同*/public  int add(int a, int b) {return a+b ;}public  int add(int a, int b,int c) {return a+b+c ;}//这里使用了静态方法public static double add(double a, double b){return a+b ;}public double add(int a, int b,double c) {return a+b+c;}}

可以看出虽然用的方法名都是add但是根据参数列表的不同选择了对应参数的add方法。

命令行传参

当运行一个程序时再传给它数据，这就要用命令行传参给 main（）函数实现。

Java命令行传参不是一种方法，而是一种在运行Java程序时向程序传递参数的方式。这些参数在程序启动时通过命令行传递给main方法，并作为main方法的参数String[] args数组的一部分被接收和处理。

在Java中，main方法是程序的入口点，它的签名是固定的，即public static void main(String[] args)。其中，args参数是一个字符串数组，用于接收命令行传递的参数。当你通过命令行运行Java程序时，可以在类名后面跟上任意数量的参数，这些参数将被作为字符串数组传递给main方法。

package com.jianstudy.method;
public class Demo04 {public static void main(String[] args) {for (int i =0; i<args.length;i++) {System.out.println("args["+i+"]="+args[i]);}}
}

当运行一个程序时再传给它数据，这就要用命令行传参给 main（）函数实现。

可变参数

在Java中，可变参数（varargs）是一种方法参数，它允许你向方法传递任意数量的参数，或者更具体地说，是传递一个可变数量的同类型参数。可变参数在方法声明中使用省略号（...）作为类型的一部分来表示。

当你不确定要传递给方法多少个参数，或者你想要方法能够接受不同数量的参数时，可变参数就非常有用了。

需要注意的是，可变参数在方法签名中必须是最后一个参数。如果一个方法接受其他类型的参数，那么可变参数必须放在这些参数的后面。

另外，虽然可变参数很方便，但也要谨慎使用，因为它们可能会使方法的签名变得不那么清晰，特别是当方法接受多个参数时。在可能的情况下，考虑使用重载（方法名相同但参数列表不同）来提供更清晰的方法接口。

方法的声明：

[修饰符] 返回的数据类型 方法名([参数列表]) {

方法体 …

执行语句 …

return 返回值; // 如果返回类型不是void，则需要有返回语句

}

可变参数声明方式：

返回类型 方法名(参数类型… 参数名) { // 方法体 }

可变参数在方法中被当作一个数组来处理。

package com.jianstudy.method;
public class Demo05 {public static void main(String[] args) {Demo05 demo05 = new Demo05();System.out.println(demo05.add());System.out.println(demo05.add(1, 2));System.out.println(demo05.add(3,1,2));}//不知道要加几次用可变参数 定义的可变参数就是数值。public int add(int... num) {//遍历数组num如果没有输入数据就输出"没有数据传入"if (num.length == 0) {System.out.print("没有数据传入");return 0;}//声明result 存放数组里的每一个数相加之后的结果int result = 0;//nums会依次取数组num里每个元素的值，然后执行循环体的程序//for eachfor (int nums : num) {result = result + nums;}return result;}
}

递归

在Java编程中，递归是一种特殊的编程技巧，它指的是一个方法在执行过程中能够调用自身的能力

1. 递归的基本概念

   递归的核心在于一个方法能够自我调用，以解决那些可以被拆解为更小、更相似子问题的大问题。这种自我调用的过程会一直持续，直至达到某个预设的终止条件，此时递归将停止，并开始逐层返回之前调用的结果。

2. 递归的两大要素

   • 递归公式：这是递归方法的核心，它定义了方法如何调用自身，并展示了如何将大问题分解为小问题进行求解
   • 终止条件）：递归必须有一个明确的结束点，以防止方法无限制地自我调用，从而避免栈溢出等严重问题。当满足这个条件时，递归将停止。

3. 递归的执行流程

   递归的执行遵循“后进先出”的原则，这与栈的工作原理相似。在递归调用中，每一次的方法调用都会被压入调用栈中，直到达到终止条件。随后，方法会按照调用的相反顺序逐层返回结果，并从调用栈中弹出。

4. 递归的优缺点

   • 优点：递归代码通常更简洁、更易读，尤其在处理递归性质的问题时（如树的遍历、斐波那契数列等）。
   • 缺点：递归可能导致性能问题（如栈溢出、重复计算等），并且有时难以调试。

5. 递归的替代方案

   在某些情况下，我们可以使用循环等迭代方式来替代递归，以避免其潜在的缺点。然而，对于某些特定问题，递归可能是最自然、最高效的解决方案。
   综上所述，递归是Java编程中的一种重要技术，它允许我们以简洁的方式解决复杂问题。然而，在使用递归时，我们必须谨慎地设计终止条件和递归公式，以确保代码的正确性和效率。

递归可以看成两部分

递”的过程

“递”的过程，实际上是递归函数不断调用自身，以解决更小规模子问题的过程。每一次调用都会将当前问题的状态（如参数值）压入调用栈中，以便在后续能够恢复之前的状态。这个过程会一直进行下去，直到满足某个特定的终止条件（也称为基准情况或递归出口）

归”的过程

“归”的过程，则是当满足终止条件时，递归调用开始逐层返回的过程。每一次返回都会从调用栈中弹出之前的状态，并根据这些状态计算并返回结果。这些返回的结果会被组合起来，以形成最终问题的解。

package com.jianstudy.method;public class Demo06 {public static void main(String[] args) {Demo06 demo06 = new Demo06();System.out.println(demo06.factorial(5));}//阶乘方法public int factorial(int n){// 1的阶乘是1  n！=n*(n-1)*n(n-2)*...*1        if(n==1 ){return 1;//factorial(1)=1  递归的基准条件}else{/* 程序处理时是从最高层返回上一层的结果，先有基准跳出的条件 n=1  f(1)=1;n*factorial(n-1)  5!=5*f(4)=5*24=120   4!=4*f(3)=4*6=24  3!=3*f(2)= 3*2=6 2!=2*(f1)=2*1=22！=2*1  3！=3*2！=3*2=6  4！=4*3！=4*6=24  5！=5*4！=5*24=120*/return n*factorial(n-1);//每次调用自身，递的过程先从最大项开始递，归的过程先从能返回基准条件开始归。2！=2*1  3！=3*2！=3*2=6  4！=4*3！=4*6=24  5！=5*4！=5*24=120/*‌递过去‌：factorial(5)调用factorial(4)factorial(4)调用factorial(3)factorial(3)调用factorial(2)factorial(2)调用factorial(1)factorial(1)返回1（满足基准情况）            ‌归回来‌：factorial(2)返回2 * factorial(1)的结果，即2 * 1 = 2factorial(3)返回3 * factorial(2)的结果，即3 * 2 = 6factorial(4)返回4 * factorial(3)的结果，即4 * 6 = 24factorial(5)返回5 * factorial(4)的结果，即5 * 24 = 120            */}}
}

每次调用自身，递的过程先从最大项开始递，归的过程先从能返回基准条件开始归。
2！=2 * 1
3！=3 * 2！=3 * 2=6
4！=4 * 3！=4 * 6=24
5！=5 * 4！=5 * 24=120
‌递过去‌：
factorial(5)调用factorial(4)
factorial(4)调用factorial(3)
factorial(3)调用factorial(2)
factorial(2)调用factorial(1)
factorial(1)返回1（满足基准情况）
每一次返回都会从调用栈中弹出之前的状态，并根据这些状态计算并返回结果
‌归回来‌：
factorial(2)返回2 * factorial(1)的结果，即2 * 1 = 2
factorial(3)返回3 * factorial(2)的结果，即3 * 2 = 6
factorial(4)返回4 * factorial(3)的结果，即4 * 6 = 24
factorial(5)返回5 * factorial(4)的结果，即5 * 24 = 120
这些返回的结果会被组合起来，以形成最终问题的解

结合最近学习的内容写一个简易计算器

package com.jianstudy.method;
import java.util.Scanner;
public class Demo07 {public static void main(String[] args) {//简易计算器Scanner scanner = new Scanner(System.in);System.out.print("请输入第一个数: ");double num1 = scanner.nextDouble();System.out.print("请输入符号: ");//输入符号要使用scanner.next().charAt(0)语句char operators = scanner.next().charAt(0);System.out.print("请输入第二个数: ");double num2 = scanner.nextDouble();//使用完要关闭scanner.close();//声明result存放运算结果double result;//运算符选择  //每个case语句里要加上break 防止case穿透switch (operators) {case '+':result = add(num1, num2);System.out.println("计算结果为: " + result);break;case '-':result = sub(num1, num2);System.out.println("计算结果为: " + result);break;case '*':result = mult(num1, num2);System.out.println("计算结果为: " + result);break;case '/':if (num2 == 0) {System.out.println("错误：除数不能为0！");} else {result = div(num1, num2);System.out.println("计算结果为: " + result);}break;default:System.out.println("错误：无效的运算符！");}}//全部使用了静态方法，如果不是使用静态方法去掉static 在main使用时只需要创建Demo07类的实例// 加法方法public static double add(double a, double b) {return a + b;}// 减法方法public static double sub(double a, double b) {return a - b;}// 乘法方法public static double mult(double a, double b) {return a * b;}// 除法方法public static double div(double a, double b) {return a / b;}
}