Klassen, die aufeinander verweisen (mit Generics)

Status
Nicht offen für weitere Antworten.

chetigol

Mitglied
Hi!

habe folgendes Problem: Habe zwei klassen, welche aufeinander verweisen sollen, dabei ist aber eine Klassenhirarchie von einer generischen Klasse abgeleitet. Jetzt bekomme ich es nicht hin, wie ich die Instanzen initialisieren soll, damit diese aufeinander verweisen sollen.

Hier mal das beispiel:

Code:
abstract class GeneratorGeneric<T extends ParameterGeneric> {

   T param;

  Generic( T param ) {
    this.param = param;
  }

  public setParam( T param ){
     this.param = param;
  }

  public abstract generate();
}


class GeneratorParamA extends GeneratorGeneric<ParamA> {

   T param;

  Generic( ParamA param ) {
    super(param)
  }

  public void generate()
  {
     .....
  }
}


class ParameterGeneric {
   GeneratorGeneric<?> generator;

   ParameterGeneric( GeneratorGeneric<?> generator ){
      this.generator = generator;

      // geht nicht, da Wildcard-Zugriff
      // this.generator.setParam( this );
   }

}

class ParamA {
 .....
 ......
}

Ich möchte beim Anlengen eines neuen Parametertyps ( zB.: new ParamA(....) ) im konstruktor den dazugehörigen Generator übergeben.
Mein Problem ist, dass der Generator auch vom Parameter wissen muss. Jetzt möchte ich alles in einem schritt erledigen, d.h. ich wollte im Konstruktor vom ParameterGeneric die setParam funktion des übergebenen Generators ausführen, was natürlich nicht funktioniert, da es eube Wildcard-Referenz ist!

Ich möchte soetwas, wie:

p = new Param
g = new Generator

p.setGenerator(g)
g.setParam(p)

verhindern und das alles, was nöti ist mehr oder weniger automatisch passiert!

könnt ihr mir da weiter helfen? irgendwelche vorschläge, wie man soetwas machen kann?

danke!
 

schalentier

Gesperrter Benutzer
Wie waere es damit:

Code:
public interface Generator {
   public void generate();
}
Code:
public interface Parameter {
   public void setGenerator( Generator g );
}

Code:
public class GeneratorParamA implements Generator {
   ParamA param;
   public GeneratorParamA( ParamA p ) { 
      param = p; 
      if( p!=null ) { p.setGenerator( this ); }
   }

   public void generate() { ... }
}
Code:
public class AbstractParameter implements Parameter {
   Generator generator;
   public void setGenerator( Generator g ) { generator = g; }
}
 

chetigol

Mitglied
hmm...daran hab ich garnicht gedacht, da ich irgendwie darauf fixiert war, dass der Generator einem Parameter zugewiesen wird und nicht umgekehrt.
wäre mir eigentlich auch lieber, aber wenn es nicht anders geht, dann muss ichs wohl so machen!

müsste halt die Generator-Klasse aber Generisch bauen:

Code:
public abstract class GenericGeneratorParam implements Generator <T extends Parameter> {
   T param;

   public GenericGeneratorParam ( T p ) {
      param = p;
      if( p!=null ) { p.setGenerator( this ); }
   }

   abstract void generate();
}

und von dieser erst die spezialisierten klassen:

Code:
public abstract class GeneratorParamA extends Generator<ParameterA> {

  public GeneratorParamA( ParameterA p ) {
      super( p )
   }

  public void generate()
  {
   // zugriffe auf das Objekt ParameterA
  }

}

werd ich halt in die umgekehrte richtung instanzieren müssen! Irgendwie fällt mir keine Alternative ein. Danke für den Vorschlag!
 

chetigol

Mitglied
ha, habe eine andere Lösung gefunden! Denke, dass sie funktionieren sollte! Dabei kann ich meine erste Klassenstruktur verwenden!

Den Konstruktor der GenericParameter - Klasse kann ich ja parametrierbar bauem, dadurch erspare ich mir hier die Wildcards und ich kann direkt auf das Generator-Object (egal welche Ableitung) zugreifen:

Code:
class ParameterGeneric {
   GeneratorGeneric<?> generator;

   <T extends GeneratorGeneric> ParameterGeneric( T generator ){
      this.generator = generator;

      // diesmal sollte der Zugriff funktionieren, da nicht über wildcards!
      generator.setParam( this );
   }

}

soviel zur theorie, schauma, obs funktioniert!

