जावा में, हमें इंटरफेस में निजी इंस्टेंस विधियों का उपयोग कब करना चाहिए?

Question

जावा 9 के अनुसार, इंटरफ़ेस में विधियाँ निजी हो सकती हैं। एक निजी विधि स्थिर या एक आवृत्ति विधि हो सकती है। चूँकि निजी विधियों का उपयोग केवल इंटरफ़ेस के तरीकों में ही किया जा सकता है, उनका उपयोग इंटरफ़ेस के अन्य तरीकों के लिए सहायक विधियों तक सीमित है।

के एस एस होर्स्टमैन, कोर जावा वॉल्यूम I - फंडामेंटल

मुझे लगता है कि हम सामान्य कार्यप्रणाली को निजी तरीकों में डाल सकते हैं और इसे सार्वजनिक रूप से सुलभ नहीं बना सकते हैं। लेकिन हमारे यहाँ दो तरह के निजी तरीके हो सकते हैं:

1. private
2. private static

private staticविधियों का उपयोग करना समझ में आता है, लेकिन हमें privateतरीकों का उपयोग कब करना चाहिए ? हम यहां उदाहरणों के साथ काम नहीं कर रहे हैं क्योंकि यह एक इंटरफ़ेस है, इसलिए बनाने के privateतरीकों की अनुमति क्यों है? क्या हमें केवल private staticतरीकों की आवश्यकता नहीं है ?

Comments

एक इंटरफ़ेस में वे विधियाँ शामिल हो सकती हैं जिन्हें अन्य उदाहरण के तरीके कहते हैं, लेकिन सार्वजनिक उपभोग के लिए अभिप्रेत नहीं हैं।

— डेव न्यूटन

इंटरफ़ेस privateको लागू करने वाली कक्षा में इंटरफ़ेस की आवृत्ति विधि को कॉल करने का प्रयास करें।

— Abra

इस तरह की एक निजी पद्धति इंटरफ़ेस से अन्य तरीकों को कॉल कर सकती है, इसलिए वे तरीकों से समकक्ष या बदली नहीं हैं private static।

— मार्क रोटेवेल

डिफ़ॉल्ट तरीके शायद

— मौरिस पेरी

Answer 1

ठीक है, वास्तव में ओपी के सवालों का जवाब देने का एक और प्रयास। जब आपको किसी निजी विधि से इंटरफ़ेस पर एक और गैर-स्थिर पद्धति को कॉल करने की आवश्यकता होती है, तो निजी विधि स्थिर नहीं हो सकती है। उदाहरण के लिए, एक संकलन त्रुटि होगी यदि नीचे दी गई निजी विधि स्थिर थी:

public interface InterfaceWithMethods {
    public default void doSomething() {
        doSomethingCommon();
    }

    public default void doSomethingElse() {
        doSomethingCommon();
    }

    public void actuallyDoSomething();

    private void doSomethingCommon() {
        System.out.println("Do something first.");
        actuallyDoSomething();
    }
}

Comments

वह प्रासंगिक क्यों है? आप हर विधि को "सार्वजनिक डिफ़ॉल्ट" के रूप में भी लागू कर सकते हैं। सवाल यह है कि क्यों / किस इरादे से आपने z पर कार्यान्वयन x या y चुना है - कैसे नहीं।

— फ्लोरियन सालिहोविक

@FlorianSalihovic आप स्थैतिक पर गैर-स्थिर का चयन करेंगे जब आपको इस निजी विधि से दूसरी विधि को कॉल करने की आवश्यकता होगी। ऐसा क्यों नहीं है?

— 13

आप गलत सवाल पूछ रहे हैं। तरीकों की दृश्यता को कम करने या संभावनाओं को चौड़ा करने के लिए चुना जाता है कि ऑब्जेक्ट एक-दूसरे के साथ कैसे बातचीत करते हैं। यह महत्वपूर्ण है कि डेवलपर्स जिस तरह से संचार कर रहे हैं, उनका इरादा इस बारे में है कि उनका कोड कैसे होना चाहिए / उपयोग किया जा सकता है। आप सब कुछ स्थैतिक विधियों में लागू कर सकते हैं या बिना किसी स्थैतिक विधि का उपयोग कर सकते हैं। यह सवाल महत्वपूर्ण है क्योंकि हमें अन्य वस्तुओं / कक्षाओं तक कार्यक्षमता तक पहुंचने के परिणामों के बारे में सोचने की आवश्यकता है, जो बिल्कुल भी सुलभ नहीं होना चाहिए।

