Programmdesign

Hi,

ich habe mich jetzt seit ein paar Wochen damit beschäftigt wie ich ein bestimmtestes Problem lösen kann und mir Grundkenntnisse der Programmierung angeeignet.
Nach diversem hin und herumprobieren möchte ich das Ganze jetzt strukturiert angehen und vor dem runter-coden (was sicher bei mir sicher sehr lange dauern wird) sicherstellen, dass die Programmstruktur und die Nutzung der Objektorientierung sinnvoll erfolgt und ich mich nicht vermeidbar verrenne.

Ich würde mich deshalb über etwas Input von erfahrenen Entwicklern zu folgendem Vorhaben freuen - da es mir sowohl an Programmierkenntnissen als auch an Erfahrung fehlt :rolleyes:.

Ich möchte in Roh-Daten vordefinierte Muster (vereinfacht: geometrische Figuren) suchen. Dann möchte ich zu den Mustern verschiedene Umgebungsvariablen zum Zeitpunkt des Auftretens des Muster untersuchen, um festzustellen welche Umgebungsvariablen sich bei welchen Mustern dazu eignen ein gutes Prognosemodell erstellen. Das geht ganz gut mit Statistik leider - habe ich nur Rohdaten, die Musterdefinition und diverse Theorien zu den relevanten Umgebungsvariablen die ich erst validieren muss.
D. h. mein zu lösendes Problem ist es aus den Rohdaten zunächst die Muster zu identifizieren und dann ebenfalls aus den Rohdaten und Mustern die Umgebungsvariablen zu erstellen. Erst anschließend kann ich statistische Methoden anwenden – die stat. Methoden sind für meine Anfrage unerheblich.

Der Roh-Datenpool umfasst ca. 20.000 Datenpunkte mit 6 Eigenschaften (Float und date).

Bei den Überlegungen dazu, wie die Muster (Vereinfacht: bspw. Rechteck, Dreiecke, …) zu erkennen sind habe ich mir einen Algorithmus überlegt, der zunächst darin besteht in allen Rohdaten die allgemeingültigen Teile der Muster zu identifizieren (vereinfacht Linien: nach rechts Linie, nach links absteigende Linie, horizontale Linie, …).
Ich möchte die Daten jeweils durch verschiedene Methoden jagen, die dann feststellen ob es Datenpunkte gibt die sich zu einem oder mehreren bestimmten Linientyp zuordnen lassen.

Meine Überlegung ist es nach der Identifikation eines Linientyps eine Klasse zu schreiben, welche die entsprechende Linienobjekte zu den Datenpunkten erzeugt.
Für jede identifizierte Linien soll dann noch ihre Güte in dem erzeugte Linienobjekt gespeichert werden – diese ist erforderlich um später die tolerierbare Ausreißerempfindlichkeit bzw. die tolerierbare dicke für eine Linie für das Prognosemodell bestimmen zu können.
Es wird je Linientyp n Ausprägungen geben.

Dann möchte ich prüfen, ob es Linien gibt die hinsichtlich Ihrer Lage die Bedingungen zur Klassifikation eines Musters (bspw. vereinfacht Rechteck) erfüllen. D. h. ich jage jetzt alle Linienobjekte durch verschiedene Methoden die dazu dienen die verschiedenen Muster zu identifizieren. Für jedes identifizierte Muster würde ich wiederum ein Objekt erzeugen und dazu die Eigenschaften aus den Linienobjekten übernehmen (bspw. Größe des Dreiecks, Anzahl der Ausreißer,….).
Theoretisch kann ein Muster Teil eines anderen Musters sein.


Ich habe mir eine Liste mit allen Datenpermutationen erstellt und bin mir ziemlich sicher, dass der Algorithmus an sich funktionieren sollte, was man schöner machen sollte würde mich natürlich dennoch interessieren.
  • Was sollte ich in der Designphase noch berücksichtigten?