Es war mir wichtig, dass die Parameter eigentlich die Generatoren aufnehmen, da ich mir den Weg offen lassen möchte, mehrere Generatoren unterschiedlichen Typs installieren zu können (dynamisch)!



EDIT: zufrüh gefreut! <T extends GeneratorGeneric> muss (sollte) ich ja auch parametrieren! sonst arbeit ich ja mitm RawType
 

schalentier

Gesperrter Benutzer
Das geht auch bei meinem Ansatz, sorum.

Code:
public abstract class AbstractParameter implements Parameter {
   Generator generator;
   protected AbstractParameter( Generator g ) {
      generator = g;
      if( g!=null ) { g.setParameter( this ); }
   }
}

Ueberleg bitte, ob du wirklich (WIRKLICH) das alles unbedingt mit generischen Parametern machen musst. Das ganze wird nicht einfacher, wenn du es so durchziehst. IMHO leidet die Lesbarkeit extrem, der Vorteil ist verschwindend gering - und die potentielle Gefahr steigt, dass du jegliches OOP Design im Kern erstickst.

Schoen zu sehen in deinem letzten Post. Du hast eine Methode (in diesem Fall ein Konstruktor), der du ein Argument uebergibst. Der Typ ist T und T leitet von GeneratorGeneric ab - das brauchst du nur, damit du T#setParam() aufrufen kannst. Wozu? Uebergib doch gleich den Typ GeneratorGeneric.

Edit: Suchst du vielleicht das: http://indicthreads.com/blogs/144/Java_Generics_Rules.html
 

chetigol

Mitglied
Natürlich funktioniert dein Ansatz auch, leider aber nur dann, wenn du keine Generics verwendest.

Mein motivation, hier generics zu verwenden war/ist folgende, und ich finde nicht wirklich, dass dies das OO-Design erstickt (lasse mich aber gerne eines besseren Belehren).

Und zwar folgendes, es soll eine Menge unterschiedlicher Parameterklassen / Objekte geben und zu diesen können austauschbare Generatoren installiert werden.
Was alle Generatorklassen gemeinsam haben ist außer der generate - Funktion, die Referenz auf ein Parameterobjekt, da aus diesem je nach Parametertyp unterschiedliche Informationen benötigt werden. Jeder Generatortyp ist also von einem bestimmten Parametertyp abhängig, deshlab also erstmal die generische Definition des Generators:

Code:
abstract class GenericGenerator<T extends GenericParameter>{
   T parameter;
   abstract generate();
}

und dann die generatoren für die unterschiedlichen Parametertypen:

Code:
class GeneratorParameterA extends GenericGenerator<T extends ParameterA>
{

   void generate(){
      parameter.Variable1_aus_klasse_ParameterA;
   }

}


class GeneratorParameterB extends GenericGenerator<T extends ParameterB>
{

   void generate(){
      parameter.VariableX_aus_klasse_ParameterB;
   }

}

die "generate" - funktion eines jeden Generators greift auf die Variablen der "Parameter" - Klassen. Würde ich keine Generics verwenden, könnte ich nicht direkt auf die spezifischen Variablen der "parameter" - Variable zugreifen, sondern müsste diese je nach generator Carsten!

Also:

Code:
// definition
InterfacePar parameter;
.....
.....
// zugriff der Klasse GeneratorParameterA :

((ParameterA)parameter).Variable1_aus_klasse_ParameterA

es ist sicher kein Problem, hab mir aber gedacht, dass ich mir das einfach erspare, da es über 40 Generatoren sind mit unterschiedlichen Parameterstrukturen!



EDIT: Hab mir deinen Link angeschaut (leider gehen dort die Sourcecode links nicht)! es ist nicht wirklich das, was ich suche! er implementiert acht Regel-Klassen, welche ein generisches Interface implementieren!
 

Marco13

Top Contributor
Hm. So einzelne Aspekte glaube ich verstanden zu haben, aber nicht komplett. Könntest du ein Beispielprogramm posten (einfach die 3 schon geposteten generischen Klassen, und 2 "Dummy"-Implementierungen, in einer Datei) wo man ganz klar sieht: "HIER" sollte der Typ bekannt sein wenn man es "SO" verwenden will?
 

schalentier

Gesperrter Benutzer
chetigol hat gesagt.:
Was alle Generatorklassen gemeinsam haben ist außer der generate - Funktion, die Referenz auf ein Parameterobjekt, da aus diesem je nach Parametertyp unterschiedliche Informationen benötigt werden.

