# Mit Java Musik machen?



## Cherryrose (19. Mai 2014)

Hallo, ich habe eine Aufgabe bekommen, in der ich mit Java Musik machen soll. Ich arbeite mit Eclipse. Ich habe folgende Idee: Wenn man als Nutzer eine Tonleiter angibt (z.B. C-Dur) dann kommt eine Melodie in C-Dur. Und wenn man eine andere eingibt, kommt die gleiche Melodie in der anderen. Die Melodie würde ich dann selber spielen und einbauen.

Ich habe es schonmal geschafft, dass wenn ich ausführe eine Melodie kommt. Doch wie mache ich, dass der Nutzer erst eingeben muss, wie die Melodie ist? Dachte mir so mit if, weiß aber von selbst nicht genau wie das geht.

Würde mich sehr über Hilfe freuen!


----------



## Gucky (20. Mai 2014)

"Ich dachte mir so mit if[...]" :lol:
Ja. Damit bist du schon mal auf dem richtigen Weg. 

Wie genau soll es denn eingestellt werden können? Soll der Nutzer ein richtiges Lied "programmieren" können?


----------



## Phash (20. Mai 2014)

Deiner Ausdrucksweise nach zu urteilen, bist du Newbie.

Von daher schlage ich dir folgende Vorgehensweise vor:
1. Erstelle das Programm so, dass du im code vorgibst, welche tonart gespielt werden soll. 
2. Ändere das Programm so, dass es nacheinander 3 verschiedene tonarten abspielt.
3. Ändere das Programm so, dass du mit if oder switch case verschiedene Bedingungen prüfen kannst,  und du nur mit einem Parameter die tonart ändern kannst. 

4. Bau eine abfrage von der Tastatur ein,  auf die du reagierst.
5. Verbessere deinen code
6. Stell die tastatureingabe auf eine graphische Eingabe um


----------



## Cherryrose (20. Mai 2014)

Also, es stimmt schon, ich habe bis jetzt nur so in der Schule den Anfang gelernt, aber diese Augabe ist völlig anders. 
Bis jetzt habe ich es geschafft, dass eine Melodie spielt, bloß weiß noch nicht wie ich das so einbaue, dass ich zB 4 Melodien zur Wahl habe.


```
package samples;

import java.io.*;
import sun.audio.*;
public class audio {
	
	public static void main(String[] args) 
	throws Exception
	{	
		String wav_file = "C:/Users/Public/Music/Sample Music/Natur4.wav"; //
		
		InputStream in = new FileInputStream(wav_file);
		
		AudioStream audio = new AudioStream(in);
		AudioPlayer.player.start(audio); 		
	}
}
```


----------



## kaoZ (20. Mai 2014)

Hier mal in PsuedoCode wir wollen ja nicht alles verraten :


```
if(userEingabe.equals("mol"){
   AudioPlayer.play();
}
if(userEingabe.equals("dur")){
   AudioPlayer.play();
}
```

man könnte dies auch elegant mit einem Switch lösen , dies würde dann folgendermaßen aussehen.


```
switch(userEingabe){
 case "mol":
     AudioPlayer.play(...);
 break;
 case "dur":
     AudioPlayer.play(...);
 break;
}
```

in beiden fällen sollte dir aufgefallen sein das es sich bei userEingabe um einen String handelt, welcher per equals(Object o); auf Inhaltliche gleichheit mit dem in der Bedingung angegebenen String verglichen wird.

Zum einlesen der Nutzereingaben solltest du insofern du ohne GUI arbeitest dir die Klasse Scanner mal genauer anschauen


----------



## Cherryrose (20. Mai 2014)

sorry, hab paar fehler gefunden und lösche das was ich hier geschrieben habe vorhin. 

Schreibe gleich, wie mein nächster Weg aussieht.


----------



## kaoZ (20. Mai 2014)

```
public class audio
```

Klassen Schreibt man Groß !

zudem wenn du dies so machen möchtest musst du den AudioPlayer im Konstruktor übergeben da sonst deine Klasse Audio keine Kenntnis von deinem Player hat .


```
public class Audio{

 AudioPlayer player;

 public Audio(AudioPlayer player){
    this.player = player;
 }
 void melodie(){
 
  ...
 }
 }


}
```

Insofern die Klasse AudioPlayer von dir erstellt ist würde ich auch eher aus OOP Sicht die Melodien diesem Player übergeben, und die Melodien in einer Separaten Klasse realisieren und als Objekte behandeln 

Quasi 


```
public AudioPlayer(Melody...melodies){....}
```

so kannst du dann deinem Player die Songs/Melodien oder whatever übergeben und dieser spielt diese dann ab.

Hier mal ein fiktives Besipiel was ich meine , *OHNE funktionale implementierung, rein zur veranschaulichung !*

Song.java

```
public class Song {
	
	File file;
	
	public Song(String filePath) {
	   this.file = new File(filePath);
    }
	
	public String getName() 		{return this.file.getName();}

}
```

AudioPlayer.java

```
public class AudioPlayer {
	
	private Song[] songs;
	
	public AudioPlayer() {}
	
	public AudioPlayer(Song...songs) {
		this.songs = songs;
    }

	public void addSongs(Song...songs){
		this.songs = songs;
	}
	
	public void play(Song song){
		System.out.println(song.getName());
	}
	
	public Song[] getSongs() 				{return this.songs;}
}
```

AudioTest.java

```
public class AudioTest {

	
	public static void main(String[] args) {
	    
		AudioPlayer player = new AudioPlayer();
		
		Song one = new Song("C:/MySong.wav");
		Song two = new Song("G:/ExampleSong.wac");
		
		player.addSongs(one,two);
		
		/*
		 * Hier kannst du sehen wie das mit dem switch
		 * funktionieren würde.
		 */
		
		Scanner sc = new Scanner(System.in);
		
		switch(sc.nextLine()){
		case "mol":
			player.play(one);
			break;
		case "dur":
			player.play(two);
			break;
		}
		sc.close();
		
    }
}
```


----------



## Cherryrose (20. Mai 2014)

```
package samples;
import java.util.*;
import java.io.*;
import sun.audio.*;
public class Audio {
	
AudioPlayer player;  

public Audio(AudioPlayer player){    
	
	this.player = player; } 
public static void main(String[] args)

		String tonleiter="C-Dur";
		switch(C-Dur){
		case "C-Dur":
			AudioPlayer.play("C:/Users/Ela/Music/C-Dur.wav"); 
			break;
		case "D-Dur":
			AudioPlayer.play("C:/Users/Ela/Music/D-Dur.wav"); 
			break;
		case "G-Dur":
			AudioPlayer.play("C:/Users/Ela/Music/G-Dur.wav"); 
			
			InputStream in = new FileInputStream(wav_file);
			
			AudioStream audio = new AudioStream(in);
			AudioPlayer.player.start(audio); 
		}
	}
```

So, das hab ich bisher. "AudioPlayer player;" wie ist das gemeint, das verstehe ich nicht, soll das alleine so stehen oder kommt noch was dazu?
Und AudioPlayer bzw. AudioPlayer.play wird überall unterstrichen. Dazu auch noch C-Dur bei switch und wav_file.
Vielen Dank für deine Hilfe!!!! 

Edit: Müssen alle 3 erstellt werden? Ich kenne das noch nicht so. Wäre schön, wenn du das anhang meiner aufgabe dies erklären könntest!


----------



## kaoZ (20. Mai 2014)

siehe mein Beispiel oben ab der roten Schrift


----------



## Cherryrose (20. Mai 2014)

Okay, ich habe grade versucht, das ihrgendwie hinzukriegen. Aber ich schaffe es nicht, da ich keine Ahnung davon habe, aber die Aufgabe muss ich lösen.


----------



## kaoZ (20. Mai 2014)

Du hast es doch schon hinbekommen musik abzuspielen ?!

dann sollte die Fallunterscheidung eigentlich nicht so das Problem sein.

Poste doch bitte mal die Klasse AudioPlayer und Audio in ihrer ursprungsform.

Dann gehen wir das mal zusammen durch und schauen wie du es am innovativsten umsetzt


----------



## Cherryrose (20. Mai 2014)

Also AudioPlayer hatte ich bis du es geschrieben hast noch nicht. Das ist das was du geschrieben hast nur mit Audio statt Song, doch ich weiß nicht recht, was genau ich damit machen soll und was alles noch eingefügt werden muss.

```
package samples;
public class AudioPlayer {
	private Audio[] songs;

	public AudioPlayer() {}

	public AudioPlayer(Audio...songs) {
		this.songs = songs;
	}

	public void addSongs(Audio...songs){
		this.songs = songs;   
	}        
	public void play(Audio song){
		System.out.println(song.getName());
	}        
	public Audio[] getSongs()
	{return this.songs;}

	}
```

Das war Audio, muss man dies für jedes Lied erstellen oder ist es allgemein?
Und auch da, was muss ich noch dazufügen?


```
package samples;

import java.io.File;

public class Audio {
	
	File file;
	
	public Audio(String filePath) {
		this.file = new File(filePath);
	} 
	public String getName()
	{return this.file.getName();} 
	
}
```

Wäre schön, wenn du mir auch morgen weiter hilfst, heute ist es ja schon spät!


----------



## kaoZ (21. Mai 2014)

Na gut , dann fangen wir mal langsam an 

1. Wir erstellen uns eine Klasse, dessen Objekte nachher unsere Sounds / Töne Darstellen, 
diese nennen wir Sound

Sound.java :


```
import java.io.File;

/**
 * 
 * @author kaoZ
 * 
 * Diese Klasse hat keine andere Funktion als lediglich
 * den Pfad und einen Namen zu einer AudioDatei zu speichern,
 * man könnte also sagen Objekte dieser Klasse sind unsere Sounds,
 * welche wir später abspielen wollen.
 *
 */

public class Sound {
	
	private String name;
	private File file;
	
	public Sound(String name, String filePath) {
		this.name = name;
		this.file = new File(filePath);
    }
	
	public String getName() 		{return this.name;}
	public File getFile() 			{return this.file;}
}
```

Jetzt schreiben wir uns einen Player welcher später dann diese Sounds abspielen können soll,
hier erstellen wir nun erstmal eine gewisse basisfunktionalität, damit man Töne zu einer Playlist hinzufügen und löschen, nach Titel suchen kann , und zu guter letzt die Dateien auch abspielen kann.

AudioPlayer.java (hier erstmal nur die Basisfunktionalität):


```
import java.util.ArrayList;

public class AudioPlayer {
	
	private ArrayList<Sound> playList;
	
	public AudioPlayer() {
		this.playList = new ArrayList<>();
	}
	
	public AudioPlayer(Sound...songs) {
		this.playList = new ArrayList<>();
		addToPlayList(songs);
    }

	public void addToPlayList(Sound...songs){
		for (Sound sound : songs) {
	        getPlayList().add(sound);
        }
	}
	
	public void removeFromPlayList(Sound sound){
		for (int i = 0; i < playList.size(); i++) {
	        if (playList.get(i).getName().equals(sound)) {
	            playList.remove(i);
            }
        }
	}
	
	//Achtung , kann NPE auslösen , hier ist handlungsbedarf !
	
	public Sound getSongByName(String name){
		
		Sound sound = null;
		
		for (int i = 0; i < playList.size(); i++) {
	        if (playList.get(i).getName().equals(name)) {
	           sound = playList.get(i);
	        }
        }
		return sound;
		
	}
	
	public void play(Sound song){
		//Hier werden dann die einzelnen Songs dann abgespielt
	}
	
	public ArrayList<Sound> getPlayList()  		{return this.playList;}
}
```


----------



## kaoZ (21. Mai 2014)

Hier jetzt die implementierung der play Methode, füge diesen code nun oben in das Beispiel ein :


```
public void play(Sound song){
        try {
	        AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
	        AudioFormat audioFormat = stream.getFormat();
	        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
	        Clip clip = (Clip) AudioSystem.getLine(info);
	        clip.open(stream);
	        clip.start();
	        clip.start();
	        
	        while(clip.getFramePosition() < clip.getFrameLength()) {
	        	
	        	 
	        };
 
        } catch (Exception e) {
	        // TODO: handle exception
        }
    }
```

Erstelle nun zum testen eine Klasse AudioTest die wie folgt aussieht :

_(bei path gibt einen Pfad zu einer deiner .wav dateien an ! )_

AudioTest.java


```
public class AudioTest {

	public static void main(String[] args) {
	  
		String path = "L:/Cinema 4d/tex/tutorials/maxon_technoloop2.wav";
		
		Sound wave = new Sound("Wave",path);
		
		AudioPlayer player = new AudioPlayer();
		
		player.play(wave);
    }
}
```

Da es hier nur darum geht dir zu zeigen wie man wav dateien abspielt sollte dies nun schon klappen, 

diesen Teil :


```
while(clip.getFramePosition() < clip.getFrameLength()) {
	        	
	        	 
	        };
```

habe ich in der play Methode nun nur zu Testzwecken implementiert, in einer richtigen Implementierung würde man die Frames vorher auslesen und danach die Bedingung richten, fügst du diesen Code nun allerdings in diesem Beispiel nicht hinzu , beendet dein Programm bevor die Datei abgespielt wird, hier könnte man das Abspielen auch in einem Extra gestarteten Thread erledigen, dies würde hier allerdings zu weit gehen.

