Witam, tak jak w temacie ... Wszedłem w świat OOP jakiś czas temu, teraz robię strony na Kohanie Bardzo przypadła mi do gustu ... Możecie powiedzieć mi kiedy używać dziedziczenia ? Wiem że jest to `jakby` rozdrabnianie klas ... Lecz nigdy nie mogłem znależć praktycznego zastosowania dziedziczenia w swoich skryptach Prosiłbym kogoś o takie szybkie i łopatologiczne rozpisanie jakiegoś skryptu np. newsów, artykułów czy czego kolwiek (byle nie zwierząt ) ... Nie mówię że ma być kod tylko jak to ma wyglądać w praktyce, w formie jakiegoś drzewka lub czego kolwiek

No i jeszcze jedno .. Jak dziedziczyć w Kohanie ? Bo widzę że moje wszystkie modele i kontrolery już dziedziczą klasy wyznaczone przez Kohane _Models i _Controllers ... Da się jeszcze podpiąć coś czy nie bardzo ?

Przepraszam jeżeli są to jakieś durne pytania, ale niepotrafie zastosować tego w praktyce

Pozdrawiam

Ja ostatnio zbudowałem sobie zestaw do tworzenia słowników z bazy danych w oparciu o własną warstwę abstrakcyjną do łączenia się z bazą.
Problem już wcześniej miałem rozwiązany funkcjami (funkcja do selecta, do multiselect, do checkboxa) ale jakoś mi się to nie podobało i teraz mam jeden mały zestaw:

abstract.menuList.php

[PHP] pobierz, plaintext 
abstract class menuList {
    protected $sortBy;
    protected $sql;
    protected $tableName;
    protected $fieldName;
    protected $idName;
    protected $checkBy;
 
    private $whereAnd = array();
    private $whereOr = array();
    private $db;
 
    abstract public function PrintList();
    abstract protected  function prepear();
 
    public function  __construct($tableName, $fieldName, $idName) {
    ...}
    protected function getItemDB() {
    ...}
    protected function addWhereAnd($item) {
    ...}
    protected function addWhereOr($item) {
    ...}
    public function sortByName($rodzaj = 'ASC') {
    ...}
    public function sortById($rodzaj = 'ASC') {
    ...}
    public function checkById(){
    ...}
    public function checkByName(){
    ...}
}
[PHP] pobierz, plaintext 

(na potrzeby pytania wykasowałem środek bo trochę tego jest)
czyli klasa robi prawie wszystko poza odpowiednim wyglądem. A teraz dziedziczenie:

[PHP] pobierz, plaintext 
include_once 'abstract.menuList.php';
 
/**
 * Klasa odpowiedzialna za wyświetlenie listy Radio na podstawie słowników
 * z bazy danych
 *
 * @author Paweł Wołkowski
 *
 * @param uchwyt $con połaczenie z bazą danych
 * @param string $tableName nazwa tabeli z której będzie tworzona rozwijalna lista
 * @param string $fieldName wyświetlane pole w liście
 * @param string $idName pole odpowiedzialne za identyfikator zrwacany z listy (id tabeli)
 * @param variant $checkVal wartość domyślnego zaznaczenia (default = 0)
 * @param boolean $aktywny wyświetlaj tylko aktywne wiersze (default = true)
 */
class radioList extends menuList {
    private $checkVal;
    private $aktywny;
    private $obrazki = False;
    private $scierzka;
    private $sortName;
 
    public function  __construct($tableName, $fieldName, $idName, $checkVal = 0, $aktywny = True) {
        parent::__construct($tableName, $fieldName, $idName);
     }
 
    protected function prepear() {
        if($this->aktywny == TRUE) {
            $this->addWhereAnd("aktywny = 't'");
        }
        if($this->checkVal != 0) $this->addWhereOr($this->idName = $this->checkVal);
        $this->sortById();
    }
 
    /**
     * Funckaja ustawia parametr obrazki na true/false jeżeli w liście radio zamiast tekstu
     * mają być wyświetlane obrazki
     * @param boolean
     */
    public function setObrazki($obrazki) {
        $this->obrazki = $obrazki;
    }
    /**
     * Funckaja ustawia parametr ścierzka na string jeżeli w liście radio zamiast tekstu
     * mają być wyświetlane obrazki wg podanej ścierzki
     * @param string $scierzka
     */
    public function setScierzka($scierzka = 'pic/') {
        $this->scierzka = $scierzka;
    }
 
