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 จัดการกับมัน (กล่าวคือมีการโหลดมากเกินไปแทนที่จะเป็นพารามิเตอร์เริ่มต้น)

สำหรับตัวสร้างดูที่ Java ที่มีประสิทธิภาพ:รายการเคล็ดลับที่ 1 ของคู่มือการเขียนโปรแกรมภาษา (พิจารณาวิธีการคงที่จากโรงงานแทนที่จะเป็นตัวสร้าง) หากการโอเวอร์โหลดกำลังซับซ้อน สำหรับวิธีอื่นการเปลี่ยนชื่อบางกรณีหรือการใช้วัตถุพารามิเตอร์สามารถช่วยได้ นี่คือเมื่อคุณมีความซับซ้อนเพียงพอที่การแยกความแตกต่างเป็นเรื่องยาก กรณีที่แน่นอนคือที่ที่คุณต้องแยกความแตกต่างโดยใช้ลำดับของพารามิเตอร์ไม่ใช่แค่จำนวนและประเภท

ไม่มี แต่คุณสามารถใช้รูปแบบการสร้างที่อธิบายไว้ในคำตอบนี้กองมากเกิน

ตามที่อธิบายไว้ในคำตอบที่เชื่อมโยงแล้วรูปแบบของตัวสร้างช่วยให้คุณสามารถเขียนโค้ดได้

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. Varargs

   ก) พารามิเตอร์ที่ไม่จำเป็นทั้งหมดอยู่ในประเภทเดียวกัน:

   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) ประเภทของพารามิเตอร์ทางเลือกอาจแตกต่างกัน:

   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. nulls เพื่อระบุข้อ จำกัด ของวิธีการก่อนหน้านี้คุณสามารถอนุญาตให้มีค่า Null และวิเคราะห์แต่ละพารามิเตอร์ในเมธอดเนื้อหา:

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

   ตอนนี้ต้องระบุค่าอาร์กิวเมนต์ทั้งหมด แต่ค่าเริ่มต้นอาจเป็นโมฆะ

4. คลาสตัวเลือก วิธีนี้คล้ายกับ nulls แต่ใช้ 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());
   

   ตัวเลือกทำให้สัญญาวิธีการที่ชัดเจนสำหรับผู้โทร แต่อย่างใดอย่างหนึ่งอาจพบว่าลายเซ็นดังกล่าวเกินไป verbose

5. รูปแบบการสร้าง รูปแบบตัวสร้างถูกใช้สำหรับตัวสร้างและนำไปใช้โดยแนะนำตัวสร้างคลาสแยก:

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

ดังที่ Scala ถูกกล่าวถึงKotlinก็มีมูลค่าการกล่าวขวัญเช่นกัน ในพารามิเตอร์ฟังก์ชัน Kotlin สามารถมีค่าเริ่มต้นได้เช่นกันและสามารถอ้างอิงพารามิเตอร์อื่น ๆ ได้:

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

เช่น Scala Kotlin ทำงานบน JVM และสามารถรวมเข้ากับโครงการ Java ที่มีอยู่ได้อย่างง่ายดาย

เลขที่

คุณสามารถบรรลุพฤติกรรมเดียวกันโดยส่งผ่าน Object ที่มีค่าเริ่มต้นอัจฉริยะ แต่มันก็ขึ้นอยู่กับสถานการณ์ของคุณ

ไม่โดยทั่วไป 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
}

ความแตกต่างที่สำคัญคือคุณต้องใช้คลาส wrapper แทนประเภท 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;
}

คุณอาจใช้เครื่องมือสร้างวิธีการเรียกใช้จาวาเพื่อสร้างตัวสร้างโดยอัตโนมัติด้วยค่าเริ่มต้น

เพียงเพิ่ม @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 คือการใช้อินเทอร์เฟซที่มี getters เริ่มต้น นี่จะเป็นช่องว่างที่ละเอียดมากขึ้น แต่เป็นการเยาะเย้ยและเป็นเรื่องที่ดีมากเมื่อคุณมีอินสแตนซ์จำนวนมากที่คุณต้องการดึงความสนใจไปที่พารามิเตอร์

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

แจ้งให้ทราบล่วงหน้าฉันสามารถเรียกชื่อวิธีการเดียวกันกับทั้งสตริงหรือฉันสามารถเรียกมันด้วยสตริงและค่าบูลีน ในกรณีนี้การตั้งค่า cleanClean เป็น true จะแทนที่ข้อความทั้งหมดใน TextArea ของฉันด้วยสตริงที่จัดเตรียมไว้ การตั้งค่า wipeClean เป็น false หรือปล่อยให้ทั้งหมดเข้าด้วยกันเพียงแค่ต่อท้ายข้อความที่ให้ไว้กับ 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
} 

มีปัญหาครึ่งโหลหรือดีกว่าเช่นนี้ในที่สุดคุณมาถึงรูปแบบสแตติกจากโรงงาน ... ดู crypto API สำหรับสิ่งนั้น เรียงลำดับยากที่จะอธิบาย แต่คิดอย่างนี้: ถ้าคุณมีคอนสตรัคเตอร์ค่าเริ่มต้นหรืออย่างอื่นวิธีเดียวที่จะเผยแพร่สถานะเกินกว่าเครื่องหมายปีกกาแบบโค้งก็คือให้บูลีน isValid; (พร้อมกับ null เป็นค่าเริ่มต้นที่ v คอนสตรัคเตอร์ที่ล้มเหลว) หรือโยนข้อยกเว้นที่ไม่เคยให้ข้อมูลเมื่อนำกลับจากผู้ใช้ฟิลด์

รหัสถูกต้องแล้วฉันเขียนตัวสร้างเส้นนับพันและทำสิ่งที่ฉันต้องการ ฉันพบว่าการใช้ isValid ที่การสร้างวัตถุ - ในคำอื่น ๆ ตัวสร้างสองบรรทัด - แต่ด้วยเหตุผลบางอย่างฉันย้ายไปยังรูปแบบโรงงานคงที่ ฉันแค่ดูเหมือนว่าคุณสามารถทำอะไรได้มากมายถ้าคุณใช้วิธีการเรียกใช้ยังมีปัญหาการซิงค์ () แต่ค่าเริ่มต้นสามารถ 'ทดแทน' ได้ดีกว่า (ปลอดภัยกว่า)

ฉันคิดว่าสิ่งที่เราต้องทำที่นี่คือปัญหาของค่า null เป็นค่าเริ่มต้น vis-a-vis บางสิ่งบางอย่าง String one = new String (""); เป็นตัวแปรสมาชิกจากนั้นทำการตรวจสอบโมฆะก่อนที่จะกำหนดสตริงที่ส่งผ่านไปยังตัวสร้าง

น่าทึ่งมากเกี่ยวกับปริมาณของวิทยาการคอมพิวเตอร์ทางสตราโตสเฟียร์ที่มีอยู่ในจาวา

C ++ และอื่น ๆ มี libs ของผู้ขายใช่ Java สามารถวิ่งเร็วกว่าบนเซิร์ฟเวอร์ขนาดใหญ่เนื่องจากเป็นกล่องเครื่องมือขนาดใหญ่ ศึกษาบล็อก initializer แบบคงที่อยู่กับเรา

ไม่รองรับจาวาในภาษาอื่นเช่น ex Kotlin

คุณสามารถใช้ดังต่อไปนี้ -

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