Kurz-Form angedachter Programmaufbau:
  1. Main-Klasse
  2. importiert Rohdaten ein
  3. Analysiert Datenpunkte und identifiziert darin vordefinierte Linientypen
  4. Erzeugt alle identifizierten Linienobjekte
  5. Analysiert Linienobjekte und identifiziert darin vordefinierte Mustertypen
  6. Erzeugt alle identifizierten Musterobjekte und verschmilzt die Eigenschaften der zugrunde liegenden Linienobjekte
  7. Exportiert die Musterobjekte
  • Ist die Struktur des Programms unter den beschriebenen Bedingungen und insbesondere die Verwendung der angedachten Objekte sinnvoll?
 
Irgendwie nicht so richtig verständlich.

Punkte sind doch 0-dimensional. Wie können Sie dann Linien enthalten?

Ist das für dich selbst überprüfbar, was das Programm machen soll?

Kannst du mal ein Beispiel bringen, was du genau machen willst?
 
Danke das Du dich trotzdem durchgewühlt hast.
Ich baue mal ein "einfaches" Programmbeispiel, dann ist es wahrscheinlich einfacher ein Feedback zu geben.
Wenn es doof konzipiert ist habe ich hinterher bestimmt trotzdem was gelernt :)
Das wird wahrscheinlich ein bisschen dauern.
 
Nach diversem hin und herumprobieren möchte ich das Ganze jetzt strukturiert angehen und vor dem runter-coden (was sicher bei mir sicher sehr lange dauern wird) sicherstellen, dass die Programmstruktur und die Nutzung der Objektorientierung sinnvoll erfolgt und ich mich nicht vermeidbar verrenne.
Lies etwas über Entwurfsmuster und versuche, es zu verstehen. Dekoratormuster, Beobachtermuster, Commandmuster, Adaptermuster, usw. Zum Schluß MVC. Ich kann dir das Buch "Entwurfsmuster von Kopf bis Fuß" wärmstens empfehlen.

Danach: einfach anfangen. Ein Versionskontrollsystem ist dein Freund.
Ich habe mich seit Ende letzten Jahres mit dergleichen Thematik herumgeschlagen und nach etwa einem halben Jahr das Ganze so gehabt wie ich es haben wollte. Ich habe bis dahin bestimmt drei Mal alles bis auf wenige Basisklassen alles gelöscht und wieder von vorn angefangen.
Ein ganz normaler Lernprozeß...
 
Danke für Eure Antworten. Ich glaube ich bin meine Problembeschreibung viel zu global und kompliziert angegangen.

Ich versuch mal einen Neustart - vergesst einfach mein Ursprungsbeitrag.
Auf Basis diverser Rohdatenprüfmethoden möchte ich aus Rohdaten dynamisch Objekte erzeugen, während das Programm die Rohdaten (liegen aktuell als String Array vor - die Datenkonvertierung sollte nicht das Problem sein) Datensatz für Datensatz durchläuft.

Die Rohdatenprüfmethoden können dazu führen, dass bei der Prüfung eines neuen Rohdatensatzes einem zuvor erzeugen Objekt weitere Daten hinzugefügt werden müssen.

Die Objekte sollen Daten vom Typ Float und Date enthalten.

Mein aktuelles Problem ist wie ich dynamisch Objekte erezugen, die unterschiedlich viele Daten beinhalten.
Ich habe schon rumgelesen und habe den Eindruck ich müsste dazu eine Art von Listen verwenden.
Mir ist jedoch nicht klar, wie ich gleichzeitig in einer Liste Objekte halten kann, denen wiederum unterschiedlich viele Datensätze zugeordnet sind. Kann man die Listen irgendwie Mehrdimensional gestalten?

Als Beispiel wähle ich mal, dass Größenmessergebnisse zu unterschiedlichen Zeitpunkten vorliegen.
Meine Rohdatenprüfmethoden erlauben mir einzelne Menschen zu identfizieren und diese möchte ich als Objekt erstellen und jedem dieser Menschen weitere aus meinen Rohdatenprüfmethoden abgeleitete Eigenschaften zuordnen.

Datum, Größe
2019-07-11 04-PM, 1.11
2019-09-11 05-PM, 1.12
2018-01-01 06-PM, 1.31
2019-01-05 07-PM, 1.42
2019-10-01 08-PM, 1.51

