Programmdesign

Diskutiere Programmdesign im Java Basics - Anfänger-Themen Bereich.
J

java_noob43

Das sind lokale Variablen und daher nur in dem Block der Variable gültig. Evtl. willst Du eine Instanzvariable nutzen oder so ....
Welche lokale Variable meinst Du in dem Code oben?


Ich dachte nach dem gleichen Schema in einem anderen Code ein Objekt erzeugt zu haben und kann dort aus dem Main auf das Objekt car1 zugreifen.


Code:
public class Program {

    public static void main(String[] args) {

        Car bmw = new Car();
        Car car1 = new Car("grün", "VW", 130);
        bmw.setColour("pink");
        car1.drive(39);
        System.out.println(car1.getColour());
        System.out.println(bmw.getColour());
    }
   

}
Code:
public class Car {

    //Attribute/Eigenschaften
    private String colour; // Farbe
    private String brand; // Marke
    private int horsePower; // PS-Zahl
   
    public Car() {};
   
    public Car(String colour, String brand, int horsePower) {
    this.colour = colour;
    this.brand = brand;
    this.horsePower = horsePower;
    }
   
    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
       
        this.colour = colour;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getHorsePower() {
        return horsePower;
    }

    public void setHorsePower(int horsePower) {
        this.horsePower = horsePower;
    }

    //Methoden
    public void drive(int speed)  {
        System.out.println("Das Auto fährt..." + speed + "km/h");
    }
    public void drive()  {
        System.out.println("Das Auto fährt...");
    }
   
    }
In dem Code mit dem Objekt trend1 dachte ich alles prinzipiell gleich zu machen - aber offensichtlich ist da ein Unterschied den ich nicht sehe und nciht verstehe :-(
 
Zuletzt bearbeitet:
J

JustNobody

Lokale Variablen werden in einem Codeblock deklariert und sind nur in diesem gültig. Wenn du einen Wert auch außerhalb der Methode nutzen willst, dann muss die Variable auch außerhalb deklariert werden.

die Variablen bmw und car1 sind also nur innerhalb main verfügbar.
 
J

java_noob43

mhm aus irgendeinem Grund nahm ich an Objekte existieren im Gegensatz zu Variablen (welche abhängig von der Sichtbarkeit und Ihrer deklaration sind) immer Global. Jetzt steh ich auf dem Schlauch wie ich dann die Objekterzeugung meiner trend1 und trend2 Objekte (innerhalb einer if bzw. if else Bedingung) außerhalb der Bedingung ansprechen kann?
 
J

JustNobody

Führen wir das einmal etwas aus:
Du hast in Java zwei Arten von Typen: Value Typen und Referenz Typen. Wenn wir dies visuell vorstellen wollen, dann ist das in etwa so wie: Zettel. Du kannst auf einen Zettel manche Dinge drauf schreiben. Das sind dann Value Typen. Aber manche Sachen passen da einfach nicht drauf. Wie kriegst du einen Hund auf den Zettel drauf? Da das nicht geht, gibt es die Referenzen. Das sind einfach Bindfäden. Wir binden also einen Bindfaden von dem Zettel bis zu dem Hund.

Nun hast Du aber noch den großen Aufräumer. Der rennt rum und schaut sich alles an. Und Alles, was keinen Bindfaden mehr zu einem Zettel hat, das räumt er weg. (Etwas stark vereinfacht. Ist etwas komplexer.)

Was sind dann lokale Variablen in z.B. einer Methode?
Die Methode weiß, was für Variablen Du in ihr nutzen willst und gibt dir dazu auch gleich die entsprechenden Zettel.
Sobald die Methode sich aber beendet, nimmt sie Die diese Zettel wieder weg! Und die Zettel sind auch fest mit der Methode verbunden. Du kannst diese also nicht weggeben.

Was Du aber machen kannst ist: Du kannst die Zettel nutzen für irgendwas. Also z.B. als Parameter für eine andere Methode. Aber die Zettel sind fest - die kannst Du nicht weggeben. Und die Methode hat an sich schon fertige Zettel dran gepappt. Also wenn Du einen zettel verwenden willst, wird da der Inhalt kopiert. Also wenn da auf dem Zettel in der Methode 5 steht, dann schreibt man auf den angepappten Zettel auch die 5. Wenn an einem Zettel ein Bindfaden war, dann spannt man einen weiteren Bindfaden - halt vom anderen Zettel hin zu z.B. dem Hund.

Also was machst Du da derzeit?
Du hast Zwei Zettel trend1 und trend2. Du erzeugst Auch Objekte und verbindest die mit diesen Zetteln. Aber dann ist die methode vorbei und die Zettel sind weg. Und dann kommt früher oder später (Wann genau ist nicht definiert) der Aufräumer und dann schmeißt er die beiden erzeugten Objekte auch weg.

Was Du also machen kannst, ist: Du nutzt Zettel, die irgendwo fest sind, was Du hast. Also z.B. Instanzvariablen. Wenn Du da dann solche Fäden spannst, dann sieht der Aufräumer die und schmeißt die auch nicht weg.

Und du kennst diese Zettel und kannst auf diese zugreifen.

Also ja: Die Objekte existieren "global". Aber Du brauchst immer eine Variable, um auf diese zuzugreifen.
 
J

java_noob43

Danke für die ausführliche Erklärung.
Leider verstehe ich den Kontext zu den Instanzvariablen nicht.

bspw.:

Code:
public class Trend {
    public int anfangsWert;
    public int letzterWert;
    public String type;
    public 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);
        }
}
Ich habe ein bischen rum gelsen und hatte das Verständnis gewonnen, dass die Instanzvariablen sind:
Code:
    public int anfangsWert;
    public int letzterWert;
    public String type;
    public String valid;
