Rozdíly

Zde můžete vidět rozdíly mezi vybranou verzí a aktuální verzí dané stránky.

--- informatika:maturita:19a [26. 04. 2015, 02.26] – [Zapouzdření] xzemla1
+++ informatika:maturita:19a [22. 02. 2026, 14.12] (aktuální) – xwolf4
@@ Řádek 1: / Řádek 1: @@
-<WRAP center round alert 60%>
+<WRAP center round tip 60%>
-Ještě není dokončeno
+Patří sem rozhraní???
 </WRAP>
 ====== Principy objektově orientovaného programování ======
-===== základní jednotky OOP: =====
+===== Vztah k ostatním paradigmatům =====
+Každé programovací paradigma se snaží vyřešit problém sdíleného stavu programu.
+  * imperativní programování - výchozí způsob - stav je libovolně měnitelný a je sdílen v globálních a lokálních proměnných
+  * funkcionální programování - "žádný sdílený stav neexistuje" - stav je neměnný, mezi tzv. "pure" funkcemi bez vedlejších účinků se posílají kopie stavu
+  * objektové programování - stav je rozdělen na malé části a zapouzdřen logikou programu v objektech
+To znamená, že konkrétní hodnoty jsou uloženy jako atributy těchto objektů. Zpracování atributů spolu s celkovou komunikací s objekty probíhá pomocí kódu, který je obsažený v metodách objektů. Navenek pak program působí jako několik navzájem spolupracujících objektů, což umožňuje snadnější přenos kódu mezi různými projekty a jednodušší úpravu již existujícího kódu pomocí dědičnosti. Další výhodou je také větší zabezpečení dat díky viditelnosti atributů.
-==== Třída ====
+Nevýhodou objektově orientovaného programování je jeho větší náročnost na paměť a výpočetní rychlost, proto se používá hlavně u moderních počítačů, kde jsou tyto nevýhody téměř neznatelné. U mikropočítačů a jednoduchých jednoúčelových strojů je však výhodnější použití strukturovaného programování.
-vzor definován uživatelem, který může obsahovat metody i proměnné (např. třída clovek, obsahující proměnné, např:
+===== Zapouzdření =====
-<WRAP center round box 60%>
+Zapouzdření není výhradně koncept OOP. Obecně v programování znamená, že nějaké data nebo logiku schováme za restriktivním rozhraním.
-class Clovek{
-string jmeno;
+V OOP je tento koncept implementován třídami, kde data jsou schována v podobě privátních atributů, které můžeme manipulovat pomocí public metod. Příkladem zapouzdření je například kolekce HashMap v jazyce Java (skrývá implementaci hašovací tabulky za metodami .put() nebo .getOrDefault()).
-int vek;}
+===== Dědičnost =====
-</WRAP>
+Dědičnost umožňuje tvorbu nových tříd podle již vytvořených tříd. Tyto odvozené třídy sdědí všechny public a protected atributy a metody rodičovských tříd. Odvozené třídy si mohou tato data různě upravovat nebo přidávat další.
-a metody, např:
-<WRAP center round box 60%>
-dychej(){...};
-rekni(string co){...};
+např:
-}
-</WRAP>
-==== Objekt ====
-instance třídy, vzájemně se liší svými vlastnostmi(atributy) a mají stejné metody jako třída
-např .
 <WRAP center round box 60%>
