导学

本节课，我们来针对之前学习过的内容进行一次综合应用。通过一个案例，来复习和学习一个比较综合的程序的编程过程。

需求分析

需求：定义一个类，对数组中的数据进行管理（增删改查）
方法：

  1. 插入数据：public int[] insertData() {}
  2. 显示所有数据 public void showData(int[] a, int length) {}
  3. 在指定位置处插入数据 public void insertAtArray(int[] a,int n,int k) {}

  4. 查询能被3整除的数据 public void divThree(int[] a) {}

    基础方法的实现

    从键盘接收数据

    1. /**
    2.   * 从键盘接收数据，将接收到的数据进行审核，并新增到数组中去
    3.   * @return
    4.   */
    5.  public int[] insertData() {
    6.      //首先定义好一个长度为10的数组
    7.      int[] a = new int[10];
    8.      //Scanner类，不是我们在同一个包中创建的类，是在Java JDK的类库中保存的类，所以使用的时候需要进行导入。
    9.      //Scanner用于监听跟键盘操作相关的内容
    10.       //引入Scanner类，快捷键 Alt + / 生成 import java.util.Scanner;
    11.      Scanner sc = new Scanner(System.in);
    12.      //从外部进入程序的数据，统称为输入性数据
    13.      //System系统类。System.in用键盘接收系统当前的输入
    14.      //sc.next();   next方法，返回值是输入的内容，next是String类型
    15.          //不断循环next()方法，可以不断接收数据
    16.      //String str = sc.next();
    17.      //int str = sc.nextInt();获取int类型的数据
    19.      //为插入数据留一个空位，长度为10的数组只能暂时先接收九个数据。
    20.      for(int i = 0; i < a.length - 1; i++) {
    21.          System.out.println("请输入第" + (i + 1) + "个数据");
    22.            //因为要将数据插入到整型数组中，所以需要保证接收到的数据为整型数据
    23.          //nextInt方法用于从键盘接收整型数据
    24.          try {
    25.              //将可能会发生异常的语句放置到try代码块中
    26.              a[i] = sc.nextInt();
    27.          } catch(InputMismatchException e) {
    28.                //通过catch语句捕获可能会发生的异常，即输入非数字的时候，执行catch代码块中的内容
    29.              System.out.println("输入的数据类型有误，不能是非数字");
    30.              //将有问题的键盘监听重新连接起来，使用next()继续去接收数据
    31.              sc.next();
    32.              //为了重新输入数据，所以针对以循环做一次重新开始
    33.              i--;
    34.          }
    36.      }
    37.      return a;
    38.  }

    数组元素的显示

    1. /**
    2.   * 显示数组中元素的内容
    3.   * @param a 数组名
    4.   * @param length 要显示的数组元素的个数
    5.   */
    6.  public void showData(int[] a, int length) {
    7.      for (int i = 0; i < length; i++) {
    8.          System.out.print(a[i] + "     ");
    9.      }
    10.      System.out.println();
    11.  }

    在指定位置处插入数据

    1. /**
    2.   * 从键盘接收一个数据，插入到数组的指定位置处
    3.   * @param a 要插入数据的数组
    4.   * @param n 要插入的数据
    5.   * @param k 要插入的位置，从0开始
    6.   */
    7.  public void insertAtArray(int[] a, int n, int k) {
    8.      // 注意从最后一个数据开始移动，避免数据覆盖
    9.      for (int i = a.length - 1; i > k; i--) {
    10.          a[i] = a[i - 1];
    11.      }
    12.      a[k] = n;
    13.  }
    14.  public static void main(String[] args) {
    15.      DataManger dm = new DataManger();
    16.      int[] a = dm.insertData();
    17.      dm.showData(a, a.length-1);//输出全部数据
    18.      Scanner sc = new Scanner(System.in);//其实此处也要处理一下非整数输入的问题
    19.      System.out.println("请输入要插入的数据：");
    20.      int n = sc.nextInt();
    21.      System.out.println("请输入要插入的位置：");
    22.      int k = sc.nextInt();
    23.      dm.insertAtArray(a, n, k);
    24.      dm.showData(a, a.length);
    25.  }

    能被3整除的方法

    1. /**
    2.   * 输出数组中能被3整除的元素
    3.   * 
    4.   * @param a
    5.   */
    6.  public void divThree(int[] a) {
    7.      String str = "";//用于保存能被三整除的数据
    8.      int count = 0;
    9.      for (int n : a) {
    10.          if (n % 3 == 0) {
    11.              str = str + n + "   ";
    12.              count++;
    13.          }
    14.      }
    15.      if (count == 0) {
    16.          System.out.println("数组中没有能被3整除的元素！");
    17.      } else {
    18.          System.out.println("数组中能被3整除的元素为：" + str);
    19.      }
    20.  }
    21.  public static void main(String[] args) {
    22.      DataManger dm = new DataManger();
    23.      int[] a = dm.insertData();
    24.      dm.showData(a, a.length-1);//输出全部数据
    25.      Scanner sc = new Scanner(System.in);//其实此处也要处理一下非整数输入的问题
    26.      System.out.println("请输入要插入的数据：");
    27.      int n = sc.nextInt();
    28.      System.out.println("请输入要插入的位置：");
    29.      int k = sc.nextInt();
    30.      dm.insertAtArray(a, n, k);
    31.      dm.showData(a, a.length);
    32.      dm.divThree(a);
    33.  }

    提示信息方法的实现

    即实现在主方法中流程的控制，我们希望在主方法中更多的去关注实现逻辑上的控制。

    1. /**
    2.   * 提示信息
    3.   */
    4.  public void notice() {
    5.      System.out.println("********************************************");
    6.      System.out.println("                1--插入数据");
    7.      System.out.println("                2--显示所有数据");
    8.      System.out.println("                3--在指定位置处插入数据");
    9.      System.out.println("                4--查询能被3整除的数据");
    10.      System.out.println("                0--退出");
    11.      System.out.println("********************************************");
    12.  }

    主方法的实现

    1. public static void main(String[] args) {
    2.      DataManger dm = new DataManger();
    3.      // int[] a = dm.insertData();
    4.      // * dm.showData(a, 8);//输出全部数据
    5.      // 将接收数据语句提取出来
    6.      Scanner sc = new Scanner(System.in);
    7.      // 将输入数据提取出来
    8.      int input;
    9.      int[] a = null;//先定义数组为一个空数组
    10.      int n=0,k=0;//n表示要插入的数据，k表示插入位置
    11.      // 1 首先实现循环输入5个指示数字
    12.      while (true) {
    13.          // 循环提示
    14.          dm.notice();
    15.          // 进行提示
    16.          System.out.println("请输入对应的数字进行操作：");
    17.          // 接收键盘操作数据
    18.          try{
    19.              input = sc.nextInt();
    20.          }catch(InputMismatchException e){
    21.              System.out.println("输入的数据格式有误，不能有非数字！");
    22.              sc.next();
    23.              continue;
    24.          }
    25.          // 针对0单独处理，退出程序（退出循环）
    26.          if (input == 0) {
    27.              System.out.println("退出程序！");
    28.              break;
    29.          }
    30.          // 通过switch语句根据操作数进行操作的选择
    31.          switch (input) {
    32.              case 1:{
    33.                  //插入数据，并接收得到的数据
    34.                  a = dm.insertData();
    35.                  //显示数据
    36.                  System.out.println("数组元素为：");
    37.                  dm.showData(a, a.length-1);
    38.                  break;
    39.              }
    40.              case 2:{//显示数据
    41.                  //需要判断数组是否已经赋值
    42.                  if(a != null) {
    43.                      System.out.println("数组元素为：");
    44.                      if(a[a.length-1]==0){
    45.                          //如果数组的最后一个元素为0，说明还没有拆入数据，因此不显示最后一个元素
    46.                          dm.showData(a, a.length-1);
    47.                      }else{
    48.                          dm.showData(a, a.length);
    49.                      }
    50.                  } else {
    51.                      System.out.println("还未在数组中插入数据，请重新选择操作！");
    52.                  }
    53.                  break;
    54.              }
    55.              case 3:{
    56.                  if(a!=null){
    57.                      System.out.println("请输入要插入的数据：");
    58.                      try{
    59.                          n=sc.nextInt();
    60.                          System.out.println("请输入要插入数据的位置：");
    61.                          k=sc.nextInt();
    62.                      }catch(InputMismatchException e){
    63.                          System.out.println("输入的数据格式有误，不能有非数字！");
    64.                          sc.next();
    65.                          break;
    66.                      }
    67.                      dm.insertAtArray(a, n, k);
    68.                      dm.showData(a, a.length);
    69.                  }else{
    70.                      System.out.println("还未在数组中插入数据，请重新选择操作！");
    71.                  }
    72.                  break;
    73.              }
    74.              case 4:{
    75.                  //查询数组中能被3整除的元素
    76.                  if(a!=null){
    77.                      dm.divThree(a);
    78.                  }else{
    79.                      System.out.println("还未在数组中插入数据，请重新选择操作！");
    80.                  }
    81.                  break;
    82.              }
    83.              default: {
    84.                  System.out.println("请输入对应的数字进行操作!");
    85.              }
    86.          }
    87.      }
    88.  }