Um in Deinem Beispiel zu bleiben wäre das ja ein konkreter Zettel. Wie kann ich darin den Zustand von Objekten speichern, also bspw. von trend1 und trend2?
 
J

JustNobody

Ja genau. Das sind Instanzvariablen. Also wenn man in dem Beispiel mit denn Zetteln bleibt, dann hat man da zwei Zettel auf denen man eine Zahl schreiben kann und zwei Zettel, die einen Bindfaden hin zu einem String Objekt aufnehmen können.
Das ist also, was ein Objekt vom Typ "Trend" ausmacht.

Aber es ging ja nicht um die Klasse Trend, sondern darum, wo Du diese genutzt hast. Das war etwas, das wie folgt aussah:
Java:
public class SomeClass {
  public void someMethod() {
    // Lokale Variablen ...
    Trend trend1;
    Trend trend1;
    
    // Die Variablen sind nur hier in der Methode gültig!
  }
}
Das könnte man zu etwas wie dem machen:
Java:
public class SomeClass {
  // Instanz - Variablen ...
  Trend trend1;
  Trend trend1;

  public void someMethod() {
    
  }
}
Jetzt sind trend1 und trend2 Instanzvariablen und somit innerhalb jeder Instanz verfügbar. Also in einer Methode kannst Du trend1 und trend2 Werte zuweisen um diese dann in einer anderen Methode zu verwenden.
 
J

java_noob43


Danke das hat sehr geholfen - im Nachhinein logisch.

Ich habe weiter recherchiert und habe den Eindruck, dass ich men Problem Objekte zur Laufzeit erzeugen zu wollen mit einer Hashmap lösen könnte.

Ich habe mich mit der Hashmap beschäftigt und einerseits versucht Objekte vom Typ Auto zur Laufzeit zu erzeugen (klappt) und gezielt aufzurufen (klappt nicht).

