Suche Hilfe , Problem mit Vektoren und klassen

[Leox]

Hallo, ich habe mal eine Frage:


Mein Ziel ist Folgendes:

Ich will eine große Liste anlegen, deren Elemente wieder eine Art Liste ist.
Ich brauch nämlich eine fertige Liste für eine Widerstandsschaltung.


Also soll es ungefähr so aussehen:



[ R { P(w1,w2), P (R ((w3,w4), W5)]

heißt: ich hab eine Reihenschaltung, bestehend aus 1., einer Parallelschaltung aus 2 Widerständen, 2. einer Parallelschaltung bestehend aus a)einer Reihenschaltung (w3,w4) und b)einem 5. Widerstand.


Erstmal will ich mir im Quelltext diese Liste anlegen, aber ich hab keinen blassen schimmer wie das gehen soll.

Also erstmal ist ja klar, dass ich nen hauptprog brauche, indem ich mir die liste anlege, diese wird wohl ein Vektor sein.
Ich hab 3 Klassen (wiederstand, reihe, parallel)...Wie bekomme ich es jetzt hin, dass ich im hauptprogramm zb´. sagen kann. 1. element der liste ist eine Reihenschaltung vom....etc.etc.


Gruß Leox

 

[SlaterB]

http://www.java-forum.org/de/viewtopic.php?t=70342

edit: ach, da hat der Topicersteller seinen Quellcode wohl gelöscht, dann hiilft das nicht so viel,
da wurde das baumartig/ vernetzt aufgebaut:

Widerstand w1 = ..;
Widerstand w2 = ..;
Parallel p1 = new Parallel(w1,w2);
Reihe r1 = new Reihe(p1, ..);
usw.

 

[Leox]

ja der Kerl hat sein Quelltext leider gelöscht.


Aber so hatte ich es mir auch cshon überlegt.
Jetzt wollte ich eigentlich nur folgendes wissen:

Ich hab 3 Klassen, zeichnewiderstand, zeichneparallel, zeichneserie,

zeichnewiderstand ruf ich auf, indem ich z.b. den widerstand i´n string verwandel, mit den koordinaten rüberschicke und er mir nen kästen + den widerstand drinne anzeigt.

bei der serie würde ich ja alle widerstände mitgeben, und er würd einzeln dann wieder zeichnewiederstand aufrufen mit den jeweiligen strings und den dazugehörigen koordinaten.

nur wie bekomme ich es hin, dass er zeichenserie mit allen übergebenen widerständen startet..

muss ich das als array machen? oder kann man auch nen vektor ´mit übergeben???

 

[Leox]

sorry doppelpost

aber noch eine ergänzung zur frage, damit das klar ist, was ich wissen will...

Parallel P2 = Parallel(w1,w2)

was ist dann das in der Klammer, also mit was wird P2 bzw. Parallel dann aufgerufen? Array? Vektor?

 

[Gast]

Du legst im Konstruktor der Klasse fest was beim Aufruf desselben übergeben werden muss. Eine Parallelschaltung besteht halt aus mehreren Widerständen.

 

[diggaa1984]

was ist dann das in der Klammer, also mit was wird P2 bzw. Parallel dann aufgerufen? Array? Vektor?

das sind referenzen auf die widerstands-objekte. Da bei Parallel klar ist wie die Elemente angeordnet sind, reicht es direkt die Widerstände zu übergeben.

wenn du vorhast ne Reihenschaltung mit einem widerstand parallel zu schalten könntest du dir andere parameter für den konstruktor überlegen. Das wird aber bei mehreren unterschiedlichen bauteilen ziemlich eklig, eventuell besser über eine abstrakte Klasse, oder ein Interface von dem die Bauteile erben/abgeleitet sind

public class Parallel {

    public Parallel(AbstraktesBauteil[] teile) {
        //setze einzelne Bauteile parallel
    }

    public Parallel(Reihenschaltung[] rs, AbstraktesBauteil[] teile) {
        //setze Reihe und Bauteile parallel
    }
}

wäre vielleicht noch am flexibelsten, wenn du nun noch Dioden oder dergleichen reinbauen sollst, dann sind die auch vom Abstrakten abgeleitet und könnten einfach übergeben werden.
Und praktisch das du hier Arrays übergibst, damit du auch mal 3 reihenschaltungen übergeben kannst ohne gleich nen neuen konstruktor zu bauen, du musst eben nur die Länge der Arrays prüfen

 

[Leox]

ja, ich leg im konstruktor fest, wieviel widerstände mit reinkommen - da liegt ja das problem.