Was du also abstrakt gesagt versuchst ist, eine einfache 1:1-Beziehung in eine abstrakte, generische Basisklasse zu packen (die Referenz). Ich glaube das ist nicht wirklich im Sinne des Erfinders (von Generics). Mach dir besser ein Interface 'Generator' mit der generate()-Methode und pack die korrekt getypten Parameter in die konkreten Implementierungen.
 

chetigol

Mitglied
schalentier hat gesagt.:
chetigol hat gesagt.:
Was alle Generatorklassen gemeinsam haben ist außer der generate - Funktion, die Referenz auf ein Parameterobjekt, da aus diesem je nach Parametertyp unterschiedliche Informationen benötigt werden.

Was du also abstrakt gesagt versuchst ist, eine einfache 1:1-Beziehung in eine abstrakte, generische Basisklasse zu packen (die Referenz). Ich glaube das ist nicht wirklich im Sinne des Erfinders (von Generics). Mach dir besser ein Interface 'Generator' mit der generate()-Methode und pack die korrekt getypten Parameter in die konkreten Implementierungen.

wieso einfach, wenn es auch kompliziert geht :D ! das wäre natürlich die einfachste Variante, ich weiß nicht wieso, aber irgendwie gefällt sie mir aber nicht...hehe. Was mir hier genau nicht gefällt, ist dass für jeden Generator die Parameterbeziehung neu implementiert wird (ich weiß, ist eh ein klax).
Wieso glaubst du, dass für solche Konstrukte die Generics nicht gedacht sind?
 

chetigol

Mitglied
Marco13 hat gesagt.:
Hm. So einzelne Aspekte glaube ich verstanden zu haben, aber nicht komplett. Könntest du ein Beispielprogramm posten (einfach die 3 schon geposteten generischen Klassen, und 2 "Dummy"-Implementierungen, in einer Datei) wo man ganz klar sieht: "HIER" sollte der Typ bekannt sein wenn man es "SO" verwenden will?

danke, mach ich dann am abend, oder morgen in der früh!
 

schalentier

Gesperrter Benutzer
chetigol hat gesagt.:
schalentier hat gesagt.:
chetigol hat gesagt.:
Was alle Generatorklassen gemeinsam haben ist außer der generate - Funktion, die Referenz auf ein Parameterobjekt, da aus diesem je nach Parametertyp unterschiedliche Informationen benötigt werden.

Was du also abstrakt gesagt versuchst ist, eine einfache 1:1-Beziehung in eine abstrakte, generische Basisklasse zu packen (die Referenz). Ich glaube das ist nicht wirklich im Sinne des Erfinders (von Generics). Mach dir besser ein Interface 'Generator' mit der generate()-Methode und pack die korrekt getypten Parameter in die konkreten Implementierungen.

wieso einfach, wenn es auch kompliziert geht :D ! das wäre natürlich die einfachste Variante, ich weiß nicht wieso, aber irgendwie gefällt sie mir aber nicht...hehe. Was mir hier genau nicht gefällt, ist dass für jeden Generator die Parameterbeziehung neu implementiert wird (ich weiß, ist eh ein klax).
Wieso glaubst du, dass für solche Konstrukte die Generics nicht gedacht sind?

Geh ich voll mit... ich hab dabei auch ein komisches Gefuehl, da man scheinbar das DRY-Prinzip (dont repeat yourself) verletzt. Allerdings ist der doppelte Code so wenig, dass an dieser Stelle Generics keinen Vorteil bringen. Es wird evtl. ein bisschen weniger Quellcode - aber du handelst dir Probleme ein, die dir bei der Loesung des eigentlichen (fachlichen) Problems in keinster Weise helfen.

Und einfach ist immer besser als komplizierter. Es sei denn du programmierst Write-Only. Letztendlich kann (und will) ich dich nicht zwingen, auf die Generics zu verzichten. Mach am besten deine eignen Erfahrungen damit. Fuer mich gilt der Grundsatz: Generics nur in Collections/Container - Ausnahmen bestaetigen die Regel ;-)

PS: Wenn mir jemand ein Beispiel zeigen kann, wo die G. wirklich unersetzlich sind - immer her damit!
 

chetigol

Mitglied
So, hatte gestern wenig Zeit mich damit zu beschäftigen! Hier mal ein stark vereinfachtes Beispiel der Generator und Paramter - Klassen.
Habe auch über deinen Vorschlag nachgedacht es doch nicht mit Generics zu lösen, trotzdem komm ich davon irgendwie nicht weg!

