Default Werte für Parameter

This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

  • Default Werte für Parameter

    Hallo,

    Ich steh vor eine Frage auf die ich keine Lösung weiß. Ich will das auch eigentlich gar nicht nutzen aber vllt. wäre es ganz gut zu wissen was man da machen könnte ;):

    In Java gibt es anders als in C++ keine Defaultwerte für Parameter. Wie wüurden
    Sie in Java stattdessen ausdrüucken, dass standardmäaßig bestimmte Parameter mit
    einen Defaultwert belegt sind?


    Was gibts denn da für Möglichkeiten? Ich dachte zuerst im Konstruktor direkt Werte zuweisen aber dann würde man ja welche vllt. überschreiben - oder auf null überprüfen und dem entsprechend was setzen, finde ich aber ehrlich gesagt ziemlich komsich Oo.
  • Man könnte die Methoden einfach überladen mit verschiedener Parameteranzahl. Die überladenen Methoden rufen dann einfach die normale Methode auf.
    (So macht es meines Wissens auch die JavaAPI)

    Source Code

    1. void foo(String param){
    2. //...
    3. }
    4. void foo(){
    5. foo("default");
    6. }


    Wobei ich glaube, dass in einem der nächsten Javaupdated sowieso irgendetwas derartiges in der Sprache integriert sein wird.
  • Die genannte Überladung ist für Methoden mit wenigen Parameter die einfachste Lösung für dieses Problem.

    Es lässt sich allerdings auch mit nur einer Methodendeklaration lösen:

    1. Primitiv: Einfacher Null-Check im Methodenkörper:

    Source Code

    1. void bla(String name) {
    2. if (name == null) {
    3. doSomething("Hans");
    4. } else {
    5. doSomething(name);
    6. }
    7. }

    2. Fortgeschritten: Du annotierst die Parameter und wertest diese aus:

    Source Code

    1. void bla(@Default("Hans") String name) {
    2. if (name == null) {
    3. String defaultValue = ... // Annotation auswerten
    4. doSomething(defaultValue);
    5. } else {
    6. doSomething(name);
    7. }
    8. }

    Die letzte Möglichkeit hat zwar einen höheren Initialaufwand, bringt aber den nicht zu unterschätzenden Vorteil, dass die Defaultwerte aus der Methodensignatur ersichtlich sind. Was du bei Überladung oder Überprüfungen im Methodenkörper eben nicht hast.
  • Danke m für diesen Beitrag! Default Paramter Annotations waren mir gänzlich neu.
    Aber diese gehören nicht zum Standardumfang, oder? Dazu muss ich die JavaDude Libs in meinen Buildpath einhängen: code.google.com/p/javadude/wiki/Annotations
    If you're creating a plugin, you can add a dependency to the com.javadude.annotation plugin. Otherwise:

    Download javadude-annotation_2.1.6.jar and import it into your project. (Alternatively you can place it in another project, export it, and add the other project as a dependency)
    Right-click on the jar and choose Build Path->Add to Build Path. (This gives you access to the annotation definitions so you can use them in your code.)
    Open your project properties (Select the project and press Alt-Enter)
    Go to Java Compiler->Annotation Processing
    Check Enable project specific settings
    Uncheck Enable processing in editor (not really necessary but can improve performance slightly)
    The plugin will automatically process the @Bean and @ExtractInterface annotations.
  • Die JavaDude Libs gehen allerdings einen gänzlich anderen Weg. Siehe das Beispiel auf deren Seite: code.google.com/p/javadude/wiki/AnnotationsPropertyExample1
    Im Prinzip wird da alles bereits vor dem Kompilieren automatisch zu fertigen Klassen zusammengebaut. Die Annotationen dienen quasi als Bauplan. Am Ende kommen also ganz normale Klassen raus, die kaum noch Spuren enthalten, aus was sie eigentlich entstanden. Ich hingegen werte die Infos erst zur Laufzeit aus. Solche Sachen zur Laufzeit zu machen ist zwar schwieriger zu handhaben, wird aber insgesamt der Objektorientierung besser gerecht, also dem Fokus auf der Dynamik von Objekten und ihrem Verhalten zur Laufzeit, statt auf dem statischen Klassenmodell mit seinen starren Beziehungen.

    AFAIK ist nichts derartiges in der Standard-API von Java. Die Annotationen kann man sich aber relativ leicht selbst bauen:

    Default.java

    Source Code

    1. @Retention(RetentionPolicy.RUNTIME)
    2. @Target(ElementType.PARAMETER)
    3. public @interface Default {
    4. String value();
    5. }


    Die Auswertung von Annotationen zur Laufzeit ist mit ein paar Umwegen verbunden. Man muss sich quasi von der Klasse, über die Methode, den ersten Parameter bis zur ersten dortigen Annotation hangeln. Wenn man es aber einmal verstanden hat, ist das Ganze absolut logisch. Außerdem kann man solche Sachen in Helper-Klassen auslagern, was die Auswertung der Annotation zum EInzeiler macht. Aber zum Verständnis hier der lange Weg:

    Source Code

    1. public class Hello {
    2. public void sayHi(@Default("Horst") String name) {
    3. if (name == null) {
    4. try {
    5. Method thisMethod = this.getClass().getMethod("sayHi", String.class);
    6. Annotation[][] annotations = thisMethod.getParameterAnnotations();
    7. Default annotation = (Default) annotations[0][0];
    8. System.out.println("Hallo " + annotation.value() + "!");
    9. } catch (Exception e) {
    10. }
    11. } else {
    12. System.out.println("Hallo " + name + "!");
    13. }
    14. }
    15. }
    Display All


    Benutzung ganz normal:

    Source Code

    1. public static void main(String[] args) {
    2. Hello h = new Hello();
    3. h.sayHi("Kevin");
    4. h.sayHi(null);
    5. }


    Source Code

    1. Hallo Kevin!
    2. Hallo Horst!