导学

对于Java的学习，已经进入尾声了。接下来，我们就通过一个综合案例，来体验一下在企业中如何进行项目的开发。本节课程，我们会按照项目需求分析、接口设计、环境搭建、功能模块开发等阶段入手，完成整个项目，并达到上线交付的成果。
9. 综合案例：播放器 - 图1

需求分析

案例：播放器管理

  • 任务：通过控制台实现播放列表管理和播放器管理
  • 具体需求：
    1. 播放列表管理主要功能
      • 将歌曲添加到主播放列表
      • 将歌曲添加到普通播列表
      • 通过歌曲id查询到播放列表中的歌曲
      • 通过歌曲名称查询播放列表中的歌曲
      • 修改播放列表中的歌曲
      • 删除播放列表中的歌曲
      • 显示播放列表的所有歌曲
    2. 播放器管理
      • 向播放器添加播放列表
      • 从播放器删除播放列表
      • 通过名字查询播放列表信息
      • 显示所有列表名称

  • 详细设计：

    • 歌曲类（Song）
      9. 综合案例：播放器 - 图2
    • 播放列表类（PlayList）
      9. 综合案例：播放器 - 图3
      9. 综合案例：播放器 - 图4
      9. 综合案例：播放器 - 图5
    • 播放器类（PlayListCollection）
      9. 综合案例：播放器 - 图6
      9. 综合案例：播放器 - 图7

    • 测试类（TestDemo）
      对功能模块进行调用测试，并在主方法中进行调用

      歌曲类

      ``` package com.dodoke.player.bean; /**

      • 歌曲类（实体类-功能仅仅是提供对一个类的描述）
      • @author Dodoke / public class Song implements Comparable{ private String id;//歌曲编号

      private String name;

      private String singer;//演唱者 public Song(String id, String name, String singer) { super(); this.id = id; this.name = name; this.singer = singer; } public Song() { super(); } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSinger() { return singer; } public void setSinger(String singer) { this.singer = singer; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime result + ((id == null) ? 0 : id.hashCode()); result = prime result + ((name == null) ? 0 : name.hashCode()); result = prime * result + ((singer == null) ? 0 : singer.hashCode()); return result; } @Override public boolean equals(Object obj) { //判断对象是否相等，相等则返回true if(this == obj) {

      1.    return true;

      } //this ！= true if(obj.getClass() == Song.class) {

      1.    //类型相同才去进行比较
      2.    Song song = (Song)obj;
      3.    return (song.getId().equals(this.id)) && (song.getName().equals(this.name)) && (song.getSinger().equals(this.singer));

      } return false; } @Override public String toString() { return “歌曲信息：id为” + id + “, 歌曲名称为” + name + “, 演唱者为” + singer; } @Override public int compareTo(Song o) { String name1 = o.getName(); int n = this.name.compareTo(name1); return n; }

}

  1. <a name="4OdaC"></a>
  2. ## 播放列表类

package com.dodoke.player.dao; import java.util.ArrayList; import java.util.Collections; import java.util.List; import com.dodoke.player.bean.Song; /**

  • 播放列表类（描述和数据操作相关的方法）

  • @author Dodoke / public class PlayList { /**

    • 播放列表名称 */ private String playListName;

      /**

    • 播放列表的歌曲集合 */ private List musicList;

      /**

    • 在创建播放列表的时候，必须对播放列表命名

    • @param playListName 播放列表名称 */ public PlayList(String playListName) { super(); this.playListName = playListName; musicList = new ArrayList(); }

      /**

    • 将歌曲添加到播放列表

    • @param song 要添加的歌曲 */ public void addToPlayList(Song song) { //要排除重复添加的情况 boolean flag = false; //判断播放列表中歌曲是否存在 for(Song song1 : musicList) {

      1.  if(song1.equals(song)) {
      2.      flag = true;
      3.      break;
      4.  }

      } if(flag) {

      1.  System.out.println("该歌曲已经存在于播放列表中，添加失败！");

      } else {

      1.  //将歌曲添加到播放列表中
      2.  musicList.add(song);

      } }

      /**

    • 显示播放列表中所有的歌曲 */ public void displayAllSong() { System.out.println(“播放列表中所有歌曲为：”); for(Song song1 : musicList) {

      1.  System.out.println(song1);

      } }

      /**

    • 通过歌曲编号查询播放列表中的歌曲
    • @param id 歌曲编号

    • @return 查询到的的歌曲信息 */ public Song searchSongById(String id) { Song song = null; //歌曲编号id唯一 for(Song song1 : musicList) {

      1.  String id1 = song1.getId();
      2.  if(id1.equals(id)) {
      3.      //编号相同，则歌曲就是相同的
      4.      song = song1;
      5.      break;
      6.  }

      } return song; }

      /**

    • 根据歌曲名称查询歌曲
    • @param name 歌曲名称

    • @return 查询的歌曲信息 */ public Song searchSongByName(String name) { Song song = null; for(Song song1 : musicList) {

      1.  String name1 = song1.getName();
      2.  if(name1.equals(name)) {
      3.      //编号相同，则歌曲就是相同的
      4.      song = song1;
      5.      break;
      6.  }

      } return song; }

      /**

    • 修改播放列表中的歌曲信息
    • @param id 要修改的歌曲id

    • @param song 新的歌曲信息 */ public void updateSong(String id, Song song) { Song song1 = searchSongById(id); if(song1 == null) {

      1.  System.out.println("没有找到歌曲编号为" + id + "的歌曲信息！");

      } else {

      1.  //先移除原有的歌曲信息，再对播放列表中的歌曲信息进行重新添加
      2.  musicList.remove(song1);
      3.  musicList.add(song);
      4.  System.out.println("修改成功！");

      } }

      /**

    • 删除播放列表中指定的歌曲信息

    • @param id 歌曲编号 */ public void deleteSong(String id) { Song song = searchSongById(id); if(song == null) {

      1.  System.out.println("没有找到歌曲编号为" + id + "的歌曲信息！");

      } else {

      1.  musicList.remove(song);
      2.  System.out.println("删除成功！");

      } }

      /**

    • 对歌曲名进行排序 */ public void sortBySongName() { Collections.sort(musicList); } public String getPlayListName() { return playListName; } public void setPlayListName(String playListName) { this.playListName = playListName; } public List getMusicList() { return musicList; } public void setMusicList(List musicList) { this.musicList = musicList; } }
      1. <a name="l252d"></a>
      2. ## 播放器类
      package com.dodoke.player.dao; import java.util.HashMap; import java.util.Map; import java.util.Set; /**
  • 设置该播放器为系统唯一播放器

  • @author Dodoke / public class Player {

    private static Player palyer = new Player();

    public static Player getInstance() {

    1.  return palyer;

    }

    Map map = new HashMap();;//存放播放列表的集合 key-播放列表名称 value-播放列表

    private Player() {

    }

    /**

    • 向播放器中新增播放列表

    • @param pl 要添加的播放列表 */ public void addPlayList(PlayList pl) { map.put(pl.getPlayListName(), pl); }

      /**

    • 删除播放列表

    • @param pl 要删除的播放列表 */ public void deletePlayList(PlayList pl) { map.remove(pl.getPlayListName()); System.out.println(“删除成功！”); }

      /**

    • 根据播放列表名称查询播放列表
    • @param playListName 播放列表名称

    • @return 播放列表 */ public PlayList searchPlayListByName(String playListName) { PlayList pl = null; //找到map中所有key值得集合 Set plKeySet = map.keySet(); for(String s : plKeySet) {

      1.  //当集合中的key与参数相同时，也就是找到了播放列表
      2.  if(s.equals(playListName)) {
      3.      pl = map.get(s);
      4.  }

      } return pl; }

      /**

    • 显示所有播放列表的名称 */ public void displayListName() { Set plKeySet = map.keySet(); System.out.println(“播放列表名称为：”); for(String s : plKeySet) {

      1.  System.out.println(s);

      } }

      public Map getMap() { return map; } public void setMap(Map map) { this.map = map; }

}

  1. <a name="ew00y"></a>
  2. ## 测试类

package com.dodoke.player.test; import com.dodoke.player.bean.Song; import com.dodoke.player.dao.PlayList; import com.dodoke.player.dao.Player; public class Test { public static void main(String[] args) { Test test = new Test(); test.testPlayer(); }

  1. /**
  2.  * 对歌曲类进行测试
  3.  */
  4. public void testSong() {
  5.     Song song1 = new Song("s001","两只老虎","小太阳");
  6.     Song song2 = new Song("s002","小燕子","风车");
  7.     Song song3 = new Song("s003","茉莉花","彩虹");
  8.     Song song4 = new Song("s003","茉莉花","彩虹");
  9.     //测试toString()方法
  10.     System.out.println(song1);
  11.     //测试song1和song3是否相等，测试song3和song4是否相等
  12.     System.out.println("song1==song3:" + song1.equals(song3));
  13.     System.out.println("song3==song4:" + song3.equals(song4));
  14. }
  16. /**
  17.  * 对播放列表类进行测试
  18.  */
  19. public void  testPlayList() {
  20.     Song song1 = new Song("s001","两只老虎","小太阳");
  21.     Song song2 = new Song("s002","小燕子","风车");
  22.     Song song3 = new Song("s003","茉莉花","彩虹");
  23.     Song song4 = new Song("s003","茉莉花","彩虹");
  24.     PlayList pl = new PlayList("主播放列表");
  25.     pl.addToPlayList(song1);
  26.     pl.addToPlayList(song2);
  27.     pl.addToPlayList(song3);
  28.     pl.addToPlayList(song4);
  29.     //显示播放列表内容
  30.     pl.displayAllSong();
  31.     //通过id查询歌曲信息
  32.     Song song = pl.searchSongById("s003");
  33.     if(song == null) {
  34.         System.out.println("抱歉，没查到");
  35.     } else {
  36.         System.out.println(song);
  37.     }
  38.     //通过歌曲名称查询
  39.     song = null;
  40.     song = pl.searchSongByName("两只老虎");
  41.     if(song == null) {
  42.         System.out.println("抱歉，没查到");
  43.     } else {
  44.         System.out.println(song);
  45.     }
  46.     //修改歌曲信息
  47.     Song songnew = new Song("s004","突然的自我","伍佰");
  48.     pl.updateSong("s001", songnew);
  49.     pl.displayAllSong();
  50.     //歌曲排序
  51.     pl.sortBySongName();
  52.     pl.displayAllSong();
  53.     //删除歌曲信息
  54.     pl.deleteSong("s002");
  55.     pl.displayAllSong();
  56. }
  58. /**
  59.  * 对播放器类进行测试
  60.  */
  61. public void testPlayer() {
  62.     Song song1 = new Song("s001","两只老虎","小太阳");
  63.     Song song2 = new Song("s002","小燕子","风车");
  64.     Song song3 = new Song("s003","茉莉花","彩虹");
  65.     //创建主播放列表
  66.     PlayList mainPlayList = new PlayList("主播放列表");
  67.     mainPlayList.addToPlayList(song1);
  68.     mainPlayList.addToPlayList(song2);
  69.     mainPlayList.addToPlayList(song3);
  70.     //定义一个新的播放列表
  71.     PlayList pl = new PlayList("流行音乐");
  72.     //从主播放列表中获取流行音乐
  73.     pl.addToPlayList(mainPlayList.getMusicList().get(0));
  74.     pl.addToPlayList(mainPlayList.getMusicList().get(1));
  75.     //将两个播放列表添加到播放器中
  76.     Player player = Player.getInstance();
  77.     player.addPlayList(mainPlayList);
  78.     player.addPlayList(pl);
  79.     //展示播放列表名字
  80.     player.displayListName();
  81.     //根据播放列表名称查询播放列表信息，并显示所有歌曲
  82.     PlayList plst = player.searchPlayListByName("流行音乐");
  83.     plst.displayAllSong();
  84.     //删除播放列表信息
  85.     System.out.println("删除前：");
  86.     player.displayListName();
  87.     System.out.println("删除后：");
  88.     player.deletePlayList(pl);
  89.     player.displayListName();
  90. }

}

  1. <a name="aEOcb"></a>
  2. ## 程序运行服务类

package com.dodoke.player.service; import java.util.Scanner; import com.dodoke.player.bean.Song; import com.dodoke.player.dao.PlayList; import com.dodoke.player.dao.Player; /**

  • 描述程序运行逻辑

  • @author Dodoke / public class PlayerService {

    /**

    • 主菜单 / public void mainMenu() { System.out.println(“**“); System.out.println(“ 主菜单 “); System.out.println(“ 1—播放列表管理 “); System.out.println(“ 2—播放器管理 “); System.out.println(“ 0—退出 “); System.out.println(“*“); }

      /**

    • 播放列表管理菜单 / public void playListMenu() { System.out.println(“**“); System.out.println(“ 播放列表管理菜单 “); System.out.println(“ 1—将歌曲添加到主播放列表 “); System.out.println(“ 2—将歌曲添加到普通播列表 “); System.out.println(“ 3—通过歌曲id查询到播放列表中的歌曲 “); System.out.println(“ 4—通过歌曲名称查询播放列表中的歌曲 “); System.out.println(“ 5—修改播放列表中的歌曲 “); System.out.println(“ 6—删除播放列表中的歌曲 “); System.out.println(“ 7—显示播放列表的所有歌曲 “); System.out.println(“ 9—返回上一级菜单 “); System.out.println(“*“); }

      /**

    • 播放器菜单 / public void playerMenu() { System.out.println(“**“); System.out.println(“ 播放器管理菜单 “); System.out.println(“ 1—向播放器添加播放列表 “); System.out.println(“ 2—从播放器删除播放列表 “); System.out.println(“ 3—通过名字查询播放列表信息 “); System.out.println(“ 4—显示所有播放列表名称 “); System.out.println(“ 9—返回上一级菜单 “); System.out.println(“*“); }

      /**

    • 执行程序逻辑规划 */ public void player() { PlayerService plService = new PlayerService(); Scanner sc = new Scanner(System.in); int input = 0, input1 = 0, input2 = 0; //创建唯一的播放列表容器（播放器） Player player = Player.getInstance(); //创建一个播放器自带的主播放列表 PlayList mPlayList = new PlayList(“主播放列表”); //将主播放列表添加到播放器 player.addPlayList(mPlayList); //预先设置一个普通播放列表的变量名 PlayList pList = null; while(true) {
      1.  plService.mainMenu();
      2.  System.out.println("请输入对应的数字进行操作：");
      3.  input = sc.nextInt();//不再进行异常的处理
      4.  if(input == 0) {
      5.      System.out.println("退出程序！");
      6.      break;
      7.  }
      8.  //针对用户在主菜单输入的数字进行判断处理
      9.  switch(input) {
      10.      case 1: {
      11.          //播放列表管理
      12.          while(true) {
      13.              plService.playListMenu();
      14.              System.out.println("请输入对应的数字进行播放列表管理操作：");
      15.              input1 = sc.nextInt();
      16.              if(input1 == 9) {
      17.                  break;
      18.              }
      19.              switch(input1) {
      20.                  case 1: {
      21.                      System.out.println("将歌曲添加到主播放列表！");
      22.                      System.out.println("请输入要添加的歌曲数量：");
      23.                      int count = sc.nextInt();
      24.                      for(int i = 1; i <= count; i++) {
      25.                          System.out.println("请输入第" + i + "首歌曲");
      26.                          System.out.println("请输入歌曲id");
      27.                          String id = sc.next();
      28.                          System.out.println("请输入歌曲名称");
      29.                          String name = sc.next();
      30.                          System.out.println("请输入歌曲演唱者");
      31.                          String singer = sc.next();
      32.                          Song song = new Song(id, name, singer);
      33.                          mPlayList.addToPlayList(song);
      34.                      }
      35.                      System.out.println("歌曲添加完毕！");
      36.                      break;
      37.                  }
      38.                  case 2: {
      39.                      System.out.println("将歌曲添加到普通播放列表！");
      40.                      System.out.println("请输入要添加的播放列表名称：");
      41.                      String playListName = sc.next();
      42.                      //判断播放列表是否在播放器中存在
      43.                      pList = player.searchPlayListByName(playListName);
      44.                      if(pList == null) {
      45.                          System.out.println("该播放列表不存在，请先将播放列表添加到播放器中！");
      46.                      } else {
      47.                          System.out.println("请输入要添加的歌曲数量：");
      48.                          int count = sc.nextInt();
      49.                          for(int i = 1; i <= count; i++) {
      50.                              System.out.println("请输入第" + i + "首歌曲");
      51.                              System.out.println("请输入歌曲id");
      52.                              //去主播放列表查询歌曲
      53.                              String id = sc.next();
      54.                              Song songs = mPlayList.searchSongById(id);
      55.                              if(songs == null) {
      56.                                  //如果不存在则让用户继续填写歌曲信息，并将歌曲同时添加到主播放列表和普通播放列表（普通播放列表是主播放列表的子集）
      57.                                  System.out.println("该歌曲在主播放列表不存在，继续输入歌曲的其他信息！");
      58.                                  System.out.println("请输入歌曲名称");
      59.                                  String name = sc.next();
      60.                                  System.out.println("请输入歌曲演唱者");
      61.                                  String singer = sc.next();
      62.                                  Song song = new Song(id, name, singer);
      63.                                  pList.addToPlayList(song);
      64.                                  mPlayList.addToPlayList(song);
      65.                              } else {
      66.                                  //如果存在主播放列表，则直接将歌曲信息添加到普通播放列表
      67.                                  pList.addToPlayList(songs);
      68.                                  System.out.println("主播放列表中已有该歌曲，已将其添加到名为：" + playListName + "的歌单中！");
      69.                              }
      70.                          }
      71.                          System.out.println("歌曲添加完毕！");
      72.                      }
      73.                      break;
      74.                  }
      75.                  case 3: {
      76.                      System.out.println("通过歌曲id查询到播放列表中的歌曲");
      77.                      System.out.println("请输入要查询的播放列表名称：");
      78.                      String playListName = sc.next();
      79.                      //判断播放列表是否在播放器中存在
      80.                      pList = player.searchPlayListByName(playListName);
      81.                      if(pList == null) {
      82.                          System.out.println("该播放列表不存在，请先将播放列表添加到播放器中！");
      83.                      } else {
      84.                          System.out.println("请输入要查询的歌曲id：");
      85.                          String id = sc.next();
      86.                          Song song = pList.searchSongById(id);
      87.                          if(song == null) {
      88.                              System.out.println("该歌曲在播放列表" + playListName + "中不存在！");
      89.                          } else {
      90.                              System.out.println("歌曲信息为：");
      91.                              System.out.println(song);
      92.                          }
      93.                      }
      94.                      break;
      95.                  }
      96.                  case 4: {
      97.                      System.out.println("通过歌曲名称查询播放列表中的歌曲");
      98.                      break;
      99.                  }
      100.                  case 5: {
      101.                      System.out.println("修改播放列表中的歌曲");
      102.                      break;
      103.                  }
      104.                  case 6: {
      105.                      System.out.println("删除播放列表中的歌曲");
      106.                      break;
      107.                  }
      108.                  case 7: {
      109.                      System.out.println("显示播放列表的所有歌曲");
      110.                      System.out.println("请输入要查询的播放列表");
      111.                      String playListName = sc.next();
      112.                      PlayList plst = player.searchPlayListByName(playListName);
      113.                      if(plst == null) {
      114.                          System.out.println("抱歉，您输入的列表名称没有匹配！");
      115.                      } else {
      116.                          plst.displayAllSong();
      117.                      }
      118.                      break;
      119.                  }
      120.                  default: {
      121.                      System.out.println("该数字没有对应的操作");
      122.                      break;
      123.                  }
      124.              }
      125.          }
      126.          break;//对于死循环明确终止以后，才可以写，否则认为是无用代码
      127.      }
      128.      case 2: {
      129.          //播放器管理
      130.          while(true) {
      131.              plService.playerMenu();
      132.              System.out.println("请输入对应的数字进行播放器管理操作：");
      133.              input2 = sc.nextInt();
      134.              if(input2 == 9) {
      135.                  break;
      136.              }
      137.              switch(input2) {
      138.                  case 1: {
      139.                      System.out.println("向播放器添加播放列表!");
      140.                      System.out.println("请输入要添加的播放列表名称");
      141.                      String playName = sc.next();
      142.                      if(playName.equals("主播放列表")) {
      143.                          System.out.println("主播放列表无需创建！");
      144.                      } else {
      145.                          pList = new PlayList(playName);
      146.                          //将创建好的播放列表对象添加到播放器中
      147.                          player.addPlayList(pList);
      148.                          System.out.println("播放列表创建完毕！");
      149.                      }
      150.                      break;
      151.                  }
      152.                  case 2: {
      153.                      System.out.println("从播放器删除播放列表！");
      154.                      System.out.println("请输入要删除的播放列表名称:");
      155.                      String playListName = sc.next();
      156.                      if(playListName.equals("主播放列表")) {
      157.                          System.out.println("抱歉！主播放列表不能删除！");
      158.                          break;
      159.                      }
      160.                      //查询要删除的播放列表是否存在
      161.                      PlayList pList1 = player.searchPlayListByName(playListName);
      162.                      if(pList1 == null) {
      163.                          System.out.println("该播放列表不存在！");
      164.                      } else {
      165.                          player.deletePlayList(pList1);
      166.                      }
      167.                      break;
      168.                  }
      169.                  case 3: {
      170.                      System.out.println("通过名字查询播放列表信息！");
      171.                      System.out.println("请输入要查询的播放列表名称：");
      172.                      String playListName = sc.next();
      173.                      PlayList pList2 = player.searchPlayListByName(playListName);
      174.                      if(pList2 == null) {
      175.                          System.out.println("该播放列表不存在！");
      176.                      } else {
      177.                          System.out.println("已查询到该播放列表");
      178.                          System.out.println("该播放列表名称为：" + playListName);
      179.                          pList2.displayAllSong();
      180.                      }
      181.                      break;
      182.                  }
      183.                  case 4: {
      184.                      System.out.println("显示所有列表名称！");
      185.                      player.displayListName();
      186.                      break;
      187.                  }
      188.                  default: {
      189.                      System.out.println("该数字没有对应的操作");
      190.                      break;
      191.                  }
      192.              }
      193.          }
      194.          break;
      195.      }
      196.      default: {
      197.          System.out.println("该数字没有对应的操作");
      198.      }
      199.  }
      } } }
      1. <a name="jaqHl"></a>
      2. ## 控制类
      package com.dodoke.player.controller; import com.dodoke.player.service.PlayerService; /**
  • 控制层-调用程序运行逻辑

  • @author Dodoke / public class PlayerController {

    public static void main(String[] args) {

    1.  PlayerService play = new PlayerService();
    2.  play.player();

    } } ```