1. 课前回顾:
  2.     1. 循环控制语句:
  3.       break:在switch中表示结束switch语句;在循环中,表示结束循环
  4.       continue:结束本次循环,进行下一次循环
  5.     2.死循环:
  6.       比较永远成立,永远是true
  7.     3.嵌套循环:
  8.       先走外层循环,进入到内层循环,内层循环就一直循环,直到内层循环结束,外层循环进行下一次循环,直到外层循环都结束了,循环整体结束
  9.     4.Random:
  10.       可以生成随机数
  11.       使用:
  12.          a.导包:import java.util.Random
  13.          b.创建对象:Random rd = new Random()
  14.          c.调用方法:
  15.             nextInt()->在int的取值范围内随机一个数
  16.             nextDouble()->在0.0 - 1.0之间随机
  17.             nextInt(int bound)->在0-(bound-1)之间随机一个数
  18.      5.数组: 
  19.        a.定义:
  20.          静态初始化:
  21.            数据类型[] 数组名 = new 数据类型[]{元素1,元素2...}->推荐
  22.            数据类型 数组名[] = new 数据类型[]{元素1,元素2...}->不推荐
  23.            简化: 数据类型[] 数组名 = {元素1,元素2}->静态初始化中极力推荐的
  24.          动态初始化
  25.             数据类型[] 数组名 = new 数据类型[数组长度]
  27.        b.获取长度
  28.          数组名.length
  29.        c.索引:元素在数组中存储的位置
  30.               从0开始的,最大索引是数组长度-1(数组名.length-1)
  31.               唯一
  32.        d.存储元素
  33.          数组名[索引值] = 值
  34.        e.获取元素
  35.          数组名[索引值]
  37.          数组名[索引值]在等号右边代表获取元素,在等号左边代表的是存储元素
  38.          arr[0] = arr1[1] ->  将arr1数组的索引1位置上的元素存储到arr数组的0索引上
  39.        f.遍历
  40.          数组名.fori
  41.        g.操作数组时容易出现的问题:
  42.          ArrayIndexOutOfBoundsException(索引越界异常)->操作的索引超出了数组索引范围
  43.          NullPointerException(空指针异常):->如果引用为null再操作就会出现
  45. 今日重点:
  46.   1.会冒泡排序(一级重点)
  47.   2.方法的四种定义格式以及调用方式(重中之重)
  48.   3.二维数组(二级重点)

第一章.冒泡排序

数组的排序，是将数组中的元素按照大小进行排序，默认都是以升序的形式进行排序，数组排序的方法很多，我们讲解的是数组的冒泡排序。

排序，都要进行数组 元素大小的比较，再进行位置的交换。冒泡排序法是采用数组中相邻元素进行比较换位。

8.1 冒泡排序图解

day05[二维数组_方法] - 图1

8.2 代码实现

  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         //定义一个数组
  4.         int[] arr = {7,6,5,4,3};
  6.         //第一圈比较,i = 0  i<4   比较了4次
  7.         for (int i = 0; i < arr.length-1-0; i++) {
  8.             if (arr[i]>arr[i+1]){
  9.                 int temp = arr[i];
  10.                 arr[i] = arr[i+1];
  11.                 arr[i+1] = temp;
  12.             }
  13.         }
  14.         System.out.println(Arrays.toString(arr));//按照[元素1,元素2]格式打印元素
  16.         //第二圈比较:i = 0 i<(4-1)   比较了3次
  17.         for (int i = 0; i < arr.length-1-1; i++) {
  18.             if (arr[i]>arr[i+1]){
  19.                 int temp = arr[i];
  20.                 arr[i] = arr[i+1];
  21.                 arr[i+1] = temp;
  22.             }
  23.         }
  24.         System.out.println(Arrays.toString(arr));//按照[元素1,元素2]格式打印元素
  26.         //第三圈比较:i = 0  i<(4-2)  比较了2次
  27.         for (int i = 0; i < arr.length-1-2; i++) {
  28.             if (arr[i]>arr[i+1]){
  29.                 int temp = arr[i];
  30.                 arr[i] = arr[i+1];
  31.                 arr[i+1] = temp;
  32.             }
  33.         }
  34.         System.out.println(Arrays.toString(arr));//按照[元素1,元素2]格式打印元素
  36.         //第四圈比较:i = 0  i<(4-3)  比较了1次
  37.         for (int i = 0; i < arr.length-1-3; i++) {
  38.             if (arr[i]>arr[i+1]){
  39.                 int temp = arr[i];
  40.                 arr[i] = arr[i+1];
  41.                 arr[i+1] = temp;
  42.             }
  43.         }
  44.         System.out.println(Arrays.toString(arr));//按照[元素1,元素2]格式打印元素
  46.         System.out.println("======================================");
  48.         for (int j = 0; j < arr.length-1; j++) {//外层循环代表的是比较的圈数
  49.             for (int i = 0; i < arr.length-1-j; i++) {//内层循环代表的是每圈比较的次数,每圈都应该少一次比较
  50.                 if (arr[i]>arr[i+1]){
  51.                     int temp = arr[i];
  52.                     arr[i] = arr[i+1];
  53.                     arr[i+1] = temp;
  54.                 }
  55.             }
  56.         }
  57.         System.out.println(Arrays.toString(arr));
  58.     }
  59. }