Im folgenden Beispiel ist die generische "parameter" Variable einmal in einer abstracten Generator-Superklasse definiert und wird von den Sub-Generatoren mit einem spezifischen Parameter parametrisiert.

Code:
import java.io.*;


public final class WithGenerics {
    
// 1. Definition der Parameterklassen
    // Allgemeine Parameterklasse, auf der alle weiteren aufsetzen
    static abstract class Parameter{
        
        // unique Kennung des PArametertyps
        public int kennung;          
        
        // erwartete Parametergröße (-1 .. dynamisch)
        // kann für nachträgliche checks verwendet werden
        // bei manchen Parametertypen wird die Größe im header eingetragen
        public int size;             
        
        protected Parameter( int kennung, int size ){
            this.kennung = kennung;
            this.size    = size;
        }
    }
    
    // Spezifischer Parameter 1
    static class SystemXYParameter extends Parameter {
        
        // subkennung, gilt nur für parameter des Systems XY
        public byte subkennung;
        
        // Parametertyp (Gilt nur für SystemXY)
        public boolean common;
        
        public SystemXYParameter( int kennung, int size, byte subkennung, boolean common ){
            super( kennung, size );
            
            this.subkennung = subkennung;
            this.common = common; 
        }
    }
    
    // Spezifischer Parameter 2
    static class ServiceZParameter extends Parameter{
        // Service Z mit oder ohne crcCheck
        public boolean crcCheck; 
        
        public ServiceZParameter( int kennung, int size, boolean crcCheck ){
            super( kennung, size );
            
            this.crcCheck = crcCheck;
        }
    }
    
    
// Definition der Generatorklassen
    // Abstrakte Generatorklasse
    // muss zumindest mit einem gültigen Paraemtertyp parametriert werden
    static abstract class Generator<P extends Parameter>{
        public P parameter;
        
        public void setParameter( P parameter ){
            this.parameter = parameter;
        }
        
        // Bereits hier könnte ich den Generator implementiren, falls alle Generatoren eine
        // gemeinsamkeit haben! Zum Beispiel einen Header-implementierung, falls dises
        // bei allen Parametern gleich ist!!!
        // und wenn der Header die Kennung und die erwartete Größe enthalten sollte,
        // so kann ich dies auch gleich hier erledigen, da alle weiteren Generatoren zumindest
        // mit der "Parameter" - Klasse parametrisiert werden müssen!
        public abstract void generate( OutputStream out );
    }
    
    
    // 1. Generatoren für Parameter des SystemXY
    // --> normal würden diese klassen eine gemeinsame superklasse haben, aber ich lass das
    // jetzt mal
    static class GeneratorSystemXYSubPar1 extends Generator<SystemXYParameter>{
        
        @Override
        public void generate(OutputStream out ){
            PrintStream data =  new PrintStream(out);
            
            // schreibe Parameterstruktur in den Stream
            //....

            //1. zugriff auf die members der super - Klasse
            data.print( parameter.kennung );
            data.print( parameter.size );
            // 2. zugriff auf die erweiterten Parameter fürs SystemXY
            data.print( parameter.subkennung );
            data.print( parameter.common );

            // 3....schreibe eigentliche parameterdaten ( aus Database, File,...je nach generator)
        }
    }
    
    // Generator für das SystemXY, SubParameter2
    static class GeneratorSystemXYSubPar2 extends Generator<SystemXYParameter>{
        
        @Override
        public void generate(OutputStream out ){
            
            PrintStream data =  new PrintStream(out);
            
            // schreibe Parameterstruktur in den Stream
            //....
            //1. zugriff auf die members der super - Klasse
            data.print( parameter.kennung );
            data.print( parameter.size );
            // 2. zugriff auf die erweiterten Parameter fürs SystemXY
            data.print( parameter.subkennung );
            data.print( parameter.common );
            // 3....schreibe eigentliche parameterdaten ( aus Database, File,...je nach generator)
            //      Die PArameterstruktur für die SubParameter unterscheiden sich voneinader
            //      dehalb unterschiedliche Generatoren
        }
    }
    
    
    public static void main(String[] args) {
    
        // 1. erzeuge einen neuen Generator für das System XY SupPArameter 1
        GeneratorSystemXYSubPar1 gen1 = new GeneratorSystemXYSubPar1();
        // 2. teile dem generator einen parameter zu
        //    Kennung: 0, size: 40000 Byte, subkennung: 1, common: true
        gen1.setParameter( new SystemXYParameter( 0, 40000, (byte)1, true) );
        
        // erzeuge einen weiteren Geberator für das System XY und den SbParameter 2
        GeneratorSystemXYSubPar2 gen2 = new GeneratorSystemXYSubPar2();
        // Teile dem Generator ein PAraemterobjekt zu
        //  Kennung: 1, size: 39 Byte, subkennung: 2, common: false
        gen2.setParameter( new SystemXYParameter( 1, 39, (byte)2, false) );
        
        // generiere paraemter 1
        gen1.generate( System.out );
        
        System.out.println();
        
        // generiere paraemter 2
        gen2.generate( System.out );
        
    }
    
}