Nach Anwendung meiner Bedingungen ergibt sich, dass ich weiß (warum und wieso lass ich der EInfachheit halber mal weg)
Mensch 1
Wohlstand= reich
2019-07-11 04-PM, 1.11
2019-09-11 05-PM, 1.12

Mensch 2
Wohlstand= arm
2018-01-01 06-PM, 1.31
2019-01-05 07-PM, 1.42
2019-10-01 08-PM, 1.51
 
Mein aktuelles Problem ist wie ich dynamisch Objekte erezugen, die unterschiedlich viele Daten beinhalten.
Was heißt "unterschiedlich viele"? Sind die Attribute im Vorfeld nicht bekannt? Und wenn ja: was bringt das?

Grundsätzlich kannst Du natürlich dynamisch Daten in ein Objekt ablegen - mit einer Liste oder einer Map.

Mir ist jedoch nicht klar, wie ich gleichzeitig in einer Liste Objekte halten kann, denen wiederum unterschiedlich viele Datensätze zugeordnet sind.
Wieso sollen den Objekten Datensätze zugeordnet sein?

weitere aus meinen Rohdatenprüfmethoden abgeleitete Eigenschaften zuordnen.
Aber Du weißt doch, welche Eigenschaften das sind, oder nicht?

Entweder geht es hier um ein etwas ungewöhnliches Problem oder Du machst es zu kompliziert.
 
Was heißt "unterschiedlich viele"? Sind die Attribute im Vorfeld nicht bekannt? Und wenn ja: was bringt das?


Grundsätzlich kannst Du natürlich dynamisch Daten in ein Objekt ablegen - mit einer Liste oder einer Map.


Wieso sollen den Objekten Datensätze zugeordnet sein?


Aber Du weißt doch, welche Eigenschaften das sind, oder nicht?

Entweder geht es hier um ein etwas ungewöhnliches Problem oder Du machst es zu kompliziert.
Danke fürs wachrütteln.

Ich habe nochmal länger drüber nachgedacht. Ich denke es ist tatsächlich nicht erforderlich die Objekte mit unterschiedlich vielen Eigenschaften auszustatten - das wäre wohl eine sehr schlechte Struktur geworden.

Eigentlich reicht es für mein Objekt und die nachfolgenden Schritte im Programm die unterschiedlichen Ausprägungen zusammenzufassen. Also Erster Wert, letzter Wert, usw. damit haben dann alle Objekte die gleiche Anzahl von Eigenschaften und ich kann dennoch damit weiter arbeiten.

Leider hänge ich nun an einer anderen Stelle fest :-(.
Ich möchte zur Laufzeit bei der Analyse eines großen Roh-Datensatzes (liegt als ArrayList) vor, nachdem bestimmte Muster in dem Roh-Datensatz gefundenen wurden, Objekte erzeugen. Diesen neuerstellten Objekten möchte ich dann Eigenschaften zuweisen oder falls die Bedingungen es ergeben bestehende Objekte hinsichtlich Ihrer Eigenschaften aktualisieren.

Wie realisiert man am besten solche dynamische Objekterstellung?

Beispiel

Datenpunkt | Wert
1 | 100
2 | 101
3 | 99
4 | 101
5 | 105
6 | 101


Angenommen meine Musterbedinung würde sein, dass ich immer dann ein Objekt erzeuge möchte, wenn 3 aufeinanderfolge Datenpunkte jeweils einen höheren Wert als der vorherige aufweisen, wie kann man das konkret realisieren, dass die Objekte dynamisch erstellt werden?

In diesem speziellen Beispiel würde mein Erstes Objekt als Ersten Datenpunkt die 4 und als letzen Datenpunkt die 6 als Eigenschaften erhalten - weil ich das für folgende Schritte im Programmablauf benötige.

Es geht mir um dynamische Erzeugung des Objekts nicht um die Formulierung der Bedingungen meiner Mustererkennung - das ist nur ein vereinfachtes Beispiel ;-)
 
So richtig verstehe ich den Sinn noch nicht.

