Упражнения и задачи за по - добро усвояване на OOP

chepa

Registered
Гледам уроци, но когато гледам урока ми е лесно, но тръгна ли да пиша.. ;д Вие как се упражнявате?


П.С - най -вече визирам класовете
 
Ами с практика и много четене на чужд код.

Дай да видим от къде учиш.
 
Колегата го каза много добре. Спазвай PSR стандартите и най-вече идеята на ООП, която е всеки клас да изпълнява своите дейности не да съдържа чужда структура. Просто се иска практика и мисъл за по-добро структуриране на системата. :) Преминеш ли веднъж на ООП и процедурният код ще ти се стори мнооого неправилно структуриран. Смисъл ще започнеш сам да пишеш единствено с ООП, защото мисълта ти ще тече в този вид, което и ще е много добре. :?: Много четене и поставяне на лични задачки. Ето от 3 годинки си имам на хоста сайт за издирване на хора онлайн и постоянно си го подобрявам от към модули. :p
 
Това, за което говори Даката е Силна свързаност(High/Strong Cohesion) и Функционална независимост(Loose coupling). Най-добрата практика е, да се спазват тези два принципа.

Ако имаш въпроси питай тука, ако можем и ни стига интелекта - ще помагаме. :D
 
Първо трябва да разбереш разликата между клас и обект, после принципите на ООП, след това обектно-ориентираното моделиране, и накрая трябва да се научиш да си създаваш абстрактни модели на задачите, които решаваш.

Правиш си online магазин, в него имаш някакви продукти, категории, потребители, кошница с продуктите, поръчки и т.н.
С обектно-ориентираното моделиране изкарваш обектите, които ще са ти нужни за решаване на задачата... в този случай имаме обектите Магазин, Продукт, Категория, Потребител, Кошница, Поръчка.
Създаваш си класове за тези обекти, като описваш само детайлите, които са важни за решаването на задачата... например, когато описваш потребителя, важни може да са потребителско име, адрес за доставка, име, телефон за връзка и т.н. Потребителя си има и други характеристики, като цвят на очите, цвят на косата височина, тегло, но тези неща едва ли ще са важни, за да му изпратиш поръчките, следователно игнорираш подобни детайли при описанието. Това се нарича абстрактен модел - концентрираш се върху важните детайли, като игнорираш всичко останало.
След като си намерил важните детайли, трябва да ги опишеш в класове, чрез свойства. Свойствата сами по себеси не са достатъчни, потребителя трябва да може да може да направи поръчката, кошницата трябва да може да добавя продукти в себе си, магазина трябва да регистрира потребители, категорията трябва да добавя продукти в себеси, а за продукта не се сещам в момента кво може да прави. Тези действия се описват чрез методи, методите оперират единствено върху данни в класа, или в най-добрия случай върху данни, подадени им през параметрите.
Класовете трябва да държат само свойства и методи, които имат смисъл в контекста на тези класове... не може в класа Потребител да има свойство "номер на продукт", или в класа Продукт да има метод "регистрирай потребител", по простата причина, че в контекста на тези класове такива свойства нямат никакъв смисъл.

Това (плюс още няколко принципа) представлява ООП - данните и работата с тях се събира в едно и образува обект, който работи като отделна единица в решаването на общия проблем.

Конкретен код не съм дал, щото ООП е повече принципи от колкото писане на код. Пък и пиша от телефон, така че ша извиняваш, ако има грешки някъде... :D
 
Благодаря на всички! Доста изчерпателно обяснение, за което ти благодаря много! Ще приключа с уроците и ще се обръщам в тази тема при нужда :)



П.С - ще прочета псота ти още 100 - 200 пъти, за да го oсмисля по - добре доста е подробен и изчерпателен ;д


ЕДИТ: Ето малко понятия с които ми е още трудно да свикна. Поствам ги, тъй като може да са полезни на някого.

Какви понятия се използват в ООП:
 Class - клас: Това е дефиниран от програмиста даннов тип, който съдържа данни и функции. Вие
може да мислите за класа като за един шаблон, чрез който може да правите различни обекти
(инстанции на класа).
 Object: една конкретна инстанция на класа.
 Променливи на класа: Това са данните, които са дефинирани в класа (още – атрибути на класа).
Тези данни трябва да са невидими за света извън класа – да могат да се достъпва, единствено
чрез функциите на класа.
 Член функции: Това са функциите, дефинирани в класа, използват се за достъп до данните в
