Care este diferența dintre interfața Go și interfețele din alte limbaje de programare?

Diferența principală în interfețele Go constă în faptul că acestea sunt implementate în mod implicit (nu explicit).

În alte limbaje (de exemplu, Java, C#), o clasă trebuie să declare explicit că implementează o anumită interfață (implementare explicită).

În Go, orice tip satisface automat o interfață dacă implementează toate metodele definite în acea interfață. Nu este necesară o declarație explicită de implementare.

Exemplu (Go):

// Definim interfața
type Reader interface {
	Read(p []byte) (n int, err error)
}

// Definim structura
type FileReader struct {
	// ... câmpuri
}

// Implementăm metoda Read pentru structura FileReader
func (fr FileReader) Read(p []byte) (n int, err error) {
	// ... logică de citire
	return 0, nil // exemplu de placeholder
}

// FileReader satisface implicit interfața Reader,
// deoarece are o metodă Read compatibilă.

Exemplu (Java - pentru comparație):

// Definim interfața
interface Reader {
    int read(byte[] p);
}

// Definim clasa
class FileReader implements Reader { // declarație explicită de implementare
    // ... câmpuri

    @Override
    public int read(byte[] p) {
        // ... logică de citire
        return 0; // exemplu de placeholder
    }
}

Avantajele cheie ale implementării implicite în Go:

• Design decuplat: Permite bibliotecilor noi să definească interfețe care pot fi satisfăcute de tipuri existente fără a le modifica.
• Flexibilitate: Facilitează crearea de funcții generale care funcționează cu diferite tipuri ce satisfac aceeași interfață.
• Fără necesitatea de "implements": Reduce boilerplate-ul de cod.
• Tipare de tip "duck" ("duck typing"): Dacă un tip arată ca o rață și quackează ca o rață, atunci este o rață. În acest caz, dacă un tip implementează metodele interfeței, poate fi folosit ca acea interfață.