Чи підтримує 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. Вараги.

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

   б) Типи необов'язкових параметрів можуть бути різними:

   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:

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

Як згадувався Скала, Котлін також варто згадати. У функціях Kotlin параметри можуть мати також значення за замовчуванням, і вони навіть можуть посилатися на інші параметри:

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
    ...
}

Як і Scala, Котлін працює на 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 на помилкове або залишити його разом, просто додає наданий текст до 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 при побудові об'єктів - іншими словами, дворядкові конструктори - але я чомусь переходжу до статичної заводської структури. Мені здається, ви можете зробити багато, якщо у виклику методу все ще виникають проблеми синхронізації (), але за замовчуванням можна краще "замінити" (безпечніше)

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

Дуже примітна кількість сировини, стратосферної інформатики, зробленої на Яві.

C ++ і так далі має ліцензії постачальників, так. Java може випередити їх на великомасштабних серверах завдяки масивній панелі інструментів. Вивчіть статичні блоки ініціалізатора, залишайтеся з нами.

Він не підтримується в Java, як і в іншій мові, наприклад. Котлін.

Ви можете використовувати наступні-

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