ne reihenschaltung kann ja aus allen möglichem bestehen. kann ja auch aus 2 parallelschaltungen wieder bestehen, die muss ich ja dennoch irgendwie mit überbringen :-(

und zum 2. post..weiß nicht, ob es an der uhrzeit liegt, aber ich hab nur die hälfte verstanden

 

[diggaa1984]

na interface oder abstrakte klasse kennst aber oder?
somit kannst einfach mal den eigenltich typ des bauteils der inne schaltung kommt "ausblenden" und alle einzelbauteile werden als AbstraktesBauteil gesehen (oder eben was äquivalentes als interface). Somit kannst in

public Parallel(AbstraktesBauteil[] teile) ..

sowohl Widerstände wie Kondesatoren oder Dioden reinbaun, ohne das du dafür nen neuen Konstruktor bauen musst, da alle vom Typ AbstraktesBauteil abgeleitet sind.

Die Angabe als Array hilft da ebenfall, da du flexibel bist, was die Anzahl an zu parallel-schaltenden Bauteilen angeht (2,4,10 Widerstände, passen alle ins Array).

Selbiges für die Reihenschaltung. Hier kannst 2,3,4 Reihenschaltungen ins Array legen, und damit selbige parallel schalten. Also ich finde für deine Problematik find ich diese Lösung noch ganz praktikabel, da du quasi beliebig viele Sachen parallel schalten kannst.

Weiss nich wie ichs noch erklären soll, aber frag ruhig nach

 

[Leox]

ok ich versuch es nochmal.

tut mir leid, wenn ich so blöde tu, aber ich hab vorher nix derartiges gemacht und hab immer noch meine probleme, mit klassen,methoden,etc.


wie auch jemand anders hier, muss ich die grafische ausgabe machen.


ich hab also folgendes vor:

1. ich muss mir eine Liste anlegen ( da weiß ich halt nicht, wie ich es machen soll)
2. ich schreib ne klasse: widerstandzeichnen. heißt: strich-rechteck-strich und oben drüber steht ne zahl
3. ich muss ne klasse schreiben: reihezeichnen. heißt in diese klasse wird z.b. übergeben. reihenschaltung 1 besteht aus parallelschaltung 1 und widerstand 1. dann muss aus der klasse ja erst auf parallelzeichnen und dann auf widerstandzeichnen zurückgegriffen werden.

jetzt habe ich mal angenommen meine liste.

die sieht dann so aus:

         R2 - R3 
       /           \
R1 -  ---R4---------R6
      \            /
          -R5 -

das heißt meine liste würde ja so aussehen:

Reihenschaltung1 { Parallelschaltung1 [ Reihenschaltung2 (R2,R3) ; R4; R5] ;R6}


jetzt muss ich ja irgendwie eine Methode aufrufen, die nachguckt, was ist das erste element in der liste.
und dann?

ich hab da einfach kein durchblick, wieviele klassen ich da in eine einzelne datei reinpacken kann oder nicht.

 

[diggaa1984]

gut muss sagen, meine ansätze betrafen eher die klassen Parallel und Reihe, damit du diese leicht mit werten füttern kannst. Zu dem Problem mit der Liste fällt mir nu erstma auch nur der Aufbau über einen Baum ein (math. definition). Den könnte man quasi in einer bestimmten richtung ablaufen und auslesen und damit würdest du erkennen welche elemente wann gezeichnet werden müssten und wie diese so verschachtelt sind. Aber das isn eigener Themenkomplex, vielleicht versuchst dich da einzulesen

 

[diggaa1984]

@Baum: könnte so aufgebaut sein:

          Reihe
   ______/  |  \______   
  /         |         \
R1        Parallel    R6
          /   |   \
       __/    |     \__
     /        |         \
   Reihe     R4           R5
  /   \
 /      \
R1     R2

so in etwa ^^

 

[Leox]

ja gut, versuch ich mal irgendwie reinzukommen...


welche variablen eignen sich denn da am besten für? vektor?

 

[diggaa1984]

das ne gute frage, da müsste sich jemand anders einschalten ^^ .. wir ham das in der uni selbst programmiert sone Baumstruktur, aus Javamitteln hab ich da noch nix genutzt und is mir nix derartiges bekannt. Kenn nur TreeMap und TreeSet, weiss aber nicht inwiefern man damit arbeitet

 

[Triebi]

public class Parallel {
[...]
}

Es ist vielleicht eine Überlegung wert, die Klassen Parallel(schaltung) und Reihenschaltung von AbstraktesBauteil erben zu lassen. Das könnte IMHO einiges erleichtern, z. B.:

ne reihenschaltung kann ja aus allen möglichem bestehen. kann ja auch aus 2 parallelschaltungen wieder bestehen

 

[diggaa1984]

Jop wär auch ne maßnahme. Brauchen wir nur noch ne Lösung für die Abbildung der Schaltung in einer Datenstruktur ^^

 

[SlaterB]

im einfachen Falle hat eine Parallelschaltung genau zwei Unterelemente die man in einzelnen Variablen speichertn,

wenn drei Dinge parallel zu schalten sind, kann man ja die erste 2er-Parallelschaltung mit dem dritten Ding neu parallel schalten

 

[Leox]

da bin ich mir nicht ganz sicher.

weiß nicht wie das in der berechnung aussieht. ob es nen unterschied gibt, wenn er alle 3 widerstände mit reinnimmt i´n die rechnung für parallelwiderstände, oder erst 2 , und dann das zusammengerechnete+den 3.


zudem wird das glaube ich etwas unübersichtlich, wenn es mehr als 3 widerstände werden, die parallel geschaltet werden sollen.

 

[SlaterB]

tja, bei ersterem kannst du dir sicher sein
http://www.elektronik-kompendium.de/sites/slt/0110192.htm

 

[Leox]

so, unglaublich aber wahr: ich hab eine fertige liste und jetzt gehts ans ´zeichnen.

Ich hoffe ein paar von euch haben noch ein bischn den Quelltext von dem anderen User im Kopf, denn ich bin da auch gerade sehr am rumraten.

Also ich hab eine Klasse gesamt:
da zeichnet er erstmal nur so nen kleinen Kreis an den anfang und guckt dann in meinem gesamtvektor nach´, was das erste Element ist und ruft dementsprechend entweder

a) widerstandzeichnen
b) seriezeichnen
c) parallelzeichnen


