java - varargs - spring data optional parameters




Дополнительные параметры Java (11)

Укороченная версия :

Использование трех точек :

public void foo(Object... x) {
    String first    =  x.length > 0 ? (String)x[0]  : "Hello";
    int duration    =  x.length > 1 ? Integer.parseInt((String) x[1])     : 888;
}   
foo("Hii", ); 
foo("Hii", 146); 

(на основании ответа Виталия Федоренко)

Как использовать дополнительные параметры в Java? Какая спецификация поддерживает дополнительные параметры?


Java теперь поддерживает опции в 1.8, я застрял в программировании на Android, поэтому я использую нули, пока не смогу реорганизовать код для использования необязательных типов.

Object canBeNull() {
    if (blah) {
        return new Object();
    } else {
        return null;
    }
}

Object optionalObject = canBeNull();
if (optionalObject != null) {
    // new object returned
} else {
    // no new object returned
}

Были упомянуты VarArgs и перегрузка. Другим вариантом является шаблон Builder, который будет выглядеть примерно так:

 MyObject my = new MyObjectBuilder().setParam1(value)
                                 .setParam3(otherValue)
                                 .setParam6(thirdValue)
                                 .build();

Хотя этот шаблон был бы наиболее подходящим, если вам нужны дополнительные параметры в конструкторе.


В JDK> 1.5 вы можете использовать его так:

public class NewClass1 {

    public static void main(String[] args) {

        try {
            someMethod(18); // Age : 18
            someMethod(18, "John Doe"); // Age & Name : 18 & John Doe
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void someMethod(int age, String... names) {

        if (names.length > 0) {
            if (names[0] != null) {
                System.out.println("Age & Name : " + age + " & " + names[0]);
            }
        } else {
            System.out.println("Age : " + age);
        }
    }
}

Вы можете использовать класс, который работает так же, как строитель, чтобы содержать ваши дополнительные значения, подобные этому.

public class Options {
    private String someString = "default value";
    private int someInt= 0;
    public Options setSomeString(String someString) {
        this.someString = someString;
        return this;
    }
    public Options setSomeInt(int someInt) {
        this.someInt = someInt;
        return this;
    }
}

public static void foo(Consumer<Options> consumer) {
    Options options = new Options();
    consumer.accept(options);
    System.out.println("someString = " + options.someString + ", someInt = " + options.someInt);
}

Использовать как

foo(o -> o.setSomeString("something").setSomeInt(5));

Выход

someString = something, someInt = 5

Чтобы пропустить все необязательные значения, вы должны называть его как foo(o -> {}); или, если хотите, вы можете создать второй метод foo() , который не принимает необязательные параметры.

Используя этот подход, вы можете указать необязательные значения в любом порядке без какой-либо двусмысленности. Вы также можете иметь параметры разных классов, в отличие от varargs. Этот подход будет еще лучше, если вы можете использовать аннотации и генерации кода для создания класса «Параметры».


Вы можете использовать что-то вроде этого:

public void addError(String path, String key, Object... params) { 
}

Параметр переменной является необязательным. Он рассматривается как нулевой массив объектов.

Как ни странно, я не мог найти ничего об этом в документации, но это работает!

Это «новое» в Java 1.5 и выше (не поддерживается в Java 1.4 или ранее).

Я вижу, что пользователь bhoot упоминал об этом слишком ниже.


Мы можем сделать необязательный параметр путем перегрузки метода или использования DataType ...

| * | Перегрузка метода:

RetDtaTyp NamFnc(String NamPsgVar)
{
    // |* CodTdo *|
    return RetVar;
}

RetDtaTyp NamFnc(String NamPsgVar)
{
    // |* CodTdo *|
    return RetVar;
}

RetDtaTyp NamFnc(int NamPsgVar1, String NamPsgVar2)
{
    // |* CodTdo *|
    return RetVar;
}

Самый простой способ

| * | DataType ... может быть необязательным параметром

RetDtaTyp NamFnc(int NamPsgVar, String... SrgOpnPsgVar)
{
    if(SrgOpnPsgVar.length == 0)  SrgOpnPsgVar = DefSrgVar; 

    // |* CodTdo *|
    return RetVar;
}

На Java нет дополнительных параметров. Что вы можете сделать, это перегрузка функций, а затем передача значений по умолчанию.

void SomeMethod(int age, String name) {
    //
}

// Overload
void SomeMethod(int age) {
    SomeMethod(age, "John Doe");
}

Существует несколько способов моделирования необязательных параметров в Java:

  1. Перегрузка метода.

    void foo(String a, Integer b) {
        //...
    }
    
    void foo(String a) {
        foo(a, 0); // here, 0 is a default value for b
    }
    
    foo("a", 2);
    foo("a");
    

    Одним из ограничений этого подхода является то, что он не работает, если у вас есть два необязательных параметра одного типа, и любой из них можно опустить.

  2. С переменным числом аргументов.

    a) Все необязательные параметры одного типа:

