উত্তর:
varargs এটি করতে পারে (একভাবে)। তা ছাড়া, পদ্ধতির ঘোষণায় সমস্ত পরিবর্তনশীল সরবরাহ করতে হবে must আপনি যদি কোনও ভেরিয়েবলটি alচ্ছিক হতে চান তবে আপনি প্যারামিটারের প্রয়োজন নেই এমন একটি স্বাক্ষর ব্যবহার করে পদ্ধতিটি ওভারলোড করতে পারেন।
private boolean defaultOptionalFlagValue = true;
public void doSomething(boolean optionalFlag) {
...
}
public void doSomething() {
doSomething(defaultOptionalFlagValue);
}জাভাতে alচ্ছিক পরামিতিগুলি অনুকরণ করার বিভিন্ন উপায় রয়েছে:
পদ্ধতি ওভারলোডিং।
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");এই পদ্ধতির একটি সীমাবদ্ধতা হ'ল যদি একই ধরণের দুটি optionচ্ছিক পরামিতি থাকে এবং সেগুলির কোনও বাদ দেওয়া যায় তবে এটি কাজ করে না।
ভারার্গস।
ক) সমস্ত alচ্ছিক পরামিতি একই ধরণের:
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);খ) paraচ্ছিক পরামিতিগুলির প্রকারগুলি পৃথক হতে পারে:
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");এই পদ্ধতির মূল অপূর্ণতা হ'ল alচ্ছিক পরামিতিগুলি যদি বিভিন্ন ধরণের হয় তবে আপনি স্ট্যাটিক ধরণের চেকিং হারাবেন। তদুপরি, যদি প্রতিটি প্যারামিটারের আলাদা অর্থ থাকে তবে তাদের আলাদা করার জন্য আপনার কিছু উপায় প্রয়োজন।
NULLs। পূর্ববর্তী পদ্ধতির সীমাবদ্ধতাগুলি সমাধান করার জন্য আপনি নাল মানগুলিকে অনুমতি দিতে পারেন এবং তারপরে কোনও পদ্ধতিতে প্রতিটি পরামিতি বিশ্লেষণ করতে পারেন:
void foo(String a, Integer b, Integer c) {
b = b != null ? b : 0;
c = c != null ? c : 0;
//...
}
foo("a", null, 2);এখন সমস্ত আর্গুমেন্টের মান অবশ্যই সরবরাহ করতে হবে তবে ডিফল্ট মানগুলি শূন্য হতে পারে।
.চ্ছিক ক্লাস। এই পদ্ধতির নালগুলির অনুরূপ, তবে পূর্বনির্ধারিত মান রয়েছে এমন পরামিতিগুলির জন্য জাভা 8 ptionচ্ছিক ক্লাস ব্যবহার করে:
void foo(String a, Optional<Integer> bOpt) {
Integer b = bOpt.isPresent() ? bOpt.get() : 0;
//...
}
foo("a", Optional.of(2));
foo("a", Optional.<Integer>absent());Ptionচ্ছিক কোনও কলারের জন্য কোনও পদ্ধতির চুক্তিকে সুস্পষ্ট করে তোলে, তবে, এই জাতীয় স্বাক্ষরটি খুব ভার্বোস খুঁজে পেতে পারে।
আপডেট: জাভা 8 java.util.Optional-এর মধ্যে ক্লাসের বাইরে ক্লাস অন্তর্ভুক্ত রয়েছে , তাই জাভা ৮-তে এই বিশেষ কারণে পেয়ারা ব্যবহার করার দরকার নেই। যদিও পদ্ধতির নামটি কিছুটা আলাদা।
বিল্ডার প্যাটার্ন। বিল্ডার প্যাটার্নটি নির্মাণকারীদের জন্য ব্যবহৃত হয় এবং আলাদা বিল্ডার শ্রেণি প্রবর্তন করে প্রয়োগ করা হয়:
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();মানচিত্র। যখন প্যারামিটারের সংখ্যা খুব বেশি থাকে এবং বেশিরভাগ ডিফল্ট মানগুলির জন্য সাধারণত ব্যবহৃত হয়, আপনি তাদের নাম / মানগুলির মানচিত্র হিসাবে পদ্ধতি যুক্তিগুলি পাস করতে পারেন:
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")); জাভা 9 এ, এই পদ্ধতিটি আরও সহজ হয়ে উঠেছে:
@SuppressWarnings("unchecked")
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);
// d = ...
}
foo(Map.of("a","a", "b",2, "d","value"));অনুগ্রহ করে নোট করুন যে আপনি পছন্দসই ফলাফল অর্জন করতে এই যে কোনও পদ্ধতির একত্রিত করতে পারেন।
aভেরিয়েবল একটি স্ট্রিং (কাস্ট সঠিক)।
জাভা 5.0 সহ optionচ্ছিক পরামিতি রয়েছে। কেবল আপনার ফাংশনটি এভাবে ঘোষণা করুন:
public void doSomething(boolean... optionalFlag) {
//default to "false"
//boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}আপনি সাথে doSomething();বা doSomething(true);এখন কল করতে পারে ।
doSomething() { doSomething(true); }
আপনি এর মতো কিছু ব্যবহার করতে পারেন:
public void addError(String path, String key, Object... params) {
}paramsপরিবর্তনশীল ঐচ্ছিক। এটি অবজেক্টের একটি nlalable অ্যারে হিসাবে গণ্য করা হয়।
আশ্চর্যজনকভাবে, ডকুমেন্টেশনে আমি এ সম্পর্কে কিছুই খুঁজে পাইনি, তবে এটি কার্যকর!
এটি জাভা 1.5 এবং এর বাইরে "নতুন" (জাভা 1.4 বা তার আগেরটি সমর্থিত নয়)।
আমি ব্যবহারকারীর ভূত এটি নীচে খুব উল্লেখ করেছি।
দুর্ভাগ্যক্রমে জাভা সরাসরি ডিফল্ট পরামিতি সমর্থন করে না।
তবে আমি জাভাবিয়ান টীকাগুলির একটি সেট লিখেছি এবং তাদের মধ্যে একটি নীচের মত ডিফল্ট পরামিতি সমর্থন করে:
protected void process(
Processor processor,
String item,
@Default("Processor.Size.LARGE") Size size,
@Default("red") String color,
@Default("1") int quantity) {
processor.process(item, size, color, quantity);
}
public void report(@Default("Hello") String message) {
System.out.println("Message: " + message);
}এটোটেশন প্রসেসর এটিকে যথাযথভাবে সমর্থন করার জন্য পদ্ধতি ওভারলোডগুলি উত্পন্ন করে।
Http://code.google.com/p/javadude/wiki/Annotations দেখুন
Http://code.google.com/p/javadude/wiki/AnnotationsDefaultParatersExample এ সম্পূর্ণ উদাহরণ
ভারআরগস এবং ওভারলোডিংয়ের কথা উল্লেখ করা হয়েছে। অন্য বিকল্পটি হ'ল একটি বিল্ডার প্যাটার্ন, যা দেখতে এরকম কিছু দেখাচ্ছে:
MyObject my = new MyObjectBuilder().setParam1(value)
.setParam3(otherValue)
.setParam6(thirdValue)
.build();যদিও সেই প্যাটার্নটি আপনার পক্ষে যখন কোনও কনস্ট্রাক্টরে alচ্ছিক পরামিতি প্রয়োজন তখন সবচেয়ে উপযুক্ত হবে।
জেডিকে> 1.5 এ আপনি এটি ব্যবহার করতে পারেন;
public class NewClass1 {
public static void main(String[] args) {
try {
someMethod(18); // Age : 18
someMethod(18, "John Doe"); // Age & Name : 18 & John Doe
} catch (Exception e) {
e.printStackTrace();
}
}
static void someMethod(int age, String... names) {
if (names.length > 0) {
if (names[0] != null) {
System.out.println("Age & Name : " + age + " & " + names[0]);
}
} else {
System.out.println("Age : " + age);
}
}
}আপনি এভাবে পদ্ধতি ওভারলোডিং ব্যবহার করে কিছু করতে পারেন।
public void load(String name){ }
public void load(String name,int age){}এছাড়াও আপনি @ ননাল টীকা ব্যবহার করতে পারেন
public void load(@Nullable String name,int age){}কেবল প্রথম পরামিতি হিসাবে নাল পাস।
আপনি যদি একই ধরণের ভেরিয়েবল পাস করে থাকেন তবে আপনি এটি ব্যবহার করতে পারেন
public void load(String name...){}ওভারলোডিং ঠিক আছে, তবে যদি ডিফল্ট মানের প্রয়োজন হয় এমন অনেকগুলি ভেরিয়েবল থাকে তবে আপনি এগুলি শেষ করবেন:
public void methodA(A arg1) { }
public void methodA( B arg2,) { }
public void methodA(C arg3) { }
public void methodA(A arg1, B arg2) { }
public void methodA(A arg1, C arg3) { }
public void methodA( B arg2, C arg3) { }
public void methodA(A arg1, B arg2, C arg3) { }সুতরাং আমি জাভা দ্বারা সরবরাহিত ভেরিয়েবল আর্গুমেন্টটি ব্যবহার করার পরামর্শ দেব। ব্যাখ্যার জন্য এখানে একটি লিঙ্ক ।
আপনি এমন একটি ক্লাস ব্যবহার করতে পারেন যা আপনার alচ্ছিক মানগুলিকে ধারণ করতে কোনও বিল্ডারের মতো কাজ করে।
public class Options {
private String someString = "default value";
private int someInt= 0;
public Options setSomeString(String someString) {
this.someString = someString;
return this;
}
public Options setSomeInt(int someInt) {
this.someInt = someInt;
return this;
}
}
public static void foo(Consumer<Options> consumer) {
Options options = new Options();
consumer.accept(options);
System.out.println("someString = " + options.someString + ", someInt = " + options.someInt);
}মত ব্যবহার করুন
foo(o -> o.setSomeString("something").setSomeInt(5));আউটপুট হয়
someString = something, someInt = 5সমস্ত alচ্ছিক মানগুলি এড়িয়ে যাওয়ার জন্য আপনাকে এটিকে পছন্দ করতে হবে foo(o -> {});বা যদি আপনি পছন্দ করেন তবে আপনি একটি দ্বিতীয় foo()পদ্ধতি তৈরি করতে পারেন যা alচ্ছিক পরামিতিগুলি গ্রহণ করে না।
এই পদ্ধতির ব্যবহার করে, আপনি কোনও অস্পষ্টতা ছাড়াই কোনও ক্রমে alচ্ছিক মান নির্দিষ্ট করতে পারেন। আপনার বিভিন্ন ভার্সেসের প্যারামিটারগুলিও ভার্সের সাথে পৃথক নয়। এই বিকল্পটি আরও ভাল হবে যদি আপনি বিকল্প ক্লাস তৈরি করতে টিকা এবং কোড উত্পন্ন করতে পারেন।
জাভা এখন 1.8 এ বিকল্পগুলি সমর্থন করে, আমি অ্যান্ড্রয়েডে প্রোগ্রামিংয়ের সাথে আটকে আছি তাই আমি untilচ্ছিক ধরণের ব্যবহারের কোডটি রিফ্যাক্ট না করা পর্যন্ত নাল ব্যবহার করছি।
Object canBeNull() {
if (blah) {
return new Object();
} else {
return null;
}
}
Object optionalObject = canBeNull();
if (optionalObject != null) {
// new object returned
} else {
// no new object returned
}ডিফল্ট যুক্তি জাভা ব্যবহার করা যাবে না। সি #, সি ++ এবং পাইথনগুলিতে যেখানে আমরা সেগুলি ব্যবহার করতে পারি ..
জাভাতে, আমাদের অবশ্যই ডিফল্ট পরামিতিগুলির পরিবর্তে 2 টি পদ্ধতি (ফাংশন) ব্যবহার করতে হবে।
উদাহরণ:
Stash(int size);
Stash(int size, int initQuantity);এটি প্রকৃত ptionচ্ছিক প্রকারের প্রবর্তনের আগেও সম্ভবত একটি পুরানো প্রশ্ন তবে এই দিনগুলিতে আপনি কয়েকটি বিষয় বিবেচনা করতে পারেন: - পদ্ধতি ওভারলোডিং ব্যবহার করুন - usedচ্ছিক প্রকারের প্রায়শই NULL পাস করা এড়ানো সুবিধা রয়েছে যা জাভা 8 এ সাধারণত ব্যবহৃত হওয়ার আগে চালু হয়েছিল was গুগলের পেয়ারা যেমন তৃতীয় পক্ষের লাইব থেকে। প্যারামিটার / আর্গুমেন্ট হিসাবে Usingচ্ছিক ব্যবহারকে অতিরিক্ত ব্যবহার হিসাবে বিবেচনা করা যেতে পারে কারণ মূল উদ্দেশ্যটি এটি একটি রিটার্ন সময় হিসাবে ব্যবহার করা ছিল।
রেফ: https://itcodehub.blogspot.com/2019/06/using-optional-type-in-java.html
মেথড ওভারলোডিং বা ডেটা টাইপ ব্যবহার করে আমরা alচ্ছিক প্যারামিটার তৈরি করতে পারি ...
| * | পদ্ধতি ওভারলোডিং:
RetDataType NameFnc(int NamePsgVar)
{
// |* Code Todo *|
return RetVar;
}
RetDataType NameFnc(String NamePsgVar)
{
// |* Code Todo *|
return RetVar;
}
RetDataType NameFnc(int NamePsgVar1, String NamePsgVar2)
{
// |* Code Todo *|
return RetVar;
}সবচেয়ে সহজ উপায়
| * | ডেটা টাইপ ... paraচ্ছিক প্যারামিটার হতে পারে
RetDataType NameFnc(int NamePsgVar, String... stringOpnPsgVar)
{
if(stringOpnPsgVar.length == 0) stringOpnPsgVar = DefaultValue;
// |* Code Todo *|
return RetVar;
}RetDtaTyp... সিরিয়াসলি? কি RetDataTypeখুব আউট টাইপ করতে কঠিন?
আপনি যদি একাধিক পরামিতিগুলির সাথে একটি ইন্টারফেস ব্যবহার করার পরিকল্পনা করে থাকেন তবে কেউ নিম্নলিখিত স্ট্রাকচারাল প্যাটার্নটি ব্যবহার করতে পারেন এবং প্রয়োগ বা প্রয়োগ প্রয়োগকে ওভাররাইড করতে পারেন - আপনার প্রয়োজনের ভিত্তিতে একটি পদ্ধতি ।
public abstract class Invoker<T> {
public T apply() {
return apply(null);
}
public abstract T apply(Object... params);
}যদি এটি একটি এপিআই এন্ডপয়েন্ট থাকে তবে একটি দুর্দান্ত উপায় হ'ল "স্প্রিং" টিকা ব্যবহার করা:
@GetMapping("/api/foos")
@ResponseBody
public String getFoos(@RequestParam(required = false, defaultValue = "hello") String id) {
return innerFunc(id);
}এক্ষেত্রে লক্ষ্য করুন যে ইনারফানকের জন্য চলক প্রয়োজন হবে এবং যেহেতু এটি এপিআই শেষ পয়েন্ট নয়, তাই এই বসন্তের টীকাকে এটি alচ্ছিক করতে ব্যবহার করতে পারে না। তথ্যসূত্র: https://www.baeldung.com/spring-request-param