ในการเขียนโปรแกรมอินเทอร์เฟซจะกำหนดลักษณะการทำงานของอ็อบเจ็กต์ แต่จะไม่ระบุลักษณะการทำงานจริง เป็นสัญญาที่จะรับประกันว่าชนชั้นหนึ่งสามารถทำบางสิ่งได้
พิจารณารหัส 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());
คลาสเกมต้องใช้หมายเลขลับ เพื่อประโยชน์ในการทดสอบคุณต้องการฉีดสิ่งที่จะใช้เป็นหมายเลขลับ (หลักการนี้เรียกว่า Inversion of Control)
คลาสเกมต้องการที่จะ "เปิดใจ" เกี่ยวกับสิ่งที่จะสร้างตัวเลขสุ่มจริงๆดังนั้นมันจะถามในตัวสร้างสำหรับ "อะไรก็ได้ที่มีเมธอดสร้าง"
ขั้นแรกอินเทอร์เฟซระบุว่าการดำเนินการใดที่วัตถุจะให้ มันมีเพียงสิ่งที่ดูเหมือน แต่ไม่มีการนำไปใช้จริง นี่เป็นเพียงลายเซ็นของวิธีการ ตามปกติแล้วในอินเทอร์เฟซ C # จะขึ้นต้นด้วย I ขณะนี้คลาสใช้อินเทอร์เฟซ IGenerate ซึ่งหมายความว่าคอมไพลเลอร์จะตรวจสอบให้แน่ใจว่าทั้งคู่มีเมธอดที่ส่งคืน int และถูกเรียกใช้Generateใช้ ตอนนี้เกมนี้ถูกเรียกว่าออบเจ็กต์สองชิ้นที่แตกต่างกันซึ่งแต่ละตัวใช้อินเทอร์เฟซที่ถูกต้อง คลาสอื่น ๆ จะทำให้เกิดข้อผิดพลาดในการสร้างโค้ด
ที่นี่ฉันสังเกตเห็นการเปรียบเทียบแบบพิมพ์เขียวที่คุณใช้:
คลาสมักถูกมองว่าเป็นพิมพ์เขียวสำหรับวัตถุ อินเทอร์เฟซระบุบางสิ่งบางอย่างที่คลาสจะต้องทำดังนั้นใคร ๆ ก็สามารถโต้แย้งได้ว่ามันเป็นแค่พิมพ์เขียวของคลาส แต่เนื่องจากคลาสไม่จำเป็นต้องมีอินเทอร์เฟซฉันจึงขอยืนยันว่าอุปมานี้กำลังทำลาย คิดว่าอินเทอร์เฟซเป็นสัญญา ชั้นเรียนที่ "ลงนาม" จะต้องถูกต้องตามกฎหมาย (บังคับโดยตำรวจคอมไพเลอร์) เพื่อปฏิบัติตามข้อกำหนดและเงื่อนไขในสัญญา ซึ่งหมายความว่าจะต้องทำสิ่งที่ระบุไว้ในอินเทอร์เฟซ
ทั้งหมดนี้เกิดจากลักษณะการพิมพ์แบบคงที่ของภาษา OO บางภาษาเนื่องจากเป็นกรณีของ Java หรือ C # ในทางกลับกันใน Python จะใช้กลไกอื่น:
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
ที่นี่ไม่มีคลาสใดที่ใช้อินเทอร์เฟซ Python ไม่สนใจเรื่องนั้นเพราะSecretGameคลาสจะพยายามเรียกสิ่งที่ส่งผ่านเข้ามาถ้าอ็อบเจกต์มีวิธีการสร้าง () ทุกอย่างก็เรียบร้อยดี ถ้าไม่มี: KAPUTT! ข้อผิดพลาดนี้จะไม่ปรากฏให้เห็นในเวลาคอมไพล์ แต่ในขณะรันไทม์อาจเป็นไปได้ว่าเมื่อโปรแกรมของคุณถูกปรับใช้และรันอยู่แล้ว C # จะแจ้งให้คุณทราบก่อนที่คุณจะเข้าใกล้สิ่งนั้น
เหตุผลที่ใช้กลไกนี้ระบุอย่างไร้เดียงสาเพราะในภาษา OO โดยธรรมชาติแล้วฟังก์ชันไม่ใช่พลเมืองชั้นหนึ่ง อย่างที่คุณเห็นKnownNumberและSecretNumberมีเพียงฟังก์ชั่นในการสร้างตัวเลข หนึ่งไม่จำเป็นต้องเรียนเลย ดังนั้นใน Python เราสามารถทิ้งมันไปและเลือกฟังก์ชั่นได้ด้วยตัวเอง:
# 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));
หมายเหตุด้านข้าง: ตัวอย่างหลังไม่สามารถทำได้เช่นนี้จนถึง Java 7 ที่นั่นอินเทอร์เฟซเป็นวิธีเดียวของคุณในการระบุพฤติกรรมนี้ อย่างไรก็ตาม Java 8 แนะนำนิพจน์แลมบ์ดาเพื่อให้ตัวอย่าง C # สามารถแปลงเป็น Java ได้ง่ายมาก ( Func<int>กลายเป็นjava.util.function.IntSupplierและ=>กลายเป็น->)