Desweiteren habe ich versucht Code-Beispiele nachzuvollziehen (klappt nicht). Insgesamt habe ich also den Eindruck ich habe die hashmap leider noch nicht richtig verstanden zu haben :-(.

Könntest Du mir noch mal ein paar Denkanstöße geben?

Code:
import java.util.ArrayList;
import java.util.HashMap;

public class Programm {

public static void main(String[] args) {

      
      ArrayList<Integer> listeWerte = new ArrayList<Integer>();
      listeWerte.add(11);
      listeWerte.add( 13);
      listeWerte.add( 14);
      listeWerte.add(9);
      listeWerte.add(7);
      listeWerte.add( 6);
   
      for (int i =0; i < listeWerte.size(); i++)
      {
        
      if (listeWerte.get(i) !=13) {
      HashMap<String, Auto> trend = new HashMap<String, Auto>();
      trend.put(Integer.toString(i),new Auto());
      System.out.println("hashmap erweitert " + i);
    /*  trend.get(Integer.toString(1)).setColour("schwarz");
      System.out.println(trend.get(i).getColour());
      -> Ich verstehe leider meinen Denkfehler an der auskommentierten Stelle nicht.
      Wie kann ich die Einträge der Hashmap hier nach einzeln ansprechen?
      *
      */
      }
      }
    
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>();
    
      // Mapping string values to int keys
      hash_map.put(10, "Geeks");
      hash_map.put(15, "4");
      hash_map.put(20, "Geeks");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You");

      // Displaying the HashMap
      System.out.println("");
      System.out.println("Initial Mappings are: " + hash_map);
      System.out.println("Hier verstehe ich nicht warum die Ausgabereihenfolge nicht [10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You] ist.");
    
    
      // Using keySet() to get the set view of keys
      System.out.println("");
      System.out.println("The set is: " + hash_map.keySet());
      System.out.println("Hier verstehe ich nicht warum die Ausgabereihenfolge nicht [10, 15, 20, 25, 30] ist.");


}
}
Code:
public class Auto {

    //Attribute/Eigenschaften
    private String colour; // Farbe
    private String brand; // Marke
    private int horsePower; // PS-Zahl
   
    public Auto() {};
   
    public Auto(String colour, String brand, int horsePower) {
    this.colour = colour;
    this.brand = brand;
    this.horsePower = horsePower;
    }
   
    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }
}
 
J

JustNobody

HashMap ist gut, wenn Du Values einem Key zuordnen willst. Aber hast Du denn wirklich einen Key? Oder hast nur eine Abfolge von Werten, so dass da eine List (z.B. ArrayList) besser geeignet wäre?

Und wenn Du eine neue Instanz von Auto erzeugst, dann ist es ok, diese abzuspeichern. Aber um dann noch Attribute zu ändern, würde ich diese nicht ständig aus der HashMap heraus holen. Du hast sie ja eben erst erzeugt...

Also typische Szenarien sind da eigentlich immer:
- Instanz in lokaler Variable erzeugen
- Instanz aufbereiten zur Speicherung (Also da alles zu setzen, was Du setzen willst)
- Instanz abspeichern.
Man kann hier natürlich teilweise die Reihenfolge verändern. Also so wie Du es gemacht hast: erst speichern und dann etwas verändern. Das kann funktionieren aber es ist vom Vorgehen her unlogisch und funktioniert auch nur, wenn
- die Referenz gesichert wurde
- der hashCode keine Rolle beim (wieder-) finden spielt.

Ein Beispiel wo es z.B. nicht funktioniert wäre ein speichern in eine Datei.

Und statt int -> String wäre evtl int -> Integer besser, so dies wirklich der Key ist. Dann muss da weniger berechnet werden, denn den Hashcode hast Du ja direkt....

Und Denkfehler ist einfach: Du hast da den Wert i genommen als Key. War den i wirklich 1? Die Schleife fängt ja z.B. bei 0 an....
 
J

java_noob43

HashMap ist gut, wenn Du Values einem Key zuordnen willst. Aber hast Du denn wirklich einen Key? Oder hast nur eine Abfolge von Werten, so dass da eine List (z.B. ArrayList) besser geeignet wäre?
Mein Problem (war) die zur Laufzeit generierten Objekte zu finden.
Ich hatte mir das so vorgestellt, dass ich den key aus einer Variable erstelle und einfach solange um eins inkrementiere wie Objekte zur Laufzeit des Programms erstellt werden - ich füge dann also jedes Objekt mit einem inkrementierendem Key der hashmap hinzu.
Dann kann ich in anderen Schritten des Programms die Hashmap nach den zur Laufzeit erstellten Objekten durchsuchen und in diesen Objekten dann die Eigenschaften verändern.

