Bagaimanakah Parameter Pilihan Boleh Disimulasikan di Java?-javaTutorial-php.cn

Bagaimanakah Parameter Pilihan Boleh Disimulasikan di Java?

Mary-Kate Olsen

Lepaskan： 2024-12-15 13:54:19

asal

170 orang telah melayarinya

How Can Optional Parameters Be Simulated in Java?

Mensimulasikan Parameter Pilihan dalam Java

Java tidak menyokong parameter pilihan secara asli. Walau bagaimanapun, terdapat pelbagai cara untuk mensimulasikan fungsi ini.

Kaedah Terlebih Muatan

Kaedah terlebih muatan dengan senarai parameter yang berbeza membolehkan anda menentukan parameter pilihan dengan menyediakan nilai lalai dalam beberapa kaedah. Contohnya:

void foo(String a, Integer b) {
    //...
}

void foo(String a) {
    foo(a, 0); // Here, 0 is the default value for b
}

foo("a", 2);
foo("a");  // Uses the default value for b

Salin selepas log masuk

Walau bagaimanapun, pendekatan ini menjadi rumit jika berbilang parameter pilihan daripada jenis yang sama wujud.

Varargs

Varargs boleh digunakan untuk mensimulasikan parameter pilihan jika semua parameter pilihan adalah sama jenis:

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

Salin selepas log masuk

Sebagai alternatif, varargs juga boleh digunakan dengan jenis parameter yang berbeza, tetapi ini memerlukan semakan tambahan:

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");  // Note that the order of arguments matters

Salin selepas log masuk

Nulls

Menggunakan nilai nol untuk parameter pilihan ialah pilihan lain:

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

foo("a", null, 2);

Salin selepas log masuk

Walau bagaimanapun, ini memerlukan menyemak nilai nol dalam badan kaedah.

Kelas Pilihan

Java 8 memperkenalkan kelas Pilihan, yang boleh digunakan untuk mewakili nilai pilihan:

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

foo("a", Optional.of(2));
foo("a", Optional.<Integer>absent());

Salin selepas log masuk

Corak Pembina

Corak pembina ialah pendekatan lain, biasanya digunakan bersama dengan pembina:

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

Salin selepas log masuk

Peta

Apabila berurusan dengan sejumlah besar parameter pilihan, menggunakan peta untuk menghantarnya sebagai pasangan nilai nama boleh menjadi mudah:

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 = (Integer)parameters.get("a");
    }
    if (parameters.containsKey("b")) { 
        //...
    }
    //...
}

foo(ImmutableMap.<String, Object>of(
    "a", "a",
    "b", 2, 
    "d", "value"));

Salin selepas log masuk

Dalam Java 9, mengakses nilai parameter daripada peta menjadi lebih mudah:

// ...
static <T> T getParm(Map<String, Object> map, String key, T defaultValue) {
  return (map.containsKey(key)) ? (T) map.get(key) : defaultValue;
}
// ...

void foo(Map<String, Object> parameters) {
  String a = getParm(parameters, "a", "");
  int b = getParm(parameters, "b", 0);
  // ...
}

foo(Map.of("a","a",  "b",2,  "d","value"));

Salin selepas log masuk

Pendekatan ini menyediakan pilihan yang berbeza untuk mensimulasikan parameter pilihan dalam Java, membolehkan anda memilih kaedah yang paling sesuai untuk keperluan khusus anda.

Atas ialah kandungan terperinci Bagaimanakah Parameter Pilihan Boleh Disimulasikan di Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!