Java에서 선택적 매개 변수를 사용하려면 어떻게합니까? 선택적 사양을 지원하는 사양은 무엇입니까?

varargs는 (어떻게 든) 그렇게 할 수 있습니다. 그 외에 메소드 선언의 모든 변수를 제공해야합니다. 변수를 선택적으로 사용하려면 매개 변수가 필요없는 서명을 사용하여 메서드를 오버로드 할 수 있습니다.

private boolean defaultOptionalFlagValue = true;

public void doSomething(boolean optionalFlag) {
    ...
}

public void doSomething() {
    doSomething(defaultOptionalFlagValue);
}

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. Varargs.

   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");

   이 방법의 주요 단점은 선택적 매개 변수가 다른 유형 인 경우 정적 유형 검사를 잃는다는 것입니다. 또한 각 매개 변수의 의미가 다른 경우이를 구별 할 방법이 필요합니다.

3. 널. 이전 접근법의 한계를 해결하기 위해 널값을 허용 한 후 메소드 본문에서 각 매개 변수를 분석 할 수 있습니다.

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

   이제 모든 인수 값을 제공해야하지만 기본 값은 null 일 수 있습니다.

4. 선택적 수업. 이 방법은 null과 비슷하지만 기본값이있는 매개 변수에 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());

   선택 사항은 호출자에게 메소드 계약을 명시 적으로 표시하지만, 그러한 서명이 너무 자세 할 수 있습니다.

   업데이트 : Java 8에는 java.util.Optional즉시 사용 가능한 클래스가 포함되어 있으므로 Java 8 에서이 특별한 이유로 구아바를 사용할 필요가 없습니다. 그러나 메소드 이름은 약간 다릅니다.

5. 빌더 패턴. 빌더 패턴은 생성자에 사용되며 별도의 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 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는 기본 매개 변수를 직접 지원하지 않습니다.

그러나 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/ 주석을 참조하십시오 .

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 및 과부하가 언급되었습니다. 또 다른 옵션은 다음과 같은 빌더 패턴입니다.

 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){}

단순히 첫 번째 매개 변수로 null을 전달하십시오.

동일한 유형 변수를 전달하면 이것을 사용할 수 있습니다

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); 

(@VitaliiFedorenko의 답변을 기반으로 함)

오버로드는 괜찮지 만 기본값이 필요한 변수가 많으면 다음과 같이 끝납니다.

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에서 제공하는 Variable Argument를 사용하는 것이 좋습니다. 다음 은 설명을 위한 링크 입니다.

빌더와 매우 유사한 클래스를 사용하여 이와 같은 선택적 값을 포함 할 수 있습니다.

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는 이제 1.8에서 옵션을 지원합니다 .Android에서 프로그래밍이 중단되어 선택적 유형을 사용하도록 코드를 리팩터링 할 때까지 null을 사용하고 있습니다.

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

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

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-

이것은 실제 선택적 유형이 도입되기 전에도 오래된 질문이지만 요즘에는 몇 가지 사항을 고려할 수 있습니다. Google의 구아바와 같은 타사 라이브러리에서 선택 사항을 매개 변수 / 인수로 사용하는 것이 주된 목적으로 반환 시간으로 사용했기 때문에 초과 사용으로 간주 될 수 있습니다.

참조 : https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html

메소드 오버로드 또는 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;
}

가장 쉬운 방법은

| * | DataType ...은 선택적 매개 변수 일 수 있습니다.

RetDataType NameFnc(int NamePsgVar, String... stringOpnPsgVar)
{
    if(stringOpnPsgVar.length == 0)  stringOpnPsgVar = DefaultValue; 

    // |* Code Todo *|
    return RetVar;
}

당신이 경우 여러 매개 변수 인터페이스를 사용할 계획 , 하나는 다음 사용할 수있는 구조 패턴을 기반으로하는 방법 - 적용 및 구현하거나 무시 귀하의 요구 사항을 .

public abstract class Invoker<T> {
    public T apply() {
        return apply(null);
    }
    public abstract T apply(Object... params);
}

API 엔드 포인트 인 경우 우아한 방법은 "봄"주석을 사용하는 것입니다.

@GetMapping("/api/foos")
@ResponseBody
public String getFoos(@RequestParam(required = false, defaultValue = "hello") String id) { 
    return innerFunc(id);
}

이 경우 innerFunc에는 변수가 필요하며 api 엔드 포인트가 아니므로이 스프링 주석을 사용하여 선택적으로 만들 수 없습니다. 참조 : https://www.baeldung.com/spring-request-param