Java varsayılan parametre değerlerini destekliyor mu?

Aşağıdaki yapıya sahip bazı Java koduyla karşılaştım:

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

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

C ++ ile bir parametreye varsayılan değer atayabileceğimi biliyorum. Örneğin:

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

Java bu tür bir sözdizimini destekliyor mu? Bu iki aşamalı sözdiziminin tercih edilmesinin herhangi bir nedeni var mı?

Hayır, bulduğunuz yapı Java'nın bunu nasıl ele aldığıdır (yani, varsayılan parametreler yerine aşırı yükleme ile).

Kurucular için, bakınız Etkili Java: Programlama Dili Rehberi'nin aşırı yükleme karmaşık oluyor eğer Madde 1 ucu (yerine inşaatçı statik fabrika yöntemleri düşünün). Diğer yöntemler için bazı durumları yeniden adlandırmak veya bir parametre nesnesi kullanmak yardımcı olabilir. Bu, farklılaşmanın zor olduğu yeterli karmaşıklığa sahip olduğunuz zamandır. Kesin bir durum, yalnızca sayı ve tür değil, parametrelerin sırasını kullanarak farklılaştırmanız gerektiğidir.

Hayır, ancak bu Yığın Taşması yanıtında açıklandığı gibi Oluşturucu Deseni'ni kullanabilirsiniz .

Bağlantılı cevapta açıklandığı gibi, Oluşturucu Kalıbı aşağıdaki gibi kod yazmanıza olanak tanır

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

bazı alanların varsayılan değerlere sahip olabileceği veya başka türlü isteğe bağlı olabileceği.

Java'da varsayılan parametreleri simüle etmenin birkaç yolu vardır:

1. Yöntem aşırı yükleme.

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

   Bu yaklaşımın sınırlamalarından biri, aynı tipte iki isteğe bağlı parametreniz varsa ve bunlardan herhangi biri atlanabilirse işe yaramayacağıdır.

2. Varargs.

   a) İsteğe bağlı tüm parametreler aynı tiptedir:

   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) İsteğe bağlı parametre türleri farklı olabilir:

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

   Bu yaklaşımın ana dezavantajı, isteğe bağlı parametreler farklı tipteyse statik tip kontrolünü kaybetmenizdir. Ayrıca, her parametrenin farklı bir anlamı varsa, bunları ayırt etmenin bir yoluna ihtiyacınız vardır.

3. Boşlara. Önceki yaklaşımların sınırlamalarını gidermek için null değerlere izin verebilir ve ardından bir yöntem gövdesindeki her parametreyi analiz edebilirsiniz:

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

   Şimdi tüm bağımsız değişken değerleri sağlanmalıdır, ancak varsayılan değerler boş olabilir.

4. İsteğe bağlı sınıf. Bu yaklaşım null değerlerine benzer, ancak varsayılan değeri olan parametreler için Java 8 Optional sınıfını kullanır:

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

   İsteğe bağlı bir yöntem sözleşmesini bir arayan için açık hale getirir, ancak böyle bir imza çok ayrıntılı bulabilir.

5. Oluşturucu desen. Oluşturucu deseni yapıcılar için kullanılır ve ayrı bir Builder sınıfı eklenerek uygulanır:

    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. Haritalar. Parametre sayısı çok fazla olduğunda ve çoğu için varsayılan değerler genellikle kullanıldığında, yöntem bağımsız değişkenlerini adlarının / değerlerinin haritası olarak iletebilirsiniz:

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

İstenilen bir sonuç elde etmek için bu yaklaşımlardan herhangi birini birleştirebileceğinizi lütfen unutmayın.

Üzgünüm hayır.

Maalesef evet.

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

Java 1.5'te şu şekilde yazılabilir:

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

Ancak, derleyicinin bir

new Boolean[]{}

her çağrı için.

Birden çok varsayılan parametre için:

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

Java 1.5'te şu şekilde yazılabilir:

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