Mir dient die Hashmap also nur dazu eine Referenzliste über alle zur Laufzeit erstellten Objekte von bestimmten Klassen zu erhalten.

Ich habe dafür jetzt eine Lösung gefunden :)

Code:
import java.util.ArrayList;
import java.util.HashMap;

public class Programm {

public static void main(String[] args) {

        
      ArrayList<Integer> listeWerte = new ArrayList<Integer>();
      listeWerte.add(11);
      listeWerte.add( 13);
      listeWerte.add( 14);

     
      HashMap<Integer, Auto> trend = new HashMap<Integer, Auto>();
      for (int i =0; i < listeWerte.size(); i++)
          {
          trend.put(i,new Auto());
          System.out.println("hashmap erweitert " + i);
          }
      
      Auto obj = trend.get(1);
      System.out.println(obj.getColour());
      obj.setColour("schwarz");
      System.out.println(obj.getColour());
      
      System.out.println("_________________________");
    
      
      
      
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>(); 
      
      // Mapping string values to int keys 
      hash_map.put(10, "Geeks"); 
      hash_map.put(15, "4"); 
      hash_map.put(20, "Geeks"); 
      hash_map.put(25, "Welcomes"); 
      hash_map.put(30, "You"); 

      // Displaying the HashMap 
      System.out.println("");
      System.out.println("Initial Mappings are: " + hash_map); 
      System.out.println("Frage 1: Hier verstehe ich nicht warum die Ausgabereihenfolge {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4} ist und nicht 10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You ist.");
      
      
      // Using keySet() to get the set view of keys 
      System.out.println(""); 
      System.out.println("The set is: " + hash_map.keySet()); 
      System.out.println("Frage 2: Hier verstehe ich nicht warum die Ausgabereihenfolge [20, 25, 10, 30, 15] ist und nicht [10, 15, 20, 25, 30] ist.");
}

}
An dem Code versteh ich zum hash_map und hash_map.keySet() jetzt leider folgendes nicht:
Frage 1: Ich verstehe nicht warum die Ausgabereihenfolge {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4} ist und nicht 10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You ist.
Frage 2: Ich verstehe nicht warum die Ausgabereihenfolge [20, 25, 10, 30, 15] ist und nicht [10, 15, 20, 25, 30] ist.");
 
J

JustNobody

Mein Problem (war) die zur Laufzeit generierten Objekte zu finden.
Ich hatte mir das so vorgestellt, dass ich den key aus einer Variable erstelle und einfach solange um eins inkrementiere wie Objekte zur Laufzeit des Programms erstellt werden - ich füge dann also jedes Objekt mit einem inkrementierendem Key der hashmap hinzu.
Dann kann ich in anderen Schritten des Programms die Hashmap nach den zur Laufzeit erstellten Objekten durchsuchen und in diesen Objekten dann die Eigenschaften verändern.

Mir dient die Hashmap also nur dazu eine Referenzliste über alle zur Laufzeit erstellten Objekte von bestimmten Klassen zu erhalten.
Also hast Du keinen Key und generierst Dir künstlich irgendwas ... Dann nimm doch eine ArrayList - da hast Du den Zugriff über den Index des hinzugefügten Elements.

Ich habe dafür jetzt eine Lösung gefunden :)

Code:
import java.util.ArrayList;
import java.util.HashMap;

