====== Kapitel 8: Felder (Arrays) ======
<WRAP center round info 60%>
**Merke** \\ 
Ein Feld (englisch: array) ist ein Speicherbereich, der viele gleichartige Objekte bzw. Werte enthält.
</WRAP>
{{ :schule:klassen:2017:10b:array_1.png?600 |}}

<WRAP center round important 60%>
Vorsicht: Felder werden von 0 an durchnummeriert. Bei obigem Beispiel enthält das Feld also die vier Variablen ''noten[0]'', ''noten[1]'', ''noten[2]'' und ''noten[3]''.
</WRAP>


<code java>
    public ArrayTest(){

        // Array deklarieren und Speicherplatz reservieren:
        int[] noten = new int[6];

        // Werte der Elemente im Array setzen:
        noten[0] = 1;
        noten[1] = 2;
        noten[2] = 4;
        noten[3] = 3;
        noten[4] = 6;
        noten[5] = 5;

        // Ausgabe des 3. Elements:
        System.out.println(noten[2]);

        // Ändern des 3. Elements
        noten[2] = 3;

        System.out.println(noten[2]);

        // Ausgabe der Anzahl der Elemente:
        System.out.println(noten.length);

        // Berechne den Mittelwert aller Noten
        int i = 0;
        double summe = 0;

        while(i < noten.length){

            summe = summe + noten[i];

            i++;
        }

        double mittelwert = summe/noten.length;

        System.out.println("Mittelwert: " + mittelwert);

    
    }
</code>

=====Aufgaben=====
  - Lagere die Mittelwertberechnung in eine eigene Methode aus!
  - Schreibe eine Methode, die die beste Note im Feld ''noten'' ermittelt und zurückgibt!
===== Lösung =====
<code java>
    private double mittelwert(int[] notenliste){
        int i = 0;
        double summe = 0;

        while(i < notenliste.length){
            summe = summe + notenliste[i];
            i++;
        }

        return summe/notenliste.length;

    }

    private double besteNote(int[] notenliste){

        int beste = 6;

        for(int i = 0; i < notenliste.length; i++){
            if(notenliste[i] < beste){
                beste = notenliste[i];
            }
        }

        return beste;
    }
</code>


===== Anwendung: Einfache Particle Engine =====
{{ :schule:klassen:2017:10b:particle_engine.png?600 |}}

Hier die Klasse für die Partikel:
<code>
import sge.Kreis;

public class Particle {

    private Kreis k;
    private double vx, vy;  // Geschwindigkeit in x- bzw. y-Richtung

    public Particle(double x, double y, double vx, double vy){
        this.vx = vx;
        this.vy = vy;

        k = new Kreis(x, y, 7);
        k.setFuellfarbe("gelb");
        k.setFuellfarbeAlpha(200);  // leicht durchsichtig
    }

    public void zeitschritt(){
        k.verschieben(vx, vy);
        vy += 0.04;
        if(vy > 0){
            k.setFuellfarbe("orange");
            k.setFuellfarbeAlpha(128);
        }
    }

    public boolean istAußerhalbDesFensters(){
        return k.istAußerhalbDesFensters();
    }

    public void vernichten() {
        k.vernichten();
    }
}
</code>

Die Partikel werden von der Klasse ''ParticleEmitter'' erzeugt und im Feld ''particles'' abgelegt. Alle 10 ms wird die Position jedes Partikels neu berechnet. Falls der Partikel das Fenster verlässt, wird er vernichtet und, seine Objektreferenz aus dem Feld ''particles'' entfernt und dafür ein neuer Partikel erzeugt. \\ Hier die Klasse ''ParticleEmitter'':

<code java>
import sge.Fenster;
import sge.Timer;
import sge.TimerListener;

public class ParticleEmitter implements TimerListener {

    // Wir speichern alle Partikel in einem Feld, damit wir
    // später alle 10 ms die Positionen aller Partikel neu berechnen 
    // und überflüssige Partikel entfernen können:
    private Particle[] particles = new Particle[200];
    
    // Objektreferenz aufs Fenster, damit wir dessen Größe ermitteln können
    private Fenster f;

    public ParticleEmitter(){

        f = new Fenster(); // Fenster öffnen

        // Der Timer sorgt dafür, dass timerSignalVerarbeiten alle 10 ms aufgerufen wird:
        Timer timer = new Timer(this, 10);
        timer.start();

    }

    @Override
    public void timerSignalVerarbeiten() {
        
        // Falls es im Feld particles eine Leerstelle (Wert == null) gibt, erzeuge einen neuen 
        // Partikel und lege seine Objektreferenz dort ab.
        for(int i = 0; i < particles.length; i++){
            if(particles[i] == null){
                Particle particle = new Particle(f.getBreite()/2, f.getHoehe() - 20,
                        Math.random()*10.0 - 5, -5 - Math.random() * 5);
                particles[i] = particle;
                break;
            }
        }
        
        // Für alle Partikel im Feld particles: Ändere die Position und
        // entferne den Partikel, falls er sich aus dem Fenster herausbewegt hat:
        for(int i = 0; i < particles.length; i++){

            if(particles[i] != null) {
                
                particles[i].zeitschritt();
                
                if(particles[i].istAußerhalbDesFensters()){
                    particles[i].vernichten();
                    particles[i] = null;
                }

            }

        }

    }
}
</code>

Hier noch der Code der Starterklasse:
<code>
public class ParticleEmitterStarter {

    public static void main(String[] args) {
        new ParticleEmitter();
    }

}
</code>