ජාවා පෙරනිමි පරාමිති අගයන්ට සහය දක්වයිද?

පහත දැක්වෙන ව්‍යුහය සහිත ජාවා කේත කිහිපයක් මට හමු විය:

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

ජාවා මේ ආකාරයේ සින්ටැක්ස් සඳහා සහය දක්වයිද? මෙම පියවර දෙකේ වාක්‍ය ඛණ්ඩය වඩාත් සුදුසු වීමට හේතු තිබේද?

නැත, ඔබ සොයාගත් ව්‍යුහය ජාවා එය හසුරුවන ආකාරයයි (එනම් පෙරනිමි පරාමිතීන් වෙනුවට අධි බර පැටවීම සමඟ).

ඉදිකිරීම්කරුවන් සඳහා, over ලදායී ජාවා බලන්න: ක්‍රමලේඛන භාෂා මාර්ගෝපදේශයේ අයිතමය 1 ඉඟිය (වැඩිපුර පැටවීම සංකීර්ණ වන්නේ නම් ඉදිකිරීම්කරුවන් වෙනුවට ස්ථිතික කර්මාන්තශාලා ක්‍රම සලකා බලන්න). වෙනත් ක්‍රම සඳහා, සමහර අවස්ථා නැවත නම් කිරීම හෝ පරාමිති වස්තුවක් භාවිතා කිරීම උපකාරී වේ. මෙය ඔබට ප්‍රමාණවත් තරම් සංකීර්ණ වූ විට අවකලනය කිරීම දුෂ්කර ය. නිශ්චිත අවස්ථාවක් නම්, සංඛ්‍යා හා වර්ගය පමණක් නොව පරාමිති අනුපිළිවෙල භාවිතා කරමින් ඔබට වෙනස හඳුනාගත යුතුය.

නැත, නමුත් ඔබට මෙම ගොඩගැසීමේ පිළිතුරෙහි විස්තර කර ඇති පරිදි, බිල්ඩර් රටාව භාවිතා කළ හැකිය .

සම්බන්ධිත පිළිතුරෙහි විස්තර කර ඇති පරිදි, බිල්ඩර් රටාව ඔබට කේත ලිවීමට ඉඩ දෙයි

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

සමහර ක්ෂේත්‍රවල පෙරනිමි අගයන් තිබිය හැකි හෝ වෙනත් ආකාරයකින් විකල්ප විය හැකිය.

ජාවා හි පෙරනිමි පරාමිතීන් අනුකරණය කිරීමට ක්‍රම කිහිපයක් තිබේ:

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. වර්ග්ස්.

   a) සියලුම විකල්ප පරාමිතීන් එකම වර්ගයට අයත් වේ:

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

   ආ) විකල්ප පරාමිතීන් වර්ග වෙනස් විය හැකිය:

   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. ශූන්‍ය. පෙර ප්‍රවේශයන්හි සීමාවන් ආමන්ත්‍රණය කිරීම සඳහා ඔබට ශුන්‍ය අගයන්ට ඉඩ දිය හැකි අතර ඉන්පසු ක්‍රමවේදය තුළ එක් එක් පරාමිතීන් විශ්ලේෂණය කරන්න:

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

   දැන් සියලු තර්ක අගයන් ලබා දිය යුතුය, නමුත් පෙරනිමි ඒවා ශුන්‍ය විය හැකිය.

4. විකල්ප පන්තිය. මෙම ප්‍රවේශය ශුන්‍යයට සමාන ය, නමුත් පෙරනිමි අගයක් ඇති පරාමිතීන් සඳහා ජාවා 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());

   විකල්පයක් මඟින් ඇමතුම්කරුවෙකු සඳහා ක්‍රම කොන්ත්‍රාත්තුවක් පැහැදිලි කරයි, කෙසේ වෙතත් යමෙකුට එවැනි අත්සනක් වාචිකව සොයාගත හැකිය.

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

ජාවා 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) {}

ජාවා 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") { ... }

