Java дефолтные значения аргументов

Does Java have default parameters?

Many programming languages like C++ or modern JavaScript have a simple option to call a function without providing values for its arguments. In Java, default method parameters require a bit more typing to achieve this effect in comparison to other languages. From this article, you will learn how the default method parameters work in Java.

1. Java default parameters in practice

The syntax of Java language doesn’t allow you to declare a method with a predefined value for a parameter. Fortunately, you can achieve the same effect with simple code constructions.

There are several options that you may use to simulate behavior known from other programming languages. You can:

• use method overloading
• allow nulls as an input
• declare a method with Java Varargs

Let’s take a closer look at these options.

1.1. Java default parameters with method overloading

Probably the best option to achieve default method parameters in Java is by using the method overloading. Method overloading allows you to declare several methods with the same name but with a different number of parameters.

How to use method overloading to simulate default method parameters?

By calling a more complex method by a simpler one.

Here is a practical example of a method which allows you to query for an optional number of some documents:

List search(String query) < return search(query, 10, 0); >List search(String query, Integer limit, Integer offset) < // method implementation >

The only required parameter is a query string. As you can see, you only have to implement the method with the highest number of parameters. To clarify, the simple method is just a proxy that passes its parameter to the more complex method and provides default parameter values for the optional arguments.

In comparison to other options, the main advantage of method overloading is the simplicity for the client code. You can easily read what set of parameters is allowed for a given method.

Although method overloading is strongly recommended, it’s worth knowing about other possibilities.

1.2. Allowing Nulls as method parameters

Another option is to declare a single method that accepts all possible parameters. Next, in the body of the method, you can check which parameters are nulls and assign them default values.

In this approach, our previous example looks as follows:

List search(String query, Integer limit, Integer offset) < if (limit == null) < limit = 10; >if (offset == null) < offset = 0; >// method implementation >

There are two main disadvantages to this approach. First, you still need to pass all arguments in client code. Even if some of them are nulls. Second, you need to know which parameters are nullable as you can’t tell that just by looking at the method declaration.

What is more, many developers consider reassinging method parameters as bad practice as it makes the code harder to follow. With this in mind, many static code analysis tools allow you to check for this kind of code smell.

1.3. Varargs parameter

The Varargs option is limited only to arguments of the same type and meaning. Therefore, it doesn’t actually solve the problem of default parameters in Java methods. But you may consider it in some cases.

User createUser(String login, Right. rights) < rights = User.DEFAULT_RIGHTS; // implementation >

Technically, it’s even possible to use Varargs as a single optional parameter. In this case, you don’t have to pass null in the client code to use the default value. Yet, it rather feels like an awful hack. I recommend sticking to method overloading.

2. Java default parameters in long parameter list

The main problem with method overloading as a solution for default parameter values reveals itself when a method accepts multiple parameters. Creating an overloaded method for each possible combination of parameters might be cumbersome.

Simply put, the Parameter Object is a wrapper object for all parameters of a method.

But wait! Aren’t we just moving the problem of the long parameter list from a method to the constructor of the new class?

Indead, we are. But class constructors give us one additional solution for the problem which is the Builder pattern.

2.1. Solving Java default parameters with Parameter Object

As mentioned before, the first thing you need is a parameter object class that wraps the list of method parameters. Let’s see how it can look like for a method from the previous example:

As you can see, the implemented parameter object is nothing more than just a regular POJO. The advantage of the Parameter Object over a regular method parameter list is the fact that class fields can have default values. Just like in the above example.

That’s it. Now you have all default parameters in a single place.

2.2. … and Builder patterns

Once you create a wrapper class for the method parameter list you should also create a corresponding builder class. Usually, you’ll do it as an inner static class.

But don’t type builders alone, automate this work!

Popular Java IDEs provide plugins that generate builder classes.

In our example the builder will look as follows:

class SearchParams < // getters . private SearchParams(Builder builder) < query = builder.query; limit = builder.limit; offset = builder.offset; >public static Builder newBuilder() < return new Builder(); >public static final class Builder < private String query; private int limit; private int offset; private Builder() < >public Builder withQuery(String val) < query = val; return this; >public Builder withLimit(int val) < limit = val; return this; >public Builder withOffset(int val) < offset = val; return this; >public SearchParams build() < return new SearchParams(this); >> >

The final step is to use the builder to construct a new parameter object. In this case, you assign only selected parameters. For those parameters you skip, their default values are going to be used. Here’s an example:

