我遇到了一些具有以下结构的 Java 代码：
public MyParameterizedFunction(String param1, int param2)
{
this(param1, param2, false);
}
public MyParameterizedFunction(String param1, int param2, boolean param3)
{
//use all three parameters here
}
我知道在 C++ 中我可以为参数分配默认值。例如：
void MyParameterizedFunction(String param1, int param2, bool param3=false);
Java 是否支持这种语法？为什么这两个步骤语法更可取？
不，您找到的结构是 Java 处理它的方式（即使用重载而不是默认参数）。
对于构造函数，如果重载变得复杂，请参阅 Effective Java：编程语言指南的第 1 项提示（考虑静态工厂方法而不是构造函数）。对于其他方法，重命名某些情况或使用参数对象会有所帮助。这是当你有足够的复杂性，难以区分的时候。一个明确的情况是您必须使用参数的顺序来区分，而不仅仅是数字和类型。
不，但您可以使用Builder Pattern，如Stack Overflow answer中所述。
如链接答案中所述，构建器模式可让您编写如下代码
Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
.name("Spicoli")
.age(16)
.motto("Aloha, Mr Hand")
.buildStudent();
其中一些字段可以有默认值或者是可选的。
在 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");
这种方法的一个限制是，如果您有两个相同类型的可选参数并且其中任何一个都可以省略，则它不起作用。
可变参数。
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");
这种方法的主要缺点是，如果可选参数的类型不同，您将失去静态类型检查。此外，如果每个参数具有不同的含义，您需要一些方法来区分它们。
空值。为了解决以前方法的局限性，您可以允许空值，然后分析方法主体中的每个参数：
void foo(String a, Integer b, Integer c) {
b = b != null ? b : 0;
c = c != null ? c : 0;
//...
}
foo("a", null, 2);
现在必须提供所有参数值，但默认值可能为空。
选修课。这种方法类似于空值，但对具有默认值的参数使用 Java 8 Optional 类：
void foo(String a, Optional<Integer> bOpt) {
Integer b = bOpt.isPresent() ? bOpt.get() : 0;
//...
}
foo("a", Optional.of(2));
foo("a", Optional.<Integer>absent());
Optional 使调用者的方法契约明确，但是，人们可能会发现这样的签名过于冗长。
生成器模式。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 = (String)parameters.get("a");
} else if (parameters.containsKey("b")) {
//...
}
//...
}
foo(ImmutableMap.<String, Object>of(
"a", "a",
"b", 2,
"d", "value"));
请注意，您可以结合使用这些方法中的任何一种来获得理想的结果。
可悲的是没有。
不幸的是，是的。
void MyParameterizedFunction(String param1, int param2, bool param3=false) {}
可以用 Java 1.5 编写为：
void MyParameterizedFunction(String param1, int param2, Boolean... params) {
assert params.length <= 1;
bool param3 = params.length > 0 ? params[0].booleanValue() : false;
}
但是你是否应该取决于你对编译器生成一个
new Boolean[]{}
每次通话。
对于多个可默认参数：
void MyParameterizedFunction(String param1, int param2, bool param3=false, int param4=42) {}
可以用 Java 1.5 编写为：
void MyParameterizedFunction(String param1, int param2, Object... p) {
int l = p.length;
assert l <= 2;
assert l < 1 || Boolean.class.isInstance(p[0]);
assert l < 2 || Integer.class.isInstance(p[1]);
bool param3 = l > 0 && p[0] != null ? ((Boolean)p[0]).booleanValue() : false;
int param4 = l > 1 && p[1] != null ? ((Integer)p[1]).intValue() : 42;
}
这与 C++ 语法相匹配，后者仅允许在参数列表末尾使用默认参数。
除了语法之外，还有一个不同之处在于，它对传递的可默认参数进行运行时类型检查，而 C++ 类型在编译期间检查它们。
不，但你可以很容易地模仿它们。C++ 中的内容是：
public: void myFunction(int a, int b=5, string c="test") { ... }
在 Java 中，它将是一个重载函数：
public void myFunction(int a, int b, string c) { ... }
public void myFunction(int a, int b) {
myFunction(a, b, "test");
}
public void myFunction(int a) {
myFunction(a, 5);
}
前面提到过，默认参数在函数重载中会导致模棱两可的情况。这根本不是真的，我们可以在 C++ 的情况下看到：是的，也许它会产生模棱两可的情况，但这些问题可以很容易地处理。它根本不是用 Java 开发的，可能是因为创建者想要一种更简单的语言，就像 C++ 一样——如果他们做对了，那就是另一个问题了。但是我们大多数人不认为他使用 Java 是因为它的简单性。
您可以在 Scala 中执行此操作，它在 JVM 上运行并与 Java 程序兼容。 http://www.scala-lang.org/
IE
class Foo(var prime: Boolean = false, val rib: String) {}
而不是使用：
void parameterizedMethod(String param1, int param2) {
this(param1, param2, false);
}
void parameterizedMethod(String param1, int param2, boolean param3) {
//use all three parameters here
}
您可以通过使用一个方法来利用 java 的 Optional 功能：
void parameterizedMethod(String param1, int param2, @Nullable Boolean param3) {
param3 = Optional.ofNullable(param3).orElse(false);
//use all three parameters here
}
主要区别在于您必须使用包装类而不是原始 Java 类型来允许null输入。Boolean而不是boolean，Integer而不是int等等。
不，但最简单的实现方法是：
public myParameterizedFunction(String param1, int param2, Boolean param3) {
param3 = param3 == null ? false : param3;
}
public myParameterizedFunction(String param1, int param2) {
this(param1, param2, false);
}
或者代替三元运算符，您可以使用if：
public myParameterizedFunction(String param1, int param2, Boolean param3) {
if (param3 == null) {
param3 = false;
}
}
public myParameterizedFunction(String param1, int param2) {
this(param1, param2, false);
}
我可能会在这里说明显而易见的事情，但为什么不自己简单地实现“默认”参数呢？
public class Foo() {
public void func(String s){
func(s, true);
}
public void func(String s, boolean b){
//your code here
}
}
默认情况下，您可以使用
func("my string");
如果你不想使用默认值，你可以使用
func("my string", false);
正如提到的 Scala，Kotlin也值得一提。在 Kotlin 中，函数参数也可以有默认值，它们甚至可以引用其他参数：
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
...
}
与 Scala 一样，Kotlin 在 JVM 上运行，可以轻松集成到现有的 Java 项目中。
不。
您可以通过传递具有智能默认值的对象来实现相同的行为。但这又取决于您手头的情况。
不。一般来说，Java 没有太多（任何）语法糖，因为他们试图制作一种简单的语言。
如果你真的想，你可以使用手动检查null：
public MyParameterizedFunction(String param1, int param2, boolean param3)
{
if(param3 == null) {
param3 = false;
}
}
但是我强烈建议使用其他东西，例如重载或静态工厂。也许你可以逃脱惩罚，但它可能会导致意外行为。例如，您的代码中可能有错误，因此您的布尔值永远不会得到值。在这种情况下，您不会得到NullPointerException. 相反，它看起来像是被设置为 false，这可能会让调试非常混乱。
它不受支持，但有几个选项，例如使用带有一些语法糖的参数对象模式：
public class Foo() {
private static class ParameterObject {
int param1 = 1;
String param2 = "";
}
public static void main(String[] args) {
new Foo().myMethod(new ParameterObject() {{ param1 = 10; param2 = "bar";}});
}
private void myMethod(ParameterObject po) {
}
}
在这个示例中，我们ParameterObject使用默认值构造并在类实例初始化部分覆盖它们{ param1 = 10; param2 = "bar";}
试试这个解决方案：
public int getScore(int score, Integer... bonus)
{
if(bonus.length > 0)
{
return score + bonus[0];
}
return score;
}
您可以使用Java 方法调用构建器自动生成具有默认值的构建器。
只需将@GenerateMethodInvocationBuilder 添加到类或接口，并将@Default 添加到需要默认值的方法中的参数。将在编译时使用您在注释中指定的默认值生成构建器。
@GenerateMethodInvocationBuilder
public class CarService {
public CarService() {
}
public String getCarsByFilter(//
@Default("Color.BLUE") Color color, //
@Default("new ProductionYear(2001)") ProductionYear productionYear,//
@Default("Tomas") String owner//
) {
return "Filtering... " + color + productionYear + owner;
}
}
然后你可以调用这些方法。
CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
.invoke(instance);
或者将任何默认值设置为其他值。
CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
.withColor(Color.YELLOW)//
.invoke(instance);
它在 java 中不受支持，就像在其他语言中一样。科特林。
在 Java 8 中工作的与https://stackoverflow.com/a/13864910/2323964类似的方法是使用带有默认 getter 的接口。这将是更多的空白，但是是可模拟的，当你有一堆你真正想要引起对参数的注意的实例时，它非常有用。
public class Foo() {
public interface Parameters {
String getRequired();
default int getOptionalInt(){ return 23; }
default String getOptionalString(){ return "Skidoo"; }
}
public Foo(Parameters parameters){
//...
}
public static void baz() {
final Foo foo = new Foo(new Person() {
@Override public String getRequired(){ return "blahblahblah"; }
@Override public int getOptionalInt(){ return 43; }
});
}
}
我现在花了很多时间来弄清楚如何将它与返回值的方法一起使用，到目前为止我还没有看到任何示例，我认为在此处添加它可能很有用：
int foo(int a) {
// do something with a
return a;
}
int foo() {
return foo(0); // here, 0 is a default value for a
}
有六个或更好的问题，最终，你会到达静态工厂模式......请参阅加密 API。排序很难解释，但是这样想：如果你有一个构造函数，无论是默认的还是其他的，将状态传播到花括号之外的唯一方法是要么有一个布尔值 isValid；（连同 null 作为默认值 v 失败的构造函数）或抛出一个异常，从字段用户那里取回它时永远不会提供信息。
代码正确该死，我写了千行构造函数并做我需要的事情。我发现在对象构造中使用 isValid - 换句话说，两行构造函数 - 但由于某种原因，我正在迁移到静态工厂模式。如果您在方法调用中，我似乎可以做很多事情，但仍然存在 sync() 问题，但可以更好地“替换”默认值（更安全）
我认为我们需要在这里做的是解决 null 作为默认值相对于某些东西的问题 String one=new String(""); 作为成员变量，然后在分配传递给构造函数的字符串之前检查是否为空。
用 Java 完成的原始、平流层计算机科学的数量非常惊人。
C++ 等有供应商库，是的。由于它是一个庞大的工具箱，Java 可以在大型服务器上超越它们。研究静态初始化块，和我们在一起。
这就是我的做法......它可能不如针对您定义的参数使用“可选参数”方便，但它可以完成工作：
public void postUserMessage(String s,boolean wipeClean)
{
if(wipeClean)
{
userInformation.setText(s + "\n");
}
else
{
postUserMessage(s);
}
}
public void postUserMessage(String s)
{
userInformation.appendText(s + "\n");
}
请注意，我可以仅使用字符串调用相同的方法名称，也可以使用字符串和布尔值调用它。在这种情况下，将wipeClean 设置为true 会将我的TextArea 中的所有文本替换为提供的字符串。将wipeClean 设置为false 或将其全部忽略只会将提供的文本附加到TextArea。
另请注意，我并没有在这两种方法中重复代码，我只是添加了能够通过创建一个具有相同名称的新方法来重置 TextArea 的功能，并且只添加了布尔值。
实际上，我认为这比 Java 为我们的参数提供一个“可选参数”要干净一些，因为我们需要为默认值等编写代码。在这个例子中，我不需要担心任何这些。是的，我在课堂上添加了另一种方法，但从长远来看，以我的拙见，它更容易阅读。
不，但是我们有函数重载形式的替代方案。
未传递参数时调用
void operation(){
int a = 0;
int b = 0;
}
在传递“a”参数时调用
void operation(int a){
int b = 0;
//code
}
当参数 b 传递时调用
void operation(int a , int b){
//code
}
一个想法是使用String... args
public class Sample {
void demoMethod(String... args) {
for (String arg : args) {
System.out.println(arg);
}
}
public static void main(String args[] ) {
new Sample().demoMethod("ram", "rahim", "robert");
new Sample().demoMethod("krishna", "kasyap");
new Sample().demoMethod();
}
}
输出
ram
rahim
robert
krishna
kasyap
来自https://www.tutorialspoint.com/Does-Java-support-default-parameter-values-for-a-method
像 for 方法这样的构造函数
static void popuping() {
popuping("message", "title");
}
static void popuping(String message) {
popuping(message, "title");
}
static void popuping(String message, String title){
JOptionPane.showMessageDialog(null, message,
title, JOptionPane.INFORMATION_MESSAGE);
}
您可以使用以下 -
public void mop(Integer x) {
// Define default values
x = x == null ? 200 : x;
}