什么规范支持可选参数?
变量函数可以(以某种方式)做到这一点。除此之外,必须提供方法声明中的所有变量。如果希望变量是可选的,可以使用不需要参数的签名重载方法。
private boolean defaultOptionalFlagValue = true;
public void doSomething(boolean optionalFlag) {
...
}
public void doSomething() {
doSomething(defaultOptionalFlagValue);
}
Java中没有可选参数。你能做的就是重载函数,然后传递默认值。
void SomeMethod(int age, String name) {
//
}
// Overload
void SomeMethod(int age) {
SomeMethod(age, "John Doe");
}
VarArgs和重载已经被提到。另一种选择是Bloch Builder模式,它看起来像这样:
MyObject my = new MyObjectBuilder().setParam1(value)
.setParam3(otherValue)
.setParam6(thirdValue)
.build();
尽管这种模式最适合于在构造函数中需要可选参数的情况。
Java 5.0中有可选参数。只需像这样声明你的函数:
public void doSomething(boolean... optionalFlag) {
//default to "false"
//boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}
你可以调用doSomething();或doSomething(真正的);现在。
你可以这样使用:
public void addError(String path, String key, Object... params) {
}
params变量是可选的。它被视为对象的可空数组。
奇怪的是,我在文档中找不到任何关于这个的东西,但它是有效的!
这是Java 1.5及以上版本的“新功能”(Java 1.4或更早版本不支持)。
我看到用户bhoot在下面也提到了这一点。
在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);
}
}
}
在Java中有几种模拟可选参数的方法:
方法重载。 void foo(字符串a,整数b) { / /…… } void foo(字符串a) { foo (0);//这里,0是b的默认值 } foo (" a ", 2); foo(“a”);
这种方法的局限性之一是,如果有两个相同类型的可选参数,并且可以省略其中任何一个,则该方法将不起作用。
瓦拉格斯。
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);
b)可选参数类型可能不同:
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");
这种方法的主要缺点是,如果可选参数的类型不同,则会丢失静态类型检查。此外,如果每个参数具有不同的含义,则需要某种方法来区分它们。
null。为了解决前面方法的局限性,你可以允许空值,然后在方法体中分析每个参数: void foo(字符串a,整数b,整数c) { B = B != null ?B: 0; C = C != null ?C: 0; / /…… } Foo ("a", null, 2);
现在必须提供所有参数值,但默认值可能为空。
Optional class. This approach is similar to nulls, but uses Java 8 Optional class for parameters that have a default value: void foo(String a, Optional bOpt) { Integer b = bOpt.isPresent() ? bOpt.get() : 0; //... } foo("a", Optional.of(2)); foo("a", Optional.absent()); Optional makes a method contract explicit for a caller, however, one may find such signature too verbose. Update: Java 8 includes the class java.util.Optional out-of-the-box, so there is no need to use guava for this particular reason in Java 8. The method name is a bit different though. Builder pattern. The builder pattern is used for constructors and is implemented by introducing a separate Builder class: 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(); Maps. When the number of parameters is too large and for most of the default values are usually used, you can pass method arguments as a map of their names/values: 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")); In Java 9, this approach became easier: @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中不能使用默认参数。在c#, c++和Python中,我们可以使用它们。
在Java中,我们必须使用两个方法(函数),而不是一个具有默认参数的方法。
例子:
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-
重载很好,但是如果有很多变量需要默认值,你最终会得到:
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提供的变量参数。
你可以像这样使用方法重载。
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...){}
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 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);
(根据@VitaliiFedorenko的回答)
我们可以通过方法重载或使用DataType…
方法重载:
RetDataType NameFnc(int NamePsgVar)
{
// |* Code Todo *|
return RetVar;
}
RetDataType NameFnc(String NamePsgVar)
{
// |* Code Todo *|
return RetVar;
}
RetDataType NameFnc(int NamePsgVar1, String NamePsgVar2)
{
// |* Code Todo *|
return RetVar;
}
最简单的方法是
| * |数据类型……可选参数
RetDataType NameFnc(int NamePsgVar, String... stringOpnPsgVar)
{
if(stringOpnPsgVar.length == 0) stringOpnPsgVar = DefaultValue;
// |* Code Todo *|
return RetVar;
}
您可以使用类似于构建器的类来包含可选值,如下所示。
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类,这种方法就更好了。
这是一个老问题,甚至在实际的可选类型引入之前,但现在你可以考虑以下几件事: -使用方法重载 - use可选类型,优点是避免传递空值 可选类型是在Java 8中引入的,通常是在第三方lib(如谷歌的Guava)中使用。使用optional作为参数/参数可能被认为是过度使用,因为主要目的是将其用作返回时间。
裁判:https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html
如果您计划使用具有多个参数的接口, 可以使用以下结构模式,并根据您的需求实现或重写apply方法。
public abstract class Invoker<T> {
public T apply() {
return apply(null);
}
public abstract T apply(Object... params);
}
如果它是一个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
推荐文章
- 到底是什么导致了堆栈溢出错误?
- 为什么Android工作室说“等待调试器”如果我不调试?
- Java:路径vs文件
- ExecutorService,如何等待所有任务完成
- Maven依赖Servlet 3.0 API?
- 如何在IntelliJ IDEA中添加目录到应用程序运行概要文件中的类路径?
- getter和setter是糟糕的设计吗?相互矛盾的建议
- Android room persistent: AppDatabase_Impl不存在
- Java的String[]在Kotlin中等价于什么?
- Intellij IDEA上的System.out.println()快捷方式
- 使用Spring RestTemplate获取JSON对象列表
- Spring JPA选择特定的列
- URLEncoder不能翻译空格字符
- Java中的super()
- 如何转换JSON字符串映射<字符串,字符串>与杰克逊JSON