Teste bitte mal ob es bei dir so funktioniert, und gib mir Rückmeldung, dann können wir weitermachen, falls du irgendetwas nicht verstehen solltest, lass es mich wissen


----------



## Cherryrose (22. Mai 2014)

Tut mir leid dass ich mich gestern nicht gemeldet habe.
Also, ich habe alles so erstellt wie du es geschrieben hast. Bin bloß bei dem "Implentieren" stecken geblieben, da ich nicht genau weiß wo hin.


----------



## kaoZ (22. Mai 2014)

Ok hier nochmal alle Klasse wie sie nun sein sollten :




Spoiler: Sound.java





```
import java.io.File;

/**
 * 
 * @author kaoZ
 * 
 * Diese Klasse hat keine andere Funktion als lediglich
 * den Pfad und einen Namen zu einer AudioDatei zu speichern,
 * man könnte also sagen Objekte dieser Klasse sind unsere Sounds,
 * welche wir später abspielen wollen.
 *
 */

public class Sound {
	
	private String name;
	private File file;
	
	public Sound(String name, String filePath) {
		this.name = name;
		this.file = new File(filePath);
    }
	
	public String getName() 		{return this.name;}
	public File getFile() 			{return this.file;}
}
```







Spoiler: AudioPlayer.java





```
import java.util.ArrayList;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;

public class AudioPlayer {
    
    private ArrayList<Sound> playList;
    
    public AudioPlayer() {
        playList = new ArrayList<>();
    }
    
    public AudioPlayer(Sound...songs) {
        super();
        addToPlayList(songs);
    }
 
    public void addToPlayList(Sound...songs){
        for (Sound sound : songs) {
            getPlayList().add(sound);
        }
    }
    
    public void removeFromPlayList(Sound sound){
        for (int i = 0; i < playList.size(); i++) {
            if (playList.get(i).getName().equals(sound)) {
                playList.remove(i);
            }
        }
    }
    
    //Achtung , kann NPE auslösen , hier ist handlungsbedarf !
    
    public Sound getSongByName(String name){
        
        Sound sound = null;
        
        for (int i = 0; i < playList.size(); i++) {
            if (playList.get(i).getName().equals(name)) {
               sound = playList.get(i);
            }
        }
        return sound;
        
    }
    
    public void play(Sound song){
        try {
	        AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
	        AudioFormat audioFormat = stream.getFormat();
	        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
	        Clip clip = (Clip) AudioSystem.getLine(info);
	        clip.open(stream);
	        clip.start();
	        clip.start();
	        
	        while(clip.getFramePosition() < clip.getFrameLength()) {
	        	
	        	 // Nur zum testen so implementiert
	        };
 
        } catch (Exception e) {
	        //Hier werden wir dann ExceptionHandling betreiben !
        }
    }
    
    public ArrayList<Sound> getPlayList()       {return this.playList;}
}
```







Spoiler: AudioTest.java





```
public class AudioTest {

	public static void main(String[] args) {
	  
		String path = "L:/Cinema 4d/tex/tutorials/maxon_technoloop2.wav";
		
		Sound wave = new Sound("Wave",path);
		
		AudioPlayer player = new AudioPlayer();
		
		//Song zur Playlist hinzufügen, anhand des Names aus der Playlist laden + abspielen
		player.addToPlayList(wave);	
		player.play(player.getSongByName("Wave"));
		
		//Oder Song direkt abspielen
		//player.play(wave);
    }
}
```




Versuch mal das nachzuvollziehen , und wenn du Fragen hast stell diese, dann können wir uns um den Rest kümmern , wie Fehlerbehandlung und die Beseitigung der NPE bei nicht gefundenem Titel in der Playlist


----------



## Cherryrose (22. Mai 2014)

Yay, es funktioniert, aber es spielt nur ein Lied ab ohne eine Auswahl zu haben. Genau dies hatte ich bereits auf eine andere Weise auch geschafft.

Du hast am Anfang noch mir etwas mit case gezeigt, wie füge ich das da rein, damit der Nutzer eine Auswahl hat?


----------



## kaoZ (22. Mai 2014)

Dazu kommen wir nun als nächstes, ich bin allerdings Grade unterwegs,  sobald ich morgen zu Hause bin zeige ich dir wie du die playlist füllst und dann dem User ermöglichst verschiedene Sounds auszuwählen


----------



## Cherryrose (22. Mai 2014)

Das ist super! Ich habe dafür noch Zeit, also hat keine Eile!


----------



## kaoZ (23. Mai 2014)

So , dann wollen wir mal ! 

Also

Hier mal die Klasse AudioTest wie man sie erstellen könnte :



Spoiler: AudioTest.java





```
public class AudioTest {
	
	Scanner sc;
	AudioPlayer player;
	String path;
	
	public AudioTest() {
	   sc = new Scanner(System.in);
	   player = new AudioPlayer();
	   path = "L:/OpenOffice/share/gallery/sounds/";
	   
	   fillPlaylist();
    }
	
	public void fillPlaylist(){
		
		Sound one	 = new Sound("one",path + "cow.wav");
		Sound two	 = new Sound("two",path + "curve.wav");
		Sound three	 = new Sound("three",path + "drame.wav");
		Sound four	 = new Sound("four",path + "explose.wav");
		Sound five	 = new Sound("five",path + "falling.wav");
		
		getPlayer().addToPlayList(one, two, three, four, five);
	}
	
	public void startSession(){
		boolean running = true;
		
		while (running) {
	        String input = sc.nextLine();
	        
	        if (input.equals("stop")) {
	            running = false;
	            sc.close();
            }
	        while(running){
	        	player.play(player.getSongByName(input));
	        	break;
	        }
        }
	}
	
	public AudioPlayer getPlayer() 				{return this.player;}

	public static void main(String[] args) {
	  
		new AudioTest().startSession();
		
    }
}
```




Nun zur Erklärung : 

Der Konstruktor :


```
public AudioTest() {
	   sc = new Scanner(System.in);
	   player = new AudioPlayer();
	   path = "L:/OpenOffice/share/gallery/sounds/";
	   
	   fillPlaylist();
    }
```

Hier werden der 
	
	
	
	





```
Scanner
```
 für die Nutzereingabe, der 
	
	
	
	





```
AudioPlayer
```
 und der 
	
	
	
	





```
Pfad
```
 welcher die Sounds ( in meinem Fall ) beinhaltet angegeben, zusätzlich wird die methode 
	
	
	
	





```
fillPlaylist();
```
 aufgerufen welche die Playlist initialisiert, kann man auch per eingabe machen , für das Beispiel reicht es aber so , hier nun die Methode 
	
	
	
	





```
fillPlaylist();
```


```
public void fillPlaylist(){
		
		Sound one	 = new Sound("one",path + "cow.wav");
		Sound two	 = new Sound("two",path + "curve.wav");
		Sound three	 = new Sound("three",path + "drame.wav");
		Sound four	 = new Sound("four",path + "explose.wav");
		Sound five	 = new Sound("five",path + "falling.wav");
		
		getPlayer().addToPlayList(one, two, three, four, five);
	}
```

Diese Methode übernimmt das initialisieren der Playlist des AudioPlayers, ich hab hier willkürlich mal ein paar .wav files hinzugefügt dich ich auf die schnelle gefunden habe.

nun noch die entscheidende Methode 
	
	
	
	





```
startSession();
```


```
public void startSession(){
		boolean running = true;
		
		while (running) {
	        String input = sc.nextLine();
	        
	        if (input.equals("stop")) {
	            running = false;
	            sc.close();
            }
	        while(running){
	        	player.play(player.getSongByName(input));
	        	break;
	        }
        }
	}
```

Zugegeben , sie sieht etwas kryptisch aus, aber es ist notwendig damit nicht nach jeder eingabe die Anwendung beendet wird, hier passiert folgendes, beim Ausführen der Methode wird der boolsche Wert 
	
	
	
	





```
running
```
 auf *true* gesetzt, somit startet die erste While Schleife und die lokal definierte Variable 
	
	
	
	





```
input
```
 wartet nun über den Scanner und dessen nextLine Methode, auf eingabe in der Konsole, solange diese nicht "stop" ist, wird die variable input mit der nächsten Zeile der Konsole belegt ,daraufhin wird die zweite while Schleife ausgeführt, die ebenfalls solange läuft wie 
	
	
	
	





```
running = true
```
 ist, in dieser wird nun die methode 
	
	
	
	





```
play(Song s);
```
, in verbindung mit der Methode 
	
	
	
	





```
getSongByName(String s);
```
 des AudioPlayers aufgerufen und dieser der Inhalt der lokalen Variable *input* gefüllt.
Nun wird in dieser Methode nach einem Song gesucht der Namentlich Identisch mit der Eingabe ist, sollte ein Soung gefunden werden spielt die Methode play(); diesen dann ab, und das 
	
	
	
	





```
break;
```
 sorgt dafür das aus der zweiten while schleife wieder heraus in die erste gesprungen wird, anders würde sonst nun die Anwendung beendet werden.

Du kannst so nun beliebig oft einen Sound nach dem anderen aus der playlist abspielen, bis du *stop* eingibst, dann wird 
	
	
	
	





```
running = false
```
 gesetzt, der Scanner geschlossen und die Anwendung beendet.

hier nun noch die Main Methode welche nurnoch dazu dient um das Programm zu starten, bzw. eine Instanz der Klasse AudioTest zu Instanziieren, und die 
	
	
	
	





```
startSession();
```
 Methode aufzurufen.


```
public static void main(String[] args) {
	  
		new AudioTest().startSession();
		
    }
```


----------



## kaoZ (23. Mai 2014)

Wir könnten nun noch beigehen und die Methoden in der Klasse AudioPlayer vernünftig implementieren und uns um Fehlerbehandlung Kümmern, oder evtl, eine kleine GUI schreiben welche das Ganze Visualisiert.


----------



## kaoZ (26. Mai 2014)

Falls dann doch schon alles geklärt sein sollte könntest du das Thema dann auch schließen


----------



## Cherryrose (26. Mai 2014)

Nein, nein noch ist garnichts geklärt. 
Hatte die letzten Tage keine Zeit dafür, habe grade erst dass gemacht, was du geschrieben hast.
Soweit habe ich keinen fehler, doch wenn ich abspielen will, erscheint keine Fehlermeldung aber auch kein Ton.
Du hast geschrieben, man muss implementieren, wie geht das?


----------



## kaoZ (26. Mai 2014)

Hast du den While Loop mit implementiert ?


```
public void play(Sound song){
        try {
            AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
            AudioFormat audioFormat = stream.getFormat();
            DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
            Clip clip = (Clip) AudioSystem.getLine(info);
            clip.open(stream);
            clip.start();
            clip.start();
            

            // *********************************************
            // Das hier ist Wichtig , sonst wird das Programm beendet bevor der Sound abgespielt wurde !

            while(clip.getFramePosition() < clip.getFrameLength()) {
                
                 // Nur zum testen so implementiert
            };
 
            //*********************************************

        } catch (Exception e) {
            //Hier werden wir dann ExceptionHandling betreiben !
        }
    }
```


Implementieren bedeutet übrigens nichts anderes als einbinden, einfügen oder etwas einem bestehendem System hinzuzufügen


----------



## Cherryrose (26. Mai 2014)

Ja dies habe ich bereits.


----------



## Cherryrose (26. Mai 2014)

Ich weiß nicht was ich noch machen soll, damit das abspielt.


----------



## kaoZ (26. Mai 2014)

Es kann sein , das das .wav file eine andere Codierung verwendet, versuch mal bitte eine andere datei abzuspielen, bei mir funktionieren auch nicht alle, ansonsten müssen wir uns noch um die Codierund kümmern.

Ansonsten musst du mal debuggen und ein Breakpoint auf das auslesen des formates setzen dann muss die Codierung 
	
	
	
	





```
"PCM_SIGNED"
```
 sein, sonst kann es sein das es zwar abgespielt wird du aber nix hörst.

Hier noch ein Screen vom Debugger :




Wenn du nicht weißt wie man den Debugger nutzt lass es mich wissen ^^

[EDIT]
Mach doch mal nen Screenshot von Deiner IDE und poste denn hier mal oder nen LInk dazu so das ich Quelltext und die Konsole sehen kann, vielleicht finde ich nen Fehler insofern es einen gibt 
[/EDIT]

[EDIT]
Poste doch auch bitte mal deine Klasse AudioTest damit ich sehen kann wie und ob du die Sounds deiner Playlist hinzugefügt hast.
[/EDIT]


----------



## Cherryrose (26. Mai 2014)

