অতিরিক্ত বড় switchএবং if/elseকনস্ট্রাক্টস প্রতিস্থাপনের জন্য একটি অবজেক্ট ওরিয়েন্টেড বিকল্পটি হ'ল aChain of Responsibility Patternসিদ্ধান্ত গ্রহণের মডেল হিসাবে ।
দায়িত্ব প্যাটার্নের চেইন
দায়বদ্ধতার শৃঙ্খলা অনুরোধের জন্য সম্ভাব্য বিপুল সংখ্যক হ্যান্ডলারের মধ্যে কোনটি এটির পদক্ষেপ নিতে হবে তা স্থির করে কোনও অনুরোধের উত্সকে আলাদা করার অনুমতি দেয়। চেইন রোল প্রতিনিধিত্বকারী শ্রেণি হ্যান্ডলারের তালিকার সাথে উত্স থেকে অনুরোধগুলি চ্যানেল পরিচালনা করে যতক্ষণ না কোনও হ্যান্ডলার অনুরোধ গ্রহণ না করে এবং এটি সম্পাদন করে।
জেনারিক্স ব্যবহার করে নিরাপদ টাইপ করা একটি উদাহরণ বাস্তবায়ন এখানে is
import java.util.ArrayList;
import java.util.List;
/**
* Generic enabled Object Oriented Switch/Case construct
* @param <T> type to switch on
*/
public class Switch<T extends Comparable<T>>
{
private final List<Case<T>> cases;
public Switch()
{
this.cases = new ArrayList<Case<T>>();
}
/**
* Register the Cases with the Switch
* @param c case to register
*/
public void register(final Case<T> c) { this.cases.add(c); }
/**
* Run the switch logic on some input
* @param type input to Switch on
*/
public void evaluate(final T type)
{
for (final Case<T> c : this.cases)
{
if (c.of(type)) { break; }
}
}
/**
* Generic Case condition
* @param <T> type to accept
*/
public static interface Case<T extends Comparable<T>>
{
public boolean of(final T type);
}
public static abstract class AbstractCase<T extends Comparable<T>> implements Case<T>
{
protected final boolean breakOnCompletion;
protected AbstractCase()
{
this(true);
}
protected AbstractCase(final boolean breakOnCompletion)
{
this.breakOnCompletion = breakOnCompletion;
}
}
/**
* Example of standard "equals" case condition
* @param <T> type to accept
*/
public static abstract class EqualsCase<T extends Comparable<T>> extends AbstractCase<T>
{
private final T type;
public EqualsCase(final T type)
{
super();
this.type = type;
}
public EqualsCase(final T type, final boolean breakOnCompletion)
{
super(breakOnCompletion);
this.type = type;
}
}
/**
* Concrete example of an advanced Case conditional to match a Range of values
* @param <T> type of input
*/
public static abstract class InRangeCase<T extends Comparable<T>> extends AbstractCase<T>
{
private final static int GREATER_THAN = 1;
private final static int EQUALS = 0;
private final static int LESS_THAN = -1;
protected final T start;
protected final T end;
public InRangeCase(final T start, final T end)
{
this.start = start;
this.end = end;
}
public InRangeCase(final T start, final T end, final boolean breakOnCompletion)
{
super(breakOnCompletion);
this.start = start;
this.end = end;
}
private boolean inRange(final T type)
{
return (type.compareTo(this.start) == EQUALS || type.compareTo(this.start) == GREATER_THAN) &&
(type.compareTo(this.end) == EQUALS || type.compareTo(this.end) == LESS_THAN);
}
}
/**
* Show how to apply a Chain of Responsibility Pattern to implement a Switch/Case construct
*
* @param args command line arguments aren't used in this example
*/
public static void main(final String[] args)
{
final Switch<Integer> integerSwitch = new Switch<Integer>();
final Case<Integer> case1 = new EqualsCase<Integer>(1)
{
@Override
public boolean of(final Integer type)
{
if (super.type.equals(type))
{
System.out.format("Case %d, break = %s\n", type, super.breakOnCompletion);
return super.breakOnCompletion;
}
else
{
return false;
}
}
};
integerSwitch.register(case1);
// more instances for each matching pattern, granted this will get verbose with lots of options but is just
// and example of how to do standard "switch/case" logic with this pattern.
integerSwitch.evaluate(0);
integerSwitch.evaluate(1);
integerSwitch.evaluate(2);
final Switch<Integer> inRangeCaseSwitch = new Switch<Integer>();
final Case<Integer> rangeCase = new InRangeCase<Integer>(5, 100)
{
@Override
public boolean of(final Integer type)
{
if (super.inRange(type))
{
System.out.format("Case %s is between %s and %s, break = %s\n", type, this.start, this.end, super.breakOnCompletion);
return super.breakOnCompletion;
}
else
{
return false;
}
}
};
inRangeCaseSwitch.register(rangeCase);
// run some examples
inRangeCaseSwitch.evaluate(0);
inRangeCaseSwitch.evaluate(10);
inRangeCaseSwitch.evaluate(200);
// combining both types of Case implementations
integerSwitch.register(rangeCase);
integerSwitch.evaluate(1);
integerSwitch.evaluate(10);
}
}
এটি কেবলমাত্র একটি দ্রুত খড়ের মানুষ যা আমি কয়েক মিনিটের মধ্যে বেত্রাঘাত করেছি, আরও পরিশীলিত বাস্তবায়ন হতে Command Patternপারে একরকমের মধ্যে ইনজেকশনের অনুমতি দেয়Case প্রয়োগের ক্ষেত্রে জন্য এটি আইওসি শৈলীর আরও একটি কল ব্যাক করতে পারে।
এই পদ্ধতির সম্পর্কে একবার দুর্দান্ত জিনিসটি হ'ল স্যুইচ / কেস স্টেটমেন্টগুলি পার্শ্ব প্রতিক্রিয়া সম্পর্কে সমস্ত হয়, এটি ক্লাসগুলিতে পার্শ্ব প্রতিক্রিয়াগুলিকে আবদ্ধ করে যাতে সেগুলি পরিচালনা করতে পারে এবং আরও ভালভাবে ব্যবহার করা যায়, এটি কার্যকরী ভাষায় প্যাটার্ন ম্যাচিংয়ের মতো আরও শেষ হয় এবং এটি একটি খারাপ জিনিস নয়।
আমি গিথুব এ এই গিস্টের কোনও আপডেট বা বর্ধন পোস্ট করব ।