Beiträge

Beginner   Java allgemein   JDBC   JNI   Networking   Online-Ressourcen   Swing + AWT   XML   Meckerecke    Antworten     Neuer Beitrag     Gesamtdarstellung Detaildarstellung Einzeldarstellung Threaddarstellung

Beitrag 71 von 2212 (3%)

Autor	NullPlan
Datum	06.06.05, 18:53
Betreff	Warteschlangen

---

ich habe jetzt eine Warteschlange vom Typ java.util.LinkedList nutzen, deren Elemente vom Typ Car sind


import java.awt.Color;

public class Car
{
    
    Color c;
    int id;
    static int counter = 0;
    
    public Car()
    {
        c = randomColor();
        id = counter ++;
    }
    
    private Color randomColor()
    {
        return new Color((int)(255*Math.random()), (int)(255*Math.random()), (int)(255*Math.random()));
    }
    
    public Color getColor()
    {
        return c;
    }
    
    public int getID()
    {
        return id;
    }
}
in einer weiteren klasse wird die linkedList implementiert:


import java.util.LinkedList;
import java.lang.Thread;

public class Road
{
    private LinkedList r = new LinkedList();
    
    
    /**
    * Car-Element in die Queue schieben
    * @param auto
    */
    public void add(Car auto)
    {
        System.out.println("add(Car auto)";
        r.add(auto);
    }
    
    /** Das nächste Car-Element aus der Queue holen.
    * Funktioniert nach dem FIFO-Prinzip (First In First Out)
    * @return
    */
    public Car removeFirst()
    {
        return (Car) r.remove();
    }
    
    /**
    * Anzahl der Car-Elemente zurückgeben
    * @return
    */
    public int size()
    {
        return r.size();
    }
    
    /**
    * Prüft ob die Queue leer ist
    * @return
    */
    public boolean isEmpty()
    {
        return r.isEmpty();
    }
    
}

nun folgt noch die frame klasse.

import java.awt.*;
import java.awt.event.*;
import java.util.LinkedList;

public class RoadFrame extends Frame implements ActionListener{
    
    Road r = null;
    
    // Variablen für Frame und Anzeige
    Button simButton, pauseButton;
    Image street, background;
    int offset = 35;
    int width = 800, height = 200;
    
    // Frame und Buttons erzeugen, Eventverarbeitung anmelden
    public RoadFrame()
    {
        setTitle("Road";
        
        setLayout(new FlowLayout());
        
        simButton = new Button("Starten";
        simButton.setBackground(Color.white);
        simButton.setForeground(new Color(0, 128, 0));
        simButton.addActionListener(this);
        add(simButton);
        
        pauseButton = new Button("Pause";
        pauseButton.setBackground(Color.white);
        pauseButton.setForeground(new Color(0, 128, 0));
        pauseButton.addActionListener(this);
        pauseButton.setEnabled(false);
        add(pauseButton);
        
        setSize(width, height);
        
        setVisible(true);
        
        addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
        
    }
    
    // wird beim Start des Programms einmalig aufgerufen
    // Hintergrundbild einlesen, Bild erstellen
    public void paint(Graphics g)
    {
        street = createImage(width, height);
        Graphics gr = street.getGraphics();
        Toolkit t = Toolkit.getDefaultToolkit();
        background = t.getImage("background.gif";
        gr.drawImage(background, 0, 0, this);
        g.drawImage(street, 0, 0, this);
    }
    
    // wird bei jedem Aufruf von repaint() aufgerufen
    // zeichnet die Autos in das Bild
    public void update(Graphics g)
    {
        Graphics gr = street.getGraphics();
        gr.drawImage(background, 0, 0, this);
        Car c;
        int x;
        
        System.out.println("update()";
        
        if (r != null)
        {
            /*
            // Zeichnen der mittleren Spur
            LinkedList lane = r.getMiddle();
            x = 385-offset*lane.size();
            for (int i=0; i<lane.size(); i++, x += offset)
            {
                c = (Car)(lane.get(i));
                drawCar(c, x, 125, gr);
            }*/
            
            
            /*
            // Zeichnen der rechten Spur
            lane = r.getRight();
            if (lane.size() > 11) x = 385;
            else x = 805-offset*lane.size();
            for (int i=0; i<lane.size(); i++, x += offset){
                c = (Car)(lane.get(i));
                drawCar(c, x, 110, gr);
            }
            
            // Zeichnen der linken Spur
            lane = r.getLeft();
            if (lane.size() > 11) x = 385;
            else x = 805-offset*lane.size();
            for (int i=0; i<lane.size(); i++, x += offset){
                c = (Car)(lane.get(i));
                drawCar(c, x, 140, gr);
            }
            */
            
        }
        else
        System.out.println("r==null";
        
        g.drawImage(street, 0, 0, this);
    }
    
    // ein einzelnes Auto zeichnen
    // Parameter: c - das Auto, x und y - die oebere linke Ecke, gr - der Graphikkontext
    private void drawCar(Car c, int x, int y, Graphics g)
    {
        g.setColor(c.getColor());
        g.fill3DRect(x, y, 30, 16, true);
        g.fill3DRect(x+8, y+1, 20, 14, true);
        g.setColor(Color.white);
        g.drawString(""+c.getID(), x+9, y+13);
    }
    
    public LinkedList getMiddle()
    {
        return null;
    }
    
    public void actionPerformed(ActionEvent e){
        
        Object o = e.getSource();
        if (o == simButton){
            if ((simButton.getLabel()).equals("Starten")
            {
                System.out.println("start";
                //ruft die Methode paint() auf
                repaint();
                r.add();
                
                simButton.setLabel("Beenden";
                pauseButton.setEnabled(true);
            }
            else
            {
                
                //------------------------------------------------------
                //------------------------------------------------------
                // Simulation beenden
                //------------------------------------------------------
                //------------------------------------------------------
                
                simButton.setLabel("Starten";
                pauseButton.setLabel("Pause";
                pauseButton.setEnabled(false);
            }
        }
        
        if (o == pauseButton){
            if ((pauseButton.getLabel()).equals("Pause"){
                
                //------------------------------------------------------
                //------------------------------------------------------
                // Simulation unterbrechen
                //------------------------------------------------------
                //------------------------------------------------------
                
                pauseButton.setLabel("Weiter";
            }
            else{
                
                //------------------------------------------------------
                //------------------------------------------------------
                // Simulation fortsetzen
                //------------------------------------------------------
                //------------------------------------------------------
                
                pauseButton.setLabel("Pause";
            }
        }
    }
    
    public static void main(String [] args){
        new RoadFrame();
    }
}
in der folgenden klasse sollte die linkedlist r gefüllt werden, ich habe aber keine ahnung wie ich das anstellen muss.
jemand eine idee?

---

Auf diesen Beitrag antworten   Neuen Beitrag verfassen