класа.
 Наследяване (Inheritance): Когато един клас се дефинира като наследяващ данни и функции на
друг (родителски или базов) клас, то имаме наследяване. Той се явява – наследник (или дете или
породен клас) на родителски клас (Parent class).
 Родителски клас (Parent class) = base class или super class: Един клас, който се наследява от друг
клас.
 Клас - наследник (Child Class) или породен клас: Клас, който наследява друг клас.
 Полиморфизъм: Това е една обектно ориентирана концепция, състояща в това: една функция да
бъде използвана за различни цели. Например функцията „move” на клас „animal” може да се
изпълнява по различен начин: пълзене, летене, вървене и т.н.
 Конструктор (Constructor): това е специална функция, която се извиква автоматично, когато се
създава конкретен обект (инстанция)на класа.
 Деструктор (Destructors): специална функция, която се извиква автоматично, когато един обект
трябва да се разруши.
 
И разбра ли от това описание какво е полиморфизъм например? :D
На човек, който от години пише обектно-ориентирано най-веротятно ще му говори нещо, но на човек, който за първи път се сблъсква с ООП едва ли.
А полиморфизма всъщност е нещо много просто... метод, който работи по различен начин в различните класове, но в крайна сметка резултата е един и същ.
Или ако го караме по твоето описание - имаме един общ клас "Animal", в който има метод "move()", имаме и 3 класа, които наследяват "Animal" - "Snake", "Eagle", "Lion". Гарантирано ни е, че класовете, които наследяват "Animal" ще имат метода "move()", но "Snake" ще декларира в себеси "move()" и ще презапише наследения метод, като имплементира пълзене... "Eagle" ще пренапише "move()", като имплементира летене, а "Lion" ще го презапише, като имплементира бягане.
Тези, които ще ползват метода не се интересуват как е имплементиран метода "move()", те знаят, че щом го извикат, всяко животно от тип "Animal" ще започне да се движи.

Код:
class Animal {
    public function move() {
        // Basic implementation
    }
}

class Snake extends Animal {
    public function move() {
        // Implements creeping
    }
}

class Eagle extends Animal {
    public function move() {
        // Implements flying
    }
}

class Lion extends Animal {
    public function move() {
        // Implements running
    }
}

Код:
class Test {
    public function move(Animal $animal) {
        $animal->move();
    }
}

$snake = new Snake();
$eagle = new Eagle();
$lion = new Lion();

$test = new Test();

$test->move($snake);
$test->move($eagle);
$test->move($lion);

Това е цялата история с полиморфизма. :D

Или още по-прост пример от реалния живот: Когато караш кола, за да спреш - натискаш педала за спирачката. Имплементации на спирачките има колкото искаш... при по-старите коли имаш барабани, при по-новите дискове. Към спирачките има различни технологии - ABS и други системи за сигурност според марката и модела. Това, което ти знаеш със сигурност е, че когато натиснеш спирачката, колата ще спре.
Това е полиморфизъм в реалния живот. :)[/code]
 
С изучаването на шаблоните за дизайн, ще му стане доста по ясна концепцията на ООП. Ще се сблъска с доста интересни противоречия и решения на проблеми. :?:
 
Рано му е да се сблъсква с шаблоните, ако още не е разбрал основните принципи. Някои шаблони са сложни и само ще го объркат.
Моя съвет е да не бърза с тях.
 
Revelation каза:
Рано му е да се сблъсква с шаблоните, ако още не е разбрал основните принципи. Някои шаблони са сложни и само ще го объркат.
Моя съвет е да не бърза с тях.
То и да не бърза те са доста често добри примери за начинаещи. Примерно Сингълтон доста добре разяснява работата при създаване на инстанции и това как всяка инстанция работи. Ако се ползва дизайна какъв проблем решава и така нататък. Фактори също е добър дизайн за обучение, но наистина първо са нужни часове писане на примери и схващане на различни идеи. Просто се иска практика. :?:
 
Шаблоните са следствие от ООП. Можеш да пишеш обектно без да знаеш каквито и да е шаблони, но не можеш да имплементираш шаблони без ООП. :D
 
Сингълтон е най-простия и независим шаблон. Всички други се усложняват малко или много със създаването на абастрактни класове, имплементации на интерфейси и т.н.
Нека за сега учи и научи основните принципи на ООП.
 