```
package samples;

import java.util.Scanner;

public class AudioTest {
	
	 Scanner sc;
	 AudioPlayer player;
	 String path;
	 public AudioTest() {
		 sc = new Scanner(System.in);
		 player = new AudioPlayer();
		 path = "C:/Users/Ela/Music";
	
    fillPlaylist();    
    }
	
	public void fillPlaylist(){  
		Sound C    = new Sound("one",path + "C-Dur.wav");
		Sound D    = new Sound("two",path + "D-Dur.wav");
		Sound G  = new Sound("three",path + "G-Dur.wav");
		getPlayer().addToPlayList(C, D, G);
		}        
	public void startSession(){       
		boolean running = true;
		while (running) {
			String input = sc.nextLine();
			if (input.equals("stop")) {
				running = false;
				sc.close();
				}
			while(running){
				player.play(player.getSongByName(input));
				break;
				}
			}
		}
	public AudioPlayer getPlayer()              {return this.player;}
	public static void main(String[] args) {
		new AudioTest().startSession();
		}
	}
```

Das ist mein AudioTest.

Wie gesagt, ich kenne mich kaum aus, deshalb weiß ich auch nicht wie man debuggt.^^


----------



## kaoZ (26. Mai 2014)

Ok kleinen moment...

1. Hier fehlt ein slash "/"


```
path = "C:/Users/Ela/Music";
```

richtig wäre :


```
path = "C:/Users/Ela/Music/";
```

bitte korrigiere das mal und führe deine Anwendung aus, sonst kann er nämlich keine der sounds finden da er nicht im richtigen Verzeichniss ist 

[EDIT]Gibt es eine Veränderung ?[/EDIT]

[TIPP]Variablen / Methoden schreibt man lowerCamelCase

```
Sound c = ....;
```
[/TIPP]


----------



## Cherryrose (26. Mai 2014)

Hups 

Funktioniert dennoch nicht.


----------



## kaoZ (26. Mai 2014)

ok, dann weiter im Text, nun müssen wir mal debuggen :

Folgendermaßen , durch doppelklick an diese stelle , setzt du einen Breakpoint, dies ist die kleine blaue kugel 





Bitte mach das mal an genau dieser Stelle in der Klasse AudioPlayer.

dann startest du deine Anwendung unter Verwendung dieses Buttons als Java Application:





und gibst dann mal zum testen "one" ein und bestätigst mit Enter.

Jetzt müsste Eclipse in die Debugg Ansicht springen und du siehts links oben solch ein Fenster :





jetzt nutzt du diesen Button solange bis du oben links wie im oberen bild audioFormat stehen hast,





klickst nun auf den pfeil davor und dann sollte es aussehen wie im Bild oben dort stehen dann informationen zu der Codierung deiner AudioDatei., mach davon bitte mal nen screenshot

[EDIT]oder bekommst du in der Console irgendwelche Exceptions oder Fehlermeldungen , falls ja bitte poste diese mal.[/EDIT]


----------



## Cherryrose (26. Mai 2014)

Ich weiß nicht so recht wo ich "one" eingeben soll. Wenn ich das als breakpoint mache und dann auf das symbol drücke dann erscheint diese Ansicht aber mit anderen Angaben und auch wenn ich alles durchgucke, das was bei dir steht entdecke ich nicht.


----------



## kaoZ (26. Mai 2014)

Wenn du deine Application in deiner IDE startest , sollte durch die while Schleifen das untere rote Viereck aktiv sein, das bedeutet die Anwendung wartet auf eingabe , du kannst dann unten wie in dem Bilder in der Konsole text eingeben, und diese dann mit Enter bestätigen .

wenn der Text den du eingibst mit einem der Songnamen übereinstimmen sollte, wird der Sound abgespielt.


----------



## kaoZ (26. Mai 2014)

Ich habe mal ein paar Ausgabe hinzugefügt damit es besser zu sehen ist das die Anwendung läuft, 

so sollte es dann aussehen wenn du die Anwendung startest, die eingekreiste Zeile ist meine Eingabe:





ersetze mal deine Klasse AudioTest mit diesem SourceCode hier, denke aber daran das du deine Songs wieder angeben musst! :


```
import java.util.Scanner;



public class AudioTest {
	
	Scanner sc;
	AudioPlayer player;
	String path;
	
	public AudioTest() {
	   sc = new Scanner(System.in);
	   player = new AudioPlayer();
	   path = "L:/OpenOffice/share/gallery/sounds/";
	   
	   fillPlaylist();
    }
	
	public void fillPlaylist(){
		
		Sound one	 = new Sound("one",path + "cow.wav");
		Sound two	 = new Sound("two",path + "curve.wav");
		Sound three	 = new Sound("three",path + "drama.wav");
		Sound four	 = new Sound("four",path + "explos.wav");
		Sound five	 = new Sound("five",path + "falling.wav");
		
		getPlayer().addToPlayList(one, two, three, four, five);
	}
	
	public void startSession(){
		boolean running = true;
		
        System.out.println("Willkommen beim AudioPlayer");
        System.out.println("***************************");
        System.out.println("- Gibt 'songlist' ein um eine Titelübersicht zu erhalten,");
        System.out.println("- gibt den Namen eines Sounds ein um ihn abzuspielen,");
        System.out.println("- oder 'stop' um den Player zu beenden.");
        System.out.println("_______________________________________");
        

		while (running) {
	        String input = sc.nextLine();
	        
	        if (input.equals("songlist")) {
	        	
	        	System.out.println("Songlist");
	        	System.out.println("********");
	        	
	            for (int i = 0; i < player.getPlayList().size(); i++) {
	                System.out.println("Sound " + i + ": " + player.getPlayList().get(i).getName());
                }
	            continue;
            }
	        
	        if(input.equals("stop")) {
	            running = false;
	            sc.close();
	            System.out.println("Player wurde beendet ! Schönen Tag noch.");
            }
	        
	        while(running){
	        	System.out.println("Spiele Sound " + input + " ab.");
	        	player.play(player.getSongByName(input));
	        	break;
	        }
        }
	}
	
	public AudioPlayer getPlayer() 				{return this.player;}

	public static void main(String[] args) {
	  
		new AudioTest().startSession();
		
    }
}
```


----------



## Cherryrose (26. Mai 2014)

Zwar hab ich den Breakpoint gemacht, aber bei mir steht nicht AudioFormat da. 

Ahh genau dies ist mir eben auch aufgefallen, dass du bei while mehr hast, wollte eben fragen, ist aber doch geklärt.


----------



## kaoZ (26. Mai 2014)

Du musst noch einen Schritt weiter klicken oben mit dem Grünen Pfeil damit die Variable belegt wird, dann sollte oben rechts auch das Format erscheinen.

[EDIT]ersetze aber trotzdem mal die Klasse AudioTest, damit du anhand der Ausgaben sehen kannst ob das Programm läuft wie es soll oder nicht [/EDIT]


----------



## Cherryrose (26. Mai 2014)

OHHHH Es funktioniert!!! 

Ich danke dir vieeeelmals! 

Ist genau so wie ich es mir erträumt habe. 

Dankeschöön!!


----------



## kaoZ (26. Mai 2014)

Top, wie gesagt, Exception Handling wäre noch ein Punkt den man definitiv nicht außer acht lassen sollte.

ansonsten halt die Sache mit der GUI, um dem User eine Grafische Darstellung zu liefern mit der er arbeiten kann.

Aber wenn du zufrieden bist , haben wir unser Ziel ja erreicht


----------



## Cherryrose (26. Mai 2014)

ja, ich denke das reicht so.  

Bloß kannst du mir noch erklären, es sind ja drei Klassen, wie genau hast du diese 3 Klassen miteinander verbunden und wozu?


----------



## kaoZ (26. Mai 2014)

Also

Eine Klasse stellt unsere Sounds dar, eine unseren Player , und eine Verbindet das Ganze.

Objekte der Klasse Sound repräsentieren die Sounds die wir abspielen wollen.

Objekte der Klasse AudioPlayer stellt unseren Player dar.

Objekte der Klasse AudioTest verknüpfen das ganze miteinander.

In der Klasse AudioTest erzeugen wir Sounds ( Objekte vom Typ Sound) welche wir an die Playlist unseres AudioPlayers übergeben,

die Klasse AudioTest erzeugt hier in unserem Fall die Schleifen welche die Nutzereingaben entgegen nimmt und dann entsprechend
darauf reagiert, z.B indem unser Player einen Sound abspielt.

In der OOP ist es so das Objekte bestimmter Typen wie in unserem Fall reelle Dinge darstellen, so stellt in userem Fall halt die klasse Sound einen Sound dar, hätte man die Klasse Handy wäre z.B ein Objekt der klasse eine nachahmung eines reelen Gegenstandes, dabei legt man über die Klasse fest welche Eigenschaften und attribute solch ein Objekt hat, zum Beispiel einen Typ oder einen Namen, dafür sind die sogenannten Member oder auch Instanzvariablen gedacht.


```
public class Handy{
  
  private String name;  // Member oder auch Instanzvariable

...
}
```

diese steht dann jedem Objekt welches erzeugt wird zur Verfügung. und kann für jedes Objekt unterschiedlich belegt sein.

Die Klasse ist also der Bauplan und ein erzeugtes Objekt dieser Klasse ist quasi ein einzelnes Element mit den in der Klasse festgelegten Eigenschaften und "Funktionen" ( methoden )


----------



## Cherryrose (26. Mai 2014)

Alles klar, danke.


----------



## kaoZ (26. Mai 2014)

Keine Ursache , wenn ich dir helfen konnte würde ich mich über einen klick auf den Danke button freuen


----------



## Cherryrose (30. Mai 2014)

Also ich hab das jetzt so ausgebaut wie ich es wollte, aber denke um noch mehr zu überzeugen könnte ich doch noch so machen, dass es in einem neuen Fenster erscheint. Ist das viel Arbeit? Ich habe noch bis nächsten Dienstag Zeit.
Würde mich sehr über weitere Hilfe freuen!


----------



## kaoZ (31. Mai 2014)

Du meinst also ein Gui ?

Klar können wir machen 

[EDIT]Am besten du machst mal eine skizze wie du dir das vorstellst, lädst diese als bild hoch und dann schauen wir mal was wir machen können ;[/EDIT]


----------



## Cherryrose (31. Mai 2014)

Danke das du mir doch nocht weiter helfen willst. 






Spoiler





```
package samples;

import java.util.Scanner; 
//Die Klasse Scanner ist in dem Paket java.util definiert.

public class AudioTest {
	
	 Scanner sc; 
	 AudioPlayer player;
	 String path;
	 
//sc repräsentiert den Scanner, der Scanner definiert Methoden zum Einlesen von Dateien	
	
	 public AudioTest() {
		 sc = new Scanner(System.in);  //Der Scanner liest normalerweise eine Datenquelle, hier die Konsolenangabe.
		 player = new AudioPlayer();
		 path = "C:/Users/Ela/Music/"; //Der Pfad zu der .wav Datei, welcher abgespiel werden soll.

		 fillPlaylist();               //Diese Methode initialisiert die Playlist
    }
	
	public void fillPlaylist(){  
		
		Sound b = new Sound("Bandoneon",path + "Bandoneon.wav"); 
		Sound f = new Sound("Blockflöte",path + "Blockflöte.wav");
		Sound g = new Sound("Glockenspiel",path + "Glockenspiel.wav"); 
		Sound h = new Sound("Harfe",path + "Harfe.wav"); 
		Sound k = new Sound("Klavier",path + "Klavier.wav"); 
		Sound o = new Sound("Orgel",path + "Orgel.wav"); 
		
		getPlayer().addToPlayList(b, f, g, h, k, o);
//Die Sounddateien werden in der Playlist angegeben, um sie dann als Nutzer auszuwählen.
	}        
	
	public void startSession(){       
		boolean running = true;
		
		 System.out.println("Hier können Sie sich für ein Instrument entscheiden, in der das Lied 'Suit' von R.Ch.Martin gespielt werden soll!");
		 System.out.println("");
		 System.out.println("1. Geben Sie als erstes 'Instrument' ein, um eine Übersicht zu erhalten.");
		 System.out.println("2. Als nächstes geben Sie den Namen eines Instrumentes ein, um sie abzuspielen. Dies können Sie beliebig oft wiederholen.");
		 System.out.println("3. Wenn Sie den Player beenden wollen, geben Sie 'stop' ein.");
		 System.out.println("");
		 System.out.println("***********************************************************************************************");
		 
		 while (running) {            
			 String input = sc.nextLine();
		 
			 if (input.equals("Instrument")) {
			 
				 System.out.println("");
				
			 
				 for (int i = 0; i < player.getPlayList().size(); i++) {
					 System.out.println(player.getPlayList().get(i).getName()); 
					 
				 } 
			 	 continue;
		}                       
		if(input.equals("stop")) {
			 running = false;
			 sc.close();
			 System.out.println("Der Player wurde beendet. Hoffentlich haben Sie die Musik genossen!");
			 System.out.println("Ich wünsche Ihnen noch einen schönen Tag!");
		}    
		 
		while(running){
			System.out.println("Das Lied wird mit " + input + " gespielt. Viel Vergnügen!");
			player.play(player.getSongByName(input));
			break; 
			
			}
		 }
	}
	public AudioPlayer getPlayer()              {return this.player;}
	
	public static void main(String[] args) { 
		new AudioTest().startSession();
//Die Main Methode dient dazu um das Programm zu starten und die startSession(); Methode aufzurufen.
		}
}
```