ජාවා හි, එය අධික ලෙස පටවන ලද ශ්‍රිතයක් වනු ඇත:

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 ++ සම්බන්ධයෙන් අපට දැකිය හැකිය: ඔව්, සමහර විට එය නොපැහැදිලි අවස්ථා නිර්මාණය කළ හැකි නමුත් මෙම ගැටළුව පහසුවෙන් විසඳා ගත හැකිය. එය හුදෙක් ජාවා හි සංවර්ධනය කර නැත, බොහෝ විට නිර්මාණකරුවන්ට C ++ තරම් සරල භාෂාවක් අවශ්‍ය වූ නිසා විය හැකිය - ඔවුන්ට නිවැරදි නම් තවත් ප්‍රශ්නයකි. නමුත් අප බොහෝ දෙනා සිතන්නේ ඔහු ජාවා භාවිතා කරන්නේ එහි සරල බව නිසා බවයි.

ඔබට මෙය කළ හැක්කේ JVM මත ධාවනය වන ජාවා වැඩසටහන් සමඟ අනුකූල වන Scala හි ය. 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);

ස්කලා සඳහන් කළ පරිදි, කොට්ලින් ද සඳහන් කිරීම වටී. කොට්ලින් හි ක්‍රියාකාරී පරාමිතීන්ට පෙරනිමි අගයන් ද තිබිය හැකි අතර ඒවාට වෙනත් පරාමිතීන් වෙත යොමු විය හැකිය:

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

ස්කලා මෙන්, කෝට්ලින් ජේවීඑම් මත ධාවනය වන අතර පවතින ජාවා ව්‍යාපෘති සමඟ පහසුවෙන් ඒකාබද්ධ කළ හැකිය.

භාවිතා කරනවා වෙනුවට:

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

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

තනි ක්‍රමයක් තිබීමෙන් ඔබට ජාවා හි විකල්ප ක්‍රියාකාරිත්වය භාවිතා කළ හැකිය:

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

ප්රධාන වෙනස නම් 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 සහ පෙරනිමි අගයන් ඔබට අවශ්‍ය ක්‍රමවේදයන්හි පරාමිතීන් වෙත efDefault එක් කරන්න. ඔබේ ව්‍යාඛ්‍යාව සමඟ ඔබ නියම කළ පෙරනිමි අගයන් භාවිතා කරමින් සම්පාදක වේලාවේදී තනන්නෙකු ජනනය වේ.

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

ජාවා 8 හි ක්‍රියාත්මක වන https://stackoverflow.com/a/13864910/2323964 ට සමාන ප්‍රවේශයක් වන්නේ පෙරනිමි ලබා ගන්නන් සමඟ අතුරු මුහුණතක් භාවිතා කිරීමයි. මෙය වඩාත් හිස් අවකාශයේ වාචික වනු ඇත, නමුත් සමච්චල් කළ හැකි අතර, ඔබට පරාමිතීන් කෙරෙහි සැබවින්ම අවධානය යොමු කිරීමට අවශ්‍ය අවස්ථා සමූහයක් ඇති විට එය විශිෂ්ටයි.

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
}

Ex සඳහා වෙනත් භාෂාවක මෙන් එය ජාවා වල සහය නොදක්වයි. කොට්ලින්.

මම එය කළ ආකාරය මෙයයි ... ඔබේ නිර්වචනය කළ පරාමිතියට එරෙහිව 'විකල්ප තර්කයක්' තිබීම එතරම් පහසු නැත, නමුත් එය කාර්යය ඉටු කරයි:

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

මට එකම ක්‍රමයේ නම නූලකින් ආයාචනා කළ හැකි බව සලකන්න. නැතහොත් මට එය නූල් සහ බූලියන් අගයකින් ආයාචනා කළ හැකිය. මෙම අවස්ථාවෙහිදී, wipeClean සත්‍ය ලෙස සැකසීම මගේ TextArea හි ඇති සියලුම පා provided යන් සපයා ඇති නූල් සමඟ ප්‍රතිස්ථාපනය කරයි. වයිප් ක්ලීන් අසත්‍ය ලෙස සැකසීම හෝ ඒ සියල්ල එකට තැබීම මඟින් සපයා ඇති පා Text ය පෙළ පෙළට එකතු කරයි.

මම ක්‍රම දෙකෙහි කේතය පුනරාවර්තනය නොකරන බව සලකන්න, මම හුදෙක් ටෙක්ස්ට්ආරියාව නැවත සැකසීමේ ක්‍රියාකාරීත්වය එක් කරන්නේ එකම නමකින් නව ක්‍රමයක් නිර්මාණය කිරීමෙන් එකතු කළ බූලියන් සමඟ පමණි.

