Elemente in einer ArrayList einander zuordnen.

[Markus_667]

Hallo Zusammen,

ich benötige etwas Inspiration bevor ich anfange zu Programmieren über folgende Problemstellung:
Es existieren drei ArrayListen (A,B,C) von verschiedenen Graphics2D Elementen.
Nun ist es so, dass ich mit der Maus auf einem JPanel ein Element aus der ArrayList A selektiere und ein Element aus der ArrayList B. Die Koordinaten der Mittelpunkte übergebe und dann dazwischen eine Linie Zeichne. Diese Linie wird dann in ArrayList C abgelegt.

Die Auswahl, ob die Mausposition zu einem Element passt mache ich mit einer For Schleife die über alle Elemente iteriert und mit .contains prüft ob etwas passt.

Wie verkette ich die ArrayListen miteinander so dass immer klar ist welches Element zu welchem Gehört.
Wenn ich alle Elemente der Reihe nach erstelle, passen die Indices zufällig zueinander. Also Element A 1 gehört zu Element B 1 und zu Element C 1.
Erstellt man aber die Elemente durcheinander passt nichts mehr zusammen.
Ebenfalls beim Löschen entstehen Probleme, da sich dann die Indices ändern und nachrutschen laut API.

Meine Überlegung war in ein weiteres Array die Zuordnungen zu schreiben, was aber aktualisiert werden muss wenn Elemente gelöscht werden.
Zweite Überlegung war die Elemente im Array null zu setzen, um die neue Indizierung zu umgehen. Aber dann bekomme ich bestimmt Probleme wenn ich beim Iterieren auf Attribute der Elemente zugreifen möchte.
Entsteht dann eine Nullpointer Exception ?

Habt jemand einen Vorschlag wie ich die Zuordnung besser implementieren kann ?
Bin für den verrücktesten Ansatz dankbar....

Danke im voraus....

Folgend noch ein Bild von meinem Aufbau der GUI
Array A Vierecke / Array B Kreise / Array C die Kanten dazwischen die gezeichnet werden durch Selektion.

 

[krgewb]

Entsteht dann eine Nullpointer Exception ?

Du kannst vorher prüfen lassen, ob es Null ist.

if(dsdfdf != null){
...
}

Du kannst eine eigene Klasse (evtl. als Unterklasse) erstellen und beliebige Variablen erstellen (u.a. eine ID). Dort kannst du auch die ganzen Informationen ("wer gehört zu wem?") eintragen. Die Objekte kannst du dann in einer ArrayList speichern.

 

[Markus_667]

Das stimmt natürlich, hätte mir auch einfallen können ... Danke