So sieht mein Code jetzt aus, ich habe Tonart durch Instrument ersetzt und würde es schön finden wenn ein Fenster erscheint wo man sich für ein Instrument entscheidet. Wenn man auf eins drückt kommt gleich die Musik, oder es erscheint ein neues Fenster wo steht welches Instrument jetzt spielt, muss aber nicht umbedingt sein. Wenn eins zuende gespielt hat kann man sich dann gleich ohne erneutes öffnen ein neues aussuchen. Also ich hoffe es ist nicht zu schwer, wäre schön wenn es klappt, dann hätte ich 2 Versionen die ich präsentieren kann!


----------



## kaoZ (1. Jun 2014)

Ich schau mir das morgen in ruhe nochmal an und dann sehen wir mal das wir dazu noch eine optionale Gui basteln


----------



## kaoZ (1. Jun 2014)

So dann wollen wir mal fix was zusammenbauen 

Zuerst müssen wir uns gedanken darüber machen wie wir das was du dort skizziert hast optisch umsetzen, wenn ich darauf schaue sehe ich z.B :

- 1 JFrame mit BorderLayout
- 1 JLabel im Head Bereich des JFrames
- 1 JPanel welches unseren Content beinhaltet ( hier mit GridLayout)
- 6 JButtons welche uns nachher die möglichkeit geben die Sounds abzuspielen

Hier der Code dazu , hier ist allerdings noch keine Funktionalität vorhanden, dazu kommen wir jetzt gleich:



Spoiler: Gui





```
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Gui extends JFrame {
    private static final long serialVersionUID = 1L;

    public final static Dimension GUI_SIZE = new Dimension(400,300);
    public final static String GUI_TITLE = "Audio Player v1.0";

    
    private JPanel contentPane;
    private JPanel headerPane;
    
    private JButton[] btns;
    
	public Gui() {
	   
		setSize(GUI_SIZE);
		setTitle(GUI_TITLE);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		
		this.contentPane = new JPanel(new GridLayout(3,2,20,20));
		this.contentPane.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
		
		this.headerPane = new JPanel();
		
		this.btns = new JButton[6];
		
		createComponents();
    }
	
	private void createComponents(){
		
		JLabel header = new JLabel("<Html>Mit welchem Instrument soll 'Suit'<br>"
				+ "von R.CH.Martin gespielt werden ?</Html>", JLabel.CENTER);
		
		Font newFont = header.getFont().deriveFont(14f);
		
		header.setFont(newFont);
	
		String[] label = {"Bandoneon","Harfe","Blockflöte","Klavier","Glockenspiel","Orgel"};
		
		for (int i = 0; i < btns.length; i++) {
	        btns[i] = new JButton(label[i]);
        }
		
		for (int i = 0; i < btns.length; i++) {
	        contentPane.add(btns[i]);
        }
		
		
		this.headerPane.add(header);
		
		this.add(BorderLayout.PAGE_START, headerPane);
		this.add(BorderLayout.CENTER, contentPane);	
	}
}
```




Das ganze schaut dann so aus :





Ich habe hier erst einmal versucht es so einfach wie möglich für dich zu gestalten , und erzeuge hier über Schleifen die nötigen Elemente, und fülle diese dann über eine weitere Schleife mit Text, welchem ich zuvor initialisiert habe, wenn du Fragen dazu haben solltest immer raus damit , schließlich sollst du es ja nachvollziehen können 

als nächstes werden wir einen Listener einbinden , und zwar in einfachster Form, welcher auf die Buttonsklicks lauscht und dann über sogenannte Events die nötigen Aktionen ausführt/aufruft.

[EDIT]Das verwenden von HTML Tags im JLabel ist notwendig da sonst keine Zeilenumbruch stattfindet, ansonsten hätten wir eine eigenständige klasse von JLabel ableiten müssen um dieses feature selbst zu implementieren, was hier eindeutig zu aufwendig wäre.[/EDIT]

Da ich nicht weiß ob nur ein Interpret mit verschiedenen Instrumenten Voraussetzung bei dir ist , 
habe ich auch nur das von dir skizzierte nachgestellt, wenn du mehrere Künstler anbieten sollst, müsste man sonst das gleiche nochmal für Künstler machen , und dann beim auswählen dieser dann dieses Fenster öffnen welches die verschiedenen Instrumente anbietet, ansonsten könnte man es so lassen.


----------



## Cherryrose (1. Jun 2014)

Alles klar hab genau das gemacht was du geschrieben hast, was was ist finde ich selber raus. 

Wie geht es weiter?


----------



## kaoZ (1. Jun 2014)

Als nächstes werden wir über folgenden Code , einen Listener implementieren, hier handelt es sich um ein Interface, da ein Interface Abstrakt ist, muss die Methode ( hier nur eine , seit Java 8 ist dies ein funktionales Interface ) überschrieben werden.

Hier der Code 


```
public class Gui extends JFrame implements ActionListener{..}
```

nachdem du über Strg + Shift + O das package des ActionListener importiert hast fordert dich Eclipse nun durch unterstreichen der Klasse Gui auf , die Methoden des Interfaces zu implementieren in unserem Fall 


```
public void actionPerformed(ActionEvent e){...}
```

Zudem müssen wir oben in der Schleife in welcher wird die Buttons erzeugen auch gleich die Buttons beim Listener anmelden, dies machen wir indem wir diesen Code hinzufügen :


```
for (int i = 0; i < btns.length; i++) {
	 btns[i] = new JButton(label[i]);
	 btns[i].addActionListener(this);  // <----
}
```

wenn du dies hast sollte es nun ( ohne die hier bereits gemachten implementierungen ) so aussehen:


```
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Gui extends JFrame implements ActionListener{
    private static final long serialVersionUID = 1L;

    public final static Dimension GUI_SIZE = new Dimension(400,300);
    public final static String GUI_TITLE = "Audio Player v1.0";

    
    private JPanel contentPane;
    private JPanel headerPane;
    
    private JButton[] btns;
    
	public Gui() {
	   
		setSize(GUI_SIZE);
		setTitle(GUI_TITLE);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		
		this.contentPane = new JPanel(new GridLayout(3,2,20,20));
		this.contentPane.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
		
		this.headerPane = new JPanel();
		
		this.btns = new JButton[6];
		
		createComponents();
    }
	
	private void createComponents(){
		
		JLabel header = new JLabel("<Html>Mit welchem Instrument soll 'Suit'<br>"
				+ "von R.CH.Martin gespielt werden ?</Html>", JLabel.CENTER);
		
		Font newFont = header.getFont().deriveFont(14f);
		
		header.setFont(newFont);
	
		String[] label = {"Bandoneon","Harfe","Blockflöte","Klavier","Glockenspiel","Orgel"};
		
		for (int i = 0; i < btns.length; i++) {
	        btns[i] = new JButton(label[i]);
	        btns[i].addActionListener(this);
        }
		
		for (int i = 0; i < btns.length; i++) {
	        contentPane.add(btns[i]);
        }
		
		
		this.headerPane.add(header);
		
		this.add(BorderLayout.PAGE_START, headerPane);
		this.add(BorderLayout.CENTER, contentPane);	
	}

	@Override
    public void actionPerformed(ActionEvent e) {
		
	  switch(e.getActionCommand()){
	  case "Bandoneon":
		  System.out.println("Test : " + e.getActionCommand());
		  break;
	  case "Harfe":
		  System.out.println("Test : " + e.getActionCommand());
		  break;
	  case "Blockflöte":
		  System.out.println("Test : " + e.getActionCommand());
		  break;
	  case "Klavier":
		  System.out.println("Test : " + e.getActionCommand());
		  break;
	  case "Glockenspiel":
		  System.out.println("Test : " + e.getActionCommand());
		  break;
	  case "Orgel":
		  System.out.println("Test : " + e.getActionCommand());
		  break;
	  }
    }
}
```

über die hier schon implementierten "prints", kannst du wenn du die Applikation ausführst und die  Buttons betätigst schon sehen das in der Console von Eclipse ausgegeben wird von welchem Button bzw. welcher ActionCommand das Event ausgelöst wird.

So sollte es nun aussehen wenn du die Buttons drückst :


----------



## Cherryrose (1. Jun 2014)

Ich hab das genauso gemacht, es zeigt auch keine Fehler an, aber wenn ich starte erscheint nur in der Console der gewöhnliche Text wie schon bisher...


----------



## Cherryrose (19. Mai 2014)

Hallo, ich habe eine Aufgabe bekommen, in der ich mit Java Musik machen soll. Ich arbeite mit Eclipse. Ich habe folgende Idee: Wenn man als Nutzer eine Tonleiter angibt (z.B. C-Dur) dann kommt eine Melodie in C-Dur. Und wenn man eine andere eingibt, kommt die gleiche Melodie in der anderen. Die Melodie würde ich dann selber spielen und einbauen.

Ich habe es schonmal geschafft, dass wenn ich ausführe eine Melodie kommt. Doch wie mache ich, dass der Nutzer erst eingeben muss, wie die Melodie ist? Dachte mir so mit if, weiß aber von selbst nicht genau wie das geht.

Würde mich sehr über Hilfe freuen!


----------



## kaoZ (1. Jun 2014)

Wenn du auf die Buttons klickst auch ?

Ansonsten poste mal den code.


----------



## Cherryrose (1. Jun 2014)

Die Buttons erscheinen nicht.


```
package samples;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Gui extends JFrame implements ActionListener{
	private static final long serialVersionUID = 1L;
	
	public final static Dimension GUI_SIZE = new Dimension(400,300);
	public final static String GUI_TITLE = "Audio Player v1.0";
	
	private JPanel contentPane;
	private JPanel headerPane;
	
	private JButton[] btns;
	
	public Gui() {
	
		setSize(GUI_SIZE);
		setTitle(GUI_TITLE);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		
		this.contentPane = new JPanel(new GridLayout(3,2,20,20));
		this.contentPane.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
		
		this.headerPane = new JPanel();
		
		this.btns = new JButton[6];
		
		createComponents();
	}        
	
	private void createComponents(){
		
		JLabel header = new JLabel("<Html>Mit welchem Instrument soll 'Suit'<br>"                
				+ "von R.CH.Martin gespielt werden ?</Html>", JLabel.CENTER);
		
		Font newFont = header.getFont().deriveFont(14f);
		
		header.setFont(newFont);
		
		String[] label = {"Bandoneon","Harfe","Blockflöte","Klavier","Glockenspiel","Orgel"};
		
		for (int i = 0; i < btns.length; i++) {
			btns[i] = new JButton(label[i]);
			btns[i].addActionListener(this);
		}
		
		for (int i = 0; i < btns.length; i++) {
			contentPane.add(btns[i]);
		}                        
		
		this.headerPane.add(header);
		
		this.add(BorderLayout.PAGE_START, headerPane);
		this.add(BorderLayout.CENTER, contentPane);
		}
   
    public void actionPerformed(ActionEvent e) {
    	switch(e.getActionCommand()){      
    	case "Bandoneon":
    		System.out.println("Test : " + e.getActionCommand());
    		break;
    	case "Harfe":
    		System.out.println("Test : " + e.getActionCommand());
    		break;
    	case "Blockflöte":
    		System.out.println("Test : " + e.getActionCommand());
    		break;
    	case "Klavier":
    		System.out.println("Test : " + e.getActionCommand());
    		break;
    	case "Glockenspiel":
    		System.out.println("Test : " + e.getActionCommand());
    		break;
    	case "Orgel":
    		System.out.println("Test : " + e.getActionCommand());
    		break;
    	}
    }
}
```


----------



## kaoZ (1. Jun 2014)

Du musst natürlich auch in unserer AudioTest.java

folgendes ändern 


```
public static void main(String[] args) {
	  
		//new AudioTest().startSession();
		
		new Gui().setVisible(true);  // <<---
		
    }
```


----------



## Cherryrose (1. Jun 2014)

Ahhh alles klar, jetzt geht es wie du beschrieben hast!


----------



## fLooojava (1. Jun 2014)

_Ich funk mal dazwischen._

*@kaoZ:* 
Weshalb generierst du die Buttons + Labels mit Schleifen? Macht das Sinn, für spätere Änderungen? Du legst hier ja doch ein statisches JButton Objekt mit 6 Objekten an, sprich auch hier müsste man dann eine Änderung vornehmen.

_Würde mich interessieren, ansonsten ganz nettes Projekt!_


flo


----------



## kaoZ (1. Jun 2014)

Ok dann weiter im Text, da wir das ganze ja nicht nach einem Design Pattern wie z.B MVC umsetzen , werden wir einfach unserer Gui als Attribut eine Referenz auf unseren AudioPlayer geben.


```
public class Gui extends JFrame implements ActionListener{
    private static final long serialVersionUID = 1L;

    public final static Dimension GUI_SIZE = new Dimension(400,300);
    public final static String GUI_TITLE = "Audio Player v1.0";

    
    private JPanel contentPane;
    private JPanel headerPane;
    
    private AudioPlayer player;  // <<---
    
    private JButton[] btns;
    
	public Gui(Sound...sounds) {...}
```