අපගේ පරාමිතීන් සඳහා ජාවා විසින් 'විකල්ප තර්කයක්' ලබා දුන්නේ නම් පෙරනිමි අගයන් සඳහා කේත කිරීමට අවශ්‍ය බැවින් මෙය ටිකක් පිරිසිදු යැයි මම සිතමි. මෙම උදාහරණයේ දී, මම ඒ කිසිවක් ගැන කරදර විය යුතු නැත. ඔව්, මම මගේ පන්තියට තවත් ක්‍රමයක් එකතු කර ඇත්තෙමි, නමුත් මගේ නිහතමානී මතය අනුව දිගුකාලීනව කියවීම පහසුය.

නැත, නමුත් ශ්‍රිත අධි බර පැටවීමේ ස්වරූපයෙන් අපට විකල්පයක් ඇත.

කිසිදු පරාමිතියක් සම්මත නොවූ විට කැඳවනු ලැබේ

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
} 

මේ වගේ දුසිම් භාගයක් හෝ ඊට වඩා හොඳ ගැටළු තිබේ, අවසානයේදී ඔබ ස්ථිතික කර්මාන්තශාලා රටාවට පැමිණේ ... ඒ සඳහා ක්‍රිප්ටෝ ඒපීඅයි බලන්න. පැහැදිලි කිරීමට අපහසු, නමුත් මේ ආකාරයෙන් සිතන්න: ඔබට ඉදිකිරීම්කරුවෙකු සිටී නම්, පෙරනිමිය හෝ වෙනත් ආකාරයකින්, වක්‍ර වරහන් වලින් ඔබ්බට රාජ්‍ය ප්‍රචාරණය කළ හැකි එකම ක්‍රමය වන්නේ එක්කෝ බූලියන් isValid ය; (ශුන්‍යය පෙරනිමි අගය ලෙස v අසමත් වූ ඉදිකිරීම්කරු සමඟ) හෝ ක්ෂේත්‍ර පරිශීලකයින්ගෙන් එය නැවත ලබා ගැනීමේදී කිසි විටෙකත් තොරතුරු නොදක්වන ව්‍යතිරේකයක් විසි කරන්න.

කේතය නිවැරදියි, මම පේළි සාදන්නන් දහසක් ලියා මට අවශ්‍ය දේ කරන්නෙමි. වස්තු ඉදිකිරීමේදී isValid භාවිතා කිරීම මට පෙනේ - වෙනත් වචන වලින් කිවහොත්, පේළි දෙකක ඉදිකිරීම්කරුවන් - නමුත් කිසියම් හේතුවක් නිසා මම ස්ථිතික කර්මාන්තශාලා රටාවට සංක්‍රමණය වෙමි. ක්‍රමවේදය ඇමතුමක දී ඔබට තවමත් බොහෝ දේ කළ හැකි බව මට පෙනේ, සමමුහුර්ත () ගැටළු තවමත් පවතින නමුත් පෙරනිමි 'ආදේශක' වඩා හොඳ (ආරක්ෂිත)

මම හිතන්නේ අප මෙහි කළ යුත්තේ ශුන්‍ය ප්‍රශ්නය පෙරනිමි අගය ලෙස සලකන දෙයක් ලෙසට ය. සාමාජික විචල්‍යයක් ලෙස, පසුව ඉදිකිරීම්කරුට සම්මත නූලක් පැවරීමට පෙර ශුන්‍යය පරීක්ෂා කරන්න.

ජාවා හි සිදු කරන ලද අමු, ආන්තික ගෝලාකාර පරිගණක විද්‍යාවේ ප්‍රමාණය ඉතා විශිෂ්ටයි.

C ++ සහ යනාදිය සඳහා විකුණුම්කරුගේ ලිබ් ඇත, ඔව්. විශාල මෙවලම් පෙට්ටියක් නිසා ජාවාට ඒවා මහා පරිමාණ සේවාදායකයන් අභිබවා යා හැකිය. ස්ථිතික ආරම්භක කුට්ටි අධ්‍යයනය කරන්න, අප සමඟ සිටින්න.

ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය

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