Nur ist mir nicht ganz klar wie ich eine ArrayList mit einem Rectangle2D, Ellipse2D, und einem Line2D Objekt pro Eintrag erstelle.
Ist das Array dann vom Deklarationstyp Shape ?
Und kann ich dann die Methoden der einzelnen Typen auch noch ansprechen ?
Sorry aber meine Java Zeit ist schon etwas her... hab leider zu viel vergessen :-(

 

[Markus_667]

Könnte ich eine Klasse (Bsp. ArrayStorage) erstellen und darin verschiedene Arrays als Obj Variablen vom Typ ArrayList anlegen und dann eine ArrayList vom Typ der Klasse erstellen ? Sozusagen eine ArrayList von ArrayListen.
Nur wie kann ich dann auf die Methoden der einzelnen Elemente zugreifen ?
Eigentlich haben diese Grafik Elemente ja eine Oberklasse Shape wenn ich nicht irre.
Eigentlich wäre es besser wenn ich ähnlich wie bei einer Datenbank die Indizes der drei verschiedenen Arrays in einer Zeile ablege. Dann hätte ich eine Zuordnung.

Fragen über Fragen... Sorry wahrscheinlich ist die Lösung ganz trivial und ich tue mich nur recht schwer mit der Sache.

 

[Markus_667]

Oder reicht es ein Klasse mit drei int Variablen zu erstellen und eine ArrayList dieser Klasse zu erstellen, dann könnte ich ganz einfach auf die Zuordnungen zugreifen...

 

[truesoul]

Hallo,

eine Implementierung alá Tree->Nodes sollte dafür bestens geeignet sein.

Also Beispiel:

public class TreeNode<T> implements Iterable<TreeNode<T>> {

    T data;
    TreeNode<T> parent;
    List<TreeNode<T>> children;

    public TreeNode(T data) {
        this.data = data;
        this.children = new LinkedList<TreeNode<T>>();
    }

    public TreeNode<T> addChild(T child) {
        TreeNode<T> childNode = new TreeNode<T>(child);
        childNode.parent = this;
        this.children.add(childNode);
        return childNode;
    }
    
 
    public List<TreeNode<T>> getChilds(T node) .....

    public boolean removeNode(T node) .....  

    usw...
}

TreeNode<String> root = new TreeNode<String>("A");
{
    TreeNode<String> node0 = root.addChild("AA");
    TreeNode<String> node1 = root.addChild("AB");
    TreeNode<String> node2 = root.addChild("AC");
    {
        TreeNode<String> node20 = node2.addChild("ACA");
        TreeNode<String> node21 = node2.addChild("ACB");
        {
            TreeNode<String> node210 = node20.addChild("ACAA");
        }
    }
}

Damit hast du immer die Möglichkeit zu jeder Node den Root und die Kinder zu bekommen.

Grüße

 

[krgewb]

Ich zeige dir mal ein paar Datentypen.

Map (bzw. HashMap):
Hier kann man Schlüssel-Wert-Paare speichern.

Map<String, String> meineMap = new HashMap<String, String>();

Dies funktioniert auch mit einer Liste von Werten.

Map<String, List<String>> meineMap = new HashMap<String, List<String>>();

Danach kannst du mit einer erweiterten for-Schleife iterieren.

        for (Map.Entry<String, List<String>> entry : meineMap.entrySet()) {
            String key = entry.getKey();
            List<String> values = entry.getValue();
            System.out.println("Personalnummer = " + key);
            System.out.println("Kinder = " + values + "\n");
        }

Zweidimensionale ArrayList:

    private static ArrayList<ArrayList<Object>> daten = new ArrayList<ArrayList<Object>>();

Objekte erstellen und hinzufügen:

        ArrayList<Object> a = new ArrayList<Object>();
        a.add("eisenerz");
        a.add(new Integer(123));
        daten.add(a);

Und dann per for-Schleife iterieren:

        for (int i = 0; i < daten.size(); i++) {
            if (daten.get(i).get(0).equals("eisenerz")) {
                ...
            }
        }

Falls du Objekte von einem bestimmten Typ speicherst kannst du natürlich auch auf die Methoden zugreifen.

daten.get(i).get(0).fuehreDiesesOderJenesAus();

Dann muss aber der Typ klar sein. Anderenfalls musst du ein neues Objekt der Klasse erstellen und Casting anwenden.

 

[truesoul]

Hallo krgewb,

mit deinem Beispiel:

Map<String, List<String>> meineMap = new HashMap<String, List<String>>();

Kein ein Root mehrere Kinder haben aber die Kinder können keine Kinder nicht haben.
Und beim Beispiel Bild gibt es Ausgangspunkt (Root) mit einem Kind und das hat auch ein Kind ...

Sicherlich kann man das mit deinem Vorschlag auch abbilden allerdings wird es ein großer Aufwand ein Kind zu löschen und alle Abhängigkeiten dazu auch.

Und dazu:

private static ArrayList<ArrayList<Object>> daten = new ArrayList<ArrayList<Object>>();

Wie weit soll man dann das verschachteln wenn alle Kinder auch Kinder haben können?

Grüße

 

[Flown]

Wie verkette ich die ArrayListen miteinander so dass immer klar ist welches Element zu welchem Gehört.
Wenn ich alle Elemente der Reihe nach erstelle, passen die Indices zufällig zueinander. Also Element A 1 gehört zu Element B 1 und zu Element C 1.
Erstellt man aber die Elemente durcheinander passt nichts mehr zusammen.
Ebenfalls beim Löschen entstehen Probleme, da sich dann die Indices ändern und nachrutschen laut API.

Das beste wäre eine eigene Klasse zu erstellen die alles Nötige gespeichert hat. Die Linie und die zwei Endpunkt-Objekte.

public class Connector {
  private Shape start;
  private Shape end;
  private Line2D connector;

  //Methoden zum Zeichnen, prüfen ob Element gelöscht werden kann, wenn ein Endpunkt gelöscht wird, etc.
}

 

[krgewb]

ähnlich wie bei einer Datenbank

In Java gibt es die Klasse Table ( https://docs.oracle.com/javase/tutorial/uiswing/components/table.html )
Dazu wird ein zweidimensionales Object-Array gefüllt:

Object[][] data = {
    {"Kathy", "Smith",
     "Snowboarding", new Integer(5), new Boolean(false)},
    {"John", "Doe",
     "Rowing", new Integer(3), new Boolean(true)},
    {"Sue", "Black",
     "Knitting", new Integer(2), new Boolean(false)},
    {"Jane", "White",
     "Speed reading", new Integer(20), new Boolean(true)},
    {"Joe", "Brown",
     "Pool", new Integer(10), new Boolean(false)}
};

Aber wie du weißt kann man bei Arrays nachträglich keine Zeilen hinzufügen.

die Indizes der drei verschiedenen Arrays in einer Zeile ablege

Ich sehe eine Möglichkeit: Eine ArrayList mit Strings. Jeder String repräsentiert solch eine Zeile. Einer der Strings ist dann z.B.:
1;14;2
Das sind die Indizes, durch Strichpunkt getrennt. Mithilfe der split-Funktion kommst du an die einzelnen Werte heran:

String[] arrayMitIndizes = meineArrayList.get(i).split(";");
int indexEins = Integer.parseInt(arrayMitIndizes[0]);
int indexZwei = Integer.parseInt(arrayMitIndizes[1]);
int indexDrei = Integer.parseInt(arrayMitIndizes[2]);

 

[Markus_667]

Guten Abend, erst mal vielen lieben Dank für die vielen Posts.
Nach einiger Überlegung scheint mir die Lösung von Flown am "saubersten" zu sein was den Programmierstil angeht.
Das habe ich auch mal ausprobiert, aber irgenwie verstehe ich noch nicht so ganz wie ich das nun befüllen kann.
Ich dachte mir dass ich die getter und setter erstelle und dann darauf zugreifen kann.
Mit set ein Element zuweisen und dann dachte ich dass ich mit arList.get().... auf die eigentlichen Methoden von bsp Recktangle2D wie .contains zugreifen kann.
Aber das klappt nicht so wie ich dachte.
Kann mich da noch jemand unterstützen ?

Eine zweite Sache ist mir noch eingefallen.
Mit dem new Operator erstelle ich ein Objekt, wenn ich dieses Objekt in zwei verschiedenen ArrayListen ablege und eines davon ändere (Bsp. die Koordinaten) ändert sich dann das andere auch ?
Weil eigentlich existiert ja nur ein Objekt, oder bin ich da falsch ?
Irgendetwas hatte ich da noch im Kopf in Verbindung mit Arrays, und CBValue/CBRerferenz.
Kann Java nicht nur CBV ?

Dicke Danke nochmal...

Folgend mein Code.


Folgend mein erster Versuch.

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;

public class G2D_ArrayList {
   
    private Rectangle2D rechteck;
    private Ellipse2D ellipse;
    private Line2D kanten;
    public Rectangle2D getRechteck() {
        return rechteck;
    }
    public void setRechteck(Rectangle2D rechteck) {
        this.rechteck = rechteck;
    }
    public Ellipse2D getEllipse() {
        return ellipse;
    }
    public void setEllipse(Ellipse2D ellipse) {
        this.ellipse = ellipse;
    }
    public Line2D getKanten() {
        return kanten;
    }
    public void setKanten(Line2D kanten) {
        this.kanten = kanten;
    }
}

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;

public class HauptKlasse {
    static ArrayList<G2D_ArrayList> arList;

    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
        arList = new ArrayList<G2D_ArrayList>();
        Rectangle2D testrect = new Rectangle2D.Double();
        Ellipse2D testelli = new Ellipse2D.Double();
        Line2D testline = new Line2D.Double();
    }
}

 

[Flown]

Kann Java nicht nur CBV ?

Ja, wenn du call-by-value meinst.

Dein Programm wird bei einem Klick ca. so aussehen (Pseudo-code):

public void onclick(event):
  for(Shape a in listA):
    if(a.contains(event.bounds)) fromListA = a;
  for(Shape b in listB).
    if(b.contains(event.bounds)) fromListB = b;
  if(fromListA.hasValue && fromListB.hasValue):
    Line2D connector = new Line2D(fromListA.center, fromListB.center);
    connections.add(fromListA, fromListB, connector);
    fromListA.clearValue
    fromListB.clearValue

 

[krgewb]

Mit dem new Operator erstelle ich ein Objekt, wenn ich dieses Objekt in zwei verschiedenen ArrayListen ablege und eines davon ändere (Bsp. die Koordinaten) ändert sich dann das andere auch ?

Ja.

Guten Abend, erst mal vielen lieben Dank für die vielen Posts.
Nach einiger Überlegung scheint mir die Lösung von Flown am "saubersten" zu sein was den Programmierstil angeht.
Das habe ich auch mal ausprobiert, aber irgenwie verstehe ich noch nicht so ganz wie ich das nun befüllen kann.
Ich dachte mir dass ich die getter und setter erstelle und dann darauf zugreifen kann.
Mit set ein Element zuweisen und dann dachte ich dass ich mit arList.get().... auf die eigentlichen Methoden von bsp Recktangle2D wie .contains zugreifen kann.
Aber das klappt nicht so wie ich dachte.
Kann mich da noch jemand unterstützen ?

Eine zweite Sache ist mir noch eingefallen.
Mit dem new Operator erstelle ich ein Objekt, wenn ich dieses Objekt in zwei verschiedenen ArrayListen ablege und eines davon ändere (Bsp. die Koordinaten) ändert sich dann das andere auch ?
Weil eigentlich existiert ja nur ein Objekt, oder bin ich da falsch ?
Irgendetwas hatte ich da noch im Kopf in Verbindung mit Arrays, und CBValue/CBRerferenz.
Kann Java nicht nur CBV ?

Dicke Danke nochmal...

Folgend mein Code.


Folgend mein erster Versuch.

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;

public class G2D_ArrayList {
   
    private Rectangle2D rechteck;
    private Ellipse2D ellipse;
    private Line2D kanten;
    public Rectangle2D getRechteck() {
        return rechteck;
    }
    public void setRechteck(Rectangle2D rechteck) {
        this.rechteck = rechteck;
    }
    public Ellipse2D getEllipse() {
        return ellipse;
    }
    public void setEllipse(Ellipse2D ellipse) {
        this.ellipse = ellipse;
    }
    public Line2D getKanten() {
        return kanten;
    }
    public void setKanten(Line2D kanten) {
        this.kanten = kanten;
    }
}

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;

public class HauptKlasse {
    static ArrayList<G2D_ArrayList> arList;

    public static void main(String[] args) {
        // TODO Automatisch generierter Methodenstub
        arList = new ArrayList<G2D_ArrayList>();
        Rectangle2D testrect = new Rectangle2D.Double();
        Ellipse2D testelli = new Ellipse2D.Double();
        Line2D testline = new Line2D.Double();
    }
}

Das könnte so aussehen:

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;

public class HauptKlasse {
	static ArrayList<G2D_ArrayList> arList;

	public static void main(String[] args) {
		// TODO Automatisch generierter Methodenstub
		arList = new ArrayList<G2D_ArrayList>();

		G2D_ArrayList g = new G2D_ArrayList();

		g.setRechteck(new Rectangle2D.Double());
		g.setEllipse(new Ellipse2D.Double());
		g.setKanten(new Line2D.Double());

		arList.add(g);
	}
}

Contains kann dann z.B. so aufgerufen werden:
if (arList.get(2).getRechteck().contains(meinPunkt)){
...
}

Aber das ist ein anderer Aufbau als der von Flown. Deshalb gebe ich ihm das Wort.

 

[truesoul]

Hallo.

Vielleicht mal nochmal mein Vorschlag aufzugreifen hier ein Beispiel:

Die Node:

import java.awt.Shape;
import java.util.LinkedList;
import java.util.List;

public class TreeNode<T extends Shape> {

    private T data;
    private TreeNode<T> parent;
    private List<TreeNode<T>> children = new LinkedList<TreeNode<T>>();

    public TreeNode(T data) {
        this.data = data;
    }

    /**
    * Erzeugt einen anhand eines Shape's neuen Knoten diesem Knoten hinzu.
    * 
    * @param child
    * @return gibt den erstellten Knoten zurück
    */
    public TreeNode<T> addChildNode(T child) {
        TreeNode<T> childNode = new TreeNode<T>(child);
        childNode.parent = this;
        this.children.add(childNode);
        return childNode;
    }

    /**
    * Gibt den Shape zurück
    * 
    * @return data
    */
    public T getData() {
        return data;
    }

    /**
    * Gibt das Ausgangsknoten dieses Knotens zurück
    * 
    * @return TreeNode<T>
    */
    public TreeNode<T> getParentNode() {
        return parent;
    }

    /**
    * Entfernt diesen Knoten vom Ausgangsknoten
    * 
    */
    public void clear() {
        if (parent != null)
            parent.removeChild(this);
    }

    /**
    * Entfernt ein Kindknoten
    * 
    * @param child
    */
    public void removeChild(TreeNode<T> child) {
        children.remove(child);
    }

    /**
    * Gibt alle Knotenkinder zurück
    * 
    * @return
    */
    public List<TreeNode<T>> getChildren() {
        return children;
    }
}

Eine Util Klasse:

import java.awt.Shape;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;

public class GraphicsUtil {

    private static final int MAX_WIDTH = 50;
    private static final int MAX_HEIGHT = 50;

    public static Shape getRectangle(int x, int y) {
        return new Rectangle2D.Double(x, y, MAX_WIDTH, MAX_HEIGHT);
    }

    public static Shape getEllipse(int x, int y) {
        return new Ellipse2D.Double(x, y, MAX_WIDTH, MAX_HEIGHT);
    }

    public static Shape getLine(TreeNode<Shape> root, TreeNode<Shape> child) {
        return new Line2D.Double(root.getData().getBounds2D().getX() + GraphicsUtil.MAX_HEIGHT / 2,
                root.getData().getBounds2D().getY() + GraphicsUtil.MAX_HEIGHT / 2,
                child.getData().getBounds2D().getX() + GraphicsUtil.MAX_HEIGHT / 2,
                child.getData().getBounds2D().getY() + GraphicsUtil.MAX_HEIGHT / 2);
    }
}

Die TreeNodeContainer Klasse:

import java.awt.Shape;

public class TreeNodeContainer {

    private TreeNode<Shape> root;

    public TreeNodeContainer(TreeNode<Shape> root) {
        this.root = root;
    }

    /**
    * Sucht im Knoten auf Position x und y nach dem richtigen Knoten
    * 
    * @param element
    * @param x
    * @param y
    * @return Gibt den gefunden Knoten zurück
    */
    public TreeNode<Shape> findNodeInElement(TreeNode<Shape> element, int x, int y) {

        if (element.getData().contains(x, y)) {
            return element;
        } else {
            for (TreeNode<Shape> node : element.getChildren()) {
                TreeNode<Shape> find = findNodeInElement(node, x, y);
                if (find != null) {
                    return find;
                }
            }
        }

        return null;
    }

    /**
    * Gibt den Ausgangsknoten zurück
    * 
    * @return
    */
    public TreeNode<Shape> getRoot() {
        return root;
    }

    /**
    * Entfernt den Knoten auf Position x und y wenn einer gefunden wird.
    * 
    * @param x
    * @param y
    * @return gibt True zurück wenn ein Knoten entfernt wurde
    */
    public boolean removeNodesIfExists(int x, int y) {
        TreeNode<Shape> find = findNodeInElement(getRoot(), x, y);
        if (find != null) {
            find.clear();

            if (find == root) {
                root = null;
            }
            return true;
        }
        return false;
    }
}

Die View Klasse:

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JFrame;

@SuppressWarnings("serial")
public class View extends JFrame implements MouseListener {

    private TreeNodeContainer nodes;

    public View(TreeNodeContainer nodes) {
        super("Lines Drawing Demo");
        this.nodes = nodes;

        setSize(960, 680);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        addMouseListener(this);
        setVisible(true);
    }

    private void drawNode(Graphics2D g2d, TreeNode<Shape> element) {
        if (element != null) {
            g2d.draw(element.getData());

            for (TreeNode<Shape> node : element.getChildren()) {
                drawNode(g2d, node);
                drawLine(g2d, element, node);
            }
        }
    }

    private void drawLine(Graphics2D g2d, TreeNode<Shape> root, TreeNode<Shape> child) {
        g2d.draw(GraphicsUtil.getLine(root, child));
    }

    public void paint(Graphics g) {
        super.paint(g);
        drawNode((Graphics2D) g, nodes.getRoot());
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        boolean removed = nodes.removeNodesIfExists(e.getX(), e.getY());
        if (removed) {
            redraw();
        }
    }

    private void redraw() {
        getGraphics().clearRect(0, 0, 960, 680);
        pack();
        setSize(960, 680);
    }

    @Override
    public void mousePressed(MouseEvent e) {
    }

    @Override
    public void mouseReleased(MouseEvent e) {
    }

    @Override
    public void mouseEntered(MouseEvent e) {
    }

    @Override
    public void mouseExited(MouseEvent e) {
    }
}

Start:

import java.awt.Shape;

import javax.swing.SwingUtilities;

public class Starter {

    public static void main(String[] args) {
        final TreeNode<Shape> root = new TreeNode<Shape>(GraphicsUtil.getRectangle(100, 100));

        TreeNode<Shape> childA = root.addChildNode(GraphicsUtil.getRectangle(240, 160));
        TreeNode<Shape> childB = root.addChildNode(GraphicsUtil.getEllipse(160, 250));
        TreeNode<Shape> childC = root.addChildNode(GraphicsUtil.getRectangle(160, 350));

        TreeNode<Shape> childAA = childA.addChildNode(GraphicsUtil.getEllipse(410, 50));
        TreeNode<Shape> childAAA = childAA.addChildNode(GraphicsUtil.getRectangle(560, 70));

        TreeNodeContainer nodes = new TreeNodeContainer(root);

        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new View(nodes);
            }
        });
    }

}