第二章.二维数组

2.1二维数组的定义格式

  1. 1.概述:
  2.   一个数组中存有多个一维数组
  3. 2.定义格式:
  4.   a.动态初始化:
  5.     数据类型[][] 数组名 = new 数据类型[m][n]->推荐使用
  6.     数据类型 数组名[][] = new 数据类型[m][n]
  7.     数据类型[] 数组名[] = new 数据类型[m][n]
  8.   m:代表的是二维数组的长度(二维数组中有多少个一维数组)
  9.   n:代表的是每一个一维数组的长度(一维数组中最多有多少个元素)
  11.   b.静态初始化
  12.      数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2..}...}
  13.     简化:
  14.      数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2..}...}
  1. public class Demo01Array {
  2.     public static void main(String[] args) {
  3.         //数据类型[][] 数组名 = new 数据类型[m][n]->推荐使用
  4.         int[][] arr1 = new int[3][3];
  5.         //数据类型 数组名[][] = new 数据类型[m][n]
  6.         int arr2[][] = new int[3][3];
  7.         //数据类型[] 数组名[] = new 数据类型[m][n]
  8.         int[] arr3[] = new int[3][3];
  10.         System.out.println("=====================");
  11.         //静态初始化
  12.         String[][] arr4 = {{"孙悟空","白骨精","青牛精"},{"姜子牙","纣王","妲己"},{"刘备","曹操","孙权"},{"宋江","晁盖","卢俊义"}};
  13.     }
  14. }

2.2获取二维数组长度

  1. 1.格式:
  2.   数组名.length
  1.  //静态初始化
  2.         String[][] arr4 = {{"孙悟空","白骨精","青牛精"},{"姜子牙","纣王","妲己"},{"刘备","曹操","孙权"},{"宋江","晁盖","卢俊义"}};
  4.         System.out.println(arr4.length);
  5.         System.out.println(arr4[0].length);

2.3获取二维数组中的元素

  1. 1.格式:
  2.   数组名[i][j]
  3.   i:代表的是一维数组在二维数组中的索引位置
  4.   j:代表的是元素在一维数组中的索引位置
  1. public class Demo02Array {
  2.     public static void main(String[] args) {
  3.         String[][] arr = {{"乔峰","虚竹","段誉"},{"张无忌","张三丰","张翠山"},{"杨过","小龙女","尹志平"}};
  4.         System.out.println(arr[0][2]);
  5.         System.out.println(arr[1][0]);
  6.         System.out.println(arr[2][2]);
  7.     }
  8. }

2.4二维数组中存储元素

  1. 1.格式:
  2.   数组名[i][j] = 元素值
  3.   i:代表的是一维数组在二维数组中的索引位置
  4.   j:代表的是元素在一维数组中的索引位置
  1. public class Demo03Array {
  2.     public static void main(String[] args) {
  3.         int[][] arr = new int[3][3];
  4.         //存元素
  5.         arr[0][0] = 100;
  6.         arr[0][1] = 200;
  7.         arr[0][2] = 300;
  9.         arr[1][0] = 400;
  10.         arr[1][1] = 500;
  11.         arr[1][2] = 600;
  13.         arr[2][0] = 700;
  14.         arr[2][1] = 800;
  15.         arr[2][2] = 900;
  17.     }
  18. }

