जावा में संघ प्रकारों का कार्यान्वयन

कोड विकसित करते समय, एक वस्तु के लिए कभी-कभी एक प्रकार के मूल्यों या किसी अन्य प्रकार के मूल्यों को शामिल करना आवश्यक होता है। प्रोग्रामिंग भाषाएं जो यूनियनों की अवधारणा का समर्थन करती हैं, एक निश्चित समय में एक मेमोरी क्षेत्र में वर्तमान मूल्य को बचाने की अनुमति देती हैं।

उदाहरण के लिए, C / C ++ में आप इस तरह लिख सकते हैं।

union value { int i; float f; }; union value v; vi = 5; /* vf - undefined behaivor */ 

इसके अलावा, यदि हम एक क्षेत्र के लिए मूल्य निर्धारित करते हैं, तो दूसरे क्षेत्र के मूल्य को पढ़ने से अपरिभाषित व्यवहार होगा।

C ++ 17 में यूनियन प्रकारों के साथ काम करना आसान करने के लिए, std :: variant class जोड़ा गया।

  std::variant<int, float> v { 5 }; std::cout << "int value: " << std::get<int>(v) << std::endl; 

जावा भाषा संघ प्रकारों का समर्थन नहीं करती है। एक विकल्प के रूप में, आप कुछ प्रकारों के दो क्षेत्रों के साथ एक डेटा वर्ग को लागू कर सकते हैं, जिसमें सेटर और गेटर्स हैं। लेकिन मैं चाहता था कि मूल्य एक क्षेत्र में संग्रहीत किया जाए, और दो में नहीं।

जैसा कि आप जानते हैं, ऑब्जेक्ट प्रकार एक प्रकार के मूल्य को बचा सकता है, और फिर दूसरे प्रकार के मूल्यों को फिर से असाइन कर सकता है। और इसका उपयोग क्लास को लागू करने के लिए किया जा सकता है, जैसे क्लास std :: variant।

चूंकि जावा में आप जेनेरिक में किसी प्रकार की चर संख्या निर्दिष्ट नहीं कर सकते हैं, एक निश्चित संख्या के लिए आपको वर्ग (Union2, Union3, आदि) के विशेषज्ञता की आवश्यकता होती है। आइए मुख्य वर्ग संघ और उसके बुनियादी कार्यों को लिखें।

  public abstract class Union { private Union() {} public abstract <T> void set(T value); public abstract <T> T get(Class<T> clazz); public abstract <T> boolean isActive(Class<T> clazz); public abstract <T> Class<T> getActive(); } 

क्लास ऑब्जेक्ट बनाने के लिए, हम फ़ैक्टरी विधियों का उपयोग करेंगे। प्रकारों की संख्या के आधार पर, वर्ग के विशिष्ट विशेषज्ञता को वापस कर दिया जाएगा।

  public static <T1, T2> Union2<T1, T2> of(Class<T1> firstClass, Class<T2> secondClass) { return new Union2<>(firstClass, secondClass); } public static <T1, T2, T3> Union3<T1, T2, T3> of(Class<T1> firstClass, Class<T2> secondClass, Class<T3> thirdClass) { return new Union3<>(firstClass, secondClass, thirdClass); } 