in unserem Konstruktor der Klasse Gui werden wir nun diesen initialisieren, außerdem werden wir hier gleich die möglichkeit geben eine playlist an die Gui und somit an den Konstruktor des AudioPlayers zu geben  :


```
public Gui(Sound...sounds) {  // <<---
	   
		setSize(GUI_SIZE);
		setTitle(GUI_TITLE);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		
		this.contentPane = new JPanel(new GridLayout(3,2,20,20));
		this.contentPane.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
		
		this.headerPane = new JPanel();
		
		this.btns = new JButton[6];
		
		this.player = new AudioPlayer(sounds);  // <<--
		
		createComponents();
    }
```

nun werden wir noch über unseren listener definieren was beim klick auf die einzelnen Buttons passieren soll, also werden wir an dieser Stelle in der Gui folgenden code in der actionPerformed Methode abändern :


```
@Override
    public void actionPerformed(ActionEvent e) {
		
	  switch(e.getActionCommand()){
	  case "Bandoneon":
		  player.play(player.getSongByName("one"));
		  break;
	  case "Harfe":
		  player.play(player.getSongByName("two"));
		  break;
	  case "Blockflöte":
		  player.play(player.getSongByName("three"));
		  break;
	  case "Klavier":
		  player.play(player.getSongByName("four"));
		  break;
	  case "Glockenspiel":
		  player.play(player.getSongByName("five"));
		  break;
	  case "Orgel":
		  //player.play(player.getSongByName(""));
		  break;
	  }
    }
```

Der gesamte Quelltext sollte nun so aussehen :



Spoiler: Gui.java





```
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Gui extends JFrame implements ActionListener{
    private static final long serialVersionUID = 1L;

    public final static Dimension GUI_SIZE = new Dimension(400,300);
    public final static String GUI_TITLE = "Audio Player v1.0";

    
    private JPanel contentPane;
    private JPanel headerPane;
    
    private AudioPlayer player;
    
    private JButton[] btns;
    
	public Gui(Sound...sounds) {
	   
		setSize(GUI_SIZE);
		setTitle(GUI_TITLE);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		
		this.contentPane = new JPanel(new GridLayout(3,2,20,20));
		this.contentPane.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
		
		this.headerPane = new JPanel();
		
		this.btns = new JButton[6];
		
		this.player = new AudioPlayer(sounds);
		
		createComponents();
    }
	
	private void createComponents(){
		
		JLabel header = new JLabel("<Html>Mit welchem Instrument soll 'Suit'<br>"
				+ "von R.CH.Martin gespielt werden ?</Html>", JLabel.CENTER);
		
		Font newFont = header.getFont().deriveFont(14f);
		
		header.setFont(newFont);
	
		String[] label = {"Bandoneon","Harfe","Blockflöte","Klavier","Glockenspiel","Orgel"};
		
		for (int i = 0; i < btns.length; i++) {
	        btns[i] = new JButton(label[i]);
	        btns[i].addActionListener(this);
        }
		
		for (int i = 0; i < btns.length; i++) {
	        contentPane.add(btns[i]);
        }
		
		
		this.headerPane.add(header);
		
		this.add(BorderLayout.PAGE_START, headerPane);
		this.add(BorderLayout.CENTER, contentPane);	
	}

	@Override
    public void actionPerformed(ActionEvent e) {
		
	  switch(e.getActionCommand()){
	  case "Bandoneon":
		  player.play(player.getSongByName("one"));
		  break;
	  case "Harfe":
		  player.play(player.getSongByName("two"));
		  break;
	  case "Blockflöte":
		  player.play(player.getSongByName("three"));
		  break;
	  case "Klavier":
		  player.play(player.getSongByName("four"));
		  break;
	  case "Glockenspiel":
		  player.play(player.getSongByName("five"));
		  break;
	  case "Orgel":
		  //player.play(player.getSongByName(""));
		  break;
	  }
    }
}
```




In der Klasse AudioTest erzeugen wir nun ein Sound Array was uns als Playlist für unseren Player dient, und übergeben diesen an unsere Gui und somit an den dadurch referenzierten AudioPlayer:


```
public static void main(String[] args) {
	  
		String path = "L:/OpenOffice/share/gallery/sounds/";
		
		Sound[] playlist = new Sound[5];
		
		playlist[0]	= new Sound("one",path + "cow.wav");
		playlist[1] = new Sound("two",path + "curve.wav");
		playlist[2]	= new Sound("three",path + "drama.wav");
		playlist[3] = new Sound("four",path + "explos.wav");
		playlist[4] = new Sound("five",path + "falling.wav");
		
		//new AudioTest().startSession();
		new Gui(playlist).setVisible(true);
		
    }
```

wenn du die Anwendung nun startest , solltest du sehen können das zwar der Sound Abgespielt wird, aber solange dies der Fall ist der Button den du betätigst hast quasi blockiert wird und gedrückt bleibt, dies liegt daran das das abspielen der Sounds hier im gleichen Thread passiert 
in welchem auch die Gui arbeitet , dieser nennt sich EDT, und man sollte* immer vermeiden*, längere und komplexe Aktionen in diesem Thread auszuführen , da sonst eben das Gui solange blockiert wird , wie die zusätzlich ausgeführte Aktion andauert.
*
Also wird der nächste logische Schritt sein das wir das abspielen der Sounds in einen Separaten Thread auslagern müssen und Benutzeraktionen nicht zu behindern.*

Wenn du soweit bist und es ausprobiert hast und alles so funtkioniert wie es hier beschrieben ist getst weiter, wir sind nichtmehr weit vom Ziel entfernt


----------



## kaoZ (1. Jun 2014)

fLooojava hat gesagt.:


> _
> 
> *@kaoZ:*
> Weshalb generierst du die Buttons + Labels mit Schleifen? Macht das Sinn, für spätere Änderungen? Du legst hier ja doch ein statisches JButton Objekt mit 6 Objekten an, sprich auch hier müsste man dann eine Änderung vornehmen.
> _


_

Einfach der Übersichtlichkeits halber, ist aber geschmackssache,

klar könnte man auch jeden Button über eine eigenes Attribut definieren, ich finde aber bei solch  kleinen Projekten wesentlich übersichtlicher.

Zudem spare ich mir nen haufen Source Code , man könnte sogar noch weiter gehen und das ganze in einer doppelten for schleifen machen , dann allerdings wird das ganze ziemlich kryptisch.

wenn ich dann einen speziellen button benötige kann ich diesen immernoch über seinen index im Array ansprechen.

zudem spar ich mir sowas hier:



		Java:In die Zwischenablage kopieren


conentPane.add(btn1);
contentPane.add(btn2);

usw... usw..


[EDIT]Wenn du natürlich im Vorfeld schon weißt das sich der ButtonText ggf. ändern könnte , vielleicht weil du ihn über die Songs in der Playlist generieren würdest, dann kannst du die Buttons auch einzeln als Attribut der Gui deklarieren, würde aber auch mit einem Array wie in meinem Beispiel funktionieren.[/EDIT]

[EDIT]




			Du legst hier ja doch ein statisches JButton Objekt mit 6 Objekten an
		
Zum Vergrößern anklicken....


ich lege ein Datencontainer (Array) mit platz für 6 JButtons an , statisch ist dies nicht.
[/EDIT]_


----------



## Cherryrose (1. Jun 2014)

Also ich hab versucht das so zu machen, aber ersetzt man mit dem was du zum AudioPlayer geschrieben hast das andere wo die files schon definiert sind?

Ich hab das probiert, hab auch mit beiden probiert, aber es kommen immer nur Fehlermeldungen.



Spoiler





```
package samples;

import java.util.Scanner; 
//Die Klasse Scanner ist in dem Paket java.util definiert.


public class AudioTest2 {
	
	 Scanner sc; 
	 AudioPlayer player;
	 String path;
	 
//sc repräsentiert den Scanner, der Scanner definiert Methoden zum Einlesen von Dateien	
	
	 public AudioTest2() {
		 sc = new Scanner(System.in);  //Der Scanner liest normalerweise eine Datenquelle, hier die Konsolenangabe.
		 player = new AudioPlayer();
		 path = "C:/Users/Ela/Music/"; //Der Pfad zu der .wav Datei, welcher abgespiel werden soll.

		 fillPlaylist();               //Diese Methode initialisiert die Playlist
    }
	
	
//Die Sounddateien werden in der Playlist angegeben, um sie dann als Nutzer auszuwählen.
	     
	
	public static void main1(String[] args) {
		
		String path = "C:/Users/Ela/Music/";
		Sound[] playlist = new Sound[6];
		
		playlist[0] = new Sound("one",path + "Bandoneon.wav");
		playlist[1] = new Sound("two",path + "Blockflöte.wav");
		playlist[2] = new Sound("three",path + "Glockenspiel.wav");
		playlist[3] = new Sound("four",path + "Harfe.wav");
		playlist[4] = new Sound("five",path + "Klavier.wav");
		playlist[5] = new Sound("six",path + "Orgel.wav");
		
		new Gui(playlist).setVisible(true);
	}
	
	public void startSession(){       
		boolean running = true;
		
		 System.out.println("Hier können Sie sich für ein Instrument entscheiden, auf dem das Lied 'Suit' von R.Ch.Martin gespielt werden soll!");
		 System.out.println("");
		 System.out.println("1. Geben Sie als erstes 'Instrument' ein, um eine Übersicht zu erhalten.");
		 System.out.println("2. Als nächstes geben Sie den Namen eines Instrumentes ein, um sie abzuspielen. Dies können Sie beliebig oft wiederholen.");
		 System.out.println("3. Wenn Sie den Player beenden wollen, geben Sie 'stop' ein.");
		 System.out.println("");
		 System.out.println("***********************************************************************************************");
		 
		 while (running) {            
			 String input = sc.nextLine();
		 
			 if (input.equals("Instrument")) {
			 
				 System.out.println("");
				
			 
				 for (int i = 0; i < player.getPlayList().size(); i++) {
					 System.out.println(player.getPlayList().get(i).getName()); 
					 
				 } 
			 	 continue;
		}                       
		if(input.equals("stop")) {
			 running = false;
			 sc.close();
			 System.out.println("Der Player wurde beendet. Hoffentlich haben Sie die Musik genossen!");
			 System.out.println("Ich wünsche Ihnen noch einen schönen Tag!");
		}    
		 
		while(running){
			System.out.println("Das Lied wird mit " + input + " gespielt. Viel Vergnügen!");
			player.play(player.getSongByName(input));
			break; 
		

			}
		 }
	}
	public AudioPlayer getPlayer()              {return this.player;}
	
	public static void main(String[] args) { 
		new Gui().setVisible(true);
		
//Die Main Methode dient dazu um das Programm zu starten und die startSession(); Methode aufzurufen.
		}
}
```


----------



## kaoZ (1. Jun 2014)

Du sollst keine neue main Methode hinzufügen!

du kannst alles in der Klasse AudioTest so lassen wie es war , und in dessen main Methode fügst du lediglich diesen Quelltext hinzu:

Wir erzeugen hier *KEINE* Instanz unserer Klasse AudioTest, da diese nur für unsere Konsolenversion ausschlagebend ist!


```
public static void main(String[] args) {
	  
		String path = "L:/OpenOffice/share/gallery/sounds/";
		
		Sound[] playlist = new Sound[5];
		
		playlist[0]	= new Sound("one",path + "cow.wav");
		playlist[1] = new Sound("two",path + "curve.wav");
		playlist[2]	= new Sound("three",path + "drama.wav");
		playlist[3] = new Sound("four",path + "explos.wav");
		playlist[4] = new Sound("five",path + "falling.wav");
		
		//new AudioTest().startSession();
		new Gui(playlist).setVisible(true);
		
    }
```


Hier mal die ganze Klasse AudioTest wie sie aussehen sollte

