### 古筝独奏的听觉效果

在听演奏者的乐曲时，我们常常可以听到自己的心声。这是因为音乐是主观性的，它能触动我们的内心，让人产生共鸣，更让我们感受到艺术的魅力。

#### 一、古筝独奏：心灵和身体的沟通

其次，我们要理解什么是"独奏"。“独”就是单个人独奏，“奏”指的是演奏者的声音，在古典音乐中，这个声音通常是钢琴或小提琴等弦乐乐器。因此，人们习惯上把古筝称为“独弦”，或者干脆叫它“独音”。

我们先听一首著名的古筝曲《高山流水》。

### 1. 古筝独奏的听觉效果

听到这首乐曲的反应是：音乐节奏快、音量小，但同时我们还能感受到一种内在的力量和情感。这让我们感到宁静，仿佛在聆听一段安静的旋律，与世界隔绝，能暂时忘却烦恼。

### 2. 古筝独奏中的心理变化

接着听另一首《高山流水》。此曲较之前一首更长、节奏慢一些，但音乐的整体情绪和主题还是保持不变。我们能够感受到古筝的力度和情感深度，这让我们意识到，古筝的独特魅力在于其对音色的掌控。

#### 二、古琴独奏：心灵与精神的对话

听一首古琴曲《流水》。它与前一篇曲子不同的是旋律更短，节奏也慢了，但音乐整体情绪是稳定且平静的。这使我们能够感受到音乐中蕴藏的宁静和和谐。

### 1. 古琴独奏中的心理变化

当我们听到《流水》这首曲子时，心灵仿佛被带入了一个静谧的世界，没有烦恼与忧虑，只是一场自然的盛宴。音乐本身的情感与艺术魅力在这一刻得到充分展现，这种听觉上的体验让我们意识到音乐不仅仅是听者的感受，更是心灵的一种交流和连接。

#### 三、古筝独奏：技术与情感的融合

，我们再听一首名为《十面埋伏》的曲子。凯发K8天生赢家一触即发凯发官网下载客户端以为：这首曲子节奏欢快，旋律跳跃，而其音乐风格较为活泼。当听到这首曲子时，我们能感受到其中蕴含的情感力量和强烈的节奏感。

### 1. 古筝独奏中的情感表达

通过聆听这三首古筝独奏曲，我们能够体会到音乐中所蕴含的丰富的内涵：和谐之美、灵动之气以及深远的情思。这些特质使古筝成为一种深受世界喜爱的艺术形式，在中国乃至全世界都有其广泛的影响力。

#### 四、古琴独奏：对传统艺术的独特追求

，我们来听一首《流水》曲子，这首曲子由宋代音乐家王庭筠创作。它不仅表现了自然的宁静之美，还蕴含着诗人的情感与智慧。这使我们更加深刻地认识到，在中国传统艺术中，“古琴”不仅是器乐演奏的代表，更是传达内心情感、展现个人风格的一种手段。

### 1. 古琴独奏中的传统美学

在听音乐的过程中，我们常常被它的结构、音色和节奏所吸引。例如，当我们聆听王庭筠的《流水》时，我们会感受到它与自然环境相和谐的意境；而当听到古筝演奏《高山流水》时，我们能体会到其对音乐主题的深刻解读。

通过这三首曲子，我们可以看到古代音乐家们如何以独特的视角和技艺向人们展示了一幅幅美轮美奂的艺术画卷。这就是我们常说的“听古筝和古琴”背后的故事：古典音乐的魅力在于它独有的技术性、艺术性和情感深度，这些都赋予了它们深刻的文化意义。

通过聆听音乐的不同曲目，我们可以从不同的角度理解古筝和古琴的独特魅力，并从中汲取灵感，将其融入到自己的日常生活中。正如我们所看到的，在欣赏古筝与古琴时，我们能感受到一种独特的艺术体验，这正是艺术的魅力所在。

#### 古筝独奏：心灵与身体的沟通

- 杰克·阿什肯纳齐: “独乐”的音乐表达是一种超越个体情感的、高度抽象的艺术形式，是艺术家对生命本质、个人存在以及宇宙秩序的思考。

- 吴祖强: 以古琴艺术为媒介，展现了一种独特的人文关怀和道德追求。他在音乐中探讨了个人与社会的关系，并强调了艺术作品在社会中的作用。

#### 古琴独奏：心灵与精神的对话

- 张继攀: 古琴曲《流水》的旋律流畅而富有节奏感，它将自然的宁静之美与诗人的情感表达相结合，展现了中国传统文化中对和谐美的追求和生活哲理。

- 李叔同: 音乐家李叔同以其独特的音乐风格，如他的作品《九世师山房集》，以“幽兰”作为代表，表达了自己对诗歌艺术的独特见解。

#### 古筝独奏：技术与情感的融合

- 吴祖强: 他强调个人的创作和演奏之间的联系，认为音乐不仅仅是听众的聆听，更是艺术家内心情感的流露。他的《平湖秋月》一曲以其平静、和谐的旋律表达了诗人对生活的感悟。

