第二周笔记

news2024/11/24 14:27:49

public class Calc {
//加法, 把和作为一个结果返回出去, 返回给调用者
public int add3(int num1, int num2){
if(num1 == 0 && num2 == 0){
return 0; //隐式包含一个if-else结构
}
//使用return 关键字
return num1 + num2;
}

public void fun1(){
System.out.println("开始执行fun1方法...");
if(true){
System.out.println("fun1方法中途退出");
return; //退出方法
}
System.out.println("fun1方法执行完成");
}

public void fun2(){
for (int i = 0; i <10 ; i++) {
System.out.println(i);
if(i == 5){
// break; //退出循环 0~5 fun2执行完成
return; //退出方法 0~5
}
}
System.out.println("fun2执行完成....");
}

public static void main(String[] args) {
Calc calc = new Calc();
/*
//调用有返回值的方法
calc.add3(10,8);//程序能正常运行, 但是返回值结果数据丢失
int rs = calc.add3(11,8);
System.out.println(rs);
long rs1 = calc.add3(11,8); // int 自动转换为long
System.out.println(rs1);
*/
//调用fun1
calc.fun1();

calc.fun2();

int[] arr = {1,2,55,22,33,111,222,56};
int[] rsArr = calc.findMaxAndMin(arr);
System.out.println("最大值:"+rsArr[0]);
System.out.println("最小值:"+rsArr[1]);
}

//如果一个方法返回多个数据找数组的最大值,最小值并返回
//返回数组
// 返回值类型可以是数组类型
public int[] findMaxAndMin(int[] arr){
int[] nums = new int[2]; //存放最大值,最小值
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
//找最大值
if(max < arr[i]){
max = arr[i];
}
//最小值
if(min > arr[i]){
min = arr[i];
}
}

//把最大值,最小值保存数组
nums[0] = max;
nums[1] = min;
return nums;
}

public int fun3(int a){
if(true){
return 1;
}
return -1;
}
}

带参方法

方法定义的参数称为形参, jdk判断方法参数列表: 根据参数数据类型, 参数个数, 参数的位置

调用方法的时候, 传递变量, 称为实参

方法的参数传递: 值传递

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值 值数据

对于引用数据类型(类类型)的参数, 形式参数的改变，影响实际参数的值 地址码

有返回值的方法

定义有返回值方法, 在方法体使用return 结果返回数据.

有返回值方法的调用: 需要定义变量接收方法返回值, 保存数据

接收返回值的变量的数据类型与返回值类型匹配

return 使用方式:

return 退出方法只能在无返回值的方法内部使用

return 结果只能在有返回值的方法内部使用, 1) 返回结果 2) 退出方法

return关键字作用: 退出方法

方法重载

如果一组方法, 功能类似的, 但是参数不一样,

第一种方式: 给每个方法取不同的名字, 通过名字来区分

缺点:

开发者想一堆的名字

使用者记一堆的名字

第二种方式: JAVA提供了方法重载的机制

在同一个类中, 方法名一样, 参数列表不一样的一组方法,称为方法的重载, 与返回值无关

参数列表不一样:

参数个数不一样

参数对应位置的数据类型不一样

与参数名无关

功能相似的推荐使用方法重载的方式, 如果不同功能的方法, 取不同的方法名

方法注意事项

方法内部不能再定义方法

//1,声明一个二维数组
int[][] arr;
//2. 开辟空间
arr = new int[3][4]; // 包含3个一维数组,而且每一个一维数组长度都是4
//第一个长度: 3: 一维数组的个数
//第二个长度: 4: 一维数组的长度
//arr[下标]: 获取下标为几的一维数组
arr[0] = new int[]{1,2,3,4,5};
arr[1] = new int[]{1,3,5,7};
arr[2] = new int[]{2,4,6,8};
//arr[3] = new int[]{2,4,6,8};

int[][] arr2 = new int[5][];
// arr2二维数组包含5个一维数组, 但是每一个一维数组的长度不确定

//循环变量
// 得到一维数组的个数: 数组名.length
for (int i = 0; i <arr.length ; i++) { //控制一维数组
// 每一个一维数组的长度 arr[i].length
for (int j = 0; j < arr[i].length; j++) { //遍历每一个一维数组
//arr[0][0]: 二维数组中第一个一维数组的第一个元素
System.out.print(arr[i][j]+", ");
}
System.out.println();
}

//冒泡排序
int arr[] = {26,34,1,29,39,28,2,44,48,27,12};

//升序排序
for (int i = 1; i <= arr.length -1 ; i++) { //控制的轮 = 数组的长度-1
for (int j = 0; j < arr.length -i; j++) { //每一轮的次数 j作为数组下标 = 数组长度 - 轮
//两两比较,如果违反规则,进行交换
//if(arr[j] > arr[j+1]){ //如果前一个元素比后一个元素大,违反规则升序
if(arr[j] < arr[j+1]){ //降序大在前,小在后违反规则(大的在后)
//交换
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}

System.out.println("排序之后的结果:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+", ");
}