Wie du siehst verwaltet jeder Knoten seine Kinder. Und alle Kinder wissen wer sein Ausgangsknoten ist.
Die Linien zu jedem Knoten müssen nicht zwingend abgespeichert werden.

 

[Markus_667]

Zunächst erst mal danke an alle Mitwirkenden.
So im Nachhinein betrachtet ist die Sache mit dem Node von truesoul gar nicht so übel....
Ich muss erst noch etwas intensiver den Quelltext studieren und verstehen, aber es wirkt sehr aufgeräumt und strukturiert.
Jedenfalls mache ich mir mal ein test Package und probiere etwas damit rum...das könnte was werden.
DICKES MERCY für deine Implementierung.

Ich habe in meinen Versuchen bisher noch keine einheitliche Struktur gefunden, einmal übergebe ich eine Index um ein Element in einem Array zu finden und ein anderes mal übergebe ich ein ganzes Graphics Objekt und vergleiche mit equals... da muss ich noch ran.

Folgend mein erster Versuch.

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;

public class G2D_ArrayList {

private Rectangle2D rechteck;
private Ellipse2D ellipse;
private Line2D kanten;
public Rectangle2D getRechteck() {
return rechteck;
}
public void setRechteck(Rectangle2D rechteck) {
this.rechteck = rechteck;
}
public Ellipse2D getEllipse() {
return ellipse;
}
public void setEllipse(Ellipse2D ellipse) {
this.ellipse = ellipse;
}
public Line2D getKanten() {
return kanten;
}
public void setKanten(Line2D kanten) {
this.kanten = kanten;
}
}