pix3l каза:
Шаблоните са следствие от ООП. Можеш да пишеш обектно без да знаеш каквито и да е шаблони, но не можеш да имплементираш шаблони без ООП. :D

Точно защото са следствие от ООП, са добър учител, защото решават проблеми, които в писането и свързването в логика на различни обекти се срещат. Кода, който си постнал е чудесен пример, за полиморфизъм и с малко преработка на логиката пък е добър пример за Фабрика :p

PHP:
interface Animal 
{
	public function move();
}

class Snake implements Animal 
{
    public function move() 
	{
        // Implements creeping
    }
}

class Eagle implements Animal 
{
    public function move() 
	{
        // Implements flying
    }
}

class Lion implements Animal 
{
    public function move() 
	{
        // Implements running
    }
}
	
class Test 
{
    public function move($animalName) 
	{
        $err = 0;
		if(class_exists($animalName)) {
			$classAnimal = new $animalName;
			if ($classAnimal instanceof Animal) {
				$classAnimal->move();
			} else {
				$err++;
			}
		} else {
			$err++;
		}
		if ($err > 0){
			throw new Exception("The $animalName does not exist!");
		} 
    }
}

$test = new Test();

$test->move("Snake");
$test->move("Eagle");
$test->move("Lion");
 
Revelation каза:
Сингълтон е най-простия и независим шаблон. Всички други се усложняват малко или много със създаването на абастрактни класове, имплементации на интерфейси и т.н.
Нека за сега учи и научи основните принципи на ООП.
Съгласен съм, но просто е неизбежно да не се срещне дори в малко по-сложните примери със шаблоните. Вариацията на кода зависи от изпълнението на програмиста. Аз като започнах да уча ООП пишех основно обекти с проста логика, но след само седмица четене нямаше как да не се усетя, че вече ползвам вариации на шаблони за дизайн. Самият код те кара да се замисляш и да четеш. :) :?:
 
dakata__92 каза:
pix3l каза:
Шаблоните са следствие от ООП. Можеш да пишеш обектно без да знаеш каквито и да е шаблони, но не можеш да имплементираш шаблони без ООП. :D

Точно защото са следствие от ООП, са добър учител, защото решават проблеми, които в писането и свързването в логика на различни обекти се срещат. Кода, който си постнал е чудесен пример, за полиморфизъм и с малко преработка на логиката пък е добър пример за Фабрика :p

PHP:
interface Animal 
{
	public function move();
}

class Snake implements Animal 
{
    public function move() 
	{
        // Implements creeping
    }
}

class Eagle implements Animal 
{
    public function move() 
	{
        // Implements flying
    }
}

class Lion implements Animal 
{
    public function move() 
	{
        // Implements running
    }
}
	
class Test 
{
    public function move($animalName) 
	{
        $err = 0;
		if(class_exists($animalName)) {
			$classAnimal = new $animalName;
			if ($classAnimal instanceof Animal) {
				$classAnimal->move();
			} else {
				$err++;
			}
		} else {
			$err++;
		}
		if ($err > 0){
			throw new Exception("The $animalName does not exist!");
		} 
    }
}

$test = new Test();

$test->move("Snake");
$test->move("Eagle");
$test->move("Lion");
Виж, шаблоните за дизайн решават конкретни проблеми, с които едва ли някой, който тепърва учи ООП ще се сблъска. Как ще обясниш на някой, който сега се учи, че с Factory се правят обекти, като той не може да направи разлика между клас и обект? :D
 
Аз го уча от 6 дни.. ;д още ми е трудно дори с термините да свикна, но тази информация, която ми давата ще ми е доста полезна! Тепърва ще наследявам класове :?:
 
pix3l каза:
dakata__92 каза:
pix3l каза:
Шаблоните са следствие от ООП. Можеш да пишеш обектно без да знаеш каквито и да е шаблони, но не можеш да имплементираш шаблони без ООП. :D

Точно защото са следствие от ООП, са добър учител, защото решават проблеми, които в писането и свързването в логика на различни обекти се срещат. Кода, който си постнал е чудесен пример, за полиморфизъм и с малко преработка на логиката пък е добър пример за Фабрика :p

PHP:
interface Animal 
{
	public function move();
}

class Snake implements Animal 
{
    public function move() 
	{
        // Implements creeping
    }
}