Bu, yalnızca parametre listesinin sonunda varsayılan parametrelere izin veren C ++ sözdizimi ile eşleşir.

Sözdiziminin ötesinde, bunun geçirilen varsayılan parametreler için çalışma zamanı türü denetimi ve C ++ türü derleme sırasında bunları denetlemesi arasında bir fark vardır.

Hayır, ama onları kolayca taklit edebilirsiniz. C ++ 'ta ne vardı:

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

Java'da aşırı yüklenmiş bir işlev olacaktır:

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

Daha önce, varsayılan parametrelerin işlev aşırı yüklemesinde belirsiz vakalara neden olduğu belirtildi. Bu doğru değil, C ++ durumunda görebiliriz: evet, belki belirsiz vakalar oluşturabilir, ancak bu sorun kolayca ele alınabilir. Java'da geliştirilmemiştir, muhtemelen içerik oluşturucular C ++ gibi çok daha basit bir dil istediler - eğer doğrularsa başka bir soru. Ama çoğumuz basitliği nedeniyle Java kullandığını düşünmüyoruz.

Bunu JVM üzerinde çalışan ve Java programlarıyla uyumlu olan Scala'da yapabilirsiniz. http://www.scala-lang.org/

yani

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

Hayır , ancak bunu uygulamanın en basit yolu :

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

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

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

veya üçlü operatör yerine şunları kullanabilirsiniz if:

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

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

public myParameterizedFunction(String param1, int param2) {

    this(param1, param2, false);
}

Burada bariz belirtiyor olabilir ama neden sadece "varsayılan" parametresini kendiniz uygulamak değil?

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

varsayılan olarak,

func("my string");

ve varsayılanı kullanmak istemiyorsanız,

func("my string", false);

Scala'dan bahsedildiği gibi, Kotlin de bahsetmeye değer. Kotlin fonksiyon parametrelerinde varsayılan değerler de olabilir ve hatta diğer parametrelere de başvurabilirler:

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

Scala gibi Kotlin de JVM üzerinde çalışır ve mevcut Java projelerine kolayca entegre edilebilir.

Hayır.

Akıllı varsayılanlara sahip bir Nesneyi ileterek aynı davranışı elde edebilirsiniz. Fakat yine de, davanızın elinizin altında olmasına bağlıdır.

Hayır. Genel olarak Java'nın basit bir dil yapmaya çalıştıkları için çok fazla sözdizimsel şekeri yoktur.

Kullanmak yerine:

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

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

Tek bir yöntem kullanarak java'nın İsteğe bağlı işlevini kullanabilirsiniz:

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

Temel fark, nullgirişe izin vermek için ilkel Java türleri yerine sarmalayıcı sınıfları kullanmanızdır . Booleanyerine boolean, Integeryerine intvb.

Desteklenmez, ancak bazı sözdizimi şekeriyle parametre nesne desenini kullanma gibi birkaç seçenek vardır:

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

Bu örnekte ParameterObjectvarsayılan değerlerle oluşturuyoruz ve bunları sınıf örneği başlatma bölümünde geçersiz kılıyoruz{ param1 = 10; param2 = "bar";}

Bu çözümü deneyin:

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

    return score;
}

Sen kullanabilirsiniz Java Yöntem çağırma Builder otomatik olarak varsayılan değerlerle oluşturucu üretmek için.

Sadece sınıfa veya arabirime @GenerateMethodInvocationBuilder ve @Default parametrelerini varsayılan değerleri istediğiniz yöntemlerde ekleyin. Ek açıklamalarınızla belirttiğiniz varsayılan değerler kullanılarak derleyici zamanında bir oluşturucu oluşturulur.

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

Ve sonra yöntemleri çağırabilirsiniz.

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

Veya varsayılan değerlerden herhangi birini başka bir şeye ayarlayın.

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

