方法
方法
方法定义及调用：
方法是语句的集合
设计方法原则：一个方法只完成一个功能
方法调用：当有返回值时，调用时当做返回一个值。无返回值时，方法调用是一条语句。
package com.lnn.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
int sum = add(1,2);//实际参数：实际调用给他的参数 //有返回值时，方法调用当做一个返回值
System.out.println(sum);
test();//无返回值，方法调用是一条语句
}
//加法 修饰符 返回值类型 方法名 参数 //static 类变量，直接调用
public static int add(int a,int b){//形式参数，用来定义作用
return a+b;//返回一个值
}
//不需要返回值 void
public static void test(){
for (int i = 1; i <=1000; i++) {
if (i%5 == 0){
System.out.print(i+"\t");
}
if (i%(5*3) == 0){
System.out.println();
//System.out.print("\n");
}
}
}
}
值传递（JAVA）拷贝
引用传递
方法重载：
重载在一个类中，有相同的函数名称，形参不同的函数。
方法重载的规则：
-
方法名必须相同
-
参数列表必须不同（个数不同，或类型不同，参数排列顺序不同）
-
方法的返回类型可以相同也可以不同
-
仅仅返回类型不同不足以成为方法的重载
package com.lnn.method;
public class Demo02 {
public static void main(String[] args) {
//实参传入的哪个类型，调用哪个方法
int max = max(10,40);//输入实参10和40类型为整型，调用参数类型为整型的方法，因为该方法返回类型也是整型，所以左面返回值类型是整型。
System.out.println("大数是" + max);
double max2 = max(10.0,40.0);
System.out.println("大数是" + max2);
int max3 = max(10,20,30);
System.out.println(max3);
}
//比大小
public static int max(int num1,int num2){
int result = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0;//终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
//方法的重载1，方法名相同，形参类型是浮点型，方法返回类型是浮点型
public static double max(double num1,double num2){//此方法返回类型可以是int，强转成int即可
double result = -1;//赋值初始化
if (num1 == num2){
System.out.println("num1 == num2");
return 0;//终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
//方法的重载2，方法名相同，形参个数不同，方法返回类型相同
public static int max(int num1,int num2,int num3){
//3个数比大小，自己瞎写的
int result = -1;
if (num1 > num2){
result = num1;
}else {
result = num2;
}
if (result < num3){
result = num3;
}
return result;
}
/*
java编译器按照不同参数，选择对应方法
*/
}
命令行传递参数：
补充：快速打for循环 fori回车
对main方法进行命令行传参
package com.lnn.method;
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]);//通过数组下标来访问每个元素是什么样子
}
}
}
将文件在资源管理器中打开，cmd,编译文件，退到src目录下，找到对应包，执行文件，并进行命令行传参 this is lnn
注意：执行class文件，要找到对应包 --java com.lnn.method.Demo03
解决问题：DOS编译不成功，编码问题，javac -encoding UTF-8 Demo03.java
可变参数：
不定项参数
jdk1.5开始;在方法声明中，在指定参数类型后加一个省略号(...);一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数必须在它之前声明。
package com.lnn.method;
public class Demo04 {
public static void main(String[] args) {
Demo04 demo04 = new Demo04();//new一个类对象
demo04.test(1,2,55,6);//类对象调用这个方法 输入可变参数//输入的实参类型要和方法的形参类型对应上哦
}
public void test(int...i){//不知道具体需要几个参数，用可变参数
System.out.println(i[0]);//类似数组调用
System.out.println(i[1]);
System.out.println(i[2]);
System.out.println(i[3]);
}
}
/*
输出结果：1
2
55
6
如果main中调用传参是空的话，出现错误，ArrayIndexOutOfBoundsException，数组下标越界；如果test方法只打印i的话，结果是对象的值。
*/
package com.lnn.method;
public class Demo04_2 {
public static void main(String[] args) {
//调用可变参数方法
printMax(34,3,3,2,56.5);
printMax(new double[]{1,2,3});//传递了一个数组，可变参数本质就是数组
}
public static void printMax(double...numbers){
if (numbers.length == 0){//可变参数看做数组，判断有没有传参数
System.out.println("No argument passed");
return;//终止本方法
}
double result = numbers[0];
//排序 找出最大数
for (int i = 1; i < numbers.length ; i++) {
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}
递归：
通常，我们是A方法调用B方法（main方法可调用其他方法）
递归是A方法调用A方法，即自己调用自己
package com.lnn.method;
public class Demo05 {
public static void main(String[] args) {
Demo05 test = new Demo05();//new一个类对象 变量类型 变量名 = 变量值
test.test();//调用类方法
}
public void test(){
test();//递归，自己调用自己
}
}
StackOverflowError：栈溢出异常，自己调用自己，内存不够，不要这么写
递归结构包括两个部分：
-
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
-
递归体：什么时候需要调用自身方法
层层调用，在返回结果；
package com.lnn.method;
public class Demo06 {
//递归思想
//阶乘
//1! 1
//2! 2*1
//5! 5*4*3*2*1
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n) {
if (n == 1) {
return 1;//判断，如果传递的是1，那么1的阶乘就是它本身
} else {
return n * f(n - 1);
}
}
}
/*
f(5)判断不等于1，执行5*f(4);f(4)再次调用自己,递归，4*f(3);
f(3)再次调用该方法，3*f(2);f(2)再次调用该方法，2*f(1);
f(1)调用该方法，得1，方法调用结束。依次返回结果。
边界条件：边界
前阶段：
返回阶段 n*(n-1)
java使用栈机制，调用一次方法，压一层，f(5)，调用5次，压5层；
深度比较大时，占用大量空间内存 ，不推荐使用递归；
基数比较小时，可考虑递归。
*/
作业：
package com.lnn.method;
import java.util.Scanner;
public class Demo07 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);//创建一个扫描器对象，接收键盘数据
System.out.println("选择+，-，*，/其中一个操作");
String str = scanner.next();//scanner.next()程序卡住，等待用户输入
switch (str){
case "+":
System.out.println("请输入两个加数：");
double add1 = scanner.nextDouble();
double add2 = scanner.nextDouble();
double result1 = add(add1,add2);//方法调用
System.out.println(add1 + "+" + add2 + "=" +result1);//注意，变量之间+//双引号里面字符串，不变的
break;
case "-":
System.out.println("请输入被减数和减数：");
double minus1 = scanner.nextDouble();
double minus2 = scanner.nextDouble();
double result2 = minus(minus1,minus2);
System.out.println(minus1+ "-" + minus2 + "=" + result2);
break;
case "*":
System.out.println("请输入两个乘数：");
double multiply1 = scanner.nextDouble();
double multiply2 = scanner.nextDouble();
double result3 = multiply(multiply1,multiply2);
System.out.println(multiply1 + "*" + multiply2 + "=" + result3 );
break;
case "/":
System.out.println("请输入被除数和除数：");
double divide1 = scanner.nextDouble();
double divide2 = scanner.nextDouble();
double result4 = divide(divide1,divide2);
System.out.println(divide1 + "/" + divide2 + "=" + result4);
break;
default:
System.out.println("输入错误！");
}
scanner.close();
}
public static double add(double a,double b){
return a+b;
}
public static double minus(double a,double b){
return a-b;
}
public static double multiply(double a,double b){
return a*b;
}
public static double divide(double a,double b){
return a/b;
}
}
//方法必须加static，才能在main方法中调用
浙公网安备 33010602011771号