Как использовать дополнительные параметры в Java? Какая спецификация поддерживает дополнительные параметры?
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"));
Обратите внимание, что вы можете комбинировать любой из этих подходов для достижения желаемого результата.
Вы можете использовать что-то вроде этого:
public void addError(String path, String key, Object... params) {
}
Переменная params не является обязательной. Он рассматривается как нулевой массив объектов.
Странно, я ничего не мог найти об этом в документации, но он работает!
Это "новое" в Java 1.5 и выше (не поддерживается в Java 1.4 или ранее).
Я вижу, что пользовательский bhoot упоминал об этом ниже.
В Java 5.0 есть необязательные параметры. Просто объявите вашу функцию следующим образом:
public void doSomething(boolean... optionalFlag) {
//default to "false"
//boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}
Вы можете позвонить с помощью doSomething(); или сделать что- doSomething(true); сейчас.
К сожалению, 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
В Java нет дополнительных параметров. Что вы можете сделать, это перегрузить функции, а затем передать значения по умолчанию.
void SomeMethod(int age, String name) {
//
}
// Overload
void SomeMethod(int age) {
SomeMethod(age, "John Doe");
}
Были упомянуты 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);
}
}
}
Это будет зависеть от того, чего вы хотите достичь, varargs или перегрузка методов должны решить большинство сценариев. Вот несколько хороших примеров их использования:
http://blog.sleekface.com/in/java-core/method-with-optional-parameters/
но имейте в виду, чтобы не использовать перегрузку метода. это приносит путаницу.
Использование трех точек:
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);
(на основании ответа Виталия Федоренко)
Вы можете делать вещи, используя перегрузку метода, как это.
public void load(String name){ }
public void load(String name,int age){}
Также вы можете использовать @Nullable аннотацию
public void load(@Nullable String name,int age){}
просто передайте null в качестве первого параметра.
Если вы передаете переменную того же типа, вы можете использовать этот
public void load(String name...){}
Перегрузка - это хорошо, но если есть много переменных, для которых требуется значение по умолчанию, вы получите:
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) { }
Поэтому я бы предложил использовать аргумент Variable Argument, предоставляемый 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
}
Вы можете использовать класс, который работает как конструктор, чтобы содержать ваши дополнительные значения, подобные этому.
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++ и Python, мы можем использовать их..
В Java мы должны использовать 2 метода (функции) вместо одного с параметрами по умолчанию.
Пример:
Stash(int size);
Stash(int size, int initQuantity);
Мы можем сделать необязательный параметр путем перегрузки метода или использования 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;
}
Это старый вопрос, может быть, даже до того, как был введен фактический тип Optional, но в наши дни вы можете рассмотреть несколько вещей: - использовать перегрузку метода - использовать тип Optional, который имеет преимущество в том, что позволяет избежать передачи NULL вокруг типа Optional, который был введен в Java 8 до того, как его обычно использовали. из сторонних библиотек, таких как Google Guava. Использование необязательных параметров/параметров можно рассматривать как чрезмерное использование, поскольку основной целью было использовать его как время возврата.
Ссылка: https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html