auf.

in diese klassen wird dann das erste element mit übernommen, welches dann wiederum ein vektor ist, so dass die abfrage aus gesamt auch nochmal dementsprechend in den einzelnen klassen (serie + parallel) abläuft.

somit hab ich schon mal garantiert, dass er die gesamte liste durchgeht und ich die liste jederzeit erweitern, verkürzen kann.


jetzt ist aber die frage, wie das ganze grafisch darstellen. wenn ne parallelschaltung nur aus 2 widerständen besteht, ist es ja noch einfach zu realisieren. aber wie krieg ich es hin, dass er es auch optisch gut hinbekommt, wenn ich z.b. eine parallelschaltung habe, die wiederum aus 2 weiteren parallelschaltungen besteht, die vielleicht wiederum aus jeweils einer serienschaltung besteht (als beispiel nur).

ich hab mir shcon bischn den anderen thread durchgelesen, aber so wirklich eine vorstellung habe ich noch nicht.

ich denke mir, dass die widerstände eine feste größe haben.
der rest ist wahrscheinlich irgendwie abhängig von der gesamtbreite und gesamthöhe des fenster, oder?

und ich hab ja jetzt vektoren in vektoren in vektoren...in einem großen vektor...wie kann ich schauen, ob in diesem gesamtvektor bestimmte andere vektoren stecken (hier halt serien oder parallelschaltungen)?

Hoffe, ihr habt noch lust mir zu helfen...

 

[SlaterB]

wenn du den Thread gelesen hast, weißt du ja, für wie schwierig ich die Sache halte ,
richtig Tipps kann man daher dazu nicht geben, ein Anfänger kann sowas normalerweise nicht programmieren,

wenns dir jemand fertig verrät, nun gut, ich nicht

 

[diggaa1984]

hm also wie man da zeichnerisch das ganze schön anordnet mit nem algorithmus zu koppeln is einfach ma imho ne blöde aufgabe ^^ ... ich selbst muss auch nen stammbaum grafisch darstellen, der wenns geht auch aussieht wie einer, grobe vorstellung hab ich schon. abhängig von daten die mir da ne "ordnung" reinbringen, aber nen non-plus-ultra-universal-algorithmus gibts da sicher nich.

ich denke du solltest vielleicht pauschal Pro element (simpel wie widerstand) ne feste größe (höhe, breite) definieren, für parallel und reihenschaltung müsste das quasi rekursiv/iterativ wie auch immer geschehen. Wenn du ne parallelschaltung der art hast: Parallel{W1,Parallel{W3,Reihe{W4,W5}},W2} .. dann würdest die Höhe aller Teile berechnen, wobei das Teil auch ne Parallelschaltung sein könnte, was mich an nen Vorredner-post erinnert der meinte, das Widerständen wie auch Parallel und Reihe von der selben Oberklasse erben.

Ne klare, code-lastige Vorstellung kann ich grad nich liefern, da habsch grad keine zeit zu, aber vielleicht hilft das schon n stück

 

[Leox]

ja ich komm der sache immer näher. immerhin hab ich es schon so weit, dass wenn er ne parallelschaltung hat, er die symbole symmetrisch anordnet...so langsam aber sicher wirds was