2.5.二维数组的遍历

  1. 思想:
  2.   先将每一个一维数组从二维数组中遍历出来->遍历二维数组
  3.   然后再将每一个元素从一维数组中遍历出来->遍历一维数组
  1. public class Demo03Array {
  2.     public static void main(String[] args) {
  3.         int[][] arr = new int[3][3];
  4.         //存元素
  5.         arr[0][0] = 100;
  6.         arr[0][1] = 200;
  7.         arr[0][2] = 300;
  9.         arr[1][0] = 400;
  10.         arr[1][1] = 500;
  11.         arr[1][2] = 600;
  13.         arr[2][0] = 700;
  14.         arr[2][1] = 800;
  15.         arr[2][2] = 900;
  17.         System.out.println("=====================");
  19.         for (int i = 0; i < arr.length; i++) {//遍历二维数组,将每一个一维数组遍历出来
  20.             for (int j = 0; j < arr[i].length; j++) {//遍历的每一个一维数组
  21.                 System.out.println(arr[i][j]);
  22.             }
  23.         }
  24.     }
  25. }

2.6二维数组内存图

  1. public class Test04 {
  2.     public static void main(String[] args) {
  3.         //代表只规定了二维数组的长度,但是没有初始化里面的一维数组,所以默认为null
  4.         int[][] arr1 = new int[3][];
  5.         //相当于在二维数组中的1索引位置上创建了一个存有1 2 3的一维数组
  6.         arr1[1] = new int[]{1,2,3};
  7.         //相当于在二维数组中的2索引位置上创建了一个长度为3的一维数组,没有元素
  8.         arr1[2] = new int[3];
  9.         //相当于在二维数组中的2索引位置上的一维数组的1索引位置上存放了100
  10.         arr1[2][1] = 100;
  11.     }
  12. }

day05[二维数组_方法] - 图2

第三章.方法的使用

1.方法介绍以及简单方法定义(无参无返回值)

  1. 1.概述:方法就是功能,是拥有功能性代码的代码块
  2.       所以,将来我们开发时,一个功能就需要定义一个方法
  3. 2.好处:
  4.   让代码好维护
  5.   提高代码的复用性
  6. 3.通用的方法定义格式:
  8.   修饰符 返回值类型 方法名(参数){
  9.       方法体;
  10.       return 结果
  11.   }
  13.   如果一个方法没有返回值,返回值类型写void,方法体中就不用写return 结果
  14.   如果一个方法有返回值,返回值类型就写具体的数据类型,写return 结果
  16. 4.从通用定义格式上细分,分出来四种方法定义格式:
  18.   无参无返回值的方法->最简单
  19.   有参数无返回值的方法
  20.   无参数有返回值的方法
  21.   有参数有返回值的方法
  23. 5.无参数无返回值的方法定义
  24.   public static void 方法名(){
  25.     方法体
  26.   }
  28.   调用:
  29.    在其他方法中:方法名()
  31. 6.注意事项:
  32.    a.方法不调用不执行->main方法是jvm调用的
  33.    b.方法之间不能互相嵌套
  34.    c.方法的执行顺序只和调用顺序有关系(谁先调用谁先执行)
  1. 需求:定义一个方法,实现两个整数相加,将结果输出
  1. public class Demo02Method {
  2.     public static void main(String[] args) {
  3.         //方法调用
  4.         sum();
  5.         System.out.println("我想要执行");
  6.     }
  8.     public static void sum(){
  9.         int a = 10;
  10.         int b = 20;
  11.         int sum = a+b;
  12.         System.out.println(sum);
  13.     }
  14. }

2.无参数无返回值的方法执行流程