class Eagle implements Animal 
{
    public function move() 
	{
        // Implements flying
    }
}

class Lion implements Animal 
{
    public function move() 
	{
        // Implements running
    }
}
	
class Test 
{
    public function move($animalName) 
	{
        $err = 0;
		if(class_exists($animalName)) {
			$classAnimal = new $animalName;
			if ($classAnimal instanceof Animal) {
				$classAnimal->move();
			} else {
				$err++;
			}
		} else {
			$err++;
		}
		if ($err > 0){
			throw new Exception("The $animalName does not exist!");
		} 
    }
}

$test = new Test();

$test->move("Snake");
$test->move("Eagle");
$test->move("Lion");
Виж, шаблоните за дизайн решават конкретни проблеми, с които едва ли някой, който тепърва учи ООП ще се сблъска. Как ще обясниш на някой, който сега се учи, че с Factory се правят обекти, като той не може да направи разлика между клас и обект? :D

Ами след седем дни на четене пишех примери по фактори, но това си го смятам по мен. Аз не съм казал веднага, че ще стане, а и разликата между обект и клас се учи още в първите минутки. Класът е изпълнителният код, докато обекта е имплементацията (инстанцията) на този клас. Един клас може да има множество обекти (инстанции) изпълняващи различна логика. Нима не се ползват прости вариации на фактори? Това, че не знаеш, че ползваш шаблон, значи само, че още не си чел за него.
PHP:
class A  
{
    public function __construct() 
	{
        print "<br>A";
    }
}

class B
{
    public function __construct() 
	{
        print "<br>B";
    }
}

class C 
{
    public function __construct() 
	{
        $a = new A;
		$b = new B;
    }
}

$c = new C;

Нима това не е орязан и прост варянт на фабрика? Толкова е оглозган, че не прилича на фабрика, но каква е идеята на шаблона, да се създават обекти. Да кода не е динамичен и е далече от идеята за преизползваемост на кода, но като пример е често срещан за различни цели, но просто не се знае, че се ползва. Има книги, които са структурирани да са последователни в изучаването на класовете с техните методи и обектите, които се създават. В интернет нещата не са така добре структурирани, за това и споменавам шаблоните, като допълнителна литература за четене. :p
 
Добре, щом си решил да говориш за шаблони, дай конкретен пример, в който предимствата на Factory ще изпъкнат.
Моя код не е добър пример, щото убиваш цялата идея на ООП, като използваш интерфейс за подобна цел. :D
 
pix3l каза:
Добре, щом си решил да говориш за шаблони, дай конкретен пример, в който предимствата на Factory ще изпъкнат.
Моя код не е добър пример, щото убиваш цялата идея на ООП, като използваш интерфейс за подобна цел. :D

Аз не казвам, че непременно трябва да започне с тях, а че е добре да ги погледне. Интерфейса го драснах само за да не променям много твоят пример, и колегата да разбере разликата между двата кода. :D Интерфейса е един договор. С неговото подписване ти гарантираш, че този клас ще има този метод. При твоят код ти наследяваш един метод и го презаписваш, докато при моят класът трябва да го има. До колкото ми е известно в Обектно Ориентираното Програмиране, не е задължително да има наследствена (extend) структура за да се достигне до някакво решение на дадена задача. Интерфейсите, както абстрактните класове или пътищата (trait) си имат своята цел. Factory сам по себе си решава най-основното нещо, за което е създаден, а именно да прави обекти. Чрез него веднага можеш да смениш обекта и това е първата полза, преименувате или заменяте класа Animal и единственото място където трябва промените е във фабриката, а не на всяко място в кода където се ползва класа Animal. Не ми се пишат примери, защото е излишно да обясняваш ползата на шаблон за дизайн. Втората възможна полза е в това, че създаването на обект може да е сложна задача и може да се пренесе работата във фабриката, вместо да се повтаря кода за установяване при всяко създаване на обект. Тоест някой обекти трябва да се създават при определени условия и фактори ти дава тази възможност. Всеки дизайн си има + и - страни. Все пак за да се стигне до тези неща се изисква време и четене, но най-вече писане на код.
 
Наследяването не е задължително, но е препоръчително да се използва, когато има очевидна връзка между класовете и единия може да допълни другия.

Имам един въпрос: За какво служат празните интерфейси? :D
Те са полезни точно толкова, колкото и тези, в които имаш методи, които трябва да се имплементират. :D
 

Горе