SearchParams params = SearchParams.newBuilder() .withQuery("gold") .withOffset(20) .build(); // params.limit = 10 by default

Our example is really simple as the method has only three parameters so it might look like overengineering. In fact, the solution for default parameters using Parameter Object and Builder shines when the list of method parameters is much longer.

Conclusion

Java doesn’t have a simple solution for default method parameters as available in other common programming languages. Yet, you can simulate it using other Java constructions and patterns. In addition, you learn a simple approach with method overloading which works for methods with a short parameter list. For complex methods, the Parameter Object pattern is more flexible.

If you find the article useful, please share it with your friends. Don’t forget to subscribe so I can notify you about other similar posts.

Источник

Поддерживает ли Java значения параметров по умолчанию?

В некоторых языках программирования, таких как C++, разработчики могут назначать дефолтные значения для параметров функции. Это позволяет им вызывать функцию с меньшим количеством аргументов, чем объявлено, и параметры, для которых значения не указаны, будут автоматически принимать их значения по умолчанию. Вот пример на C++:

void MyFunction(int param1, bool param2=false) < // код функции >

В этом примере, если функция MyFunction вызывается только с одним аргументом, то param2 автоматически получает значение false .

Но как обстоят дела с Java? Поддерживает ли Java такую функциональность?

Ответ: Нет, Java не поддерживает значения параметров по умолчанию

В языке Java нет встроенной поддержки значений параметров по умолчанию. Если функция в Java ожидает два параметра при вызове, то необходимо предоставить оба параметра. Нет возможности определить значения по умолчанию для параметров, как это делается в C++.

Альтернативный подход в Java

Но в Java существует альтернативный подход для достижения похожего результата, который называется перегрузкой методов. Это означает, что можно создать несколько методов с одинаковыми именами, но различающимися списками параметров.

public void MyFunction(String param1, int param2) < this(param1, param2, false); >public void MyFunction(String param1, int param2, boolean param3) < // используется все три параметра >

В этом примере, если метод MyFunction вызывается только с двумя аргументами, то третий параметр автоматически получает значение false .

Заключение

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

Источник

Необязательные параметры методов — Основы Java

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

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

Это наглядно видно на таком примере:

// Пример того, как задаются параметры по умолчанию в языке JavaScript class App  // Функция возведения в степень // Степень — это второй параметр со значением по умолчанию 2 function pow(x, base = 2)  return x ** base; > > App.pow(3); // Результат — 9, так как по умолчанию возводим во вторую степень // Возводим в третью степень App.pow(3, 3); // 27 

В отличие от других языков, в Java нет возможности задать значение по умолчанию, но ее можно имитировать с помощью перегрузки методов.

Что это такое? Java позволяет создать несколько методов с одинаковым именем. У таких одинаковых методов должны быть:

• Разные типы входных параметров
• Разное количество параметров
• Или все это одновременно

Посмотрим на примере метода, складывающего два числа:

class App  public static int sum(int x, int y)  return x + y; > > App.sum(2, 3); // 5 

Теперь напишем другой метод sum() , который принимает только один параметр и складывает его с числом 10:

class App  public static int sum(int x)  return x + 10; > > App.sum(2); // 12 App.sum(2, 1); // 3 

Компилятор без проблем выполнит такой код и создаст два метода с одним именем. Как Java узнает, какой метод нужно использовать?

Все очень просто: во время компиляции выбирается та версия метода, которая совпадает по типу и количеству параметров. Если такой метод не был найден, то возникнет ошибка.

Как минимум с одним перегруженным методом мы уже встречались — это метод substring() . По умолчанию он извлекает подстроку до конца, но ему можно передать второй параметр, который ограничит длину:

// Вызываются два разных метода с одним именем "hexlet".substring(3); // "let" "hexlet".substring(3, 5); // "le" 

Перегрузка методов может приводить к дублированию кода, особенно когда речь идет про значения по умолчанию. В таких ситуациях логика одинаковая, разница лишь в начальной инициализации.

Для снижения дублирования достаточно сделать два шага:

• Сначала определить общий метод, который принимает больше всего параметров
• Затем вызывать его из тех методов, где есть значения по умолчанию

class App  public static int sum(int x, int y)  return x + y; > public static int sum(int x)  // Вызываем уже готовый метод суммирования return sum(x, 10); > > 

В этом примере мы не сократили код, но он наглядно показывает принцип, описанный выше.

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Об обучении на Хекслете

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Источник