java जावा में एक इंटरफेस घोषणा पर अधिक बाधाओं को कैसे लागू करें?




generics interface (3)

मान लें कि मेरे पास निम्न इंटरफ़ेस है:

interface Mammal {
    void marry(Mammal m);
    Mammal giveBirthTo();
}

हालांकि, यह बिल्कुल ठीक नहीं कहता कि मैं क्या चाहता हूं।

जाहिर है, एक इंसान कुत्ते से शादी नहीं कर सकता, न ही बिल्ली को जन्म दे सकता है। तो मैं इस जानकारी को इंटरफ़ेस में कैसे एम्बेड कर सकता हूं, जैसे इनपुट प्रकार और आउटपुट प्रकार को स्वचालित रूप से बदला जा सकता है क्योंकि इसे लागू किया जाता है?


आप एक पुनरावर्ती प्रकार चर का उपयोग कर अपने इंटरफ़ेस को जेनरेट कर सकते हैं:

interface Mammal<T extends Mammal<T>> {
  void marry(T m);
  T giveBirthTo();
}

इस तरह, जावा कंपाइलर आपको एक निश्चित सत्यापन स्तर दे सकता है। ध्यान दें कि यह दृष्टिकोण अभी भी दुर्व्यवहार के लिए खुला है। उदाहरण के लिए:

class Cat implements Mammal<Cat> {
  @Override void marry(Cat cat) { ... }
  @Override Cat giveBirthTo() { ... }
}

class Dog implements Mammal<Cat> { // implements wrong interface
  @Override void marry(Cat cat) { ... }
  @Override Cat giveBirthTo() { ... }
}

कंपाइलर केवल आश्वस्त कर सकता है कि आप कुछ प्रकार के एक ही इंटरफ़ेस द्वारा Mammal इंटरफ़ेस को कार्यान्वित करते हैं, लेकिन उस विशेष वर्ग द्वारा नहीं जो इसे लागू करता है। इस बाद की प्रकार की बाधा जावा प्रोग्रामिंग भाषा में व्यक्त नहीं की जा सकती है।


जेनेरिक्स। के साथ प्रयास करें

 private static interface Race {
}

private static class Human implements Race {}
private static class Canine implements Race {}

private static interface Being<R extends Race> {
    void marry(Being<R> other);
    Being<R> giveBirthTo();
}

private void tryMe() {
    Being<Human> aHuman = new Being<Human>() {

        @Override
        public void marry(Being<Human> other) {
        }

        @Override
        public Being<Human> giveBirthTo() {
            return null;
        }
    };

    Being<Canine> aCanine = new Being<Canine>() {

        @Override
        public void marry(Being<Canine> other) {
        }

        @Override
        public Being<Canine> giveBirthTo() {
            return null;
        }
    };

    aHuman.marry(aCanine); // not possible
}

आप जेनेरिक का उपयोग कर सकते हैं और अपना डिज़ाइन बदल सकते हैं।

कुछ पंक्तियों में:

interface Marriable<T extends Mammal> {
    void marry(T sweetHalf);
    T giveBirthTo();
}

... जहां Mammal आपका शीर्ष इंटरफ़ेस या अमूर्त वर्ग है, और Human , Dog , Unicorn इत्यादि इसे विस्तार / कार्यान्वित करता है।





interface