Witam
dziś szukając informacji o abstrakcji obiektów natchnołem się na ten artykuł
http://blog.dywicki.pl/2007/04/04/o-abstra...-i-interfejsow/


Zrozumiałem tyle:
Abstrakcja
-Wymusza tworzenie obiektów w klasach pochodnych
-Przekazuje informacje o działającym skrypcie


Interfejs
-Wymusza użycie metod w klasach impletujących go
-Przekazuje nadzędzia działającego systemu


Używamy
Klasę abstrakcyjną gdy:
-Mamy mniejszy system
-Musimy zawrzeć w funkcji która będzie wymuszona jakiś kod
-Chcemy używać niektórych z jej metod


Interfejs gdy:
-Mamy wielki system
-Wymuszamy użycie metod w których nie musimy zawierać kodu
-Definiujemy medtody które zainicjujemy w klasach impletujących interfejs



Nie zrozumiałem:
-Co to jest Elastyczność obiektu
-"Budowa złożonej aplikacji bez użycia interfejsów jest posunięciem wysoce nierozsądnym, ponieważ to właśnie dzięki nim, nawet w językach kompilowanych ze statycznym typowaniem jesteśmy w stanie zyskać nadzwyczajnie elastyczny kod"
-"Nawet jeśli koncepcja implementacji obróci się o 180 stopni to nasz interfejs, będący swoistą fasadą, ukryje te zmiany przed osobami, których one nie dotyczą bądź nie interesują."


Dziękuje z góry oraz proszę o wyrozumiałośc ale jeśli mi ktoś nie wytłumaczy nie pojmę niczego tego do końca.

Chodzi o to, aby zmiana implementacji jakiejś metody nie pociągała za sobą konieczności zmian w wielu miejscach, albo co gorsza, zmian w kodzie użytkującym tą metodę. np. Dwie klasy News (ahh, nieśmiertelny przykład) - ten sam interfejs, ale działanie kodu wewnątrz klas jest inne

[PHP] pobierz, plaintext 
<?php
//print date('Y-m-d', 1218467120);
class Comment
{
	protected $content;
	protected $id;
 
	public function __construct($content='')
	{
		$this->content=$content;
	}
 
	public function getId()
	{
		if(!$this->id)
		{
			$this->id=rand(1, 300); // ot, symulacja
		}
		return $this->id;
	}
 
	public function getContent()
	{
		return $this->content;
	}
}
 
interface Commentable
{
	public function getComments();
	public function getComment($id);
	public function addComment(Comment $comment);
 
}
 
class News implements Commentable
{
	protected $comments=array();
 
	public function getComment($id)
	{
		return $this->comments[$id];
	}
 
	public function getComments()
	{
		return $this->comments;
	}
 
	public function addComment(Comment $comment)
	{
		$this->comments[$comment->getId()]=$comment;
	}
}
 
 
class News implements Commentable
{
	protected $comments=array();
 
	public function getComment($id)
	{
		if(isset($this->comments[$id]))
		{
			return $this->comments[$id];
		}
		else
		{
			throw new Exception("Cannot find comment (id: $id)");
		}
	}
 
	public function getComments()
	{
		return $this->getFiltered($this->comments);
	}
 
	public function getFiltered($comments)
	{
		$data=array();
		foreach($comments as $key=>$comment)
		{
			if((integer)$key%2==0)
			{
				print $key;
				$data[$key]=$comment;
			}
		}
		return $data; // tylko parzyste identyfikatory
	}
 
	public function addComment(Comment $comment)
	{
		$this->comments[$comment->getId()]=$comment;
	}
}
 
$news=new News();
 
try
{
	$news->addComment(new Comment());
	$news->addComment(new Comment());
	$news->addComment(new Comment());
	print_r($news->getComments());
}
catch(Exception $e)
{
	print $e->getMessage();
}
 
?>
[PHP] pobierz, plaintext 

Metoda News::getComment(), pobiera identyfikator jako parametr i wyszukuje odpowiadający mu obiekt w lokalnej kolekcji. Możemy też rozbudować funkcję tak, aby w przypadku nieznalezienia obiektu, szukała w bazie danych, a dopiero potem zwracała błąd. Zauważ, że zawsze przekazujemy tylko identyfikator - nie musimy nic zmieniać w wywołaniu tej metody.
Teraz mając system, który ma np. 10 klas News (np dla Swiat, Polska, Warszawa), metoda wyszukiwania i pobierania Komentarzy może być różna dla każdej z nich. Jeszcze mały przykład