— फ्लोरियन सालिहोविक

@FlorianSalihovic लेकिन जैसा कि मैंने लोगों की टिप्पणियों से सीखा है, ओपी दृश्यता के बारे में नहीं पूछ रहा था या जब स्थिर बनाम गैर-स्थिर का उपयोग करना था, इसके बजाय वे पूछ रहे थे कि निजी स्थिर प्रतीत होने पर गैर-स्थिर निजी तरीकों को भी इंटरफेस पर क्यों अनुमति दी जाती है। मेरे जवाब ने एक उपयोग मामला प्रदान किया जहां केवल एक गैर-स्थैतिक विधि काम करेगी।

— jingx

Answer 2

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

कुछ मामलों में, कार्यक्षमता की आवश्यकता होती है (शायद विभिन्न डिफ़ॉल्ट तरीकों में कोड पुन: उपयोग के लिए ), लेकिन इसे उजागर नहीं किया जाना चाहिए क्योंकि यह कक्षा के ऑब्जेक्ट / नामस्थान को प्रदूषित करेगा। यह वह जगह है जहाँ निजी डिफ़ॉल्ट तरीके काम आते हैं। निजी डिफ़ॉल्ट तरीकों के उदाहरण कारखाने, सत्यापन या डिफ़ॉल्ट राज्य हैंडलिंग हो सकते हैं।

package com.company;

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class Main {

  public static void main(final String[] args) {
    var messages =
        List.of(
            MessageQueue.newSubject("Message 1"),
            MessageQueue.newTopic("Message 2"),
            MessageQueue.newTopic("Message 3"));
    final MessageQueueAdapter1 queue1 = () -> messages;
    inspectQueue(queue1);
    final MessageQueueAdapter2 queue2 = () -> messages;
    inspectQueue(queue2);
  }

  private static void inspectQueue(final MessageQueue queue) {
    final List<Message> messagesWithSubject = queue.getMessagesWithSubject();
    assert messagesWithSubject.size() == 1 : "expected one message with 'Subject'";
    final List<Message> messagesWithTopic = queue.getMessagesWithTopic();
    assert messagesWithTopic.size() == 2 : "expected two message with 'Topic'";
    assert !queue.getMessages().isEmpty() && 3 == queue.getMessages().size()
        : "expected three messages in total";
  }

  @FunctionalInterface
  interface Message {
    private static boolean isPrefixedBy(final String message, final String prefix) {
      return message != null && !message.isEmpty() && message.startsWith(prefix);
    }

    default boolean hasSubject() {
      return isPrefixedBy(this.getMessage(), MessageQueue.PREFIX_SUBJECT);
    }

    default boolean hasTopic() {
      return isPrefixedBy(this.getMessage(), MessageQueue.PREFIX_TOPIC);
    }

    String getMessage();
  }

  interface MessageQueue {
    String PREFIX_SUBJECT = "Subject: ";

    String PREFIX_TOPIC = "Topic: ";

    private static Message newMessage(final String message) {
      return () -> message;
    }

    static Message newSubject(final String message) {
      return newMessage(PREFIX_SUBJECT + message);
    }

    static Message newTopic(final String message) {
      return newMessage(PREFIX_TOPIC + message);
    }

    List<Message> getMessages();

    List<Message> getMessagesWithSubject();

    List<Message> getMessagesWithTopic();
  }

  @FunctionalInterface
  interface MessageQueueAdapter1 extends MessageQueue {
    private static List<Message> filterBy(
        final List<Message> messages, final Predicate<Message> predicate) {
      return messages.stream().filter(predicate).collect(Collectors.toList());
    }

    /** {@inheritDoc} */
    @Override
    default List<Message> getMessagesWithSubject() {
      return filterBy(this.getMessages(), Message::hasSubject);
    }

    /** {@inheritDoc} */
    @Override
    default List<Message> getMessagesWithTopic() {
      return filterBy(this.getMessages(), Message::hasTopic);
    }
  }

  @FunctionalInterface
  interface MessageQueueAdapter2 extends MessageQueue {
    private List<Message> filterBy(final Predicate<Message> predicate) {
      return this.getMessages().stream().filter(predicate).collect(Collectors.toList());
    }

    /** {@inheritDoc} */
    @Override
    default List<Message> getMessagesWithSubject() {
      return filterBy(Message::hasSubject);
    }

    /** {@inheritDoc} */
    @Override
    default List<Message> getMessagesWithTopic() {
      return filterBy(Message::hasTopic);
    }
  }
}