Поддерживает ли 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 обрабатывает ее (то есть с перегрузкой вместо параметров по умолчанию).

Конструкторы см. В разделе 1 «Эффективная Java: Руководство по языку программирования» (рассмотрим статические фабричные методы вместо конструкторов), если перегрузка усложняется. Для других методов может помочь переименование некоторых случаев или использование объекта параметра. Это когда у вас достаточно сложности, чтобы дифференцировать сложно. Определенный случай, когда вы должны различать, используя порядок параметров, а не только число и тип.

Нет, но вы можете использовать шаблон Builder , как описано в ответе на переполнение стека .

Как описано в связанном ответе, шаблон Builder позволяет писать код

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. С переменным числом аргументов.

   а) Все необязательные параметры имеют одинаковый тип:

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

   Основным недостатком этого подхода является то, что если дополнительные параметры имеют разные типы, вы теряете статическую проверку типов. Кроме того, если каждый параметр имеет разное значение, вам нужен какой-то способ их различения.

3. Нулевые. Чтобы устранить ограничения предыдущих подходов, вы можете разрешить нулевые значения, а затем проанализировать каждый параметр в теле метода:

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

   Теперь все значения аргументов должны быть предоставлены, но значения по умолчанию могут быть нулевыми.

4. Необязательный класс. Этот подход аналогичен пустым значениям, но использует необязательный класс 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());

   Необязательно делает контракт метода явным для вызывающей стороны, однако, такая сигнатура может оказаться слишком многословной.

5. Образец строителя. Шаблон 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();

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 ++: да, возможно, он может создавать неоднозначные случаи, но эти проблемы могут быть легко решены. Он просто не был разработан в Java, возможно, потому, что создатели хотели гораздо более простой язык, чем был C ++ - если они имели право, это другой вопрос. Но большинство из нас не думают, что он использует 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);
}

Я мог бы заявить об очевидном здесь, но почему бы просто не реализовать параметр «по умолчанию» самостоятельно?

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
}

Основное отличие состоит в том, что вы должны использовать классы-обертки вместо примитивных типов Java, чтобы разрешить nullввод. 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 Method Invocation Builder для автоматической генерации компоновщика со значениями по умолчанию.

Просто добавьте @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);

Аналогичный подход к https://stackoverflow.com/a/13864910/2323964, который работает в Java 8, заключается в использовании интерфейса с получателями по умолчанию. Это будет более детализированный пробел, но это будет насмешливо, и это здорово, когда у вас есть куча примеров, когда вы действительно хотите привлечь внимание к параметрам.

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; (вместе со значением NULL в качестве значения по умолчанию v конструктор с ошибкой) или сгенерировать исключение, которое никогда не будет информативным при получении его от полевых пользователей.

Будь проклят код, я пишу тысячи конструкторов строк и делаю то, что мне нужно. Я использую isValid при построении объектов - другими словами, двухстрочные конструкторы - но по какой-то причине я перехожу на статический шаблон фабрики. Я просто думаю, что вы можете многое сделать, если вы в вызове метода, все еще есть проблемы с sync (), но значения по умолчанию можно «заменить» лучше (безопаснее)

Я думаю, что здесь нам нужно решить проблему с нулем как значение по умолчанию для чего-то String one = new String (""); в качестве переменной-члена, затем выполняет проверку на нулевое значение, прежде чем присваивать строку, переданную в конструктор.

Весьма примечательно, что на Яве сделано огромное количество необработанных стратосферных компьютерных наук.

C ++ и т. Д. Имеет библиотеки поставщика, да. Java может опередить их на крупных серверах, потому что это огромный набор инструментов. Изучите статические блоки инициализатора, оставайтесь с нами.

Это не поддерживается в Java, как в других языках, например. Котлин.

Вы можете использовать следующие

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