Nehmen wir mal an, ich habe eine Stechuhr, die mir eine Datei liefert, wo in jeder Zeile "Mitarbeiternummer, Datum/Zeit, Richtung" steht- also "123, 01.01.19, 8.00 PM, Z" bedeutet, dass Mitarbeiter nr. 123, zu der angegebenen Zeit den Bereich betreten hat. Nun kann ich also feststellen, dass es eine Anzahl Objekte der Klasse "Aufenthalt" gibt, die als Attribute, die Ankunft(Z ugang) und das Verlassen( W eggang) besitzt. Offensichtlich kann ich nun diese Objekte Objekten der Klasse "Mitarbeiter" zuordnen, so dass die Objekte der Klasse "Mitarbeiter" eine Liste aus Objekten der Klasse "Aufenthalt" beinhalten.

Kannst du das Problem, was du bearbeiten willst, an diesem Beispiel mal erklären? Und es zur Not so ausbauen, dass man nachvollziehen kannst, was du genau willst?
 
So richtig verstehe ich den Sinn noch nicht.

Nehmen wir mal an, ich habe eine Stechuhr, die mir eine Datei liefert, wo in jeder Zeile "Mitarbeiternummer, Datum/Zeit, Richtung" steht- also "123, 01.01.19, 8.00 PM, Z" bedeutet, dass Mitarbeiter nr. 123, zu der angegebenen Zeit den Bereich betreten hat. Nun kann ich also feststellen, dass es eine Anzahl Objekte der Klasse "Aufenthalt" gibt, die als Attribute, die Ankunft(Z ugang) und das Verlassen( W eggang) besitzt. Offensichtlich kann ich nun diese Objekte Objekten der Klasse "Mitarbeiter" zuordnen, so dass die Objekte der Klasse "Mitarbeiter" eine Liste aus Objekten der Klasse "Aufenthalt" beinhalten.

Kannst du das Problem, was du bearbeiten willst, an diesem Beispiel mal erklären? Und es zur Not so ausbauen, dass man nachvollziehen kannst, was du genau willst?
Irgendwie habe ich den Eindruck das Beispiel eignet sich nicht besonders gut für den Transfer meines Problems. Ich versuche mal die Unterschiede zu konkretisieren.
1. Meine Roh-Daten haben keine Mitarbeiternr., sondern nur einen Float-Werte und einen Zeitstempel. Es gibt pro Zeit nur einen Wert. Insofern könnte man dann vielleicht über die Zeit als Schlüßel gehen.
Mein Datensatz wäre eher
"01.01.19, 10.6"
"02.01.19, 11.6"
"03.01.19, 12.6"
"04.01.19, 10.6"
"05.01.19, 9.6"

Nehmen wir an eine Zeile repräsentiert die Arbeitszeit aller Mitarbeiter eines Unternehmens pro Werktag in Stunden.

2. Aus diesen Rohdaten möchte ich unterschiedliche Basis-Objekte erzeugen die bestimmten Basis-Bedingungen entsprechen.

Basis-Objekt1
Typ: Steigend
Max: 12,6
Stärke: 3 (Tage)
Startzeitpunkt: 01.01.19
Endezeitpunkt: 03.01.19

Basis-Objekt2
Typ: Fallend
Stärke: 3 (Tage)
Startzeitpunkt: 03.01.19
Endezeitpunkt: 05.01.19
Min: 9,6

Ich habe mir damit auf meine Rohdaten eine neue Perspektive erzeugt.

3. Mit dieser anderen Perspektive möchte ich dann im Programm weiterarbeiten, um verschiedene vordefinierte Thesen zu prüfen.

Die Thesen würde ich dann als Klasse implementieren.
Aus diesen Klassen würde ich dann Thesen-Objekte erzeugen, wenn es Basis-Objekte gibt welche die erforderlichen Bedinungen erfüllen.
Eine These könnte in Bezug auf Dein Beispiel sein auszuwerten, ob die Arbeitsstunden nach den unmittelbar hintereinander auftretenden Mustern vom Typ "fallend" und "steigend" einen Wert erreicht, dessen Maximum die Differenz zwischen Maximum und Minimum der Objekte 1 & 2 (max=12,6, min= 9,6 -> Differenz 3) ist.
In diesem Beispiel ergäbe sich Besipielsweise folgendes Thesen-Objekt (status am 05.01.19):

Thesen-Objekt