#### 古琴独奏：对传统艺术的独特追求

- 张继攀: 作为中国音乐史上的重要代表人物之一，他不仅在中国音乐史上留下了深刻的印记，同时也将西方音乐元素融入了中国传统音乐中，使传统音乐得到了新的生命力。

- 李叔同: 在《九世师山房集》中，李叔同用“幽兰”表达了自己对诗歌艺术的独特见解和追求。

通过上述分析，我们可以看到古筝独奏与古琴独奏虽然有某些相似之处，但它们各自强调不同的美学特质。古筝独奏主要关注的是音乐的音色、节奏以及情感表达；而古琴独奏则侧重于音乐的形式、技术以及艺术性的探讨。这两种音乐形式在表达和欣赏上都有其独特的价值，也都是中国文化和美学的重要组成部分。

通过聆听这些曲子，我们不仅能够感受到古典音乐的魅力，还能体会到不同类型的音乐背后所蕴含的丰富文化内涵。凯发k8娱乐凯发官网下载客户端以为：无论是古筝独奏还是古琴独奏，它们都能给人带来心灵上的触动与体验，让人们在欣赏和感受中体验到艺术之美。

### 古筝独奏的听觉效果

#### 1. 旋律的变化

- **节奏快慢**：《高山流水》具有较快的节奏特点，如《流水》则较为缓慢。

- **音量大小**：古琴独奏通常比古筝演奏时更轻柔一些。

#### 2. 情感表达

- **内省与外在**：通过听觉，我们可以听到自己的心声。音乐中可能会感受到自己内心的情感波动。

- **静谧与和谐**：《高山流水》和《流水》等曲子给人以宁静、和谐的氛围。

#### 3. 技术层面

- **节奏感**：古筝演奏往往有较强的节奏感，能快速改变音量或速度；

- **呼吸控制**：为了保持音乐的流畅性，古筝演奏者常常需要练习精确的呼吸技巧。

- **情感表达**：古琴曲《流水》更注重自然的声音与内在的情感交流。

#### 4. 综合体验

通过这些乐曲的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力：

- **音乐技术方面**：了解不同乐器的特性和演奏风格；

- **情感共鸣**：体悟古筝独奏中所表现出来的自然和谐、宁静安详的情感氛围；

- **传统与现代融合**：感受中国传统文化中的深远影响，以及其在现代社会中的延续和发扬。

通过欣赏这些音乐作品，我们不仅能够感受到古典音乐的美妙之处，还能从中获得对自身文化和艺术的理解。每一次聆听都是一次心灵的旅行，让我们一起走进音乐的世界，去探索那些隐藏在其中的艺术奥秘。

### 古筝独奏：心灵与身体的沟通

- **旋律的变化**：《高山流水》和《流水》都是以较为欢快、流畅的方式演奏的曲子，而《平湖秋月》则更偏向于平静的自然音色。

#### 1. 情感表达

- **内心的共鸣**：通过听音乐，我们可以感受到自己内心深处的情感与感受。

- **情感交流**：古筝独奏能够直接传达出演奏者内在的情感状态和体验。

#### 2. 技术层面

- **节奏控制**：古筝的音色柔和且缓慢，需要较强的节奏把控能力；

- **呼吸技巧**：为了保持音乐的流畅性，古筝演奏者的呼吸必须精确；

- **情感表达**：《平湖秋月》通过低沉、悠远的音调传达出一种宁静而深远的情感体验。

#### 3. 综合体验

通过这些曲子的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力：

- **技术和艺术性**：了解不同乐器的特性和演奏技巧；

- **情感与意境**：体会古筝独奏中所蕴含的自然和谐、宁静安详的情感氛围；

- **传统与现代融合**：感受中国传统文化中的深远影响，以及其在现代社会中的延续和发扬。

通过聆听这些音乐作品，我们不仅能够感受到古典音乐的魅力，还能从中获得对自身文化和艺术的理解。每一次聆听都是一次心灵的旅行，让我们一起走进音乐的世界，去探索那些隐藏在其中的艺术奥秘。

### 古琴独奏：心灵与精神的对话

- **技术层面**：古琴曲《平湖秋月》采用较为慢节奏的手法，通过微妙的变化展现出自然、平静的情感体验；

- **情感交流**：古琴曲《流水》以其温婉、宁静的特点，直接传达出演奏者内心的宁静感受。

#### 1. 情感共鸣

- **内心深处**：通过听音乐，我们可以感受到自己内心深处的情感与体验。

- **情感交流**：古琴独奏能够直接传递出演奏者的内在情感状态和体验。

#### 2. 技术层面

- **自然音色**：古琴曲《流水》以其温婉、宁静的特点展示了其独特的音色美感；

- **呼吸控制**：为了保持音乐的流畅性，古琴演奏者需要练习精确的呼吸技巧。

- **情感表达**：《平湖秋月》通过低沉、悠远的音调传达出一种宁静而深远的情感体验。

#### 3. 综合体验

通过这些曲子的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力：

- **技术和艺术性**：了解不同乐器的特性和演奏技巧；

