प्रोग्रामिंग में, एक इंटरफ़ेस परिभाषित करता है कि किसी वस्तु का व्यवहार क्या होगा, लेकिन यह वास्तव में व्यवहार को निर्दिष्ट नहीं करेगा। यह एक अनुबंध है, जो गारंटी देगा, कि एक निश्चित वर्ग कुछ कर सकता है।
यहाँ C # कोड के इस टुकड़े पर विचार करें:
using System;
public interface IGenerate
{
int Generate();
}
// Dependencies
public class KnownNumber : IGenerate
{
public int Generate()
{
return 5;
}
}
public class SecretNumber : IGenerate
{
public int Generate()
{
return new Random().Next(0, 10);
}
}
// What you care about
class Game
{
public Game(IGenerate generator)
{
Console.WriteLine(generator.Generate())
}
}
new Game(new SecretNumber());
new Game(new KnownNumber());
खेल वर्ग को एक गुप्त संख्या की आवश्यकता होती है। इसे जांचने के लिए, आप उसे एक गुप्त संख्या के रूप में उपयोग करने के लिए इंजेक्ट करना चाहेंगे (इस सिद्धांत को इनवर्सन ऑफ कंट्रोल कहा जाता है)।
गेम क्लास "ओपन माइंडेड" होना चाहता है, जो वास्तव में रैंडम नंबर बनाएगा, इसलिए वह अपने कंस्ट्रक्टर में "कुछ भी, जिसके लिए एक जेनरेट मेथड है" पूछेगा।
सबसे पहले, इंटरफ़ेस निर्दिष्ट करता है, जो ऑब्जेक्ट एक ऑपरेशन प्रदान करेगा। इसमें वही शामिल है जो यह दिखता है, लेकिन कोई वास्तविक कार्यान्वयन नहीं दिया गया है। यह सिर्फ विधि का हस्ताक्षर है। परम्परागत रूप से, C # इंटरफेस में I. के साथ उपसर्ग होता है। कक्षाएं अब IGenerate Interface को कार्यान्वित करती हैं। इसका मतलब यह है कि संकलक यह सुनिश्चित करेगा, कि उन दोनों के पास एक विधि है, जो एक इंट रिटर्न देता है और कहा जाता है Generate। खेल को अब दो अलग-अलग ऑब्जेक्ट कहा जा रहा है, जिनमें से प्रत्येक सही इंटरफ़ेस लागू करता है। अन्य कक्षाएं कोड बनाने पर त्रुटि उत्पन्न करती हैं।
यहाँ मैंने आपके द्वारा उपयोग किए गए ब्लूप्रिंट सादृश्य पर ध्यान दिया:
एक वर्ग को आमतौर पर एक वस्तु के लिए खाका के रूप में देखा जाता है। एक इंटरफ़ेस कुछ निर्दिष्ट करता है जो एक वर्ग को करने की आवश्यकता होगी, इसलिए कोई यह तर्क दे सकता है कि यह वास्तव में एक वर्ग के लिए केवल एक खाका है, लेकिन चूंकि एक वर्ग को इंटरफ़ेस की आवश्यकता नहीं है, मैं तर्क देता हूं कि यह रूपक टूट रहा है। एक अनुबंध के रूप में एक इंटरफ़ेस के बारे में सोचो। अनुबंध में नियमों और शर्तों का पालन करने के लिए वर्ग जो "इसे हस्ताक्षर करता है" कानूनी रूप से आवश्यक (कंपाइलर पुलिस द्वारा लागू) होगा। इसका मतलब है कि यह करना होगा, जो इंटरफ़ेस में निर्दिष्ट है।
यह सब कुछ OO भाषाओं की वैधानिक रूप से टाइप की गई प्रकृति के कारण है, क्योंकि यह Java या C # के मामले में है। दूसरी ओर पायथन में, एक अन्य तंत्र का उपयोग किया जाता है:
import random
# Dependencies
class KnownNumber(object):
def generate(self):
return 5
class SecretNumber(object):
def generate(self):
return random.randint(0,10)
# What you care about
class SecretGame(object):
def __init__(self, number_generator):
number = number_generator.generate()
print number
यहां, कोई भी वर्ग इंटरफ़ेस को लागू नहीं करता है। पायथन को इस बात की कोई परवाह नहीं है, क्योंकि SecretGameवर्ग बस जो भी वस्तु पारित की जाती है उसे कॉल करने की कोशिश करेगा। यदि वस्तु एक उत्पन्न () विधि है, तो सब कुछ ठीक है। यदि यह नहीं है: KAPUTT! यह गलती संकलन समय पर नहीं, बल्कि रनटाइम पर दिखाई देगी, इसलिए संभवतः जब आपका प्रोग्राम पहले से ही तैनात और चल रहा हो। आपके पास आने से पहले C # आपको सूचित करेगा।
इस तंत्र का उपयोग करने का कारण, भोलेपन से कहा गया है, क्योंकि OO भाषाओं में स्वाभाविक रूप से कार्य प्रथम श्रेणी के नागरिक नहीं हैं। जैसा कि आप देख सकते हैं, KnownNumberऔर SecretNumberएक संख्या उत्पन्न करने के लिए कार्यों को शामिल कर सकते हैं । एक को वास्तव में कक्षाओं की आवश्यकता नहीं है। पायथन में, इसलिए, कोई भी उन्हें दूर फेंक सकता है और अपने कार्यों को चुन सकता है:
# OO Approach
SecretGame(SecretNumber())
SecretGame(KnownNumber())
# Functional Approach
# Dependencies
class SecretGame(object):
def __init__(self, generate):
number = generate()
print number
SecretGame(lambda: random.randint(0,10))
SecretGame(lambda: 5)
एक मेमना सिर्फ एक फ़ंक्शन है, जिसे "लाइन में, जैसा कि आप जाते हैं" घोषित किया गया था। एक प्रतिनिधि केवल C # में समान है:
class Game
{
public Game(Func<int> generate)
{
Console.WriteLine(generate())
}
}
new Game(() => 5);
new Game(() => new Random().Next(0, 10));
साइड नोट: बाद के उदाहरण जावा 7 तक इस तरह संभव नहीं थे। इस व्यवहार को निर्दिष्ट करने के लिए इंटरफेस आपके एकमात्र तरीके थे। हालांकि, जावा 8 लैम्ब्डा भाव शुरू की तो सी # उदाहरण बहुत आसानी से (जावा में बदला जा सकता Func<int>हो जाता है java.util.function.IntSupplierऔर =>हो जाता है ->)।