[PHP] pobierz, plaintext 
<?php
class ChinaNews extends News
{
	public function addComment(Comment $comment)
	{
		$this->comments[$comment->getId()]=$this->censorship($comment);
	}
 
	public function censorship(Comment $comment)
	{
		if(eregi("Tibet", $comment->getContent()))
		{
			throw new Exception('We apologize, but our servers are overloaded. Please try again later'); // 
		}
		return $comment;
	}
}
 
// i jeszcze kod użytkujący
$news=new ChinaNews();
 
try
{
	$news->addComment(new Comment('Free Tibet!!!'));
}
catch(Exception $e)
{
	print $e->getMessage();
}
?>
[PHP] pobierz, plaintext 

To jest właśnie elastyczność - ukrycie implementacji za interfejsem.

Pozdrawiam.

Przenoszę na OOP

Czyli elastyczność to zastosowanie interfejsów/ klas abstrakcyjnych które wymuszą użycie jednej metody która ma kilka zadań w zależności od klas?

Nie do końca. W pewnym stopniu tak, ale tu chodzi o ukrycie szczegółów implementacji, a metoda powinna robić zazwyczaj to samo, albo przynajmniej zwracać oczekiwane wyniki. Czyli kogoś, kto używa tej metody nie obchodzi jak ona działa. "Ten kto używa", to inny kod (tzw. użytkownik), albo inny programista.
To tak jak z samochodem - przekręcasz kierownicę w prawo i nie interesuje Cię w tym momencie, co się dzieje wewnątrz tego mechanizmu - interesuje Cię tylko to, że samochód skręca - bo taka była Twoja intencja, gdy przekręcałeś kierownicę

Pozdrawiam.

Czyli Elastyczność to jest:
Ktośużywa funkcji (skrypt banu) z intencją zbanowania ale niewie jak to działa w środku skryptu wie co to robi lecz nie wie jak to jest napisane, na jakich tabelach/klasach operuje?

Tutaj wyczytałem
http://forum.php.pl/index.php?showtopic=65622&st=10

że interfejsy są bardziej potrzebne od strony dokumentacji kodu??

To jest interfejs i wtedy masz rację. Zapewnia on elastyczność, ale jest ona widoczna dopiero z punktu widzenia.. z wewnątrz metody. Programista może napisać np. 10 wersji tej samej metody i zmieniać je jak rękawiczki (np. testować najbardziej wydajną). Nie musi jednak zmieniać sposobu, w jaki ktoś tej metody używa (interfejsu). Jeśli metoda jest w systemie często wykorzystywana (bywa i kilkaset razy), to zmiana jej działania wpływa od razu na cały system, bo ten operuje na wyższym poziomie - na interfejsie właśnie. Nie musisz latać po kodzie i zmieniać jakichś zmiennych, kopiować i wklejać fragmentów kodu itp.

[PHP] pobierz, plaintext 
<?php
Interface ValidatorInterface
{
	/**
	*validate		function
	*Sprawdzaj
	*@var	 (*)string	 Tekst do sprawdzenia
	*@acces		public
	*/
	public function validate($string);
 
	/**
	*getErrors		function
	*
	*Zwróć blędy
	*@acces		public
	*/
	public function getErrors();
}
 
Abstract Class Validator
{
	protected $errorsAmount = 0;
	protected $validatingText;
	abstract public function validate($string);
	function TestWielopoziomowegoDziedziczenia()
	{
		echo 'Testuje';
	}
}
 
Class StringValidator extends Validator
{
	public function validate($string)
	{
		$this->validatingText = $string;
	}
 
 
}
 
Class IntValidator extends Validator
{
	public function validate($int)
	{
		$this->validatingText = $int;
	}
}
 