Würde man, wie du vorgeschlagen hast, in jedem Spezielen Generator den Spezifischen Parameter definieren, müsste man sich bei jeder Klasse eben mit dieser Definition herumschlagen:


Code:
public class WithoutGenerics {

    interface Generator{
        void generate( OutputStream out );
    }
    
    
    static class Generator1 {
        Parameter1 parameter;

        // setze parameter
        void setParameter( Parameter1 parameter){
            this.parameter = parameter;
        }
    }
    
    static class Generator2 {
        Parameter2 parameter;
        
        // und nochmal das ganze
        void setParameter( Parameter2 parameter){
            this.parameter = parameter;
        }
    }
    
    static class Generator3 {
        Parameter3 parameter;
        
        // und nochmal einmal
        void setParameter( Parameter3 parameter){
            this.parameter = parameter;
        }
    }
    
}

Was ist, wenn jetzt doch etwas gemeinsames dazu kommt? eben wie das Generieren eines headers, wobei einige Daten aus der gemeinsamen Parameter-Superklasse dafür verwendet werden? So könnte man das natürlich in einer gemeinsamen Genrator-Superklasse erledigen, tortzdem wird das dadurch immer komplizierter. bei den Generics bleibt es meiner meinung nach viel übersichtlicher!

Code:
public class WithoutGenerics2 {

    interface Generator{
        void generate( OutputStream out );
    }
    
    static abstract class GeneratorCommon implements Generator{
        protected void generateHeader( OutputStream out, Parameter parameter ){
            // generiere header aus "parameter"
            // .....
            // ....
        }
    }
    
    static class Generator1 extends GeneratorCommon{
        Parameter1 parameter;

        // setze parameter
        void setParameter( Parameter1 parameter){
            this.parameter = parameter;
        }
        
        void generate( OutputStream out ){
            // 1. generiere header
            generateHeader( out, parameter );
            // 2. den rest/daten
        }
    }
    
    // für alle weiteren Generatoren muss das gleiche gemacht werden!
    
}


Außerdem man hat einen größeren Faktor bezöglich typensicherheit! So könnte eine beleibige Person einen Generator Implementieren, welcher eine nicht auf der von "Parameter" abgeleiteten Struktur aufsetzt!
Bei der Generischen Generatorklasse degegen wird bereits in der Superklasse mindestens die Abstammung von "Parameter" vorgeschrieben.

Was sagt ihr dazu? Lieg ich komplett daneben?
Hoffentlich hat überhaupt jemand lust sich das durchzuschauen, was ich da fabriziert hab...hehe!
 

schalentier

Gesperrter Benutzer
Also, logischerweise musst du beim Weg ohne Generics den Setter/Getter fuer den Parameter "programmieren".

Code:
public class WithoutGenerics3 {

    interface Generator{
        void generate( OutputStream out );
        Parameter getParameter();
    }
   
    static abstract class GeneratorCommon implements Generator{
        protected void generateHeader( OutputStream out ){
            // generiere header aus getParameter();
            // .....
            // ....
        }
        void generate( OutputStream out ) {
            generateHeader( out );
            generateContent( out );
        }
        abstract void generateContent( OutputStream out );
    }
   
    static class Generator1 extends GeneratorCommon{
        Parameter1 parameter;

        // setze parameter
        void setParameter( Parameter1 parameter){
            this.parameter = parameter;
        }
        Parameter getParameter() { return parameter; } // hier muesste auch Parameter1 als Rueckgabetyp klappen
       
        void generateContent( OutputStream out ){
            // 2. den rest/daten
        }
    }
   
    // Wenn es wirklich viele von diesen Generatoren gibt, wuerde ich mir ein LiveTemplate dafuer bauen.   
}
 

chetigol

Mitglied
Hi!