    public function  PrintList() {
        $ar = $this->getItemDB();
        foreach ($ar as $pole) {
            if($this->checkVal == $pole[$this->fieldName]) {
                $selected = ' checked="checked" ';
            }else {
                $selected = '';
            }
            if($this->obrazki){
                $label = '<img src="pic/'.$pole[$this->fieldName].'.png" width="16" height="16" alt="'.$pole[$this->fieldName].'" title="'.$pole[$this->fieldName].'"/>';
            }else{
                $label = $pole[$this->fieldName];
            }
            $tekst .= '<input type="radio" '.$selected.' name="'.$this->tableName.'" value="'.$pole['id'].'" /><label for="imie">'.$label.'</label>';
        }
        return $tekst;
    }
}
 
[PHP] pobierz, plaintext 

Druga klasa

[PHP] pobierz, plaintext 
include_once 'abstract.menuList.php';
 
/**
 * 
 * 
 * @author Paweł Wołkowski
 *
 */
final class selectMenu extends menuList {
 
    private $aktywny;
    private $checkVal;
    private $wolne;
    private $firstField = '___BRAK___';
 
    public function  __construct($tableName, $fieldName, $idName, $checkVal = '', $aktywny = False, $wolne = False) {
        parent::__construct($tableName, $fieldName, $idName);
 
        $this->aktywny = $aktywny;
        $this->checkVal = $checkVal;
        $this->wolne = $wolne;
 
        $this->prepear();
    }
 
    protected  function prepear() {
 
        if($this->aktywny == TRUE) {
            $this->addWhereAnd("aktywny = 't'");
            if($this->checkVal != '') {
                $this->addWhereOr("$this->idName = $this->checkVal");
            }
        }
 
        if($this->wolne == TRUE) {
            $this->addWhereAnd("stan = 'W'");
            if($this->checkVal != '') {
                $this->addWhereOr("$this->idName = $this->checkVal");
            }
        }
 
        $this->checkByName();
        $this->sortByName();
 
    }
 
 
    public function PrintList() {
 
        $ar = $this->getItemDB();
        $tekst = '<SELECT NAME="'.$this->idName.'" SIZE="1" style="width:111">'. "\n";
        $tekst .= '<OPTION VALUE="">'.$this->firstField.'</OPTION>'. "\n";
        foreach ($ar as $pole) {
                if($this->checkVal == $pole[$this->checkBy]) {
                    $selected = ' SELECTED = "SELECTED" ';
                }else {
                    $selected = '';
                }
                $tekst .= '<OPTION VALUE="'.$pole[$this->idName].'"'.$selected.'>'.$pole[$this->fieldName].'</OPTION>'. "\n";
        }
        $tekst .= '</SELECT>'. "\n";
        return $tekst;
    }
}
 
$test = new selectMenu('nawigacja', 'numer_ewidencyjny', 'id_naw','30');//nawigacja nazwa tabeli, numer_ewidencyjny - wyświetlana wartość, id_naw zwracany identyfikator, 30 - zaznaczona pozycja
$test->checkById();
$test->sortByName('DESC');//standardowo malejąco ale jak trzeba to można rosnąco
echo $test->PrintList();
[PHP] pobierz, plaintext 

Dziedziczenie jest w tym przypadku bardzo fajne bo teraz wpadłem na pomysł i chcę rozbudować te klasy o możliwość podawania tablicy z której wygenerowane zostaną słowniki a nie jak teraz tylko z bazy. Tak musiałbym przerabiać funkcje pod nowe wymagania a tak tylko przeciążenie konstruktora i pozamiatane

Powiem w miarę prosto słowami. Dziedziczenie jest używane tam, gdzie klasa która ma powstać jest bardzo podobna do już istniejącej i wykorzystuje rozwiązania, które ona implementuje. Najczęściej używa sie go gdy owa nowa klasa rozszerza możliwości klasy starszej. Wyobraź sobie sytuację, że każde dziecko jest idealną kopią swoich rodziców i dziedziczy po nich wszystko (w php nie jest to możliwe, gdyż nie można dziedziczyć po więcej niż 1 klasie, ale to "szczegół" , przyjmij że php pozwala Ci wybrać tylko jednego rodzica do tego celu ). Ma więc wszystkie cechy zarówno swojej matki, jak i swojego ojca (w php wszystko albo ojca, albo matki, zależnie po kim dziedziczysz), wszystkie ich zdolności + jeszcze dodaje swoje własne. Na starcie więc nie musi się niemal niczego uczyć, gdyż posiada pełną wiedzę i umiejętności obojga (jednego z) rodziców. Wszystko co jest nowe, poszerza jego umiejętności. Podobnie się ma rzecz z programowaniem. Dziedziczenie określa pewne umiejętności podstawowe, które nowa klasa "przejmuje" po rodzicu. Co ciekawe, to może dziecko owe stare metody "poprawić". Wystarczy, że funkcje owe zostaną w nowej klasie napisane na nowo. A by było jeszcze ciekawiej, dziecko może wybrać czy chce korzystać w takim wypadku z własnej metody, czy odziedziczonej po rodzicu