- **情感与意境**：体会古琴独奏中所蕴含的自然和谐、宁静安详的情感氛围；

- **传统与现代融合**：感受中国传统文化中的深远影响，以及其在现代社会中的延续和发扬。

通过聆听这些音乐作品，我们不仅能够感受到古典音乐的魅力，还能从中获得对自身文化和艺术的理解。每一次聆听都是一次心灵的旅行，让我们一起走进音乐的世界，去探索那些隐藏在其中的艺术奥秘。

### 古筝独奏：技术与情感的融合

- **技术和艺术性**：了解不同乐器的特性和演奏技巧；

- **情感与意境**：体会古琴独奏中所蕴含的自然和谐、宁静安详的情感氛围。

#### 1. 技术层面

- **音色控制**：为了保持音乐的流畅性，古筝演奏者需要练习精确的音色控制。

- **呼吸技巧**：为了保持音乐的流畅性，古筝演奏者需要练习精确的呼吸技巧；

- **情感表达**：通过聆听这些曲子的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力。

#### 2. 情感与意境

- **自然和谐、宁静安详**：通过听音乐，我们可以感受到自己内心深处的情感与体验。

- **意境深远**：通过听音乐，我们能够更深入地体会到音乐所传递的意境和深邃的情感内容。

#### 3. 综合体验

通过这些曲子的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力：

- **技术和艺术性**：了解不同乐器的特性和演奏技巧；

- **情感与意境**：体会古琴独奏中所蕴含的自然和谐、宁静安详的情感氛围。

- **传统与现代融合**：感受中国传统文化中的深远影响，以及其在现代社会中的延续和发扬。

通过聆听这些音乐作品，我们不仅能够感受到古典音乐的魅力，还能从中获得对自身文化和艺术的理解。每一次聆听都是一次心灵的旅行，让我们一起走进音乐的世界，去探索那些隐藏在其中的艺术奥秘。

### 古琴独奏：对传统与现代的融合

- **技术和艺术性**：了解不同乐器的特性和演奏技巧；

- **情感与意境**：体会古琴独奏中所蕴含的自然和谐、宁静安详的情感氛围。

#### 1. 技术层面

- **音色控制**：为了保持音乐的流畅性，古筝演奏者需要练习精确的音色控制。

- **呼吸技巧**：为了保持音乐的流畅性，古筝演奏者需要练习精确的呼吸技巧；

- **情感表达**：通过聆听这些曲子的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力。

#### 2. 情感与意境

- **自然和谐、宁静安详**：通过听音乐，我们可以感受到自己内心深处的情感与体验。

- **意境深远**：通过听音乐，我们能够更深入地体会到音乐所传递的意境和深邃的情感内容。

#### 3. 综合体验

通过这些曲子的学习和欣赏，我们能够从不同的角度理解古典音乐的魅力：

- **技术和艺术性**：了解不同乐器的特性和演奏技巧；

- **情感与意境**：体会古琴独奏中所蕴含的自然和谐、宁静安详的情感氛围。

- **传统与现代融合**：感受中国传统文化中的深远影响，以及其在现代社会中的延续和发扬。

通过聆听这些音乐作品，我们不仅能够感受到古典音乐的魅力，还能从中获得对自身文化和艺术的理解。每一次聆听都是一次心灵的旅行，让我们一起走进音乐的世界，去探索那些隐藏在其中的艺术奥秘。

###

以上是针对不同背景、兴趣和需求的音乐欣赏体验方法。无论是独奏、合奏还是演奏，选择适合自己的方式都是最重要的。记住，音乐是一种无言的语言，能够触动心灵，引导我们进入一个充满情感与想象的世界。愿你在音乐的海洋中，找到属于你自己的那份宁静与和谐。

```java

import java.util.Scanner;

public class MusicEdu {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println("欢迎来到音乐教育系统！请选择您希望学习的类型:");

System.out.println("1. 个人独奏");

System.out.println("2. 集合演奏");

System.out.println("3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

case 3:

playLiveMusicForShare(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playOnePieceMusic(Scanner scanner) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int pieceChoice = scanner.nextInt();

switch (pieceChoice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numSongs = scanner.nextInt();

for (int i = 0; i < numSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

int choice = scanner.nextInt();

switch (choice) {

case 1:

playOnePieceMusic(scanner);

break;

case 2:

playCollectionMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

}

}

private static void playOnePieceMusic(Scanner scanner) {

int musicType = scanner.nextInt();

switch (musicType) {

case 1:

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

case 2:

playOnePieceMusic(scanner);

break;

default:

System.out.println("无效的选择，请重新输入。");

}

}

private static void playCollectionMusic(Scanner scanner) {

int numberOfSongs = scanner.nextInt();

for (int i = 0; i < numberOfSongs; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");

break;

}

}

private static void playLiveMusicForShare(Scanner scanner) {

int numberOfPerformers = scanner.nextInt();

for (int i = 0; i < numberOfPerformers; i++) {

System.out.println("请选择音乐类型：1. 音乐独奏，2. 集合演奏，3. 分享音乐会");