import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;

public class HauptKlasse {
static ArrayList<G2D_ArrayList> arList;

public static void main(String[] args) {
// TODO Automatisch generierter Methodenstub
arList = new ArrayList<G2D_ArrayList>();
Rectangle2D testrect = new Rectangle2D.Double();
Ellipse2D testelli = new Ellipse2D.Double();
Line2D testline = new Line2D.Double();
}
}
Markus_667, Gestern um 21:49 UhrMelden

Aber mir fehlt immer noch die Sache mit der eigenen Klasse und dem Ansprechen der Methoden die ich implementiert habe und den Methoden eines Graphics2D Typs wie .getX()
Hierbei würde ich gerne noch einmal eure Hilfe annehmen.

@Flown: War das eigentlich richtig so wie du das meintest ?

 

[Flown]

@Flown: War das eigentlich richtig so wie du das meintest ?

Ja.

 

[krgewb]

Aber wie spricht er die Methoden dann an? Stimmt das, was ich in Beitrag #13 geschrieben habe?

 

[krgewb]

Wie hast du es letztendlich gemacht?

 

[Markus_667]

Ich habe eine Klasse geschrieben in der für jede Art von Objekten ein eigenes Array erstellt wird.
Dann kann ich mit den Methoden die ich geschrieben haben darauf zugreifen... ist zwar nicht ganz das was ich mit vorgestellt hatte aber es funktioniert...
Noch einmal vielen Dank an alle die mit mit Rat und Tat zur Seite standen... Allein wäre ich verzweifelt.