    void foo(String a, Integer... b) {
        Integer b1 = b.length > 0 ? b[0] : 0;
        Integer b2 = b.length > 1 ? b[1] : 0;
        //...
    }
    
    foo("a");
    foo("a", 1, 2);
    

    б) Типы необязательных параметров могут быть разными:

    void foo(String a, Object... b) {
        Integer b1 = 0;
        String b2 = "";
        if (b.length > 0) {
          if (!(b[0] instanceof Integer)) { 
              throw new IllegalArgumentException("...");
          }
          b1 = (Integer)b[0];
        }
        if (b.length > 1) {
            if (!(b[1] instanceof String)) { 
                throw new IllegalArgumentException("...");
            }
            b2 = (String)b[1];
            //...
        }
        //...
    }
    
    foo("a");
    foo("a", 1);
    foo("a", 1, "b2");
    

    Основным недостатком этого подхода является то, что, если необязательные параметры имеют разные типы, вы теряете контроль статического типа. Кроме того, если каждый параметр имеет различный смысл, вам нужно каким-то образом отличить их.

  3. Нулевые. Чтобы устранить ограничения предыдущих подходов, вы можете разрешить нулевые значения и затем проанализировать каждый параметр в теле метода:

    void foo(String a, Integer b, Integer c) {
        b = b != null ? b : 0;
        c = c != null ? c : 0;
        //...
    }
    
    foo("a", null, 2);
    

    Теперь должны быть указаны все значения аргументов, но по умолчанию они могут быть пустыми.

  4. Необязательный класс. Этот подход похож на нуль, но использует Java 8 Необязательный класс для параметров, которые имеют значение по умолчанию:

    void foo(String a, Optional<Integer> bOpt) {
        Integer b = bOpt.isPresent() ? bOpt.get() : 0;
        //...
    }
    
    foo("a", Optional.of(2));
    foo("a", Optional.<Integer>absent());
    

    Необязательно делает метод контракт явным для вызывающего, однако, такая подпись может быть слишком многословной.

    Обновление: Java 8 включает класс java.util.Optional из коробки, поэтому нет необходимости использовать guava по этой конкретной причине в java 8. Название метода немного отличается.

  5. Рисунок Builder. Шаблон построителя используется для конструкторов и реализуется путем введения отдельного класса Builder:

     class Foo {
         private final String a; 
         private final Integer b;
    
         Foo(String a, Integer b) {
           this.a = a;
           this.b = b;
         }
    
         //...
     }
    
     class FooBuilder {
       private String a = ""; 
       private Integer b = 0;
    
       FooBuilder setA(String a) {
         this.a = a;
         return this;
       }
    
       FooBuilder setB(Integer b) {
         this.b = b;
         return this;
       }
    
       Foo build() {
         return new Foo(a, b);
       }
     }
    
     Foo foo = new FooBuilder().setA("a").build();
    
  6. Карты. Когда количество параметров слишком велико, и для большинства из них обычно используются значения по умолчанию, вы можете передавать аргументы метода как карту их имен / значений:

    void foo(Map<String, Object> parameters) {
        String a = ""; 
        Integer b = 0;
        if (parameters.containsKey("a")) { 
            if (!(parameters.get("a") instanceof Integer)) { 
                throw new IllegalArgumentException("...");
            }
            a = (Integer)parameters.get("a");
        }
        if (parameters.containsKey("b")) { 
            //... 
        }
        //...
    }
    
    foo(ImmutableMap.<String, Object>of(
        "a", "a",
        "b", 2, 
        "d", "value")); 
    

Обратите внимание, что вы можете комбинировать любой из этих подходов для достижения желаемого результата.


Существуют дополнительные параметры с Java 5.0. Просто объявите свою функцию следующим образом:

public void doSomething(boolean... optionalFlag) {
    //default to "false"
    //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}

вы можете позвонить с помощью doSomething(); или doSomething(true); сейчас.


Аргументы по умолчанию не могут использоваться в Java и C #. Где в C ++ и Python мы можем их использовать.

В Java нам нужно использовать 2 метода (функции) вместо одного с параметрами по умолчанию.

Пример:

Stash(int size); 

Stash(int size, int initQuantity);

http://parvindersingh.webs.com/apps/forums/topics/show/8856498-java-how-to-set-default-parameters-values-like-c-







optional-parameters