day05[二维数组_方法] - 图3

  1. public class Demo01Method {
  2.     public static void main(String[] args) {
  3.       //调用
  4.         famer();//调用处
  5.         cooker();
  6.         cooker();
  7.         customer();
  8.     }
  10.     //农民伯伯
  11.     public static void famer(){
  12.         System.out.println("种菜");
  13.         System.out.println("浇水");
  14.         System.out.println("施肥");
  15.         System.out.println("拔草");
  16.         System.out.println("收割");
  17.     }
  19.     //厨师
  20.     public static void cooker(){
  21.         System.out.println("洗菜");
  22.         System.out.println("切菜");
  23.         System.out.println("炒菜");
  24.         System.out.println("尝尝");
  25.         System.out.println("装盘");
  26.     }
  28.     //顾客
  29.     public static void customer(){
  30.         System.out.println("洗手");
  31.         System.out.println("吃菜");
  32.     }
  33. }

3.方法定义各部分解释

  1.   修饰符 返回值类型 方法名(参数){
  2.       方法体;
  3.       return 结果
  4.   }
  6.   1.修饰符:目前先写成public static
  7.   2.返回值类型:返回值的数据类型(return后面那个结果的数据类型)
  8.   3.方法名:见名知意即可
  9.   4.参数:传递到方法内部的数据   数据类型 变量名,数据类型 变量名
  10.   5.方法体:具体实现此方法(此功能)的具体代码
  11.   6.return 结果:代表将方法运行的结果返回给调用处(用户)

day05[二维数组_方法] - 图4

4.有参数无返回值的方法定义和执行流程

  1. 1.格式:
  2.   public static void 方法名(参数){
  3.       方法体
  4.   }
  5. 2.调用:
  6.   方法名(参数具体的值)
  1. 需求:定义一个方法实现两个整数相加
  1. public class Demo03Method {
  2.     public static void main(String[] args) {
  3.       //调用处(用户)
  4.         sum(1,2);
  5.     }
  7.     public static void sum(int a,int b){
  8.         int sum = a+b;
  9.         System.out.println(sum);
  10.     }
  11. }

day05[二维数组_方法] - 图5

5.无参数有返回值定义以及执行流程

  1. 1.格式:
  2.   public static 返回值类型 方法名(){
  3.       方法体
  4.       return 结果;
  5.   }
  6. 2.注意:结果会返给调用处(用户)
  8. 3.调用:
  9.   数据类型 变量名 = 方法名()
  1. 需求:定义一个方法,实现两个整数相加,并将结果返回
  1. public class Demo04Method {
  2.     public static void main(String[] args) {
  3.         //调用处(用户)
  4.         int result = sum();//30  推荐使用
  5.         System.out.println(result);
  6.         System.out.println("=================");
  7.         System.out.println(sum());//不推荐
  8.     }
  10.     //定义一个方法,实现两个整数相加,并将结果返回
  11.     public static int sum(){
  12.         int a = 10;
  13.         int b = 20;
  14.         int sum = a+b;
  15.         return sum;//30
  16.     }
  17. }

day05[二维数组_方法] - 图6

6.有参数有返回值定义以及执行流程

  1. 1.定义格式:
  2.   public static 返回值类型 方法名(参数){
  3.      方法体
  4.      return 结果;
  5.   }
  7. 2.调用
  8.   数据类型 变量名 = 方法名(具体的值)
  1. 定义方法,实现两个整数相加,将结果返回
  1. public class Demo05Method {
  2.     public static void main(String[] args) {
  3.         //调用处(用户)
  4.         int result = sum(10,20);//30  推荐使用
  5.         System.out.println(result);
  6.     }
  8.     //定义一个方法,实现两个整数相加,并将结果返回
  9.     public static int sum(int a,int b){
  10.         int sum = a+b;
  11.         return sum;//30
  12.     }
  13. }

day05[二维数组_方法] - 图7

7.形式参数和实际参数区别

  1. 形式参数:在定义方法的时候在小括号中定义的参数,此时并没有给值
  2. 实际参数:在调用方法的时候给参数赋予的实际的值