```
import java.util.Scanner;



public class AudioTest {
	
	Scanner sc;
	AudioPlayer player;
	String path;
	
	public AudioTest() {
	   sc = new Scanner(System.in);
	   player = new AudioPlayer();
	   path = "L:/OpenOffice/share/gallery/sounds/";
	   
	   fillPlaylist();
    }
	
	public void fillPlaylist(){
		
		Sound one	 = new Sound("one",path + "cow.wav");
		Sound two	 = new Sound("two",path + "curve.wav");
		Sound three	 = new Sound("three",path + "drama.wav");
		Sound four	 = new Sound("four",path + "explos.wav");
		Sound five	 = new Sound("five",path + "falling.wav");
		
		getPlayer().addToPlayList(one, two, three, four, five);
	}
	
	public void startSession(){
		boolean running = true;
		
        System.out.println("Willkommen beim AudioPlayer");
        System.out.println("***************************");
        System.out.println("- Gibt 'songlist' ein um eine Titelübersicht zu erhalten,");
        System.out.println("- gibt den Namen eines Sounds ein um ihn abzuspielen,");
        System.out.println("- gib 'remove' ein um einen Song aus der Playlist zu entfernen,");
        System.out.println("- oder 'stop' um den Player zu beenden.");
        System.out.println("_______________________________________");
        

		while (running) {
	        String input = sc.nextLine();
	        
	        if (input.equals("songlist")) {
	        	
	        	System.out.println("Songlist");
	        	System.out.println("********");
	        	
	            for (int i = 0; i < player.getPlayList().size(); i++) {
	                System.out.println("Sound " + i + ": " + player.getPlayList().get(i).getName());
                }
	            continue;
            }
	        
	        if (input.equals("remove")) {
	        	
	        	System.out.println("Geben Sie den Namen der Sounds ein den Sie entfernen möchten :");
	            
	        	String sound = sc.nextLine();
	        	
	        	for (int i = 0; i < player.getPlayList().size(); i++) {
	                if (player.getPlayList().get(i).getName().equals(sound)) {
	                    player.removeFromPlayList(sound);
                    }
                }
	        	continue;
            }
	        
	        if(input.equals("stop")) {
	            running = false;
	            sc.close();
            }
	        
	        while(running){
	        	player.play(player.getSongByName(input));
	        	break;
	        }
        }
	}
	
	public AudioPlayer getPlayer() 				{return this.player;}

	public static void main(String[] args) {
	  
		String path = "L:/OpenOffice/share/gallery/sounds/";
		
		Sound[] playlist = new Sound[5];
		
		playlist[0]	= new Sound("one",path + "cow.wav");
		playlist[1] = new Sound("two",path + "curve.wav");
		playlist[2]	= new Sound("three",path + "drama.wav");
		playlist[3] = new Sound("four",path + "explos.wav");
		playlist[4] = new Sound("five",path + "falling.wav");
		
		//new AudioTest().startSession();  // <<-- auskommentiert da nicht benutzt!
		new Gui(playlist).setVisible(true);
		
    }
}
```

Ich wollte dir damit eigentlich zeigen das du sowohl die Konsolenversion nutzen als auch die GuiVersion nutzen kannst, je nachdem von welcher Klasse du eine Instanz erzeugst, AudioTest für die KonsolenVersion, und Gui für die Version mit Grafischer Darstellung, wenn du das nicht nachvollziehen kannst können wir sonst auch eine gesonderte Klasse erstellen die die main Methode beinhaltet, falls dich das zu sehr verunsichern sollte


----------



## Cherryrose (1. Jun 2014)

Achso, alles klar 

Jetzt hab ich es so gemacht und dann erscheint die fehlermeldung:

Exception in thread "main" java.lang.NullPointerException
	at samples.AudioPlayer.addToPlayList(AudioPlayer.java:24)
	at samples.AudioPlayer.<init>(AudioPlayer.java:20)
	at samples.Gui.<init>(Gui.java:44)
	at samples.AudioTest2.main(AudioTest2.java:102)


----------



## kaoZ (1. Jun 2014)

änder mal bitte in der Klasse AudioPlayer :

den 2ten Konstruktor von 


```
public AudioPlayer(Sound...songs) {
    	super();
        addToPlayList(songs);
    }
```

in


```
public AudioPlayer(Sound...songs) {
    	playList = new ArrayList<>();
        addToPlayList(songs);
    }
```

keine Ahnung was mich da geritten hat 
	
	
	
	





```
super();
```
 hinzuschreiben, das ist nämlich völliger blödsinn ^^

nun sollte es soweit gehen das der Sound abspielt , aber der Button solange gedrückt bleibt, darum kümmern wir uns dann jetzt.


----------



## Cherryrose (1. Jun 2014)

Der Sound spielt nicht ab und der Button bleibt auch nicht gedrückt. :/


----------



## kaoZ (1. Jun 2014)

Poste mal deine Klasse Gui bitte


----------



## Cherryrose (1. Jun 2014)

Hab den fehler grade selbst gemerkt!

Also bei mir bleibt der Button so lange gedrückt wie das Lied lang ist, danach kann ich ein weiteres auswählen!  Das ist doch das was ich wollte, oder fällt da noch etwas?


----------



## kaoZ (1. Jun 2014)

ja eins fehlt noch 

um genau dies zu beheben , werden wir die play() Methode der Klasse AudioPlayer , so um schrieben das das Abspielen der Sounds in einem eigenen Thread stattfindet:

nun kannst du sogar mehrere Sounds gleichzeitig abspielen , da jeder Sound in einem Separaten Thread abgespielt wird.

dies lässt sich ganz einfach folgendermaßen umsetzen :

hier hab ich mal den alten teil auskommentiert :


```
public void play(Sound song){
    	
    	try{
    		new Thread(){
    			@Override
    			public void run(){
    				try {
    			        AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
    			        AudioFormat audioFormat = stream.getFormat();
    			        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
    			        Clip clip = (Clip) AudioSystem.getLine(info);
    			        clip.open(stream);
    			        clip.start();
    			        
    			        while(clip.getFramePosition() < clip.getFrameLength()) {
    			        	
    			        	 // Nur zum testen so implementiert
    			        };
    		 
    		        } catch (Exception e) {
    			        if (song == null) {
    			           	JOptionPane.showMessageDialog(null, "Sound wurde nicht gefunden !");
    		            }
    		        }
    			}
    		}.start();
    	}
    	catch(Exception ex){
    		ex.printStackTrace();
    	}
    	
    /*	try {
	        AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
	        AudioFormat audioFormat = stream.getFormat();
	        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
	        Clip clip = (Clip) AudioSystem.getLine(info);
	        clip.open(stream);
	        clip.start();
	        
	        while(clip.getFramePosition() < clip.getFrameLength()) {
	        	
	        	 // Nur zum testen so implementiert
	        };
 
        } catch (Exception e) {
	        if (song == null) {
	           	System.out.println("Song wurde nicht in der Playlist gefunden, oder Existiert nicht !");
            }
        } */
    }
```

hier wird nun bei jedem aufruf dieser Methode ein neuer Thread gestartet, dessen Task , oder in dem Fall Runnable es ist  die Daten aus dem Stream zu lesen, in einen Clip umzuwandeln und abzuspielen.

[EDIT]
Zugegeben das mit der Fehlerbehandlung ist eher unschön und Suboptimal , aber für ein einfaches Beispiel ausreichend und funktionsfähig!
[/EDIT]

Du kannst nun selbst bestimmen, ob du deine Anwendung in der Konsolenversion, oder mit der Gui startest.

dies kannst du in der Klasse AudioTest.java ganz einfach ausprobieren indem du ganz mal an dieser Stelle die Gui auskommentierst und eine Instanz der Klasse AudioTest erstellst


```
public static void main(String[] args) {
	  
		String path = "L:/OpenOffice/share/gallery/sounds/";
		
		Sound[] playlist = new Sound[5];
		
		playlist[0]	= new Sound("one",path + "cow.wav");
		playlist[1] = new Sound("two",path + "curve.wav");
		playlist[2]	= new Sound("three",path + "drama.wav");
		playlist[3] = new Sound("four",path + "explos.wav");
		playlist[4] = new Sound("five",path + "falling.wav");
		
		//new AudioTest().startSession(); // <-- ohne Gui
		new Gui(playlist).setVisible(true); // <-- mit Gui
		
    }
```


----------



## Cherryrose (1. Jun 2014)

Das mit dem selbst bestimmen habe ich anders geregelt, ich habe AudioTest2 erstellt und das ist für GUI und das normale für Konsole, also das hatte ich schon. 

Jetz habe ich Audioplayer bearbeitet und bei mir erscheint eine fehlermeldung, zudem ist "getPlayList().add" ; "(song.getFile());" ; "(song == null)" unterstrichen und auch die aller letzte } Klammer

```
//Der AudioPlayer spielt die Sounds ab.
package samples;

import java.util.ArrayList;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;

public class AudioPlayer {

	private ArrayList<Sound> playList; 
	public AudioPlayer() {                            //Mit "public ..." werden die Methoden definiert ↓
		playList = new ArrayList<>();
		}
	public AudioPlayer(Sound...songs) {
		playList = new ArrayList<>();
		addToPlayList(songs);
		}
	public void addToPlayList(Sound...songs){
		for (Sound sound : songs) {
			getPlayList().add(sound);
			} 
		}
	public void removeFromPlayList(Sound sound){
		for (int i = 0; i < playList.size(); i++) {
			if (playList.get(i).getName().equals(sound)) {
				playList.remove(i);
				}
			}
		}
	        public Sound getSongByName(String name)
	        {                Sound sound = null;
	        for (int i = 0; i < playList.size(); i++) {
	        	if (playList.get(i).getName().equals(name)) {
	        		sound = playList.get(i);
	        		}
	        	}
	        return sound;
	        }
	        public void play(Sound song){
//Hier werden die Lieder abgespielt.
	        	 try{
	        		 new Thread(){
	        			 @Override
	        			 public void run(){
	        				 try { 
	        					 AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
	        					 AudioFormat audioFormat = stream.getFormat();
	        					 DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
	        					 Clip clip = (Clip) AudioSystem.getLine(info);
	        					 clip.open(stream);
	        					 clip.start();
	        					 
	        					 while(clip.getFramePosition() < clip.getFrameLength()) {
	        						 // Nur zum testen so implementiert
	        					 };
	        				 } catch (Exception e) {
	        					 if (song == null) {
	        						 System.out.println("Song wurde nicht in der Playlist gefunden, oder Existiert nicht !");
	        					 }
	        				 }
	        			 }
	        		 }.start();
	        	 }       
	        	 catch(Exception ex){
	        		 ex.printStackTrace();
	        	 }
	        }
	        	 
// Auch die Playlist kann durch ein mehrfaches Eingeben wiederholt werden.
```


----------



## kaoZ (1. Jun 2014)

da fehlt unten auch eine Klammer , und der öffentliche Getter , also die Methode 
	
	
	
	





```
getPlayList()
```
 


```
import java.util.ArrayList;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.swing.JOptionPane;

public class AudioPlayer {
    
    private ArrayList<Sound> playList;
    
    public AudioPlayer() {
        playList = new ArrayList<>();
    }
    
    public AudioPlayer(Sound...songs) {
    	playList = new ArrayList<>();
        addToPlayList(songs);
    }
 
    public void addToPlayList(Sound...songs){
        for (Sound sound : songs) {
            getPlayList().add(sound);
        }
    }
    
    public void removeFromPlayList(String sound){
        for (int i = 0; i < playList.size(); i++) {
            if (playList.get(i).getName().equals(sound)) {
                playList.remove(i);
            }
        }
        System.out.println(sound + " wurde aus der Playlist entfernt!");
    }
    
    //Achtung , kann NPE auslösen , hier ist handlungsbedarf !
    
    public Sound getSongByName(String name){
        
        Sound sound = null;
        
        for (int i = 0; i < playList.size(); i++) {
            if (playList.get(i).getName().equals(name)) {
               sound = playList.get(i);
            }
        }
        return sound;
        
    }
    
    public void play(Sound song){
    	
    	try{
    		new Thread(){
    			@Override
    			public void run(){
    				try {
    			        AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
    			        AudioFormat audioFormat = stream.getFormat();
    			        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
    			        Clip clip = (Clip) AudioSystem.getLine(info);
    			        clip.open(stream);
    			        clip.start();
    			        
    			        while(clip.getFramePosition() < clip.getFrameLength()) {
    			        	
    			        	 // Nur zum testen so implementiert
    			        };
    		 
    		        } catch (Exception e) {
    			        if (song == null) {
    			           	JOptionPane.showMessageDialog(null, "Sound wurde nicht gefunden !");
    		            }
    		        }
    			}
    		}.start();
    	}
    	catch(Exception ex){
    		ex.printStackTrace();
    	}
    }

    public ArrayList<Sound> getPlayList()       {return this.playList;}
}
```


----------



## Cherryrose (1. Jun 2014)

Jetzt ist immernoch was unterstrichen und wenn ich Klavier eingeben kommt das:

Klavier
Das Lied wird mit Klavier gespielt. Viel Vergnügen!
Exception in thread "Thread-1" java.lang.Error: Unresolved compilation problems: 
	Cannot refer to a non-final variable song inside an inner class defined in a different method
	Cannot refer to a non-final variable song inside an inner class defined in a different method

	at samples.AudioPlayer$1.run(AudioPlayer.java:51)


----------



## kaoZ (1. Jun 2014)

Bei mir funktioniert es reibungslos mit Gui sowie in der Konsolenversion,

was steht in dieser Zeile bei dir ?



> at samples.AudioPlayer$1.run(AudioPlayer.java:51)



und den Code der Klasse den du ausführen möchtest,

normalerweise sollte alles Funktionieren da wir die Variable song vom Typ Sound nur an einer Stelle in der inneren Klasse verwenden,

ansonsten füge an dieser stelle mal ein final hinzu:


```
public void play(final Sound song){  // <---
    	
    	try{
    		new Thread(){
    			@Override
    			public void run(){
    				try {
    			        AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
    			        AudioFormat audioFormat = stream.getFormat();
    			        DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
    			        Clip clip = (Clip) AudioSystem.getLine(info);
    			        clip.open(stream);
    			        clip.start();
    			        
    			        while(clip.getFramePosition() < clip.getFrameLength()) {
    			        	
    			        	 // Nur zum testen so implementiert
    			        };
    		 
    		        } catch (Exception e) {
    			        if (song == null) {
    			           	JOptionPane.showMessageDialog(null, "Sound wurde nicht gefunden !");
    		            }
    		        }
    			}
    		}.start();
    	}
    	catch(Exception ex){
    		ex.printStackTrace();
    	}
    }
```