Class EmailValidator extends StringValidator implements ValidatorInterface
{
	#Algorytm poprawności
	protected $pattern = '/^[a-zA-Z0-9-.]+@[a-z0-9-]+.[a-z0-9-]{2,6}+$/';
 
 
	/**
	*Trwa sprawdzanie
	*
	*@return		bool		Poprawność
	*/
	public function validate($subject)
	{
		#Sprawdz
		if (strlen($subject) < 5)
			++$this->errorsAmount;
		if (!preg_match($this->pattern, $subject))
			++$this->errorsAmount;
 
		$arrSubjectPart = explode('@', $subject);
		if (count($arrSubjectPart) != 2)
			++$this->errorsAmount;
 
		#Zwróć wynik
		return ($this->errorsAmount > 0) ? false : true;
	}
 
 
	public function getErrors()
	{
		return $this->errorsAmountAmount;
	}
 
	/**
	*Usuń niepotrzebne dane
	*
	*@return		null		null
	*/
	function __destruct()
	{
		unset($this->pattern);
		unset($this->validatingText);
		unset($this->errorsAmountAmount);
	}
}
 
Class NumValidator extends IntValidator implements ValidatorInterface
{
	public function validate($int)
	{
		if (!is_int($int))
			++$this->errorsAmount;
		else
			return true;
	}
	public function getErrors()
	{
		return $this->errorsAmountAmount;
	}
}
 
$numValidator = new NumValidator;
$numValidator->TestWielopoziomowegoDziedziczenia();
?>
[PHP] pobierz, plaintext 

Tutaj znalazłem zastosowanie interfejsów
bo klasa abstrakcyjna nie wymusi metody u klasy wnuka

A elastyczności nie mogę zrozumieć. Ok więc robie tak:
Piszę
klasy

[PHP] pobierz, plaintext 
<?php
Interface Układy
{
	public function kierownicy();
	public function silnika();
	public function napędu();
	public function biegów();
}
 
 
Abstract Class Samochod
{
	protected $rok;
	protected $stan;
	protected $marka;
	protected $model;
 
	public function zwrocRok()
	{
		return $this->rok;
	}
 
	public function zwrocStan()
	{
		return $this->stan;
	}
 
	public function zwrocModel()
	{
		return $this->model;
	}
 
	public function zwrocMarka()
	{
		return $this->marka;
	}
}
?>
[PHP] pobierz, plaintext 

I dam tą klase komuś
i w zależności czy ktoś dopisze funkcje

[PHP] pobierz, plaintext 
<?php
function unapedu()
{
	return ++$gaz;
}
?>
[PHP] pobierz, plaintext 

czy

[PHP] pobierz, plaintext 
<?php
function unapedu()
{
	return $gaz += 2*$gaz;
}
?>
[PHP] pobierz, plaintext 

To zawsze doda gazu.

Czy to jest elastyczność

Z pewnego wątku na forum mam takie coś

[PHP] pobierz, plaintext 
<?php
interface inteligencjaNaPewenymPoziomie{}
abstract class Ssaki{}
 
class Czlowiek extends Ssaki implements inteligencjaNaPewenymPoziomie{}
class Orangutan extends Ssaki{}
 
// 2  podobne, ale jakże różne klasy Budowniczy
 
class Budowniczy{
 
function budujSamolot(Ssaki $object){}
function budujSamolot(Ssaki $object); //orangutan z powodzeniem wybuduje na samolot : )
function malujWPaincie(Ssaki $object){} // orangutan i czlowiek mogą używać Painta(TM)
}
 
 
class Budowniczy{
 
function __construct(Ssaki $object){}
function budujSamolot(inteligencjaNaPewenymPoziomie $object){} // tutaj tylko obiekt typu inteligencjaNaPewenymPoziomie bedzie mógł wykonać zadan
ie
function malujWPaincie(Ssaki $object){} // orangutan zawsze może pomalować : P
}
?>
[PHP] pobierz, plaintext 

Chodzi mi na temat o info o czymś takim
budujSamolot(inteligencjaNaPewenymPoziomie $object)

albo widzialem gdzieś takie coś funkcja(JakasKlasa $object)?

[PHP] pobierz, plaintext 
<?
metoda_czy_funkcja(NAZWA $zmienna){
}
?>
[PHP] pobierz, plaintext 

W PHP taka konstrukcja oznacza, że parametr $zmienna musi:
1) Obiektem klasy NAZWA
2) Obiektem, któego klasa dziedziczy po NAZWA
3) Obiektem, którego klasa implementuje interfejs NAZWA
(dodatkowo takie wymusznie typu możesz zostosować jeszcze do tablic (array). I niestety tylko tyle)