Typ: Next-Top
Erwarteter Wert: 3
Startzeitpunkt: 01.01.19
Wendezeitpunkt: 03.01.19
Endezeitpunkt: 05.01.19
Tatsächlicher Wert: NULL
Status: Inital

Der Eigenschaften des Thesenobjekts würden mit jedem neuen Rohdatensatz aktualisiert werden.
Als Status wären möglich Inital, bestätigt oder widerlegt.
Da der Rohdatensatz am 05.01.19 das Thesenobjekt erst erschaffen hat ist der Status inital.
Der tatsächliche Wert würde solange erhöht bis es Wert gibt, welcher unter dem Minimum von 9,6 liegt.


Anmerkung: Die Start-, Wende- Endezeitpunkte in den Objekten möchte ich speichern, um damit verknüpft aus den Rohdaten die Werte auslesen zu können und diese zu visualisieren.


Ich musste mich glaub ich recht weit von Deinem Beispiel entfernen und grübele noch darüber wie ich das besser beschreiben kann.

Hilft Dir das beim Verständniss?
 
In diesem speziellen Beispiel würde mein Erstes Objekt als Ersten Datenpunkt die 4 und als letzen Datenpunkt die 6 als Eigenschaften erhalten - weil ich das für folgende Schritte im Programmablauf benötige.
Die 6 verstehe ich ja noch, aber die 4?!? Die 99 aus der 3 ist doch niedriger als die 101 aus der 2 und die 100 aus der 1.

Ansonsten Ringbuffer mit 3 Elementen, Thema erledigt.
 
Nur um zu schauen, ob ich es richtig verstehe:

Du willst aus einer Serie von Elementen eine neue Serie von Elementen machen.
Dabei hast Du in so einem neuen Element:
- Typ: Steigend/Fallend
- Stärke: Anzahl der Elemente
- Start
- Ende
- min bzw max (In Abhängigkeit des Typs)

Und es ist nicht klar, wie viele Elemente in Aufsteigender oder Absteigender Folge kommen (Wenn das immer 3 wäre, dann müsstest Du den Counter nicht speichern, oder?)

Also da kannst Du Schritt für Schritt durch die Werte gehen. Am Anfang nimmst du die ersten zwei Werte obj1, obj2.

Typ ist am Anfang ASCENDING (obj1.value < obj2.value) oder DESCENDING
Startzeit ist timestamp obj1
Schwellwert ist obj2.value;
Counter ist 2
LetztesObjekt ist obj2

Dann gehst Du alle weiteren Elemente durch:
- Typ ist ASCENDING und obj.value ist größer/gleich Schwellwert oder DESCENDING und eben kleiner/gleich
==> Counter++, LetztesObjekt ist Obj
- Sonst:
==> Neues Objekt erstellen mit Counter, Schwellwert, Startwert, Endwert ist letztesObj.timestamp und Typ und speichern
==> Typ umsetzen, Counter = 2, Startzeit = LetzesObjekt.timestamp
- Schwellwert ist obj.value (Das immer machen!)
- LetztesObjekt = obj

So ein Algorithmus sollte das doch in etwa abhandeln. oder sehe ich das falsch?
 
Du willst aus einer Serie von Elementen eine neue Serie von Elementen machen.
Dabei hast Du in so einem neuen Element:
- Typ: Steigend/Fallend
- Stärke: Anzahl der Elemente
- Start
- Ende
- min bzw max (In Abhängigkeit des Typs)
genau.

Und es ist nicht klar, wie viele Elemente in Aufsteigender oder Absteigender Folge kommen (Wenn das immer 3 wäre, dann müsstest Du den Counter nicht speichern, oder?)
Im Prinzip ja - es ist nur leider noch komplexer.
Es gibt mehr als 2 Typen und ein Wert kann Ausgangspunkt für mehrere Elemente des gleichen und/oder verschiedener Typen sein.

Typ ist am Anfang ASCENDING (obj1.value < obj2.value) oder DESCENDING
Startzeit ist timestamp obj1
Schwellwert ist obj2.value;
Counter ist 2
LetztesObjekt ist obj2