Nie myl dziedziczenia z implementacją. Dziedziczenie to bowiem "skopiowanie żywcem" od rodzica funkcji, metod. Implementacja określa tylko, że pewne rzeczy muszą się znaleźć w nowej klasie, ale nie mówi jak i co. To od Ciebie zależy co z tym zrobisz. Dlatego właśnie nawet nazewnictwo dziedziczenia łatwo pamiętać... jest to bowiem extends, a to po angielsku znaczy "rozszerz". To zaś w dużej mierze główne zastosowanie dziedziczenia: poszerzanie możliwości już istniejących klas bez konieczności kopiowania całego kodu na zasadzie, weź wszystko od mojego rodzica

No kodzik fajny i zaczeło mi już coś świtać
Czyli w pierwszej klasie zrobiłeś sobie połączenia z bazą danych itp
A w drugiej i trzeciej reszte Powiedzcie mi jeszcze jak takie coś można byłoby zastosować w Kohanie ? Czy w ogóle się da używać tam dziedziczenia ? Bo z chęcią nauczyłbym się używania tej magicznej rzeczy

Pozdrawiam

Tak jak kolega wyżej napisał, albo możesz sobie spojrzeć np. w manual php na klasy DOMNode i przyległe. Np. DOMDocument po niej dziedziczy - DOMNode zapewnia jakąś podstawową funkcjonalność wspólną dla każdego swojego potomka, a potomkowie dodają coś od siebie, bo np. nie było sensu żeby dana metoda znalazła się wyżej w hierarchii (w tym przypadku w klasie DOMNode), bo jest specyficzne tylko dla nich. W ten sposób każdy stworzony obiekt posiada tylko to co jest mu niezbędne. Dla programisty natomiast łatwiej jest zapamiętać że potrzebna mu metoda znajduje się np w klasie DOMElement, niż szukać jej w gąszczu metod DOMNode.

Oczywiście nie musisz wcale używać dziedziczenia, ale bardzo ułatwia ono ponowne użycie kodu. Na przykładzie obsługi plików:

[PHP] pobierz, plaintext 
 
class File {
  protected $_name;
  protected $_size;
  protected $_type;
 
  public function __construct() {
    //tu następuje zainicjowanie pól klasy odpowiednimi wartościami
  }
 
  public function create() {
 
  }
 
  public function remove() {
 
  }
}
 
[PHP] pobierz, plaintext 

Dysponujesz klasą, która posiada podstawową funkcjonalność wspólną dla każdego pliku. Teraz powiedzmy że chciałbyś do swojego skryptu, w którym używasz tej klasy dodać pewną specyficzną funkcjonalność, np. dla obrazków i plików tekstowych. Masz dla wyjścia - albo przerobić (dodać) kod klasy file i zmienić jej nazwę (dwukrotnie), albo dziedziczyć:

[PHP] pobierz, plaintext 
 
class Image extends File {
  public function __construct() {
    parent::__construct();
  }
 
  public function crop() {
  }
 
  public function scale() {
  }
 
  public function round() {
  }
}
 
class Txt extends File {
  private $_content;
 
  public function __construct($content) {
    parent::__construct();
    $this->_content = $content;
  }
 
  public function addContent($addedContent) {
    //tralala
  }
}
 
[PHP] pobierz, plaintext 

Kumasz?

To tak trochę bardziej łopatologicznie:
Dziedziczenie interfejsu: interfejsy
Dziedziczenie interfejsu + implementacji: dziedziczenie

Kiedy używać dziedziczenia?
Bardzo prosto... kiedy o obiekcie klasy A możesz powiedzieć, że jest on również obiektem klasy B.
O ile dobrze pamiętam na stronach Suna fajnie było to opisane: http://java.sun.com/docs/books/tutorial/ja...nheritance.html
W ogóle dobrze będzie jak sobie przeczytasz: http://java.sun.com/docs/books/tutorial/ja...epts/index.html (co prawda w PHP nie ma paczek (ang. package), ale są przestrzenie nazw (ang. namespaces), które w pewnym sensie oznaczają to samo) - będziesz przynajmniej wiedział jakie są podstawowe narzędzia obiektówki.

To nie jest rozdrabnianie - to jest precyzowanie/wyszegóławianie (niepoprawnie to napisałem) klas.
Przykłady ze zwierzętami czy kształtami są bardzo dobre - ale w świecie Javy itp., a nie PHP.