ja, das ist ja das Problem! es gibt viele Parametertypen und Generatoren! und es können welche von dritten integriert werden.
Was sind LiveTemplates? Komme eigentlich von C/C++ (Embeded) - Entwicklung!
 

schalentier

Gesperrter Benutzer
Wieviel ist den viel?
Gib mal paar Zahlen (Anzahl Parameterklassen, Generatorklassen und wie tief wird der Ableitungsbaum ca. wird).

Ohne mehr Wissen ueber dein eigentliches Ziel, ist es schwer dir vernuenftige Hinweise zu geben. Es gibt noch ca. 100000 andere Wege. Z.B. Codegenerator, eine eigne kleine DSL, Einsatz einer Skriptsprache. Brauchst du diese Parameterklassen ueberhaupt? Reicht nicht vielleicht auch eine HashMap oder die Properties-Klasse? Oder kannste vielleicht sogar die Parameter-Felder direkt an die Generatoren dran packen?

Mit LiveTemplates kannste dir Tipparbeit sparen, indem du dann im Quellcode z.B. "gen" tippst und dann TAB drueckst (oder Strg+Space?). Das generiert dann Quellcode (z.B. die 1:1 Beziehung + generateContent-Stub). Das ganze findest du irgendwo im Menu (^^).
 
G

Guest

Gast
Also, es kommen derzeit etwa 50 Parameterarten des selben Parametertyps zum Einsatz, also einfach nur anders initialisiert:

new PrameterX( 1, 40,..., ... );
new ParameterY( ............... );

für jede einzelne Parameterart gibt es einen eigenen Generator (sehen nun mal anders aus).

zusätzlich kommen noch ca 10 Parameter eines komplett anderen Parametertyps für die es wieder andere Generatoren gibt.

Diese information, die in der Parameterklasse steckt wird auf jeden Fall benötigt. Wo sie entnommen wird ist dann eine Desginentscheidung. Man könnte haufenweise constante an in einer eigenen Klasse definieren und die Generatoren greifen auf diese zu, zum Beispiel.

Ich wollte aber diese Werte aber Parametrierbar bauen, deshalb eine eigene "Parameter" - Klasse! Genaugenommen hat die Parameterklasse zusätzlich eine statische Liste aller Parametertypen:

Code:
abstract Parameter{
    static List<Parameter> parameter;
    
    static Parameter getParameter( paramId );

}

Jede erzeugt Parameterklasse meldet sich in dieser Liste an. Das alles ist nach außen transparent, es kann also Jeder seine eigenen Parameterklassen erzeugen.

Das Konzept schaut ca folgenermassen aus:

// Irgendwo werden neue oder zusätzliche Parameter angemeldet

new PrameterX( 1, 40,..., ..., new GeneratorX() );
new ParameterY( ..............., new GeneratorY() );


Code:
// eigene Core - Klasse, an welche von außen eine Liste der zu erzeugenden Parameter übergeben wird
GeneratorCore( ListParameter2Generate[] )

    // parameterliste durchlaufen und records generieren
    for(...){
       Parameter param = Parameter.getParaemter( ListParameter2Generate[i].paramId )
       param.getGenerator().generate( stream );
     }

weiters möchte ich mir die möglichkeit offen lassen, dass pro parametertyp mehrere generatoren installiert werden können.