Dann gehst Du alle weiteren Elemente durch:
- Typ ist ASCENDING und obj.value ist größer/gleich Schwellwert oder DESCENDING und eben kleiner/gleich
==> Counter++, LetztesObjekt ist Obj
- Sonst:
==> Neues Objekt erstellen mit Counter, Schwellwert, Startwert, Endwert ist letztesObj.timestamp und Typ und speichern
==> Typ umsetzen, Counter = 2, Startzeit = LetzesObjekt.timestamp
- Schwellwert ist obj.value (Das immer machen!)
- LetztesObjekt = obj
Also Dein Vorschlag ist, im main die Daten zu analysieren, die Elemente zu typisieren und dort einen counter mitlaufen zu lassen, den ich für die Erstellung jedes Elements verwende?

Wie kann ich einen Counter so in den Objektnamen einbinden, dass der sich der Objektname dynamisch erzeugen lässt?
Diese letzte Frage nehme ich aktuell als mein Hauptproblem war.
 
Also wo die Implementation wie zu finden ist, ist erst einmal dem Algorithmus egal. Aber ich würde generell davon absehen, irgendwas in main zu machen sondern ich würde generell zu einem objektorientierten Ansatz raten.

Was für weitere Typen gibt es? Ich hatte es so verstanden, dass das, was noch danach gekommen ist, dann die neu erstellten Instanzen benutzt. Aber generell kann der Vorgang auch weiter so umgesetzt werden. Ist aus meiner Sicht eine einfache Auswertung von Werten. Du hast einen Eingang, da kommt ein Wert nach dem anderen rein und daraus wird dann im Anschluss etwas gemacht. Ich habe sowas in der Vergangenheit "Eventbasiert" gemacht, d.h. Ich hatte einfach ein Objekt, das dann in einem Aufruf Werte entgegen genommen hat um diese dann zu verarbeiten. Wenn gewisse Dinge erfolgt sind, hat es dann andere Objekte informiert (die unbekannt sind, es war halt dann ein anderes Event).

Was Du mit "Counter im Objektnamen einbinden" meinst, verstehe ich nicht. Was für einen Objektnamen willst Du dynamisch erzeugen?
 
Ich finde immer noch, dass wir um den heißen Brei rumreden, solange wir nicht wissen, worum es geht.

Bis jetzt sehe ich nur eine Menge M mit m ( ist Element von M)={t,w1}, wobei t eine Zeit ist und e1 ein Wert. So kann ich nicht mal Intervalle festlegen, da mir dazu ein Indiz fehlt. also müsste m als m={id,t,w1) dargestellt werden. Diese Menge M wären die sogenannten Rohdaten und ein m wäre ein Rohdatensatz. Verbleibe ich bei m mit der obigen Festlegung, dann kann ich auch Teilmengen T, feststellen. Diese enthalten Elemente t mit i1 und i2, als Beginn und Ende des Intervalls, in dem eine Bedingung, formuliert als Satz s( s ist Element der Menge an Sätzen(Thesen) S), erfüllt wird. Das Element wäre also t={id,i1,i2,}. Nun muss man erst eine Beziehungsmenge B bilden, deren Elemente b die Teilmengen T(s)sind. Nun kann man eine Verkettungsmenge K bilden mit k={t,s}.

Damit erscheint aber die Erstellung neuer Werte wie in #6 nicht möglich. ( aus Längenwerten Vermögenslage feststellen).

Also gibbt es entweder noch weitere Werte. Sind die in m als Element von M enthalten. oder benutzt du noch eine
 
Vielen Dank für den Ansatz mit den Events.


Was für weitere Typen gibt es?
Im MvP 2.
Anschließend kommen dann noch 2-3 dazu je nachdem wie lange ich das betreibe ;-).

Ich hatte es so verstanden, dass das, was noch danach gekommen ist, dann die neu erstellten Instanzen benutzt.
Das ist korrekt.
Teilweise wird das Vorhandensein von 2 unterschiedlichen Elementen Bedinung dafür sein eine weiteres Element (These) zu erschaffen (Du meinst These = Instanz ?- ich möchte den Begriff der Instanz nicht vorschnell und falsch verwenden ).

