Дополнительные параметры Java
Как использовать дополнительные параметры в Java? Какая спецификация поддерживает необязательные параметры?
16 ответов
Varargs может сделать это (в некотором роде). Кроме этого, все переменные в объявлении метода должны быть предоставлены. Если вы хотите, чтобы переменная была необязательной, вы можете перегрузить метод, используя сигнатуру, которая не требует параметра.
private boolean defaultOptionalFlagValue = true;
public void doSomething(boolean optionalFlag) {
...
}
public void doSomething() {
doSomething(defaultOptionalFlagValue);
}
Есть несколько способов симулировать необязательные параметры в Java:
Метод перегрузки.
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");Одним из ограничений этого подхода является то, что он не работает, если у вас есть два необязательных параметра одного типа, и любой из них может быть опущен.
Спеременным числом аргументов.
а) Все необязательные параметры имеют одинаковый тип:
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");Основным недостатком этого подхода является то, что если дополнительные параметры имеют разные типы, вы теряете статическую проверку типов. Кроме того, если каждый параметр имеет разное значение, вам нужен какой-то способ их различения.
Нулевые. Чтобы устранить ограничения предыдущих подходов, вы можете разрешить нулевые значения, а затем проанализировать каждый параметр в теле метода:
void foo(String a, Integer b, Integer c) { b = b != null ? b : 0; c = c != null ? c : 0; //... } foo("a", null, 2);Теперь все значения аргументов должны быть предоставлены, но значения по умолчанию могут быть нулевыми.
Необязательный класс. Этот подход аналогичен пустым значениям, но использует необязательный класс 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. Хотя имя метода немного отличается.Образец строителя. Шаблон 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();Карты. Если число параметров слишком велико и для большинства из них обычно используются значения по умолчанию, вы можете передать аргументы метода в виде карты их имен / значений:
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 9 этот подход стал проще:
@SuppressWarnings("unchecked") static <T> T getParm(Map<String, Object> map, String key, T defaultValue) { return (map.containsKey(key)) ? (T) map.get(key) : defaultValue; } void foo(Map<String, Object> parameters) { String a = getParm(parameters, "a", ""); int b = getParm(parameters, "b", 0); // d = ... } foo(Map.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); сейчас.
Вы можете использовать что-то вроде этого:
public void addError(String path, String key, Object... params) {
}
params переменная не обязательна. Он рассматривается как обнуляемый массив объектов.
Странно, я не смог найти ничего об этом в документации, но это работает!
Это "новое" в Java 1.5 и более поздних версиях (не поддерживается в Java 1.4 или более ранних версиях).
Я вижу, что пользователь bhoot упомянул об этом и ниже.
В Java нет дополнительных параметров. То, что вы можете сделать, это перегрузить функции и затем передать значения по умолчанию.
void SomeMethod(int age, String name) {
//
}
// Overload
void SomeMethod(int age) {
SomeMethod(age, "John Doe");
}
К сожалению, Java не поддерживает параметры по умолчанию напрямую.
Однако я написал набор аннотаций JavaBean, и одна из них поддерживает параметры по умолчанию, такие как следующие:
protected void process(
Processor processor,
String item,
@Default("Processor.Size.LARGE") Size size,
@Default("red") String color,
@Default("1") int quantity) {
processor.process(item, size, color, quantity);
}
public void report(@Default("Hello") String message) {
System.out.println("Message: " + message);
}
Процессор аннотаций генерирует перегрузки метода для правильной поддержки этого.
См. http://code.google.com/p/javadude/wiki/Annotations
Полный пример на http://code.google.com/p/javadude/wiki/AnnotationsDefaultParametersExample
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 void load(String name){ }
public void load(String name,int age){}
Также вы можете использовать аннотацию @Nullable
public void load(@Nullable String name,int age){}
просто передайте ноль в качестве первого параметра.
Если вы передаете переменную того же типа, вы можете использовать это
public void load(String name...){}
Укороченная версия:
Используя три точки:
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);
(по ответу @ Виталия Федоренко)
Это будет зависеть от того, чего вы хотите достичь, varargs или перегрузка методов должны решить большинство сценариев. Вот несколько хороших примеров их использования:
но имейте в виду, чтобы не использовать перегрузку метода. это приносит путаницу.
Перегрузка - это хорошо, но если есть много переменных, которым нужно значение по умолчанию, вы получите:
public void methodA(A arg1) { }
public void methodA( B arg2,) { }
public void methodA(C arg3) { }
public void methodA(A arg1, B arg2) { }
public void methodA(A arg1, C arg3) { }
public void methodA( B arg2, C arg3) { }
public void methodA(A arg1, B arg2, C arg3) { }
Поэтому я бы предложил использовать Аргумент Переменной, предоставляемый Java. Вот ссылка для объяснения.
Если это конечная точка API, элегантным способом является использование аннотаций Spring:
@GetMapping("/api/foos")
@ResponseBody
public String getFoos(@RequestParam(required = false, defaultValue = "hello") String id) {
return innerFunc(id);
}
Обратите внимание, что в этом случае для innerFunc потребуется переменная, и, поскольку это не конечная точка api, нельзя использовать эту аннотацию Spring, чтобы сделать ее необязательной. Ссылка: https://www.baeldung.com/spring-request-param
Вы можете использовать класс, который работает как конструктор, чтобы содержать ваши дополнительные значения, подобные этому.
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. Этот подход был бы еще лучше, если бы вы могли использовать аннотации и генерацию кода для создания класса Options.
Аргументы по умолчанию не могут использоваться в Java и C#. Где в C++ и Python, мы можем использовать их..
В Java мы должны использовать 2 метода (функции) вместо одного с параметрами по умолчанию.
Пример:
Stash(int size);
Stash(int size, int initQuantity);
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
}
Это старый вопрос, возможно, даже до того, как был введен фактический необязательный тип, но в наши дни вы можете рассмотреть несколько вещей: - использовать перегрузку метода - использовать необязательный тип, который позволяет избежать передачи NULL вокруг необязательного типа, введенного в Java 8 до того, как он обычно использовался из сторонней библиотеки, такой как Google Guava. Использование необязательных параметров / аргументов можно рассматривать как чрезмерное использование, поскольку основной целью было использовать его как время возврата.
Ссылка: https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html
Мы можем сделать необязательный параметр путем перегрузки метода или с помощью 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;
}
Если вы планируете использовать интерфейс с несколькими параметрами, можно использовать следующий структурный шаблон и реализовать или переопределить apply - метод, основанный на ваших требованиях.
public abstract class Invoker<T> {
public T apply() {
return apply(null);
}
public abstract T apply(Object... params);
}