public class Programm {

public static void main(String[] args) {

       
      ArrayList<Integer> listeWerte = new ArrayList<Integer>();
      listeWerte.add(11);
      listeWerte.add( 13);
      listeWerte.add( 14);

    
      HashMap<Integer, Auto> trend = new HashMap<Integer, Auto>();
      for (int i =0; i < listeWerte.size(); i++)
          {
          trend.put(i,new Auto());
          System.out.println("hashmap erweitert " + i);
          }
     
      Auto obj = trend.get(1);
      System.out.println(obj.getColour());
      obj.setColour("schwarz");
      System.out.println(obj.getColour());
     
      System.out.println("_________________________");
   
     
     
     
      HashMap<Integer, String> hash_map = new HashMap<Integer, String>();
     
      // Mapping string values to int keys
      hash_map.put(10, "Geeks");
      hash_map.put(15, "4");
      hash_map.put(20, "Geeks");
      hash_map.put(25, "Welcomes");
      hash_map.put(30, "You");

      // Displaying the HashMap
      System.out.println("");
      System.out.println("Initial Mappings are: " + hash_map);
      System.out.println("Frage 1: Hier verstehe ich nicht warum die Ausgabereihenfolge {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4} ist und nicht 10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You ist.");
     
     
      // Using keySet() to get the set view of keys
      System.out.println("");
      System.out.println("The set is: " + hash_map.keySet());
      System.out.println("Frage 2: Hier verstehe ich nicht warum die Ausgabereihenfolge [20, 25, 10, 30, 15] ist und nicht [10, 15, 20, 25, 30] ist.");
}

}
An dem Code versteh ich zum hash_map und hash_map.keySet() jetzt leider folgendes nicht:
Frage 1: Ich verstehe nicht warum die Ausgabereihenfolge {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4} ist und nicht 10=Geeks, 15=4, 20=Geeks, 25=Welcomes, 30=You ist.
Frage 2: Ich verstehe nicht warum die Ausgabereihenfolge [20, 25, 10, 30, 15] ist und nicht [10, 15, 20, 25, 30] ist.");
Die Keys sind ein Set, also eine Menge. Da ist keine Reihenfolge. Wenn Du Elemente in einer Reihenfolge hast, dann verwende entsprechende Datentypen.
 
J

java_noob43

Also hast Du keinen Key und generierst Dir künstlich irgendwas ... Dann nimm doch eine ArrayList - da hast Du den Zugriff über den Index des hinzugefügten Elements.
Die Keys sind ein Set, also eine Menge. Da ist keine Reihenfolge. Wenn Du Elemente in einer Reihenfolge hast, dann verwende entsprechende Datentypen.

Eigentlich haben die Daten keine Reihenfolge. Ich konnte bloß das Beispiel nicht nachvollziehen. Nachdem Du den Mengenbegriff nochmal in den Vordegrund geschoben hast macht das natürlich Sinn. Vielen Dank!


Da ich die Objekte nur ablegen muss und gedenke anschließend durch die kompletten Werte mit einer Schleife zu laufen, um je Objekt ein Objektattribut aufzurfen und zu vergleichen frage ich mich ob die Hashmap oder die arraylist geeigneter ist. Reihenfolge hilft mir aufgrund des Dateninhalts und weiteren Programmablaufs nicht.

Die Schleife zum Aufruf der Objekte und der Werte-Vergleich wird allerdings in verschiedenen Speilarten sehr häufig vorkommen und es sind ca. 20.000 Elemente in der Liste. Ich stelle mir daher die Frage ob es performanter ist eine Arraylist zu nehmen oder eine Hashmap (in dr ich den key selber hochzählen würde)?
 
J

JustNobody

Eine Map besteht aus Key/Value Paaren ... scheinst Du nicht zu haben....
Dann gibt es die Liste - da kann man Dinge rein stopfen und sie behalten die Reihenfolge ...
Dann gibt es Sets - da ist die Reihenfolge egal.

Wenn die Reihenfolge egal ist, dann würde ich mich mal bei den Sets umschauen. Wobei es ja auch nicht schadet, wenn die Reihenfolge weiter sicher gestellt ist, daher kannst Du auch bei der List bleiben.
 
mrBrown

mrBrown

Dann gibt es Sets - da ist die Reihenfolge egal.

Wenn die Reihenfolge egal ist, dann würde ich mich mal bei den Sets umschauen.
Wobei es auch Sets gibt, die die Reihenfolge behalten (LinkedHashSet zB), relevantere Eigenschaft von Sets dürfte das nicht-erlauben von Duplikaten sein.
 
J

java_noob43

Danke.

