Java가 기본 매개 변수 값을 지원합니까?

다음과 같은 구조를 가진 일부 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가 Java를 처리하는 방식입니다 (즉, 기본 매개 변수 대신 오버로드 사용).

생성자 가 오버로드가 복잡 해지는 경우 효과적인 Java : 프로그래밍 언어 안내서의 항목 1 팁 (생성자 대신 정적 팩토리 메소드 고려)을 참조하십시오. 다른 방법의 경우 일부 사례의 이름을 바꾸거나 매개 변수 객체를 사용하면 도움이 될 수 있습니다. 이것은 차별화가 어려운 복잡성이 충분할 때입니다. 명확한 경우는 숫자와 유형뿐만 아니라 매개 변수의 순서를 사용하여 차별화해야하는 경우입니다.

아니요, 그러나이 스택 오버플로 답변에 설명 된대로 빌더 패턴을 사용할 수 있습니다 .

링크 된 답변에 설명 된 것처럼 빌더 패턴을 사용하면 다음과 같은 코드를 작성할 수 있습니다

Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
                 .name("Spicoli")
                 .age(16)
                 .motto("Aloha, Mr Hand")
                 .buildStudent();

일부 필드는 기본값을 가질 수 있거나 그렇지 않은 경우 선택 사항입니다.

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

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

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 = (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 ++의 경우에서 볼 수 있습니다. 예, 모호한 경우를 만들 수 있지만 이러한 문제는 쉽게 처리 할 수 ​​있습니다. C ++처럼 훨씬 간단한 언어를 원했기 때문에 Java로 개발되지 않았을 것입니다. 그러나 대부분의 사람들은 단순성 때문에 Java를 사용하지 않는다고 생각합니다.

이 작업은 Scala에서 수행되며, JVM에서 실행되며 Java 프로그램과 호환됩니다. http://www.scala-lang.org/

즉

class Foo(var prime: Boolean = false, val rib: String)  {}

아니요 , 그러나 이것을 구현하는 가장 간단한 방법 은 다음과 같습니다.

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

여기에 명백한 내용이 있지만 "default"매개 변수를 직접 구현하지 않는 이유는 무엇입니까?

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는 간단한 언어를 만들려고 시도했기 때문에 많은 구문 설탕이 없습니다.

사용하는 대신:

void parameterizedMethod(String param1, int param2) {
    this(param1, param2, false);
}

void parameterizedMethod(String param1, int param2, boolean param3) {
    //use all three parameters here
}

단일 메소드를 사용하여 java의 선택적 기능을 활용할 수 있습니다.

void parameterizedMethod(String param1, int param2, @Nullable Boolean param3) {
    param3 = Optional.ofNullable(param3).orElse(false);
    //use all three parameters here
}

주요 차이점은 null입력 을 허용하려면 기본 Java 유형 대신 랩퍼 클래스를 사용해야한다는 것 입니다. Boolean대신에 boolean, Integer대신에 int등등.

지원되지 않지만 일부 구문 설탕과 함께 매개 변수 객체 패턴을 사용하는 것과 같은 몇 가지 옵션이 있습니다.

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 8에서 작동 하는 https://stackoverflow.com/a/13864910/2323964에 대한 비슷한 접근 방식 은 기본 게터가있는 인터페이스를 사용하는 것입니다. 이것은 더 많은 공백이 될 것이지만 조롱 할 수 있으며 실제로 매개 변수에주의를 기울이려는 인스턴스가 많은 경우에 좋습니다.

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
}

이것은 내가 한 방법입니다 ... 정의 된 매개 변수에 대해 '선택적 인수'를 갖는 것만 큼 편리하지는 않지만 작업을 완료합니다.

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
} 

이와 같은 십여 가지 이상의 문제가 있습니다. 결국 정적 팩토리 패턴에 도달합니다 ... 암호 API를 참조하십시오. 설명하기는 어렵지만 다음과 같이 생각하십시오. 기본 또는 기타 생성자가있는 경우 중괄호를 넘어서 상태를 전파하는 유일한 방법은 부울 isValid입니다. (기본값 v 실패 생성자로 널과 함께) 또는 필드 사용자로부터 다시 가져올 때 정보가없는 예외를 발생시킵니다.

Code Correct는 저주를 받았으며 수천 줄의 생성자를 작성하고 필요한 작업을 수행합니다. 객체 구성에서 isValid를 사용한다는 것을 알 수 있습니다. 다시 말하면 2 줄 생성자입니다. 그러나 어떤 이유로 정적 팩토리 패턴으로 마이그레이션하고 있습니다. 메소드 호출에서 여전히 많은 작업을 수행 할 수 있지만 여전히 sync () 문제가 있지만 기본값은 더 나은 '대체'될 수 있습니다 (더 안전합니다)

여기에서해야 할 일은 null 문제를 기본값으로 표시하는 것입니다. string one = new String ( ""); 멤버 변수로, 생성자에 전달 된 문자열을 할당하기 전에 null을 확인합니다.

Java로 수행 된 원시, 성층권 컴퓨터 과학의 양이 매우 뛰어납니다.

C ++ 등에는 공급 업체 라이브러리가 있습니다. Java는 대규모 도구 상자로 인해 대규모 서버에서이를 능가 할 수 있습니다. 정적 초기화 블록을 연구하고 우리와 함께하십시오.

예를 들어 다른 언어와 마찬가지로 Java에서는 지원되지 않습니다. 코 틀린

다음을 사용할 수 있습니다

public void mop(Integer x) {
  // Define default values
        x = x == null ? 200 : x;
}