Czym są mixiny i cechy (traits)?

Question

Accepted Answer

**Mixiny** i **cechy (traits)** to jednostki *wielokrotnie użytecznego zachowania*, które wkomponowujesz do klasy bez pełnej relacji dziedziczenia is-a. Pozwalają niezwiązanym ze sobą klasom dzielić funkcjonalność — jak dziedziczenie wielokrotne, ale skupione na zachowaniu zamiast budowania głębokich hierarchii typów.

## Mixin w Python

```python
class JsonSerializableMixin:           # reusable behavior, not a base "type"
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class TimestampMixin:
    def touch(self):
        import time
        self.updated_at = time.time()

class User(JsonSerializableMixin, TimestampMixin):   # mix in both
    def __init__(self, name): self.name = name

u = User("Mai")
u.touch()
print(u.to_json())                     # gained both behaviors via mixins
```

`User` *nie jest* "JsonSerializable" — po prostu *nabywa* tę zdolność.

## Traits (np. Scala/Rust/PHP)

Cechy (traits) są podobne, ale bardziej sformalizowane: mogą wymagać metod, dostarczać domyślne implementacje i mieć zdefiniowaną kolejność rozwiązywania konfliktów.

```scala
trait Greet { def name: String; def greet = s"Hi, $name" }  // requires name
class Person(val name: String) extends Greet
```

## Mixin/trait vs. dziedziczenie vs. interfejs

| | Dostarcza zachowanie | Dostarcza stan | Wiele na klasę |
|---|---|---|---|
| Interfejs | W większości nie | Nie | Tak |
| Klasa abstrakcyjna | Tak | Tak | Nie (jeden) |
| Mixin/Trait | **Tak** | Czasami | **Tak** |

## Pułapka

Układanie wielu mixinów odtwarza zamieszanie z diamentem/MRO — kolizje nazw i zachowanie zależne od kolejności. Utrzymuj każdy mixin mały, skoncentrowany i idealnie bez stanu.

## Dlaczego to ważne

Mixiny/cechy to praktyczna odpowiedź na pytanie "Muszę dzielić zachowanie między niezwiązanymi klasami bez wymuszania jednej linii dziedziczenia" — skład *zdolności*, a nie typów.

Zapewniają działanie rzeczywistych frameworków (Django class-based views, standardowe cechy Rust), a zrozumienie ich wyjaśnia, jak języki zapewniają korzyści wielokrotnego dziedziczenia, unikając jego najgorszych pułapek.

	Dostarcza zachowanie	Dostarcza stan	Wiele na klasę
Interfejs	W większości nie	Nie	Tak
Klasa abstrakcyjna	Tak	Tak	Nie (jeden)
Mixin/Trait	Tak	Czasami	Tak