संघ वर्ग की ठोस विशेषज्ञता एक निश्चित संख्या में प्रकार और एक फ़ील्ड ऑब्जेक्ट संग्रहित करेगी। यदि हम गलत प्रकार का संकेत देते हैं, तो हमें एक त्रुटि मिलेगी।

  private static class Union2<T1, T2> extends Union { private final Class<T1> firstClass; private final Class<T2> secondClass; private Object value; private Union2(Class<T1> firstClass, Class<T2> secondClass) { this.firstClass = firstClass; this.secondClass = secondClass; } @Override public <T> void set(T value) { if (value.getClass() == firstClass || value.getClass() == secondClass) { this.value = value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union two types: [" + firstClass.getName() + ", " + secondClass.getName() + "]"); } } @Override public <T> T get(Class<T> clazz) { if (clazz == firstClass || clazz == secondClass) { return (T) value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union two types: [" + firstClass.getName() + ", " + secondClass.getName() + "]"); } } @Override public <T> boolean isActive(Class<T> clazz) { return value.getClass() == clazz; } @Override public <T> Class<T> getActive() { return (Class<T>) value.getClass(); } } private static class Union3<T1, T2, T3> extends Union { private final Class<T1> firstClass; private final Class<T2> secondClass; private final Class<T3> thirdClass; private Object value; private Union3(Class<T1> firstClass, Class<T2> secondClass, Class<T3> thirdClass) { this.firstClass = firstClass; this.secondClass = secondClass; this.thirdClass = thirdClass; } @Override public <T> void set(T value) { if (value.getClass() == firstClass || value.getClass() == secondClass || value.getClass() == thirdClass) { this.value = value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union three types: [" + firstClass.getName() + ", " + secondClass.getName() + ", " + thirdClass.getName() + "]"); } } @Override public <T> T get(Class<T> clazz) { if (clazz == firstClass || clazz == secondClass || value.getClass() == thirdClass) { return (T) value; } else { throw new UnionException("Incorrect type: " + value.getClass().getName() + "\n" + "Union three types: [" + firstClass.getName() + ", " + secondClass.getName() + ", " + thirdClass.getName() + "]"); } } @Override public <T> boolean isActive(Class<T> clazz) { return value.getClass() == clazz; } @Override public <T> Class<T> getActive() { return (Class<T>) value.getClass(); } } 

अब आइए एक उदाहरण देखें कि इस वर्ग का उपयोग कैसे किया जाए। जैसा कि आप देख सकते हैं, संघ विशिष्ट विशेषज्ञता के साथ काम नहीं करता है, जो कोड को सरल बनाता है।

  Union triUnion = Union.of(Integer.class, String.class, Float.class); triUnion.set(15f); assertEquals(triUnion.getActive(), Float.class); assertTrue(triUnion.isActive(Float.class)); triUnion.set("Dot"); assertEquals(triUnion.getActive(), String.class); assertTrue(triUnion.isActive(String.class)); triUnion.set(10); assertEquals(triUnion.getActive(), Integer.class); assertTrue(triUnion.isActive(Integer.class)); 

आप वर्तमान मूल्य की जांच करने के लिए एक साधारण आगंतुक भी लिख सकते हैं।

  Union biUnion = Union.of(Integer.class, String.class); biUnion.set("Line"); Union triUnion = Union.of(Integer.class, String.class, Float.class); triUnion.set(15f); matches(biUnion, Integer.class, i -> System.out.println("bi-union number: " + i), String.class, s -> System.out.println("bi-union string: " + s) ); matches(triUnion, Integer.class, i -> System.out.println("tri-union int: " + i), String.class, s -> System.out.println("tri-union string: " + s), Float.class, f -> System.out.println("tri-union float: " + f) ); 

  public static <V, T1, T2> void matches(V value, Class<T1> firstClazz, Consumer<T1> firstConsumer, Class<T2> secondClazz, Consumer<T2> secondConsumer) { Class<?> valueClass = value.getClass(); if (firstClazz == valueClass) { firstConsumer.accept((T1) value); } else if (secondClazz == valueClass) { secondConsumer.accept((T2) value); } } public static <T1, T2, T3> void matches(Union value, Class<T1> firstClazz, Purchaser<T1> firstConsumer, Class<T2> secondClazz, Purchaser<T2> secondConsumer, Class<T3> thirdClazz, Purchaser<T3> thirdConsumer) { Class<?> valueClass = value.getActive(); if (firstClazz == valueClass) { firstConsumer.obtain(value.get(firstClazz)); } else if (secondClazz == valueClass) { secondConsumer.obtain(value.get(secondClazz)); } else if (thirdClazz == valueClass) { thirdConsumer.obtain(value.get(thirdClazz)); } } 

सारांशित करते हुए, हम कह सकते हैं कि जावा भाषा में, पुस्तकालय स्तर पर संघ प्रकारों के लिए समर्थन लागू किया जा सकता है। लेकिन एक कमी के रूप में, प्रत्येक प्रकार की संख्या के लिए आपको यूनियन वर्ग की अपनी विशेषज्ञता की आवश्यकता होती है और इसके अतिरिक्त सभी प्रकारों को बचाते हैं।

कक्षा का पूर्ण स्रोत कोड github: कोड पर देखा जा सकता है