8.参数和返回值使用的时机

  1. 看需求
  3. 返回值:
  4.   什么时候用返回值:当调用者需要被调用方法的结果时,被调用的方法就需要将结果return
  6.   什么时候不用返回值:当调用者不需要被调用方法的结果时,被调用的方法就不需要将结果return
  8. 参数:
  9.   什么时候使用参数:
  10.    1.当定义方法的时候不确定要操作什么数据时,就需要定义参数,等着调用方法的时候给我传递具体的值
  11.    2.想将一个方法中的数据传递到另外一个方法的时候,也可以通过参数传递

9.变量作为实参使用

  1. 需求:定义一个方法,比较两个整数的大小,如果第一个参数比第二个参数大,返回true,否则返回false;
  3. 方法三要素
  4. 参数: 要
  5. 返回值:要
  6. 方法名:要
  1. public class Demo07Method {
  2.     public static void main(String[] args) {
  3.         int i = 10;
  4.         int j = 20;
  5.         boolean compare = compare(i, j);
  6.         System.out.println(compare);
  7.     }
  9.     public static boolean compare(int a,int b){//int a = 10;int b = 20
  10.         if (a>b){
  11.             return true;
  12.         }else{
  13.             return false;
  14.         }
  15.     }
  16. }

第四章.方法的练习

1.方法练习1(判断奇偶性)

  1. 需求:
  2.    键盘录入一个整数,将整数传递到另外一个方法中,在此方法中判断这个整数的奇偶性
  3.    如果是偶数,方法返回"偶数"  否则返回"奇数"
  4. 方法名:要
  5. 参数:要
  6. 返回值:要
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Scanner sc = new Scanner(System.in);
  4.         int data = sc.nextInt();
  5.         String result = method(data);
  6.         System.out.println(result);
  7.     }
  9.     public static String method(int n){
  10.         if (n%2==0){
  11.             return "偶数";
  12.         }else {
  13.             return "奇数";
  14.         }
  15.     }
  16. }

2.方法练习2(1-100的和)

  1. 需求 :  求出1-100的和,并将结果返回
  2. 方法名:要
  3. 参数:不要
  4. 返回值:要
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         int sum = sum();
  4.         System.out.println(sum);
  6.         int i = sum1(100);
  7.         System.out.println(i);
  8.     }
  10.     public static int sum(){
  11.         int sum = 0;
  12.         for (int i = 1; i <= 100; i++) {
  13.             sum+=i;
  14.         }
  15.         return sum;
  16.     }
  18.     public static int sum1(int n){
  19.         int sum = 0;
  20.         for (int i = 1; i <= n; i++) {
  21.             sum+=i;
  22.         }
  23.         return sum;
  24.     }
  25. }

3.方法练习3(不定次数打印)

  1. 需求:
  2.   定义一个方法,给这个方法传几,就让这个方法循环打印几次"我是一个有经验的大数据开发工程师"
  4. 方法名:要
  5. 参数 : 要
  6. 返回值:不要
  1. public class Test03 {
  2.     public static void main(String[] args) {
  3.        method(1);
  4.     }
  6.     public static void method(int n){
  7.         for (int i = 0; i < n; i++) {
  8.             System.out.println("我是一名大数据库开发工程师");
  9.         }
  10.     }
  11. }

4.方法练习4(遍历数组)

  1. 需求:
  2.   在main方法中定义一个数组,将数组传递到方法中,在此方法中遍历数组
  1. public class Test04 {
  2.     public static void main(String[] args) {
  3.         //定义数组
  4.         int[] arr = {1,2,3,4};
  5.         method(arr);//0x001
  6.     }
  8.     public static void method(int[] arr){//int[] arr1 = arr    0x001
  9.         for (int i = 0; i < arr.length; i++) {
  10.             System.out.println(arr[i]);
  11.         }
  12.     }
  13. }

day05[二维数组_方法] - 图8

5.方法练习5(求数组最大值)

  1. 需求: 
  2.   在main方法中定义数组,传递到另外一个方法中,在此方法中实现获取数组最大值
  1. public class Test05 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {4,5,4,5,7,5,3};
  4.         int result = method(arr);//0x001
  5.         System.out.println(result);
  6.     }
  8.     public static int method(int[] arr) {//0x001
  9.         //1.定义一个变量max用于拿两个元素之间较大的元素
  10.         int max = arr[0];
  11.         //2.遍历数组,将每一个元素获取出来
  12.         for (int i = 1; i < arr.length; i++) {
  13.             /*3.循环比较
  14.           如果max的值小于遍历出来的元素,将较大的元素重新赋值给max*/
  15.             if (max<arr[i]){
  16.                 max = arr[i];
  17.             }
  18.         }
  19.         //4.直接输出max
  20.         return max;
  21.     }
  23. }

