Java_从入门到JavaEE_06

作者：繁依Fanyi0 | 2024-05-02 17:30:40

踩

Java_从入门到JavaEE_06

一、方法

1.静态方法

理解：特定功能的代码块

好处：解决代码的冗余

语法结构：

访问修饰符 static 返回值类型方法名([参数列表]){

…代码块…

}

分类：

无参数无返回值的方法

带参数的方法

带返回值的方法

2.无参数无返回值的方法

语法结构：

public static void 方法名(){

…代码块

}
注意：

1.public是访问修饰符的一种，表示公有的

2.void表示无返回值（关键字）

3.方法在类中声明

4.方法与方法之间是平级关系

5.方法没被调用，就是个摆设

实例1：

public class Test{
public static void main(String[] args){
		
		//调用方法
		//Test01.run();
		//Test01.run();
		//Test01.play();
		//Test01.run();
		//Test01.play();
		//Test01.run();
		
		//调用方法 ps:只有在同一个类才行
		run();
		run();
		play();
		run();
		play();
		run();
	}
	public static void run(){
		System.out.println("111");
	}
	
	public static void play(){
		System.out.println("222");
	}
}
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

实例2：用“*”打印三角形（方法版）

public class Test{
public static void main(String[] args){
			printStar();
}
public static void printStar(){
	for(int i = 0;i<5;i++){
		for(int j = 0;j<=i;j++){
			System.out.print("*");
		}
		System.out.println();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

3.带参数的方法

语法结构：

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

…代码块…

}

注意：

.形式参数/形参：声明方法时规定的参数
形参必须声明类型
形参属于该方法的变量，作用域就在该方法内，形参也是局部变量
局部变量：方法里声明的变量
实际参数/实参：调用方法时传入的数据
实参和形参的类型必须兼容
实参和形参可以有多个，用逗号分割
案例1：设计一个方法，打印三角形，三角形的行数由调用方传入
public class Test{
    public static void main(String[] args){
        printStar(5);
    }
    public static void printStar(int num){
        for(int i = 0;i<num;i++){
			for(int j = 0;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();
    }
} 
1
2
3
4
5
6
7
8
9
10
11
12
案例2：设计一个方法，传入两个int值，输出最大值
public class Test{
    public static void main(String[] args){
        getMax(10,20);
    }
    public static void getMax(int a,int b){
       int max=(a>b)?a:b;
       System.out.println("最大值为："+ max);
    }
} 
1
2
3
4
5
6
7
8
9

4.带返回值的方法

语法结构：

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

…代码块…

return 数据;//1.结束当前方法 2.将数据返回给调用方

}

注意：

带返回值的方法有没有参数要看具体需求
声明方法时需要设置返回值类型
return后接的是需要返回的具体数据
方法功能单一性（一个方法的功能不要过于强大）
方法声明时规定的返回值类型和 return后的数据必须兼容
返回值只能有一个，如果想返回多个值就必须使用数组、集合、…
案例：设计一个方法，传入两个int值，返回最大值在控制台输入是三个int值，输出最大值
import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        System.out.println("输入第一个数:");
        int a = scan.nextInt();
        System.out.println("输入第二个数:");
        int b = scan.nextInt();
        System.out.println("输入第三个数:");
        int c = scan.nextInt();
        
        int max=getMax(a,b);
        max=getMax(max,c);
        
        System.out.println("最大值为："+max);
        
    }
	public static int getMax(int a,int b){
    	int max=(a>b)?a:b;
        return max;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

二、方法的重载

概念：方法之间的关系

条件：

在同一个类中
方法名必须一致
参数列表的个数或者类型不一致
与返回值无关

好处：系统会根据实参类型自动匹配到对应的方法中

应用场景：在同一个类中，多个方法功能大概一致，但是细节实现不一致，就可以考虑使用重载

设计方法的步骤：

考虑方法名（见名知意）
考虑形参（几个？类型？）
考虑返回值（需不需要？返回值类型）

三、方法的递归

含义：方法调用方法自身

注意：递归是一种程序设计的思想

经验：

找规律：什么情况下方法应该调用方法自身
找出口：什么情况下应该解决该方法
案例1：设计一个方法，传入一个int值n，求n的阶乘

找规律：n！=（n-1）！*n
找出口：1！=1
public class Test{
	public static void main(String[] args){
		
		int num = getFactorial(5);
		System.out.println(num);
	}
	
	public static int getFactorial(int n){
		
		if(n != 1){
			return getFactorial(n-1) * n;
		}else{
			return 1;
		}
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行逻辑：

主方法向getFactorial（）传入数据“5”

在getFactorial方法中开始判断

5！=1 —> 执行getFactorial(5-1) * 5 —> 调用getFactorial(4) … 直到getFactorial(1) —> return 1 （同时释放getFactorial(1)方法） —> getFactorial(1)*2（释放getFactorial(2)方法） … return getFactorial(4) * 5 =120

打印num。
案例2：不死神兔问题：有1对兔子，从出生后的第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第n个月有几对兔子，设计一个方法，传入月份，获取当月兔子的对数

找规律：当月兔子的对数等于上个月+上上个月兔子的对数
找出口：1月或2月都是1对兔子
import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入查询的月份");
        int month =  scan.nextInt();
        int sum=getRabbit();
        System.out.println(month+"月，一共有"+sum+"对兔子");
    }
    public static int getRabbit(int month){
        if(month==1 || month==2){
            return 1;
        }else{
            return getRabbit(month-1)+getRabbit(month-2);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
扩展：

不死神兔的数据：1,1,2,3,5,8,13,21…

这种数列叫做斐波那契数列/黄金分割数列

该数列相邻两个数的比例越往后越趋近于0.618

四、一维数组

理解：一组数据的容器
声明：

数据类型[] 数组名;

数据类型数组名[];
概念：
1. 数组是引用数据类型
2. 数组中的数据也叫做元素
3. 元素都是编号也叫做下标/索引
4. 下标从0开始
5. 数组元素在内存中开辟的空间是连续的
6. 数组一旦初始化成功，长度不可变（意味着数组不能添加和删除）
数组的初始化：

静态初始化：元素由程序员指定，长度由系统分配

动态初始化：长度由程序员指定，元素由系统分配

整数类型默认值：0

浮点类型默认值：0.0

字符类型默认值：’ ’

布尔类型默认值：false

引用类型默认值：null(空)

静态初始化

public class Test{
    public static void main(String[] args){
        //设置静态初始化
        //1.String[] names =new String[]{"张三","李四","王五","赵六"};
        //2.String[] names;
        //  names=new String[]{"张三","李四","王五","赵六"};
        //3.
        String[] names={"张三","李四","王五","赵六"};
        
        //修改
        names[1]="小明";
        String str=names[1];
        System.out.println(str);
        //获取下标长度
        int len=names.lengthl
        System.out.println("长度为："+len);
        //遍历1.
        for(int i=0,i<names.length;i++){
            System.out.println(names[i]);
        }
        //遍历2.
        for(String element:names){
            System.out.println(element);
        }
    }
}
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

遍历使用for与foreach的使用：

遍历数组时，使用到下标 – for循环
遍历数组时，不使用到下标 – foreach

动态初始化

public class Test{
    public static void main(String[] args){
        //设置动态初始化
        //1.String[] names=new String[4];
        //2.
        String[] names;
        names=new String[4];
        //设置内容
        names[0]="张三";
        names[1]="李四";
        names[2]="王五";
        names[3]="赵六";
        
        String str=names[1];
        System.out.println(str);
        //获取下标长度
        int len=names.lengthl
        System.out.println("长度为："+len);
        //遍历1.
        for(int i=0,i<names.length;i++){
            System.out.println(names[i]);
        }
        //遍历2.
        for(String element:names){
            System.out.println(element);
        }
    }
}
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

在设置下标上的元素时，如果下标超出开辟的空间数，会报ArrayIndexOutOfBoundsException数组下标越界异常。

一维数组案例：创建一个int类型的数组，长度由用户指定，数据由用户输入，输入完毕后获取最大值并输出

import java.util.Scanner;
public class Test{
    public  static void main(String[] args){
        Scanner scan= new Scanner(System.in);
        System.out.println("请输入数组长度：");
        int[] arr=scan.nextInt();
        for(int i=0;i<arr.length;i++){
            System.out.println("请输入第"+i+"个元素：");
            int num=scan.nextInt();
            arr{i}=num;
        }
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        System.out.println("最大值为："+max);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

小结：

初始化时只知道元素，就使用静态初始化
初始化时只知道长度，就使用动态初始化
int类型的数组为引用数据类型，数组中的元素是基本数据类型

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/525269