Natürlich könnte ich mir hier die Parameterklasse sparen und wie du schon geschrieben hast, einfach eine HashTable durchlaufen, was ist aber, wenn ich pro Parametertyp eben irgendwann mehrere Generatoren, die die Parameter unterschiedlich erzeugen, einsetzen möchte?
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
I Mehrere Klassen mit den selben Daten Allgemeine Java-Themen 5
Zrebna Wie ermittelt man alle testbaren (zu testenden) Klassen in seinem Maven-Projekt? Allgemeine Java-Themen 23
8u3631984 Jacoco Testcoverage bei Abstracten Klassen in verschachtelten Modulen Allgemeine Java-Themen 6
Encera Gleichzeitiges Ausführen und verbinden von 2 Java-Klassen über die Eingabeaufforderung und Eclipse Allgemeine Java-Themen 21
8u3631984 Problem beim Mocken von Record Klassen Allgemeine Java-Themen 4
B Ein Objekt einer Klasse mehreren anderen Klassen zur Verfügung stellen? Allgemeine Java-Themen 6
B Java Reflection Probleme beim wehcselseitigen Referenzieren zweier Klassen/Objekte Allgemeine Java-Themen 14
P9cman java.Lang Klassen fehlen in JRE System Library Allgemeine Java-Themen 1
B Wie kann ich mein 8 Klassen Gebilde objektorientierter schreiben? Allgemeine Java-Themen 114
N abstracte klassen methoden Allgemeine Java-Themen 32
W Klassen Zugriff auf ein Textfile aus allen Klassen. Allgemeine Java-Themen 2
M Klasse durch Klassen Aufteilung verbessern, aber wo? Allgemeine Java-Themen 1
stormyark Problem beim Klassen erstellen Allgemeine Java-Themen 1
M Kann man Annotationen auf Klassen einschränken die ein Interface implementieren? Allgemeine Java-Themen 1
nonickatall Methoden Kann man Klassen/Methoden aus Variablen heraus aufrufen? Allgemeine Java-Themen 6
H Interface PluginSystem ClassNotFound exception für library Klassen Allgemeine Java-Themen 10
L Classpath Zur Laufzeit bestimmte Klassen in Classloader hinzufügen? Allgemeine Java-Themen 4
P Abstrakte Klassen vs. Interface Allgemeine Java-Themen 4
I Klassen aus Jar-Dateien aus anderem Ordner laden Allgemeine Java-Themen 3
D OOP Gemeinsamen ID-Raum für zwei Klassen implementieren Allgemeine Java-Themen 7
B Problem mit meinen Klassen Allgemeine Java-Themen 6
I Array Parameter mit 2 Klassen - NullPointerException Allgemeine Java-Themen 3
F ArrayList`s in Klassen mit Getter/Setter Allgemeine Java-Themen 8
F Code in Klassen bringen Allgemeine Java-Themen 4
J Problem beim Generischen Klassen und Interfaces Allgemeine Java-Themen 2
F Klassen Verwendung abstrakter Klassen Allgemeine Java-Themen 9
W Variablenübergabe über mehrere Klassen Allgemeine Java-Themen 4
B Vererbung Interface und implementierende Klassen Allgemeine Java-Themen 8
D Klassen JLabels in anderen Klassen verwenden. Allgemeine Java-Themen 7
H Klassen LibGDX - Verschiedene Klassen als Value in einer Map Allgemeine Java-Themen 8
J Best Practice Objekt an alle Klassen verteilen ( Discord Bot ) Allgemeine Java-Themen 7
A Anonyme Klassen - Interface Allgemeine Java-Themen 5
ReinerCoder auf Klassen innerhalb eines package zugreifen Allgemeine Java-Themen 22
J Tetris Probleme bei Klassen Allgemeine Java-Themen 14
cool_brivk24 Klassen Klassen Aufruf Fehlgeschlagen Allgemeine Java-Themen 14
S Parametrisierte jUnit 5-Tests mit eigenen Datentypen/Klassen-Objekten als Test-Parameter Allgemeine Java-Themen 0
rentasad Design-Frage - Interfaces, Klassen, statische Methoden Allgemeine Java-Themen 3
S Klassen Abstrakte Klassen Allgemeine Java-Themen 5
T Log4J - Deaktivierung für einzelne Klassen Allgemeine Java-Themen 7
Tommy Nightmare Klassen Globale Klassen erstellen Allgemeine Java-Themen 7
X Klassen aus jar in jar Laden Allgemeine Java-Themen 1
S Klassen Klassen "virtuell" erstellen Allgemeine Java-Themen 5
J Aus mehreren Klassen ein Datei ausführbare machen Allgemeine Java-Themen 6
S equals-Methode bestimmer Klassen abfangen Allgemeine Java-Themen 2
M Klassen Eine Klasse in mehreren Klassen einbinden Allgemeine Java-Themen 11
Sin137 Struktur der Klassen & Package Allgemeine Java-Themen 2
G Klassen und interne Klassen Allgemeine Java-Themen 1
S Klassen übergeben Allgemeine Java-Themen 13
C Klassen und Konstruktor Allgemeine Java-Themen 2
S Classpath Wie kann ich Java-Library Klassen "verstecken"..? Allgemeine Java-Themen 4
A Java speech - 2 Klassen Allgemeine Java-Themen 1
V Wie kann ich die Fragen mit den anderen Klassen verbinden? Allgemeine Java-Themen 1
T Schlüsselworte mehrere public-Klassen in einem Paket Allgemeine Java-Themen 7
V Klassenname von allen Klassen mit einer bestimmten Eigenschaft bekommen Allgemeine Java-Themen 2
B Classpath Eclipse findet importierte Klassen nicht Allgemeine Java-Themen 1
C DBConnection als Methode in mehreren Klassen Allgemeine Java-Themen 4
C Arten von Klassen Allgemeine Java-Themen 3
7 Verbinden von Mehreren Klassen Allgemeine Java-Themen 29
A Klassen ein Interface aufzwingen Allgemeine Java-Themen 4
O Java-Obfuscator, welcher einzelne Methoden, Klassen und Ordnerstrukturen ausnehmen kann. Allgemeine Java-Themen 1
A also definition von klassen und string methoden und algorithmik Allgemeine Java-Themen 13
D Problem bei Vererbung abstrakter Klassen Allgemeine Java-Themen 6
M Interface Generische Klassen mit mehreren Typen überschreiben Allgemeine Java-Themen 0
L OOP Klassen-Design (static oder nicht?) Allgemeine Java-Themen 3
X Eigene Annotation - mit Bedingung für ganze Klassen oder Methoden Allgemeine Java-Themen 2
O Klassen Programm in Klassen unterteilt, werte werden nicht mehr übernommen Allgemeine Java-Themen 3
J C++ Projekt (QT) in Java mit Klassen (nicht imperativ) nutzen (BridJ? JavaCPP? SWIG? JNA? JNI?) Allgemeine Java-Themen 2
T Datentypen Eine Liste - verschiedenen Klassen - eine Abstracte Klasse Allgemeine Java-Themen 3
S .jar hat nicht alle Klassen ??? Allgemeine Java-Themen 10
S Polymorphie Polymorphismus bei Abstrakten Klassen Allgemeine Java-Themen 2
S Tool um mehrere Klassen in einer Klasse vereinen? Allgemeine Java-Themen 6
T Wie kann ich alle existierenden Java-Klassen anzeigen lassen? Allgemeine Java-Themen 10
Landei Welche Klassen fehlen im JDK? Allgemeine Java-Themen 18
S Kapselung Statische Helper Klassen Allgemeine Java-Themen 5
A Vererbung Klassen-Downcasting wirft ClassCastException Allgemeine Java-Themen 2
N Java Klassen mit ID Allgemeine Java-Themen 21
antonbracke Klassen Klassen gegenseitig laden Allgemeine Java-Themen 4
R SecurityManager für einzelne Klassen/Threads? Allgemeine Java-Themen 38
T Java Klassen aus externer .jar laden und ausführen Allgemeine Java-Themen 3
S JPA und Entity-Klassen: Wert ungültig Allgemeine Java-Themen 6
M OO / Klassen / Projektstruktur Allgemeine Java-Themen 5
O Klassen werden nicht importiert Allgemeine Java-Themen 3
E selber Klassen kompilieren/ prüfen Allgemeine Java-Themen 5
Z Abstrakte Klassen /Interface Allgemeine Java-Themen 5
A Klassen und JLabel's Allgemeine Java-Themen 12
J Java-Implementierung diverser Beziehungen zwischen Klassen bzw. Objekten Allgemeine Java-Themen 2
M Methoden/Klassen für andere Projekte Allgemeine Java-Themen 4
J Suche: Tool zum Auffinden gleichnamiger Klassen (Name und Package gleich) in unteschiedlichen JARs Allgemeine Java-Themen 5
E instanceof mit nicht öffentlichen Klassen Allgemeine Java-Themen 2
D Datentypen Typbestimmung unbekannter Wrapper-Klassen Allgemeine Java-Themen 5
S Klassen in einer Schleife durchlaufen Allgemeine Java-Themen 11
X Generic muss zwei Klassen/Interfaces erfüllen Allgemeine Java-Themen 5
N Vergleich eigener Klassen Allgemeine Java-Themen 5
M Klassen Array aus Klassen bestimmter Klassen ? Allgemeine Java-Themen 11
C OOP Klassen mit "Eigenschaften" Allgemeine Java-Themen 10
H Klassen kommunizieren lassen Allgemeine Java-Themen 3
A Problem bei Serialisierung von Bibliotheks-Klassen Allgemeine Java-Themen 6
R Implementierung eines Interface durch 2 verschiedene Klassen Allgemeine Java-Themen 6
T Classpath Klassen dynamisch erstellen Allgemeine Java-Themen 4
I Klassen Klassen-/Objektinteraktion Allgemeine Java-Themen 2

Ähnliche Java Themen

Neue Themen


Oben