----------



## Cherryrose (1. Jun 2014)

Mit final ist es besser, aber wenn ich was falsches eingebe erscheint nicht das was soll, sondern er will das falsche abspielen.



Spoiler





```
//Der AudioPlayer spielt die Sounds ab.
package samples;

import java.util.ArrayList;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.swing.JOptionPane;

public class AudioPlayer {

	private ArrayList<Sound> playList; 
	public AudioPlayer() {                            //Mit "public ..." werden die Methoden definiert ↓
		playList = new ArrayList<>();
		}
	public AudioPlayer(Sound...songs) {
		playList = new ArrayList<>();
		addToPlayList(songs);
		}
	public void addToPlayList(Sound...songs){
		for (Sound sound : songs) {
			getPlayList().add(sound);
			} 
		}
	public void removeFromPlayList(Sound sound){
		for (int i = 0; i < playList.size(); i++) {
			if (playList.get(i).getName().equals(sound)) {
				playList.remove(i);
			}
		}
		System.out.println(sound + " wurde aus der Playlist entfernt!");
	}
	        public Sound getSongByName(String name)
	        {                Sound sound = null;
	        for (int i = 0; i < playList.size(); i++) {
	        	if (playList.get(i).getName().equals(name)) {
	        		sound = playList.get(i);
	        		}
	        	}
	        return sound;
	        }
	        public void play(final Sound song){
	        	try{
	        		new Thread(){
	        			@Override
	        			public void run(){
	        				try {
	        					AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
	        					AudioFormat audioFormat = stream.getFormat();
	        					DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
	        					Clip clip = (Clip) AudioSystem.getLine(info);
	        					clip.open(stream);
	        					clip.start();
	        					
	        					while(clip.getFramePosition() < clip.getFrameLength()) {
	        				 
	        					};
	        					
	        				 } catch (Exception e) {
	        					 if (song == null) {
	        						 JOptionPane.showMessageDialog(null, "Sound wurde nicht gefunden !");
	        					}
	        				}
	        			}
	        		}.start();
	        	 }       
	        	 catch(Exception ex){
	        		 ex.printStackTrace();
	        	 }
	        }
	        public ArrayList<Sound> getPlayList()       {return this.playList;}
} 
// Auch die Playlist kann durch ein mehrfaches Eingeben wiederholt werden.
```


----------



## kaoZ (1. Jun 2014)

Das liegt daran das wie uns noch nicht um anständige Fehler/Ausnahme Behandlung Gekümmert haben,  hatte ich aber schon mehrfach erwähnt  bin jetzt allerdings auch erstmal unterwegs.
Schaue mir das später nochmal an


----------



## kaoZ (1. Jun 2014)

Um dies zu umgehen das wenn du etwas eingibst was in der Playlist nicht existiert könntest du folgendes machen, da du ja 2 Versionen hast, hier eine lösung für die Konsolenvariante des Players :

Hier in der p
	
	
	
	





```
lay()
```
 Methode des AudioPlayers


```
public void play(final Sound song){
 
    	new Thread(){
    		@Override
    		public void run(){
    			try {
    				AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
					AudioFormat audioFormat = stream.getFormat();
					DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
			        Clip clip = (Clip) AudioSystem.getLine(info);
			        clip.open(stream);
			        clip.start();
			        
			        while(clip.getFramePosition() < clip.getFrameLength()) {};
			        
                } catch (NullPointerException | IOException | UnsupportedAudioFileException | LineUnavailableException  e) {
                	
                	if (e instanceof NullPointerException) {
	                    System.out.println("Dieser Song exestiert in der PlayList nicht !");
                    }
                	else{
                    	System.out.println("Folgender Fehler ist augetretten : " + e.toString());
                		
                		//JOptionPane.showMessageDialog(null, "Folgender Fehler ist aufgetretten : " + e.toString());
    	                
    	                /* Muti-Catch lösung, hier wird bei einem Fehler die Anwendung weiter Ausgeführt,
    	                 * bei einer NPE wird hier gesondert ausgegeben das ein Sound mit diesem Namen nicht
    	                 * in der Playlist existiert, anderfalls wird
    	                 * der User aber über das Auftreten eines nicht normalen
    	                 * Programmverhaltens informiert! 
    	                 */
                	}
                }
    		}
    	}.start();
    }
```


----------



## kaoZ (2. Jun 2014)

Es gäbe auch noch die Möglichkeit im Methodenkopf zu deklarieren das eine Ausnahme geworfen werden könnte, dies würde man dann so deklarieren:


```
public void play(Sound song) throws Exception{....}
```

hier würde man dann die Exception an den Aufrufer dieser Methode delegieren und die Ausnahme nicht gleich behandeln, (hätten wir vorher gewusst das wir eine Gui Schreiben) hätte man gleich zu beginn dafür sorgen können hier mit Delegation zu arbeiten und die Fehlerbehandlung entweder durch die Gui, z.B durch das anzeigen eines Dialoges, oder durch die Klasse AudioTest in Form von gezielten und aussagekräftigen Konsolenausgaben zu realisieren.

Da wir bei der Gui Version hier selbst dafür verantwortlich sind welche sounds wir in die Playlist übergeben, können wir dies hier mehr oder weniger vernachlässigen da wir festlegen welcher Button welches Lied abspielt , anders bei der Konsolenversion, bei der der User ( und wir gehen im Normalfall immer vom DAU aus ) die Eingabe macht, wenn du nun die oben zuerst genannte Lösung nutzt sollte es so aussehen :


```
Willkommen beim AudioPlayer
***************************
- Gibt 'songlist' ein um eine Titelübersicht zu erhalten,
- gibt den Namen eines Sounds ein um ihn abzuspielen,
- gib 'remove' ein um einen Song aus der Playlist zu entfernen,
- oder 'stop' um den Player zu beenden.
_______________________________________
sdfsdf
Dieser Song existiert in dieser Playlist nicht !
```


----------



## kaoZ (2. Jun 2014)

Hier nochmal eine übersicht der Klassen wie sie nun bei mir aussehen :



Spoiler: Sound.java





```
import java.io.File;

/**
 * 
 * @author kaoZ
 * 
 * Diese Klasse hat keine andere Funktion als lediglich
 * den Pfad und einen Namen zu einer AudioDatei zu speichern,
 * man könnte also sagen Objekte dieser Klasse sind unsere Sounds,
 * welche wir später abspielen wollen.
 *
 */

public class Sound {
	
	private String name;
	private File file;
	
	public Sound(String name, String filePath) {
		this.name = name;
		this.file = new File(filePath);
    }
	
	public String getName() 		{return this.name;}
	public File getFile() 			{return this.file;}
}
```






Spoiler: AudioPlayer.java





```
import java.io.IOException;
import java.util.ArrayList;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;

public class AudioPlayer {
    
    private ArrayList<Sound> playList;
    
    public AudioPlayer() {
        playList = new ArrayList<>();
    }
    
    public AudioPlayer(Sound...songs) {
    	playList = new ArrayList<>();
        addToPlayList(songs);
    }
 
    public void addToPlayList(Sound...songs){
        for (Sound sound : songs) {
            getPlayList().add(sound);
        }
    }
    
    public void removeFromPlayList(String sound){
        for (int i = 0; i < playList.size(); i++) {
            if (playList.get(i).getName().equals(sound)) {
                playList.remove(i);
            }
        }
        System.out.println(sound + " wurde aus der Playlist entfernt!");
    }
    
    //Achtung , kann NPE auslösen , hier ist handlungsbedarf !
    
    public Sound getSongByName(String name){
    
    	Sound sound = null;
    	
    	for (int i = 0; i < playList.size(); i++) {
	        if (playList.get(i).getName().equals(name)) {
	            sound = playList.get(i);
            }
        }
    	return sound;  
    }
    
    public void play(final Sound song){
 
    	new Thread(){
    		@Override
    		public void run(){
    			try {
    				AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
					AudioFormat audioFormat = stream.getFormat();
					DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
			        Clip clip = (Clip) AudioSystem.getLine(info);
			        clip.open(stream);
			        clip.start();
			        
			        while(clip.getFramePosition() < clip.getFrameLength()) {};
			        
                } catch (NullPointerException | IOException | UnsupportedAudioFileException | LineUnavailableException  e) {

                	if (e instanceof NullPointerException) {
	                    System.out.println("Dieser Song existiert in dieser Playlist nicht !");
                    }
                	else{
                		System.out.println("Folgender Fehler ist aufgetretten : " + e.toString());
                	}
                }
    		}
    	}.start();
    }

    public ArrayList<Sound> getPlayList()       {return this.playList;}
}
```






Spoiler: AudioTest.java





```
import java.util.Scanner;



public class AudioTest {
	
	Scanner sc;
	AudioPlayer player;
	String path;
	
	public AudioTest() {
	   sc = new Scanner(System.in);
	   player = new AudioPlayer();
	   path = "L:/OpenOffice/share/gallery/sounds/";
	   
	   fillPlaylist();
    }
	
	public void fillPlaylist(){
		
		Sound one	 = new Sound("one",path + "cow.wav");
		Sound two	 = new Sound("two",path + "curve.wav");
		Sound three	 = new Sound("three",path + "drama.wav");
		Sound four	 = new Sound("four",path + "explos.wav");
		Sound five	 = new Sound("five",path + "falling.wav");
		
		getPlayer().addToPlayList(one, two, three, four, five);
	}
	
	public void startSession(){
		boolean running = true;
		
        System.out.println("Willkommen beim AudioPlayer");
        System.out.println("***************************");
        System.out.println("- Gibt 'songlist' ein um eine Titelübersicht zu erhalten,");
        System.out.println("- gibt den Namen eines Sounds ein um ihn abzuspielen,");
        System.out.println("- gib 'remove' ein um einen Song aus der Playlist zu entfernen,");
        System.out.println("- oder 'stop' um den Player zu beenden.");
        System.out.println("_______________________________________");
        

		while (running) {
	        String input = sc.nextLine();
	        
	        if (input.equals("songlist")) {
	        	
	        	System.out.println("Songlist");
	        	System.out.println("********");
	        	
	            for (int i = 0; i < player.getPlayList().size(); i++) {
	                System.out.println("Sound " + i + ": " + player.getPlayList().get(i).getName());
                }
	            continue;
            }
	        
	        if (input.equals("remove")) {
	        	
	        	System.out.println("Geben Sie den Namen der Sounds ein den Sie entfernen möchten :");
	            
	        	String sound = sc.nextLine();
	        	
	        	for (int i = 0; i < player.getPlayList().size(); i++) {
	                if (player.getPlayList().get(i).getName().equals(sound)) {
	                    player.removeFromPlayList(sound);
                    }
                }
	        	continue;
            }
	        
	        if(input.equals("stop")) {
	            running = false;
	            sc.close();
            }
	        
	        while(running){
	                player.play(player.getSongByName(input));
	        	break;
	        }
        }
	}
	
	public AudioPlayer getPlayer() 				{return this.player;}

	public static void main(String[] args) {
	  
		String path = "L:/OpenOffice/share/gallery/sounds/";
		
		Sound[] playlist = new Sound[5];
		
		playlist[0]	= new Sound("one",path + "cow.wav");
		playlist[1] = new Sound("two",path + "curve.wav");
		playlist[2]	= new Sound("three",path + "drama.wav");
		playlist[3] = new Sound("four",path + "explos.wav");
		playlist[4] = new Sound("five",path + "falling.wav");
		
		new AudioTest().startSession();
		//new Gui(playlist).setVisible(true);
		
    }
}
```






Spoiler: Gui.java





```
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Gui extends JFrame implements ActionListener{
    private static final long serialVersionUID = 1L;

    public final static Dimension GUI_SIZE = new Dimension(400,300);
    public final static String GUI_TITLE = "Audio Player v1.0";

    
    private JPanel contentPane;
    private JPanel headerPane;
    
    private AudioPlayer player;
    
    private JButton[] btns;
    
	public Gui(Sound...sounds) {
	   
		setSize(GUI_SIZE);
		setTitle(GUI_TITLE);
		setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		setLocationRelativeTo(null);
		
		this.contentPane = new JPanel(new GridLayout(3,2,20,20));
		this.contentPane.setBorder(BorderFactory.createEmptyBorder(30, 30, 30, 30));
		
		this.headerPane = new JPanel();
		
		this.btns = new JButton[6];
		
		this.player = new AudioPlayer(sounds);
		
		createComponents();
    }
	
	private void createComponents(){
		
		JLabel header = new JLabel("<Html>Mit welchem Instrument soll 'Suit'<br>"
				+ "von R.CH.Martin gespielt werden ?</Html>", JLabel.CENTER);
		
		Font newFont = header.getFont().deriveFont(14f);
		
		header.setFont(newFont);
	
		String[] label = {"Bandoneon","Harfe","Blockflöte","Klavier","Glockenspiel","Orgel"};
		
		for (int i = 0; i < btns.length; i++) {
	        btns[i] = new JButton(label[i]);
	        btns[i].addActionListener(this);
        }
		
		for (int i = 0; i < btns.length; i++) {
	        contentPane.add(btns[i]);
        }
		
		
		this.headerPane.add(header);
		
		this.add(BorderLayout.PAGE_START, headerPane);
		this.add(BorderLayout.CENTER, contentPane);	
	}

	@Override
    public void actionPerformed(ActionEvent e) {
		
		
	  switch(e.getActionCommand()){
	  case "Bandoneon":
		  player.play(player.getSongByName("one"));
		  break;
	  case "Harfe":
		  player.play(player.getSongByName("two"));
		  break;
	  case "Blockflöte":
		  player.play(player.getSongByName("three"));
		  break;
	  case "Klavier":
		  player.play(player.getSongByName("four"));
		  break;
	  case "Glockenspiel":
		  player.play(player.getSongByName("five"));
		  break;
	  case "Orgel":
		  //player.play(player.getSongByName(""));
		  break;
	  }
	}
}
```