Co do interefejsów:
Wyobraź sobie, że masz obok siebie cztery telewizory. Każdy z nich ma pięć przycisków:
1) Power (off/on)
2) Zwiększ głośność
3) Zmniejsz głośność
4) Kanał w górę
5) Kanał w dół

Gdy chcesz włączyć którykolwiek z tych telewizorów wykonujesz następującą akację: wciskasz przycisk power. I z Twojej strony to już jest koniec operacji. Teraz wewnątrz telewizora jego elektornika włącza wyświetlacz (zwróć uwagę, że Ciebie to już nie interesuje czy to jest kineskop, ekran LCD czy plazma), głośniki (ponownie nie interesuje Cie czy to jest jeden głośnik mono czy stereo czy może telewizor korzysta z zewnętrznego układu głośników) itp.

Jeszcze jeden przykład: Jakiego byś telewizoru nie kupił będziesz potrafił korzystać z jego podstawowych opcji na pilocie (5 punktów powyżej). Dlaczego? Ponieważ jest tam powtórzony pewien schemat, jednolity interfejs. Oczywiście pilot może oferować dużo większe możliwości (takie, których inne nie oferują) ale te, które są zapisane w interfejscie wykonuje dokładnie tak samo jak inne piloty.

A więc interfejs ujednolica dostęp do określonych zachowań (w OOP można by przyjąć, że w polach przechowujemy stany obiektu (np. telewizor: włączony/wyłączony, glośność 80, 70, 100, kontrast: 75, 22) a w metodach mamy "zachowania" (zmiejsz/zwiększ kontrast, włącz/wyłącz))

Co do klas/metod abstrakcyjnych. One pozwalają na to by pewne zachowania były wspólne dla różnych obiektów. Dzięki temu, że raz zapiszemy pewne zachowanie w klasie abstrakcyjnej (którą dziedziczy klasa dziecko) nie musimy pisać tego samego kodu 5 razy. Ponownie przykład telewizorów:

[PHP] pobierz, plaintext 
<?
 
interface iTelewizor{
  public function wlacz();
  public function glosnosc($wartosc = 0);
  public function kontrast($wartosc = 100);
}
 
abstract class Telewizor{
  protected $wlaczony = false;
  protected $glosnosc = 75;
  protected $mute = false;
  protected $kontrast = 40;
 
  //wszystkie telewizory dzialaja tak samo. Jak jest wlaczony i klikniemy "Power" to sie wylaczy i vice versa
  public function wlacz(){
	$this->wlaczony = ($this->wlaczony === false) ? true : false;
  }
 
  protected function mute(){
	return $this->mute = ($this->mute === false) ? true : false;
  }
}
 
class Kineskopowy extends Telewizor implements iTelewizor{
  //nasz kineskopowy telewizor w przypadku gdy glosnosc jest rowna zeru wlacza funkc
je mute.
  public function glosnosc($wartosc = 0){
	if($wartosc == 0)
	  return $this->mute();
 
	$this->glosnosc = (int) $wartosc;
  }
 
  //reszta klasy bez metody wlacz();
}
 
class LCD extends Telewizor implements iTelewizor{
  //natomiast nasz nowy LCD, dbajac o nasze zdrowie w przypadku proby ustawienia zby
t duzej glosnosci poprosi jeszcze o potwierdzenie
  //przy $wartosc = 0, nie wlacza mute, poprostu scisza do zera
  public function glosnosc($wartosc = 0){
	if($wartosc >= 75){
	  $this->potwierdzenieGlosnosci();
	}
 
	$this->glosnosc = (int) $wartosc;
 
	if($this->posiadamZewnetrzySystemGlosnikow()){
	  $this->glosnoscSubbuffera = $this->zmiejszGlosnoscSubbufera($wartosc); //w osobnej metodzie, ktora ma jakis tam algorytm okreslajacy o ile zmiejszyc (normalnie powinno okreslac czy zmiejszyc czy wiekszyc w zaleznosci od tego 
co robimy) glosnosc glosnika niskotonowego
	}
  }
 
  //reszta klasy bez metody wlacz();
}
?>
[PHP] pobierz, plaintext 

Klasy abstrakcyjne pozwalają nam (programiście, nie uzytkownikowi (warto zaznaczyć, że programista jest czasami użytkownikiem)) zaimplementować pewne powatarzale zachowania.

Dziękuje rozjaśniło mi się Pozdrowienia dla dwóch osób które zechciały pomóc