Jetzt komme ich endlich gut voran.
Habt ihr noch einen Tipp wie man einem Objekt, dass eine arraylist als attribut hat, einzeln werte in die arrayliste anfügen kann?

Code:
obj.setListeBreakValues(1.2);
schmeißt der Compiler
"The method setListeBreakValues(ArrayList<Float>) in the type Trend is not applicable for the arguments (Float)"

Setter in der Klasse des Objekts:
Code:
    public void setListeBreakValues(ArrayList<Float> listeBreakValues) {
        this.listeBreakValues = listeBreakValues;
    }

In der Klasse, welche das Objekt erstellt habe ich die Liste wie folgt deklariert:
Code:
private ArrayList<Float> listeTouchValues = new ArrayList<Float>();

Offensichtlich passt der setter nicht zur Liste.
Ich möchte aber eigentlich nicht einen Wert in der Arrayliste überschreiben, sondern dort mehrere hinzufügen.
Wie kann man da ordentlich hinkommen?
Ich hatte die Hoffnung, dass ich add nehemn kann, aber das bietet mir die Entwicklungsumgebung nicht mal an :-(
 
J

JustNobody

Statt einem Setter kannst du eine add Methode schreiben, die dann das Element hinzu fügt.
 
J

java_noob43

Statt einem Setter kannst du eine add Methode schreiben, die dann das Element hinzu fügt.
Der Tip hat geholfen.

Gibts ne Möglichkeit den Namen einer Array-List aus einer Variable auszulesen und darauf dann bspw. per .get zuzugreifen?
 
W

White_Fox

Ja, das nennt sich Reflexion.


Es ist aber mit Vorsicht zu genießen und durchaus etwas umständlich. Ich halte es für sehr wahrscheinlich, daß es für dein Problem eine bessere Lösung gibt.
 
J

java_noob43

Ok. Danke. Ich seh schon mehr Kontext würde helfen.

Also ich habe eine Methode die aus einer Array-Liste Objekte nimmt und damit etwas macht.
Den im wesentlichen gleichen Code der Methode muss ich auch auf die Objekte des gleichen Typs in diversen anderen Array-Listen anwenden.
Mit künftiger Weiterentwicklung des Programmes werden weitere Array-Listen die von der gleichen Methode zu verarbeiten sind zu behandeln sein.

Jetzt möchte ich natürlich nicht die Methode x-mal kopieren und darin jeweils nur hart die unterschiedlichen Array-listen vedrahten und ein paar andere Sachen ändern die Abhängig von der Array-list dsind und mich bei jeder Arraylisten-Erweiterung wieder dadurchquälen alle Abhängigkeiten richtig zu ändern und aufwändig zu testen.

Statt dessen habe ich mir überlegt an einer zentralen Stelle zu pflegen, welche Array-Listen-Namen es gibt - und die anderen Sachen (die anderen Parameter lass ich der einfachheit halb mal weg, da wenn ich die Lösung für das eine Problem kenn dieselbe Lösung auch darauf anwendbar sein wird).
Ich möchte die Methode dann so ändern, dass ich diese ohne Angabe der Array-Liste aufrufe kann und innerhalb der Methode dann in einer Schleife Array-Listen-Namen zuweise, mit dennen die Methode dann ihren Code ausführt.

Der fehlende Teil dazu ist gerade, wie kann ich eine Variable mit einem Befehl verketten.

Beispiel hart verdrahtet als pseude code:
Code:
ArrayList<Extreme> listOfHighExtemeValues= new ArrayList<Extreme>();
ArrayList<Extreme> listOfHLowExtemeValues= new ArrayList<Extreme>();

for (int i = 0, i < listOfHighExtemeValues.size(), i++)
{
listOfHighExtemeValues.get(i).AndereMethodeaufrufen();
}


for (int i = 0, i < listOfHLowExtemeValues.size(), i++)
{
listOfHLowExtemeValues.get(i).AndereMethodeaufrufen();
}

// die for-Schleife siehe oben müsste dann für jede weitere Liste vom Typ Extreme kopiert und angepasst werden
Vorstellung generischer pseudocode:
Code:
ArrayList<Extreme> listOfHighExtemeValues= new ArrayList<Extreme>();
ArrayList<Extreme> listOfHLowExtemeValues= new ArrayList<Extreme>();

//folgendes würde ich dann an zentraler Stelle einmalig pflegen
ExtremValueNames.add("listOfHighExtemeValues");
ExtremValueNames.add("listOfHLowExtemeValues");

//Hier dann schön generisch
for (int index = 0; index < ExtremValueNames.size(); index ++)
{
String c = ExtremValueNames.get(index);

for (int i  = 0, i < c.size(), i++)
{
c.get(i).AndereMethodeaufrufen();
}
}
Oder gibts da ne bessere Lösung für als, das was ich mir unter generischer Pseudocode skizziert habe?
 
J

JustNobody

Wenn nur die Array Liste unterschiedlich ist, dann gib die als Parameter an die Methode.
Wenn eine Methode unterschiedlich ist (z.B. unterschiedliche Getter für einen Wert), dann kannst du das auch als Parameter übergeben....

Aber ich verstehe derzeit nicht, was das eigentliche Problem ist. Evtl. kannst du ja mal zwei Methoden/Klassen zeigen ....

Wenn es um ein Verhalten in unterschiedlichen Klassen geht, dann könnte man das auch in einer eigenen Klasse Kapseln. Das ginge dann etwas Richtung Strategy Pattern, das auch ein Verhalten kapselt (auch wenn es hier etwas anders gelagert ist, da es nicht nur um ein Verhalten geht so wie ich es verstanden habe ...)
 
J

java_noob43

Wenn nur die Array Liste unterschiedlich ist, dann gib die als Parameter an die Methode.
Die Listen an die Methode
Code:
 AndereMethodeaufrufen()
zu übergeben habe ich mir auch gedacht - siehe Beispiel. Ich möchte allerdings erreichen, dass ich nicht für jede neue Liste die ich dem Programm hinzufüge einen seperaten Aufruf der Methode mit der neu hinzugefügten Liste schreiben muss.
Code:
ArrayList<Extreme> listOfHighExtemeValues= new ArrayList<Extreme>();
ArrayList<Extreme> listOfHLowExtemeValues= new ArrayList<Extreme>();

//folgendes würde ich dann an zentraler Stelle einmalig pflegen
ExtremValueNames.add("listOfHighExtemeValues");
ExtremValueNames.add("listOfHLowExtemeValues");

//Hier dann schön generisch
for (int index = 0; index < ExtremValueNames.size(); index ++)
{
String c = ExtremValueNames.get(index);

for (int i  = 0, i < c.size(), i++)
{
c.get(i).AndereMethodeaufrufen();
}
}

Statt dessen möchte ich, dass das Programm die Methode solange aufruft wie ich in einer Liste der Listennamen
Code:
 ExtremValueNames
, Listennamen angegeben habe. Dazu habe ich mir soetwas wie oben überlegt, also der Variable c eine Listennamen aus der Liste der Listennamen zu übergeben und mi diesem dann die Methode aufzurufen. Es harkt jetzt daran, dass ich nicht weiß wie ich den der Variable c zugewiesenen Listennamen mit ".get(i).AndereMethodeaufrufen();" so verknüpfen kann, dass der Compiler
Code:
 c.get(i).AndereMethodeaufrufen();
als
Code:
  ExtremValueNames.get(i).AndereMethodeaufrufen()
interpretiert.


Aber ich verstehe derzeit nicht, was das eigentliche Problem ist. Evtl. kannst du ja mal zwei Methoden/Klassen zeigen ....
Die Methode
Code:
 AndereMethodeaufrufen
verändert das Objekt das die Methode aufruft.
Im Wesentlichen ist die Methode
Code:
 AndereMethodeaufrufen
eine Mastemethode, welche diverse Vergleiche und Operationen durchführt und abhängig von den Ergebnissen unterschiedliche Verzweigungen durchläuft in dennen sie wiederum andere Methoden aufruft.


Hilft das?
 
Thema: 

Programmdesign

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben