Apakah Java mendukung nilai parameter default?

Saya menemukan beberapa kode Java yang memiliki struktur berikut:

public MyParameterizedFunction(String param1, int param2)
{
    this(param1, param2, false);
}

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

Saya tahu bahwa di C ++ saya dapat menetapkan parameter sebagai nilai default. Sebagai contoh:

void MyParameterizedFunction(String param1, int param2, bool param3=false);

Apakah Java mendukung sintaks semacam ini? Adakah alasan mengapa sintaks dua langkah ini lebih disukai?

Tidak, struktur yang Anda temukan adalah bagaimana Java menanganinya (yaitu, dengan overloading bukan parameter default).

Untuk konstruktor, Lihat Tip Java yang Efektif: Memprogram Tip Item 1 Panduan Bahasa (Pertimbangkan metode pabrik statis alih-alih konstruktor) jika kelebihan beban semakin rumit. Untuk metode lain, mengganti nama beberapa case atau menggunakan objek parameter dapat membantu. Ini adalah ketika Anda memiliki kompleksitas yang cukup yang membedakan sulit. Kasus yang pasti adalah di mana Anda harus membedakan menggunakan urutan parameter, bukan hanya jumlah dan jenisnya.

Tidak, tetapi Anda dapat menggunakan Pola Builder , seperti yang dijelaskan dalam jawaban Stack Overflow ini .

Seperti dijelaskan dalam jawaban yang ditautkan, Pola Builder memungkinkan Anda menulis kode seperti

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

di mana beberapa bidang dapat memiliki nilai default atau opsional.

Ada beberapa cara untuk mensimulasikan parameter default di Java:

1. Metode kelebihan beban.

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

   Salah satu batasan dari pendekatan ini adalah bahwa itu tidak berfungsi jika Anda memiliki dua parameter opsional dari jenis yang sama dan salah satu dari mereka dapat dihilangkan.

2. Varargs.

   a) Semua parameter opsional memiliki tipe yang sama:

   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) Jenis parameter opsional mungkin berbeda:

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

   Kelemahan utama dari pendekatan ini adalah bahwa jika parameter opsional dari tipe yang berbeda Anda kehilangan pemeriksaan tipe statis. Lebih jauh, jika setiap parameter memiliki arti yang berbeda, Anda perlu cara untuk membedakannya.

3. Nulls. Untuk mengatasi keterbatasan pendekatan sebelumnya, Anda dapat mengizinkan nilai nol dan kemudian menganalisis setiap parameter dalam tubuh metode:

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

   Sekarang semua nilai argumen harus disediakan, tetapi yang standar mungkin nol.

4. Kelas opsional. Pendekatan ini mirip dengan nol, tetapi menggunakan kelas Java 8 Opsional untuk parameter yang memiliki nilai default:

   void foo(String a, Optional<Integer> bOpt) {
       Integer b = bOpt.isPresent() ? bOpt.get() : 0;
       //...
   }
   
   foo("a", Optional.of(2));
   foo("a", Optional.<Integer>absent());
   

   Opsional membuat metode kontrak eksplisit untuk penelepon, namun, orang mungkin menemukan tanda tangan seperti itu terlalu lisan.

5. Pola pembangun. Pola pembangun digunakan untuk konstruktor dan diimplementasikan dengan memperkenalkan kelas Builder yang terpisah:

    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. Peta. Ketika jumlah parameter terlalu besar dan sebagian besar dari mereka nilai default biasanya digunakan, Anda bisa meneruskan argumen metode sebagai peta nama / nilai mereka:

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

Harap dicatat bahwa Anda dapat menggabungkan salah satu dari pendekatan ini untuk mencapai hasil yang diinginkan.

Sayangnya tidak.

Sayangnya ya.

void MyParameterizedFunction(String param1, int param2, bool param3=false) {}

dapat ditulis dalam Java 1.5 sebagai:

void MyParameterizedFunction(String param1, int param2, Boolean... params) {
    assert params.length <= 1;
    bool param3 = params.length > 0 ? params[0].booleanValue() : false;
}

Tetapi apakah Anda harus bergantung pada bagaimana perasaan Anda tentang pembuat kompiler a

new Boolean[]{}

untuk setiap panggilan.

Untuk beberapa parameter default:

void MyParameterizedFunction(String param1, int param2, bool param3=false, int param4=42) {}

dapat ditulis dalam Java 1.5 sebagai:

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

Ini cocok dengan sintaksis C ++, yang hanya mengizinkan parameter default di akhir daftar parameter.

Di luar sintaks, ada perbedaan di mana ini telah menjalankan jenis waktu memeriksa untuk melewati parameter defaultable dan tipe C ++ memeriksa mereka selama kompilasi.

Tidak, tetapi Anda dapat dengan mudah meniru mereka. Apa yang ada di C ++ adalah:

public: void myFunction(int a, int b=5, string c="test") { ... }

Di Jawa, itu akan menjadi fungsi kelebihan beban:

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

Sebelumnya disebutkan, bahwa parameter default menyebabkan kasus ambigu dalam fungsi yang berlebihan. Itu tidak benar, kita dapat melihat dalam kasus C ++: ya, mungkin itu dapat membuat kasus yang ambigu, tetapi masalah ini dapat dengan mudah ditangani. Itu tidak dikembangkan di Jawa, mungkin karena pembuatnya menginginkan bahasa yang lebih sederhana seperti C ++ - jika mereka benar, adalah pertanyaan lain. Tetapi kebanyakan dari kita tidak berpikir dia menggunakan Jawa karena kesederhanaannya.

Anda dapat melakukannya di Scala, yang berjalan pada JVM dan kompatibel dengan program Java. http://www.scala-lang.org/

yaitu

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

Tidak , tetapi cara paling sederhana untuk mengimplementasikan ini adalah:

public myParameterizedFunction(String param1, int param2, Boolean param3) {

    param3 = param3 == null ? false : param3;
}

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

atau alih-alih operator ternary , Anda dapat menggunakan if:

public myParameterizedFunction(String param1, int param2, Boolean param3) {

    if (param3 == null) {
        param3 = false;
    }
}

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

Saya mungkin menyatakan yang jelas di sini tapi mengapa tidak menerapkan parameter "default" sendiri?

public class Foo() {
        public void func(String s){
                func(s, true);
        }
        public void func(String s, boolean b){
                //your code here
        }
}

untuk standarnya, Anda akan menggunakannya

func("my string");

dan jika Anda tidak ingin menggunakan default, Anda akan menggunakannya

func("my string", false);

Seperti Scala disebutkan, Kotlin juga layak disebut. Di Kotlin, parameter fungsi dapat memiliki nilai default juga dan mereka bahkan dapat merujuk ke parameter lain:

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

Seperti Scala, Kotlin berjalan pada JVM dan dapat dengan mudah diintegrasikan ke dalam proyek Java yang ada.

Tidak.

Anda dapat mencapai perilaku yang sama dengan melewati Obyek yang memiliki default pintar. Tetapi sekali lagi itu tergantung pada kasus Anda.

Tidak. Secara umum Jawa tidak memiliki banyak gula sintaksis, karena mereka mencoba membuat bahasa yang sederhana.

Alih-alih menggunakan:

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

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

Anda dapat menggunakan fungsionalitas opsional java dengan memiliki satu metode:

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

Perbedaan utama adalah bahwa Anda harus menggunakan kelas wrapper alih-alih tipe Java primitif untuk memungkinkan nullinput. Booleanbukannya boolean, Integerbukannya intdan sebagainya.

Itu tidak didukung tetapi ada beberapa opsi seperti menggunakan pola objek parameter dengan beberapa gula sintaks:

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

Dalam sampel ini kami membangun ParameterObjectdengan nilai default dan menimpanya di bagian inisialisasi instance kelas{ param1 = 10; param2 = "bar";}

Coba solusi ini:

public int getScore(int score, Integer... bonus)
{
    if(bonus.length > 0)
    {
        return score + bonus[0];
    }

    return score;
}

Anda dapat menggunakan Java Method Invocation Builder untuk secara otomatis menghasilkan builder dengan nilai default.

Cukup tambahkan @GenerateMethodInvocationBuilder ke kelas, atau antarmuka, dan @Default ke parameter dalam metode di mana Anda ingin nilai default. Builder akan dihasilkan pada waktu kompilasi, menggunakan nilai default yang Anda tentukan dengan anotasi Anda.

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

Dan kemudian Anda dapat memanggil metode.

CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
  .invoke(instance);

Atau atur nilai default apa pun ke sesuatu yang lain.

CarService instance = new CarService();
String carsByFilter = CarServiceGetCarsByFilterBuilder.getCarsByFilter()//
  .withColor(Color.YELLOW)//
  .invoke(instance);