Aber generell kann der Vorgang auch weiter so umgesetzt werden. Ist aus meiner Sicht eine einfache Auswertung von Werten. Du hast einen Eingang, da kommt ein Wert nach dem anderen rein und daraus wird dann im Anschluss etwas gemacht. Ich habe sowas in der Vergangenheit "Eventbasiert" gemacht, d.h. Ich hatte einfach ein Objekt, das dann in einem Aufruf Werte entgegen genommen hat um diese dann zu verarbeiten. Wenn gewisse Dinge erfolgt sind, hat es dann andere Objekte informiert (die unbekannt sind, es war halt dann ein anderes Event).
Ich habe mit Events noch gar keine Erfahrung und gar keine Kentniss, da werde ich jetzt mal recherchieren.

Was Du mit "Counter im Objektnamen einbinden" meinst, verstehe ich nicht. Was für einen Objektnamen willst Du dynamisch erzeugen?
Folgend mal ein Code-Beispiel (ich habe da jetzt nicht alle Bedingungen zu Ende programmiert), die Thesen konnte ich darin jetzt nicht unterbringen, weil ich auf meine Objekte nicht zugrifen kann wie ich das gerne möchte.
Der Compiler zeigt in den Zeilen in dennen ich die Objekte trend1 und trend2 erstelle die Meldung
"The value of the local variable trend1/2 is not used" an, obwohl die Println Anweisung aus der Objektklasse ausgeführt wird.
Was mach ich da falsch?

Code:
import java.util.ArrayList;


public class Program {
       static int currentValue;
       static int lastValue;
       static int valueBeforeLastValue;


          public static void main(String[] args) {
         
              //Timestamp-Beispiele erzeugen
              ArrayList<Integer> listeTimestamps = new ArrayList<Integer>();
              listeTimestamps.add(1);
              listeTimestamps.add(2);
              listeTimestamps.add(3);
              listeTimestamps.add(4);
              listeTimestamps.add(5);
           
             
              //Werte-Beispiele erzeugen
              ArrayList<Integer> listeWerte = new ArrayList<Integer>();
              listeWerte.add(12);
              listeWerte.add(13);
              listeWerte.add(14);
              listeWerte.add(9);
              listeWerte.add(7);

             
              //Schleife zum Durchlauf aller Rohdaten-Werte, um den Objekten Trend den das Attribut Typ (auf- oder absteigend) zuzuordnen
              for (int i =0; i < listeWerte.size(); i++) {                  
                   if (i == 0)       {
                             currentValue = listeWerte.get(i);  
                           }
                               
                   else if (i == 1) {
                       lastValue = currentValue;
                       currentValue = listeWerte.get(i);
                       }
                       
                   else if (i >= 2) {
                        valueBeforeLastValue = lastValue;
                        lastValue = currentValue;
                        currentValue = listeWerte.get(i);
                      
                        //Bedingung um den Typ aufsteigend zuzordnen
                        if (valueBeforeLastValue < lastValue && lastValue < currentValue == true){           
                           
                            //Erzeugen der Elemente/Objekte vom Typ aufsteigend
                            Trend trend1 = new Trend(valueBeforeLastValue, currentValue, "aufsteigend", "inital");

                            /* FRAGE: Mit jedem Durchlauf der übergeordneten for Schleife überschreibe ich hier aktuell mein Objekt trend1
                            Wie kann ich den Objektnamen dynamsich bilden?
                            Leider weiß ich nicht wie ich einen Objektnamen aus Variablen erzeuge kann :-(
                            Gibts dafür eine alternative Möglichkeit?
                            */
                        }
                       
                        //Bedingung um den Typ absteigend zuzordnen   
                        else if (valueBeforeLastValue > lastValue && lastValue > currentValue == true) { 
                              Trend trend2 = new Trend(valueBeforeLastValue, currentValue, "absteigend", "inital");
       
                        }
                     
                   }
                
       
                  }
              
           
             
                       
             
             
         }       
         

}
Code:
public class Trend {
    private int anfangsWert;
    private int letzterWert;
    private String type;
    private String valid;