-clovek kaja{
+class Zpevak extends Clovek {
-jmeno = "Karel Novak";
+zpivej(){};
-vek = 55;
+tancuj(){};
 }
 </WRAP>
+V tomto příkladu jsme vytvořili novou třídu //Zpevak//, která je odvozena od třídy //Clovek//. Objekt třídy //Zpevak// tedy může využívat všechny atributy a metody třídy //Clovek// (např. metoda //vstan()// a atribut //barvaOci//) a zároveň nově vytvořené metody //zpivej()// a //tancuj()//.
-a můžeme použít metodu
+Podle kritiků by se dědičnost měla používat velmi vzácně, protože vytváří problém přílišné abstrakce a hluboké hiearchie dědičnosti, ve které člověk nepozná, kde je logika skutečně implementována. Z těchto důvodů existuje nepsané pravidlo, že dědičnost by měla být hluboká pouze 1 vrstvu. (dceřiná třída nesmí být rodičovskou třídou pro jiné třídy)
-<WRAP center round box 60%>
-kaja.rekni("Mam hlad");
-kaja.dychej();
+Na druhou stranu existují případy, kde je vícevrstvá dědičnost velmi výhodná - například při implementaci datových struktur ve standardní knihovně jazyku Java nebo ve vývoji her (hierarchie typu Entity -> Character -> Player).
-</WRAP>
+==== Vícenásobná dědičnost ====
+Počet rodičovských tříd je určen použitým programovacím jazykem (např. Java umožňuje pouze jednu rodičovskou třídu, C++ umožňuje více).
-můžeme si vytvořit více instancí:
-<WRAP center round box 60%>
-clovek honza{
-jmeno = "Jan Cerny";
+===== Polymorfismus =====
+Umožňuje použít jednotné rozhraní pro práci s různými typy objektů.
+==== Compile-time polymorfismus ====
+Přetěžování metod - metoda může fungovat více různými způsoby, které se rozliší podle druhu a počtu parametrů. (funguje pouze v jazycích s )
-vek = 10;}
+Programovací jazyk se statickými typy ví, jaké datové typy používá, a proto umí vybrat správnou metodu při kompilaci.
-</WRAP>
-a opět můžeme použít stejné metody...
+Příkladem je třída PrintStream v jazyce Java (implementuje System.out.println()):
+{{:informatika:maturita:java_printstream.png?800|}}
-===== Základní pilíře OOP =====
+==== Runtime polymorfismus ====
-OOP stojí na třech základních pilířích:
+Při běhu programu se musí zjistit, který datový typ používá a tím pádem kterou metodu volat.
-==== Zapouzdření ====
+způsoby implementace:
+  * alespoň 2 třídy mají stejnou rodičovskou třídu
+  * alespoň 2 třídy implementují stejné rozhraní
-umožňuje nám skrýt ty metody a atributy, ke kterým nechceme, aby bylo možné přistupovat z vnějšku. Např. u třídy clovek můžeme proměnnou datumNarozeni nechat na skrytou (private) a tím zabráníme, aby mohla být změněna z vnějšku. Tuto vlastnost definujeme pomocí viditelnosti, která může nabývat hodnot public, protected, private. Díky tomu můžou objekty fungovat jako tzv. černé skříňky: můžeme jim dát vstup, přičemž dostaneme nějaký výstup, ale nemusíme se vůbec zajímat o to, jak to vevnitř funguje.
+<code>
-Na tomto principu funguje rozhraní(interface), jehož vlastnosti poté implementujeme do různých tříd.
+public class OsobaGML {
-==== Dědičnost ====
+    public abstract void prezujSe();
+}
-Usnadňuje vytváření podobných tříd. Z rodičovské třídy si vezme podtřída všechny metody a proměnné(resp. ty, které mají nastavenou viditelnost na public nebo protected) a může si navíc přidat svoje.
+public class StudentGML extends OsobaGML {
+    @Override
+    public void prezujSe() {
+        System.out.println("Jdu ke skříňkám, otevřu svou skříňku, přezuji se.")
+    }
+}
-např:
+public class KantorGML extends OsobaGML {
-<WRAP center round box 60%>
+    @Override
-class Zpevak extends Clovek {(říkáme, že třída pro zpěváky je potomkem člověka)
+    public void prezujSe() {
+        System.out.println("Jdu do svého kabinetu, přezuji se.")
+    }
+}
-zpivej{};
+public static void main(String[] args){
+    OsobaGML[] osoby = new {new KantorGML(), new StudentGML()};
-tancuj{};
+    // Mám pole všech osob a chci, aby se všichni přezuli.
+    for(osoba : osoby){
+        osoba.prezujSe(); // Zde musí program rozlišit, jestli je konkrétní osoba kantorem nebo studentem.
+    }
 }
-</WRAP>
+</code>
+===== Viditelnost atributů a metod =====
+Nastavením viditelnosti dat můžeme určit, které části programu budou mít k těmto datům přístup. Nastavit můžeme tři základní možnosti.
+  * private - data jsou viditelná pouze pro konkrétní objekt
+  * public - data jsou viditelná komukoli
+  * protected - data jsou viditelná pouze pro konkrétní třídu a odvozené třídy
+===== Rozhraní =====
+Zjistíme, že programátor umí psát na počítači a účetní také. Intuitivně cítíme, že nebudou mít mnoho dalších společných schopností a navíc tuto dovednost může mít napříč povoláními leckdo, proto nemá smysl tvořit třídu na způsob ČlovekPracujícíSPočítačem a od ní dědit Programátora a Účetní, ale je výhodnější například vytvořit rozhraní SchopenPsátNaPočítači s požadavkem na metodu napišNaPočítači() a upravit třídy Programátor a Účetní tak, aby toto rozhraní implementovaly, tedy předepsanou metodu, a to každý po svém. V definici rozhraní nemůže být obsažen kód (implementace) dané metody, ale všechny třídy, které toto rozhraní implementují, musí být schopny se s příkazem napišNaPočítači() nějak vypořádat.
-==== Polymorfismus ====
+Obdobně může abstraktní třída předepisovat doimplementování metod, pro které ona sama nemá vlastní kód, ale jen předpis abstraktní metody.
-Umožňuje použít jednotné rozhraní pro práci s různými typy objektů
+===== Design patterns (návrhové vzory) =====
-např:
+Navrhují konkrétní způsoby řešení častých problémů v OOP. Tyto způsoby byly poprvé popsány v knize [[https://en.wikipedia.org/wiki/Design_Patterns#Patterns_by_type|Design Patterns]] v roce 1994.
-instance třídy //mladyClovek// bude metodu //presunSe();// vykonávat za pomocí metody //chod//, ale instance třídy //staryClovek// bude tu samou metodu //presunSe();// vykonávat za pomocí //chodOHoli//
+Výhody:
+  * rychlost implementace (Nemusím vymyslet způsob řešení problému.)
+  * komunikace v týmu (Kolega rychle pochopí, protože taky dobře zná tyto návrhové vzory-)
+  * údržba kódu (Tyto vzory vytváří tzv. "loose coupling". To znamená, že můžu nahradit jednu část systému, aniž bych rozbil všechno ostatní.)
+Nevýhody:
+  * Často vedou ke příliš komplikovanému kódu, protože byly použity, aniž by byly potřeba.
-To znamená, že i když každý objekt tuto metodu vykonává jinak, z vnějšího hlediska se tváří stejně a my nemusíme tedy přemýšlet, jak přesně toho u různých objektů docílit.
+Tady je seznam nejdůležitějších z každé kategorie:
+==== Creational ====
-Pod pojmem polymorfismus můžeme také rozumět **Přetěžování metod** - to znamená že metoda může fungovat více různými způsoby, které se rozliší podle druhu a počtu parametrů.
+Nabízí alternativní způsoby vytvoření objektů.
-Např metoda //rekni(string vyrok);// umožní objektu clovek říct nějaký výrok jen tak do vzduchu, zatímco metoda //rekni(string vyrok; clovek prijemce; zpusobHlasitosti hlasitost)// umožní tomu samému objektu říct výrok konkrétnímu příjemci a zvolenou hlasitostí.
+  * [[https://en.wikipedia.org/wiki/Builder_pattern|Builder]]
+  * [[https://en.wikipedia.org/wiki/Singleton_pattern|Singleton]]
+==== Structural ====
-==== Vícenásobná dědičnost ====
+Vysvětlují, jak uspořádat objekty do větších struktur.
-Možnost potomka dědit z více tříd zároveň. Její použití se příliš neosvědčilo, kvůli riziku konfliktu jmen, konstruktorů, a dalším problémům. Lze ji využít např. v C++
+  * [[https://en.wikipedia.org/wiki/Adapter_pattern|Adapter]]
+  * [[https://en.wikipedia.org/wiki/Decorator_pattern|Decorator]]
+==== Behavioral ====
+Vysvětlují komunikaci mezi objekty.
+  * [[https://en.wikipedia.org/wiki/Iterator|Iterator]]
+  * [[https://en.wikipedia.org/wiki/Observer_pattern|Observer]]