Pendekatan serupa dengan https://stackoverflow.com/a/13864910/2323964 yang berfungsi di Java 8 adalah dengan menggunakan antarmuka dengan getter default. Ini akan menjadi lebih banyak spasi putih, tetapi bisa dipermainkan, dan itu bagus untuk ketika Anda memiliki banyak contoh di mana Anda benar-benar ingin menarik perhatian pada parameter.

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

Saya sekarang telah menghabiskan cukup banyak waktu untuk mencari tahu bagaimana menggunakan ini dengan metode yang mengembalikan nilai, dan saya belum melihat contoh sejauh ini, saya pikir mungkin berguna untuk menambahkan ini di sini:

int foo(int a) {
    // do something with a
    return a;
}

int foo() {
    return foo(0); // here, 0 is a default value for a
}

Beginilah cara saya melakukannya ... mungkin tidak semudah mungkin memiliki 'argumen opsional' terhadap parameter yang Anda tentukan, tetapi menyelesaikan pekerjaan:

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

Perhatikan saya bisa memanggil nama metode yang sama hanya dengan string atau saya bisa memohonnya dengan string dan nilai boolean. Dalam hal ini, pengaturan wipeClean ke true akan mengganti semua teks di TextArea saya dengan string yang disediakan. Mengatur wipeClean ke false atau membiarkannya bersama-sama cukup menambahkan teks yang disediakan ke TextArea.

Perhatikan juga saya tidak mengulangi kode dalam dua metode, saya hanya menambahkan fungsionalitas untuk dapat mengatur ulang TextArea dengan membuat metode baru dengan nama yang sama hanya dengan boolean yang ditambahkan.

Saya benar-benar berpikir ini sedikit lebih bersih daripada jika Java memberikan 'argumen opsional' untuk parameter kita karena kita perlu kode untuk nilai-nilai default dll. Dalam contoh ini, saya tidak perlu khawatir tentang semua itu. Ya, saya telah menambahkan metode lain ke kelas saya, tetapi lebih mudah untuk membaca dalam jangka panjang menurut pendapat saya.

TIDAK, Tapi kami punya alternatif dalam bentuk fungsi kelebihan beban.

dipanggil ketika tidak ada parameter yang dilewati

void operation(){

int a = 0;
int b = 0;

} 

dipanggil ketika "a" parameter dilewatkan

void operation(int a){

int b = 0;
//code

} 

dipanggil ketika parameter b berlalu

void operation(int a , int b){
//code
} 

Ada setengah lusin masalah atau lebih baik seperti ini, pada akhirnya, Anda tiba di pola pabrik statis ... lihat API crypto untuk itu. Agak sulit untuk dijelaskan, tetapi pikirkan seperti ini: Jika Anda memiliki konstruktor, default atau sebaliknya, satu-satunya cara untuk menyebarkan keadaan di luar kurung kurawal adalah dengan memiliki Boolean yang valid; (bersama dengan null sebagai nilai default v gagal konstruktor) atau melemparkan pengecualian yang tidak pernah informatif ketika mendapatkannya kembali dari pengguna bidang.

Terkutuklah kode, saya menulis ribuan konstruktor garis dan melakukan apa yang saya butuhkan. Saya menemukan menggunakan isValid pada konstruksi objek - dengan kata lain, konstruktor dua baris - tetapi untuk beberapa alasan, saya bermigrasi ke pola pabrik statis. Saya sepertinya Anda bisa melakukan banyak hal jika Anda dalam pemanggilan metode, masih ada masalah sync () tetapi default dapat 'diganti' lebih baik (lebih aman)

Saya pikir apa yang perlu kita lakukan di sini adalah mengatasi masalah nol sebagai nilai default vis-a-vis sesuatu String one = new String (""); sebagai variabel anggota, kemudian melakukan pemeriksaan untuk null sebelum menetapkan string yang diteruskan ke konstruktor.

Sangat luar biasa jumlah ilmu komputer stratosfer mentah yang dilakukan di Jawa.

C ++ dan seterusnya memiliki lib vendor, ya. Java dapat berlari lebih cepat dari mereka di server skala besar karena itu adalah kotak peralatan besar. Pelajari blok penginisialisasi statis, tetap bersama kami.

Ini tidak didukung di java seperti dalam bahasa lain untuk ex. Kotlin.

Anda dapat menggunakan berikut-

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