No to na szybko. Czym jest news i artykuł? Oba te obiekty są formą jakiegoś wpisu, które współdzielą jakieś cechy (autor, data utworzenia, treść).

[PHP] pobierz, plaintext 
<?php
 
abstract class TextItem {
  protected $author;
  protected $title;
  protected $content;
  protected $created_at;
 
  protected $viewed = 0; // ilość wyświetleń
 
  abstract function load($id); // metoda wczytująca z bazy i wypełniająca obiekt pobranymi danymi
 
  public function increaseViewed() {
     ++$this->viewed;
  }
 
  // tutaj cała masa getterów/setterów
}
 
class News extends TextItem {
  protected $short_content; // News ma jeszcze skrócona tresc
  protected $display_on_abc; // News ma jeszcze właściwość "Wyświetlaj w ABC"
 
  public function load($id) {
     //....
  }
 
  // gettery/settery dla dwóch nowych pól
}
 
class Article extends TextItem {
  // A to akurat nie ma niczego specjalnego, ale oczywiście mogło by mieć. Np.: zaimplementowany podział treści na strony
 
  public function load($id) {
     //....
  }  
}
[PHP] pobierz, plaintext 

Nie znam tego FW, ale... normalnie? Poprzez extends
Możesz sobie utworzyć swoją własną klasę np.: MyController, która (by silnik Kohany mógł to obsłużyć) musi dziedziczyć po _Controllers. Wtedy w niej możesz zaimplementować swoje własne metody, a kontrolery niech dziedziczą po Twojej klasie. De facto będą one dziedziczyć po MyController i _Controllers (czyli obu).

Moja wina... Crozin zauważył moją pomyłkę Pisałem implementacja mając na myśli interfejsy

Co do Kohany to ja bardzo często dziedziczę w niej. Jak to wygląda? Ano choćby tak, że Kohana ma domyślnie swoją klasę Template jest ona w sumie uboga, ale udostępnia swoim potomkom wystarczająco by na jej podstawie sobie szablon główny strony utworzyć. Ten szablon, już dostosowany do moich potrzeb strony, jest z kolei podstawą, by ładnie rozpisać szablon osobny dla usera i osobny dla admina. Tworzy się więc zależność:
Template Kohanowski po którym dziedziczy Template Bazowy strony. A z kolei po Template Bazowy dziedziczą template Admin i Template User.
Można też zrobić dziedziczenie uprawnień choćby
Klasa obsługi gościa. Rozszerza ją klasa Registered User bo ma to samo co Gość + kilka funkcji dodatkowych. Moderator dziedziczy po Userze rozszerzając o kolejne funkcje. Zaś Admin dziedziczy i rozszerza Moderatora Zauważ, że w razie czego nowe funkcjonalności "przechodzą" na klasy pochodne. Jeśli dodam coś do Gość to będą mieć to wszyscy. Jeśli dodam do Moderator, to i Admin też to otrzyma, ale już Gość i User nie, bo są "starsze". Tworzy się drzewko dziedziczenia.

~Damiankossek
Praktyczne zastosowanie już znasz, teraz kolej na teoretyczny bełkot
Dziedziczenie, w zależności od strony z której spojrzeć, nazywa się specjalizacją lub generalizacją. O specjalizacji mówimy gdy patrzymy na klasy "od góry", czyli od pierwszej/głównej klasy. Każda klasa, która dziedziczy po pierwszej jest specjalną odmianą rodzica. Klasa taka posiada wszystkie elementy rodzica oraz własne, specjalne, elementy. Stąd nazwa - specjalizacja. Oczywiście łańcuch dziedziczenia nie kończy się na jednej klasie. Wyspecjalizowanych klas może być więcej, np Klasa1 -> Klasa11 -> Klasa111...
Generalizacja jest odwrotnością specjalizacji i polega na patrzeniu na hierarchię klas "od dołu". Czyli zaczynamy od klasy, po której nic już nie dziedziczy i przesuwamy się "do góry". W takim przypadku rodzic jest uogólnionym przypadkiem danej klasy. Innymi słowy jest to to samo, tylko ma mniejsze możliwości.

Jeśli chcesz poznać więcej teorii, to poczytaj na temat diagramów klas w UML.

W "Kohanej" można stosować własne klasy w formie bibliotek więc jak najbardziej nawet mój przykład tam pasuje i wykorzystuję go na mojej stronie.
Ja podchodzę do dziedziczenia tak.

Mam do napisania kilka klas robiących coś.
Jeżeli 20% lub więcej kodu powtarza się w każdej klasie to znaczy, że trzeba zastosować dziedziczenie. I wywalić powtarzający się kod do rodzica (często posiadającego metody abstrakcyjne aby zachować interfejs) i potem sobie dziedziczę.