Java 8'de çalışan https://stackoverflow.com/a/13864910/2323964 için benzer bir yaklaşım , varsayılan alıcılarla bir arabirim kullanmaktır. Bu, daha fazla boşluklu bir ayrıntı olacak, ancak mockable olabilir ve parametrelere gerçekten dikkat çekmek istediğiniz bir sürü örneğiniz olduğunda harika.

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

Şimdi değerleri döndüren yöntemlerle bu nasıl kullanılacağını anlamak için biraz zaman geçirdim ve şimdiye kadar herhangi bir örnek görmedim, ben buraya eklemek için yararlı olabilir düşündüm:

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

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

Bu şekilde yaptım ... belki de tanımlanmış parametrenize karşı 'isteğe bağlı bir argüman' olması kadar uygun değil, ama işi hallediyor:

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

Dikkat sadece bir dize ile aynı yöntem adını çağırabilir veya bir dize ve bir boolean değeri ile çağırabilir. Bu durumda, wipeClean öğesini true olarak ayarlamak TextArea'mdaki metnin tamamını sağlanan dizeyle değiştirir. WipeClean öğesini false olarak ayarlamak veya hepsini bir arada bırakmak, sağlanan metni TextArea öğesine ekler.

Ayrıca iki yöntemde kod tekrarlamıyorum dikkat, ben sadece eklenen boole ile aynı ada sahip yeni bir yöntem oluşturarak TextArea sıfırlama işlevselliğini ekliyorum.

Aslında bu daha sonra varsayılan değerler vb kodlamak gerekir çünkü Java bizim parametreler için 'isteğe bağlı bir argüman' sağlanan daha biraz daha temiz olduğunu düşünüyorum. Bu örnekte, ben bunlardan herhangi biri için endişelenmenize gerek yok. Evet, sınıfıma başka bir yöntem daha ekledim, ancak uzun vadede mütevazi düşüncemle okumak daha kolay.

HAYIR, Ama fonksiyon aşırı yüklenmesi şeklinde bir alternatifimiz var.

parametre geçilmediğinde çağrılır

void operation(){

int a = 0;
int b = 0;

} 

"a" parametresi geçtiğinde çağrılır

void operation(int a){

int b = 0;
//code

} 

b parametresi geçtiğinde çağrılır

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

Bunun gibi yarım düzine veya daha iyi sorun var, sonunda statik fabrika modeline ulaşıyorsunuz ... bunun için kripto API'sına bakın. Açıklamak zor, ancak bunu şu şekilde düşünün: Varsayılan veya başka bir yapıcıya sahipseniz, durumu kıvırcık parantezlerin ötesine yaymanın tek yolu bir Boolean isValid'e sahip olmaktır; (varsayılan değer v başarısız yapıcı olarak null ile birlikte) veya alan kullanıcılarından geri alırken hiçbir zaman bilgilendirici olmayan bir istisna atar.

Kod Doğru lanet olsun, bin satır kurucuları yazıyorum ve ihtiyacım olanı yapıyorum. Nesne yapımında - yani iki satırlı yapıcılarda - isValid kullanıyorum, ancak bir nedenle statik fabrika modeline geçiyorum. Sadece bir yöntem çağrısında çok şey yapabileceğiniz gibi görünüyor, hala sync () sorunları var ama varsayılanlar 'yerine' daha iyi (daha güvenli)

Burada ne yapmamız gerektiğini varsayılan değer vis-a-vis bir şey olarak null sorunu çözmek olduğunu düşünüyorum Bir = new String (""); üye değişkeni olarak, daha sonra yapıcıya iletilen dize atamadan önce null olup olmadığını kontrol edin.

Java'da yapılan ham, stratosferik bilgisayar biliminin miktarı çok dikkat çekici.

C ++ ve benzeri satıcı kütüphaneleri vardır, evet. Java, büyük bir araç kutusundan dolayı büyük ölçekli sunucularda onları aşabilir. Statik başlatıcı bloklarını inceleyin, bizimle kalın.

Java için ex diğer dillerde olduğu gibi desteklenmez. Kotlin.

Aşağıdakileri kullanabilirsiniz.

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