Hierbei enthält die Klasse AudioTest die main Methode, diese könnte man auch einfach um ein besseres Verständniss dafür zu bekommen in eine andere beliebige Klasse auslagern , und die Klasse AudioTest.java z.B in KonsolenVersion.java umbenennen.


----------



## Cherryrose (2. Jun 2014)

Also ich habe jetzt AudioPlayer bearbeitet und er sieht nun so aus:



Spoiler





```
//Der AudioPlayer spielt die Sounds ab.
package samples;

import java.io.IOException;
import java.util.ArrayList;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import javax.swing.JOptionPane;

public class AudioPlayer {

	private ArrayList<Sound> playList; 
	public AudioPlayer() {                            //Mit "public ..." werden die Methoden definiert ↓
		playList = new ArrayList<>();
		}
	public AudioPlayer(Sound...songs) {
		playList = new ArrayList<>();
		addToPlayList(songs);
		}
	public void addToPlayList(Sound...songs){
		for (Sound sound : songs) {
			getPlayList().add(sound);
			} 
		}
	        public Sound getSongByName(String name)
	        {                Sound sound = null;
	        for (int i = 0; i < playList.size(); i++) {
	        	if (playList.get(i).getName().equals(name)) {
	        		sound = playList.get(i);
	        		}
	        	}
	        return sound;
	        }
	        public void play(final Sound song) throws Exception{
	        	try{
	        		new Thread(){
	        			@Override
	        			public void run(){
	        				try {
	        					AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
	        					AudioFormat audioFormat = stream.getFormat();
	        					DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
	        					Clip clip = (Clip) AudioSystem.getLine(info);
	        					clip.open(stream);
	        					clip.start();
	        					
	        					while(clip.getFramePosition() < clip.getFrameLength()) {
	        				 
	        					};
	        					
	        				} catch (NullPointerException | IOException | UnsupportedAudioFileException | LineUnavailableException  e) {
	        					if (song == null) {
	        						JOptionPane.showMessageDialog(null, "Sound wurde nicht gefunden !");
	        					}                    
	        					else{
	        						System.out.println("Folgender Fehler ist aufgetretten : " + e.toString());
	        						}	
	        					}
	        				}
	        				
	        			}.start();
	        	 }       
	        	 catch(Exception ex){
	        		 ex.printStackTrace();
	        	 }
	        }
	        public ArrayList<Sound> getPlayList()       {return this.playList;}
} 
// Auch die Playlist kann durch ein mehrfaches Eingeben wiederholt werden.
```




Doch bei Gui wird bei jedem Instrument diese Zeile unterstrichen: player.play(player.getSongByName("Bandoneon"));


----------



## kaoZ (2. Jun 2014)

Entferne das throws Exception in Methodenkopf der play Methode  da du im Catch block schon für behandlung eventuell auftretender Ausnahmen sorgst brauchst du das dort nicht.

Es war nur ein Beispiel wie man es anders machen könnte.


----------



## Cherryrose (2. Jun 2014)

Dennoch steht in der Konsole, dass das Instrument pkkt spielt? Das zeigt nicht an , dass es nicht existiert.


----------



## kaoZ (2. Jun 2014)

Dad liegt daran das du in deiner Klasse AudioTest irgendwo die Ausgabe Erzeugst das der aktuelle Sound gespielt wird bevor geprüfte wird ob dieser vorhanden ist, poste mal deine Klasse AudioTest

[EDIT]da ich arbeiten bin Scheibe ich zzt. Von Handy aus,  sonst muss ich heute abend nochmal drüber schauen [/EDIT]


----------



## Cherryrose (2. Jun 2014)

AudioTest



Spoiler





```
package samples;

import java.util.Scanner; 
//Die Klasse Scanner ist in dem Paket java.util definiert.


public class KonsolenVersion {
	
	 Scanner sc; 
	 AudioPlayer player;
	 String path;
	 
//sc repräsentiert den Scanner, der Scanner definiert Methoden zum Einlesen von Dateien	
	
	 public KonsolenVersion() {
		 sc = new Scanner(System.in);  //Der Scanner liest normalerweise eine Datenquelle, hier die Konsolenangabe.
		 player = new AudioPlayer();
		 path = "C:/Users/Ela/Music/"; //Der Pfad zu der .wav Datei, welcher abgespiel werden soll.

		 fillPlaylist();               //Diese Methode initialisiert die Playlist
    }
	
	public void fillPlaylist(){  
		
		Sound b = new Sound("Bandoneon",path + "Bandoneon.wav"); 
		Sound f = new Sound("Blockflöte",path + "Blockflöte.wav");
		Sound g = new Sound("Glockenspiel",path + "Glockenspiel.wav"); 
		Sound h = new Sound("Harfe",path + "Harfe.wav"); 
		Sound k = new Sound("Klavier",path + "Klavier.wav"); 
		Sound o = new Sound("Orgel",path + "Orgel.wav"); 
		
		getPlayer().addToPlayList(b, f, g, h, k, o);
//Die Sounddateien werden in der Playlist angegeben, um sie dann als Nutzer auszuwählen.
	}        
	
	public void startSession() throws Exception{       
		boolean running = true;
		
		 System.out.println("Hier können Sie sich für ein Instrument entscheiden, in der das Lied 'Suit' von R.Ch.Martin gespielt werden soll!");
		 System.out.println("");
		 System.out.println("1. Geben Sie als erstes 'Instrument' ein, um eine Übersicht zu erhalten.");
		 System.out.println("2. Als nächstes geben Sie den Namen eines Instrumentes ein, um sie abzuspielen. Dies können Sie beliebig oft wiederholen.");
		 System.out.println("3. Wenn Sie den Player beenden wollen, geben Sie 'stop' ein.");
		 System.out.println("");
		 System.out.println("***********************************************************************************************");
		 
		 while (running) {            
			 String input = sc.nextLine();
		 
			 if (input.equals("Instrument")) {
			 
				 System.out.println("");
				
			 
				 for (int i = 0; i < player.getPlayList().size(); i++) {
					 System.out.println(player.getPlayList().get(i).getName()); 
					 
				 } 
			 	 continue;
		}                       
		if(input.equals("stop")) {
			 running = false;
			 sc.close();
			 System.out.println("Der Player wurde beendet. Hoffentlich haben Sie die Musik genossen!");
			 System.out.println("Ich wünsche Ihnen noch einen schönen Tag!");
		}    
		 
		while(running){
			System.out.println("Das Lied wird mit " + input + " gespielt. Viel Vergnügen!");
			player.play(player.getSongByName(input));
			break; 

			}
		 }
	}
	public AudioPlayer getPlayer()              {return this.player;}
	
	public static void main(String[] args) throws Exception { 
		new KonsolenVersion().startSession();
		
//Die Main Methode dient dazu um das Programm zu starten und die startSession(); Methode aufzurufen.
		}
}
```


----------



## kaoZ (2. Jun 2014)

Entferne in Zeile 69

```
System.out.println("Das Lied wird mit " + input + " gespielt. Viel Vergnügen!");
```

Oder versuche mal es hinter den Aufruf von play....
Einzufügen.


----------



## Cherryrose (2. Jun 2014)

Also wenn ich es entferne erscheint garnichts mehr, nicht mal das andere und darunter verändert sich nichts.


----------



## kaoZ (2. Jun 2014)

Wenn du es entfernst,  sollte der Sound abgespielt werden ohne dass es eine Meldung gibt, wenn du etwas falsches eingibst sollte die Meldung erscheinen das der Titel in der playlist nicht Vorhanden ist, zur Not kopierte aus meinen letzten Post die Klasse AudioPlayer und ersetze deine dadurch, wenn du unbedingt eine Ausgabe haben möchtest, welcher Sound abgespielt wird, müsste man dies in der Methode play Realisieren und zuvor Prüfen ob der Titel existiert, dies können wir gern machen, allerdings nicht vom Handy aus


----------



## Cherryrose (2. Jun 2014)

Ich krieg das nicht richtig hin, denke ich lass das einfachso, da ich nicht den ganzen Tag dafür Zeit habe.

In der Konsole steht jatzt das: Das Lied wird mit s gespielt. Viel Vergnügen!
                                          Diese Instrument wurde doch nicht gefunden!


----------



## kaoZ (2. Jun 2014)

Das "Problem" ist das du parallel versucht hast eigene features hinzuzufügen , welche aber mir nicht bekannt waren/sind, deswegen funktioniert meine Version hier bei mir reibungslos und deine in Verbindung mit meiner nicht 

Ich taste mich nochmal ganz langsam ran , also....

1. du musst nicht an jede Methode eine *throws* Deklaration anfügen, sondern 

 - nur da wo du das Exception Handling an den Aufrufer delegieren möchtest
 - wo auch Exceptions geworfen werden können

2. wenn du möchstest das ausgegeben wird welcher Sound aktuell abgespielt wird, musst du dies 
an folgender Stelle / folgendermaßen realisieren, wenn der eingegebene Sound nun nicht existiert wird hier schon beim Aufrufen geprüft oder null übergeben wurde, und wenn ja ein dementsprechender Hinweis ausgegeben :


```
public void play(final Sound song){
    	
    	if (song == null) {
	        System.out.println("Dieser Sound existiert in der Playlist nicht !");
        }
    	else{
    		System.out.println("Es wird Sound " + song.getName() + " abgespielt , viel Spaß !");
    		
    		new Thread(){
        		@Override
        		public void run(){
        			try {
        				AudioInputStream stream = AudioSystem.getAudioInputStream(song.getFile());
    					AudioFormat audioFormat = stream.getFormat();
    					DataLine.Info info = new DataLine.Info(Clip.class, audioFormat);
    			        Clip clip = (Clip) AudioSystem.getLine(info);
    			        clip.open(stream);
    			        clip.start();
    			        
    			        while(clip.getFramePosition() < clip.getFrameLength()) {};
    			        
                    } catch (IOException | UnsupportedAudioFileException | LineUnavailableException  e) {

                    	System.out.println("Folgender Fehler ist aufgetretten : " + e.toString());
               
                    }
        		}
        	}.start();
        }
    }
```

_da wir hier die play Methode nur in verbindung mit der Methode 
	
	
	
	






		Code:In die Zwischenablage kopieren


[COLOR="Black"]getSongByName(String song){...}[/COLOR]

 nutzen , und diese insofern der Sound nicht in der Playlist existieren sollte null zurück liefert, prüfen wir hier den eingabeparameter und falls null übergeben wurde geben wir eine entsprechende Meldung aus das der Sound nicht in der Liste existiert !_

3. Exception Handling in separat zum Haupt Thread laufenden Threads ist um einiges Komplizierter als reguläres Exception Handling, da du hier beim Überschrieben der 
	
	
	
	





```
run()
```
 methode des Runnables keine *throws* deklaration hinzufügen kannst, sonder einen 
	
	
	
	





```
ExceptionHandler
```
 nutzen müsstest.

folgendermaßen sieht die Konsolenversion und dessen Ausgabe nach oben stehenden Modifikation nun aus :


```
Willkommen beim AudioPlayer
***************************
- Gibt 'songlist' ein um eine Titelübersicht zu erhalten,
- gibt den Namen eines Sounds ein um ihn abzuspielen,
- gib 'remove' ein um einen Song aus der Playlist zu entfernen,
- oder 'stop' um den Player zu beenden.
_______________________________________
sdfsdf
Dieser Sound existiert in der Playlist nicht !
three
Es wird Sound three abgespielt , viel Spaß !
```


----------



## Cherryrose (3. Jun 2014)

Ahhhh, jetzt funktioniert es reibungslos!


----------



## Cherryrose (3. Jun 2014)

Ich habe ein letztes Problem...

Ich muss mein Programm per e-mail jemanden senden und dabei soll der jenige auch eclipse öffnen und alles so sehen wie ich es sehe. DasPproblem dabei ist, dass der Pfad zu den Songs auf meinem Rechner gespeichert ist, und wenn ich ihn verändern will, muss da dennoch C:/ oder sowas stehen und wenn ich dann versende wird die Musik nicht abgespielt.

Wie soll ich dass versenden, damit bei dem jenigen die Musik auch abspielt?


----------



## Cherryrose (3. Jun 2014)

Ich habs doch hinbekommen, also nehme ich die letzte Frage zurück.


----------