6.方法练习6(按照指定格式输出数组元素)

  1. 需求:
  2.   1.定义一个数组 int[] arr = {1,2,3,4}
  3.   2.遍历数组,输出元素按照[1,2,3,4]
  1. public class Test06 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {1,2,3,4};
  4.         method(arr);
  5.     }
  7.     public static void method(int[] arr) {
  8.         System.out.print("[");
  9.         for (int i = 0; i < arr.length; i++) {
  10.             //判断如果i的值变化到最大索引了,证明要输出的是最后一个元素,最后一个元素输出之后,后面直接跟]
  11.             if (i==arr.length-1){
  12.                 System.out.print(arr[i]+"]");
  13.             }else{
  14.                 System.out.print(arr[i]+",");
  15.             }
  16.         }
  17.     }
  18. }

7.练习7

  1. 数组作为返回值返回
  1. public class Test07 {
  2.     public static void main(String[] args) {
  3.         int[] arr1 = method();
  4.         for (int i = 0; i < arr1.length; i++) {
  5.             System.out.println(arr1[i]);
  6.         }
  7.     }
  9.     public static int[] method(){
  10.         int a = 10;
  11.         int b = 20;
  13.         int sum = a+b;
  14.         int multiply = a*b;
  16.         //将sum和multiply同时返回
  17.         int[] arr = {sum,multiply};
  18.         return arr;
  19.     }
  20. }

day05[二维数组_方法] - 图9

总结:如果参数和返回值是基本类型,我们操作的是具体的数据

  1.      如果参数和返回值是引用类型,我们操作的是地址值

第五章.方法注意事项终极版

  1. 1.方法不调用不执行
  2. 2.方法之间不能互相嵌套
  3. 3.方法的执行顺序只和调用顺序有关
  4. 4.void 和 [return 结果]不能共存
  5.   void : 代表没有返回值
  6.   return 结果:将结果返回,然后结束方法
  8.   但是void 能和 return 共存
  9.   单纯的有一个return  仅仅代表结束方法
  10. 5.一个方法中不能连续return多个返回值(if...else除外)
  11. 6.写代码时,调用方法的时候要看看我们有没有定义此方法(调用方法时要完全匹配:方法名 参数个数 参数类型)

第六章.方法的重载

  1. 需求:定义方法,完成2个整数相加,3个整数相加,4个整数相加
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         sum(1,2);
  4.         sum(1,2,3);
  5.         sum(1,2,3,4);
  6.     }
  8.     public static void sum(int a,int b){
  9.         int sum = a+b;
  10.         System.out.println(sum);
  11.     }
  13.     public static void sum(int a,int b,int c){
  14.         int sum = a+b+c;
  15.         System.out.println(sum);
  16.     }
  18.     public static void sum(int a,int b,int c,int d){
  19.         int sum = a+b+c+d;
  20.         System.out.println(sum);
  22.     }
  23. }
  1. 1.概述:
  2.   方法名相同,参数列表不同,叫做方法的重载
  4. 2.什么时候可以定义重载的方法?
  5.   功能一样,但是具体实现(细节)不一样
  7. 3.什么叫参数列表不同?
  8.   参数个数不同
  9.   参数类型不同
  10.   参数类型顺序不同
  11. 4.判断是否为重载的方法和什么无关:
  12.   和参数名无关
  13.   和返回值无关
  15. 5.总结:
  16.   想判断方法是否为重载方法,只看方法名和参数列表
  1. public static void open(){}
  2. public static void open(int a){}
  3. static void open(int a,int b){}
  4. public static void open(double a,int b){}
  5. public static void open(int a,double b){}
  6. public void open(int i,double d){}
  7. public static void OPEN(){}
  8. public static void open(int i,int j){}