     public Trend(int anfangsWert, int letzterWert, String type, String valid) {
        this.anfangsWert = anfangsWert;
        this.letzterWert = letzterWert;
        this.type = type;
        this.valid = valid;
        System.out.println("Gerade erstellt mit dem Anfangswert: " + anfangsWert + " Typ: "+ type + " Validity: " + valid);
        }

    public String getValid() {
        return valid;
    }

    public void setValid(String valid) {
        this.valid = valid;
    }

    public int getAnfangsWert() {
        return anfangsWert;
    }

    public int getLetzterWert() {
        return letzterWert;
    }

    public void setLetzterWert(int letzterWert) {
        this.letzterWert = letzterWert;
    }

    public void setTyp(String type) {
        this.type = type;
    }
}
 
Also bezüglich der "dynamischen Objektnamen": Du hast eine Applikation, und die muss mit den Daten etwas sinnvolles machen. Da erzeugt man nicht dynamisch weitere Variablen (So habe ich Dich jetzt verstanden). Und würde Dir auch nichts bringen, denn Du machst ja auch im Folgenden nichts mit den Daten (Was Dir der Compiler auch versucht hat, mitzuteilen).

Daher musst Du Dir als Entwickler überlegen, was mit den Daten weiter passieren soll. Typische Dinge sind da halt:
- Speichern für spätere Verarbeitung (Also z.B. in eine Datei oder im Speicher in einer Liste oder so ...)
- Direkt weiter geben, also sofort bearbeiten. Das ist, was ich mit Events meint, wobei das etwas .Net lastig ausgedrückt ist. Aber in Java wäre eine einfache Implementierung z.B. ein einfacher Consumer. Also könnte Deine Klasse Program eine Instanz vom Typ Consumer<Trend> haben und immer, wenn ein Trend erfolgreich erzeugt werden konnte, wird der Trend direkt an den Consumer weiter gegeben.

Die Idee ist halt nur, dass man die Abarbeitung in schöne kleine Happen aufteilt, von denen jeder für sich relativ einfach und unkompliziert ist und es nur minimale Abhängigkeiten zueinander gibt.
 
Also bezüglich der "dynamischen Objektnamen": Du hast eine Applikation, und die muss mit den Daten etwas sinnvolles machen. Da erzeugt man nicht dynamisch weitere Variablen (So habe ich Dich jetzt verstanden). Und würde Dir auch nichts bringen, denn Du machst ja auch im Folgenden nichts mit den Daten (Was Dir der Compiler auch versucht hat, mitzuteilen).

Daher musst Du Dir als Entwickler überlegen, was mit den Daten weiter passieren soll. Typische Dinge sind da halt:
- Speichern für spätere Verarbeitung (Also z.B. in eine Datei oder im Speicher in einer Liste oder so ...)
- Direkt weiter geben, also sofort bearbeiten. Das ist, was ich mit Events meint, wobei das etwas .Net lastig ausgedrückt ist. Aber in Java wäre eine einfache Implementierung z.B. ein einfacher Consumer. Also könnte Deine Klasse Program eine Instanz vom Typ Consumer<Trend> haben und immer, wenn ein Trend erfolgreich erzeugt werden konnte, wird der Trend direkt an den Consumer weiter gegeben.
Ich wollte keine Variablen bzw. Objekte zum Selbstzweck erstellen ;-).
Ich wollte auf die Trend1/2 Objekte mit zugreifen, um zu zeigen, was ich dann weiter damit machen möchte.
Allerdings funktioniert das leider nicht.
Bspw.:
Code:
System.out.println(trend1.getValid());
Der Compiler sag dazu "trend1 cannot be resolved"

Du hast natürlich recht die Compiler Meldung "The value of the local variable trend1/2 is not used" ist nur Symptom dessen, dass ich mit den Objeketen nichts mache und nicht Auslöser dafür, dass ich die Objekte nicht bspw. mit System.out.println(trend1.getValid()); nich ansprechen kann.

Kannst Du mir einen Typ geben, warum ich auf das Objekt trend1 in der Klasse Programm nach dessen Erstellung nicht zugreifen kann?
 
Das sind lokale Variablen und daher nur in dem Block der Variable gültig. Evtl. willst Du eine Instanzvariable nutzen oder so ....
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben