Java: Abstraktní třídy, dědičnost a rozhraní - Historie editací

Spravce: Doplnění abstraktních tříd.

2020-02-24T14:31:55Z

Doplnění abstraktních tříd.

← Starší verze		Verze z 24. 2. 2020, 14:31
Řádka 2:		Řádka 2:

	== Dědičnost ==		== Dědičnost ==
−	~~; Zápis dědičnosti~~	+
	* Klíčové slovo <code>extends</code>.		* Klíčové slovo <code>extends</code>.
	* Třída může mít pouze jednu rodičovskou třídu!		* Třída může mít pouze jednu rodičovskou třídu!
Řádka 8:		Řádka 8:
	* Potomek může kdykoli nahradit předka. Takže pokud máme proměnnou datového typu <code>Predek</code>, můžeme do ní uložit instanci třídy <code>Potomek</code>. Opačně to však nejde!		* Potomek může kdykoli nahradit předka. Takže pokud máme proměnnou datového typu <code>Predek</code>, můžeme do ní uložit instanci třídy <code>Potomek</code>. Opačně to však nejde!

−	; Překrývání metod	+	<div class="Priklad">
		+	public class Zivocich {
		+	...
		+	}
		+	public class Moucha '''extends''' Zivocich {
		+	...
		+	}
		+	</div>
		+
		+
		+	=== Překrývání metod ===
	* Potomek automaticky dědí všechny metody předka. Ty může používat jako vlastní metody.		* Potomek automaticky dědí všechny metody předka. Ty může používat jako vlastní metody.
	* Potomek ale může metodu nadefinovat znovu, čímž ''překryje'' (''override'') původní chování metody předka.		* Potomek ale může metodu nadefinovat znovu, čímž ''překryje'' (''override'') původní chování metody předka.
−	~~; Příklady~~	+
	<div class="Priklad">		<div class="Priklad">
−	public class Zivocich ~~extends Actor~~ {	+	public class Zivocich {
	...		...
−	public void ~~act~~() { this.move(5); } ''// Živočichové se pohybují vpravo.''	+	public void hybejSe() { this.move(5); } ''// Živočichové se pohybují vpravo.''
	...		...
	}		}
Řádka 21:		Řádka 31:
	...		...
	'''@Override'''		'''@Override'''
−	public void ~~act~~() {	+	public void hybejSe() {
	this.turn(30);		this.turn(30);
	''// Moucha se nebude pohybovat, jen se bude točit na místě!''		''// Moucha se nebude pohybovat, jen se bude točit na místě!''
Řádka 29:		Řádka 39:
	</div>		</div>

−	; Odkaz na kód předka	+	=== Odkaz na kód předka ('''super''') ===
	* Klíčové slovo <code>super</code>.		* Klíčové slovo <code>super</code>.
	* Můžeme odkazovat:		* Můžeme odkazovat:
Řádka 77:		Řádka 87:
	; Deklarace rozhraní		; Deklarace rozhraní

		+	<div class="Priklad">
	public interface Zasahnutelne {		public interface Zasahnutelne {
−	public void zasah(Strela s);	+	public void zasah(Strela s)''';'''
	''// Neříkáme, '''jak''' se má objekt chovat.''		''// Neříkáme, '''jak''' se má objekt chovat.''
	''// Jen vyžadujeme, že '''bude mít''' tuto metodu.''		''// Jen vyžadujeme, že '''bude mít''' tuto metodu.''
	}		}
		+	</div>

	; Třída, která implementuje rozhraní		; Třída, která implementuje rozhraní
−		+	<div class="Priklad">
−	public class Prisera {	+	public class Prisera '''implements''' Zasahnutelne {

	''...''		''...''
Řádka 95:		Řádka 107:
	this.getWorld().removeObject(this);		this.getWorld().removeObject(this);
	}		}
		+	</div>

	== Abstraktní třída ==		== Abstraktní třída ==
	* Klíčové slovo <code>abstract</code>.		* Klíčové slovo <code>abstract</code>.
−	* ~~Těla některých~~ metod ~~nejsou uvedena~~.	+	* Nelze vytvořit instance této třídy.
		+	* Abstraktní třídu lze ale použít jako společného předka dalších metod, které už abstraktní být nemusí.
		+
		+	<div class="Priklad">
		+	public '''abstract''' class Predmet {
		+
		+	''...''
		+	}
		+	</div>
		+
		+	=== Abstraktní metody ===
		+	* Abstraktní třída může mít abstraktní metody.
		+	* U takových metod není uveden kód, který se bude provádět, pouze fakt, že metoda ve třídě musí být.
		+	* Pokud potomci nebudou abstraktní, musí ke každé abstraktní metodě uvést konkrétní kód.
		+
		+	<div class="Priklad">
		+	public '''abstract''' class Predmet {
		+	'''...'''
		+
		+	public '''abstract''' void pouzij()''';'''
		+
		+	'''...'''
		+	}
		+
		+	public class Mic extends Predmet {
		+
		+	'''...'''
		+
		+	public void pouzij()
		+	{
		+	''... // Co se má stát při volání metody pouzij().''
		+	}
		+
		+	'''...'''
		+	}
		+	</div>


Řádka 114:		Řádka 162:
	* Je jakýmsi mezistupněm, kdy přebíráme kód jen některých metod.		* Je jakýmsi mezistupněm, kdy přebíráme kód jen některých metod.
	* Nelze vytvářet instance abstraktní třídy.		* Nelze vytvářet instance abstraktní třídy.
−
−
−	~~== Odkaz na předka — <code>super</code> ==~~
−	* Jsou situace, kdy potřebujeme změnit chování některé metody předka v potomkovi. Mluvíme o překrývání metod.
−	* Pokud potřebujeme v potomkovi přesto použít metodu předka, použijeme k tomu klíčové slovo <code>super</code>.
−	* Klíčovým slovem <code>super</code> lze také zavolat konstruktor předka.


Řádka 146:		Řádka 188:
	}		}

−	<div class="Varovani">Pozor, musíme si být stoprocentně jisti, že objekt, který je uložen v proměnné datového typu <code>Predek</code> je ve skutečnosti opravdu datového typu <code>Potomek</code>. Pokud by nebyl, běh programu by skončil výjimečný stavem a aplikace by havarovala.</div>	+	<div class="Varovani">Pozor, musíme si být stoprocentně jisti, že objekt, který je uložen v proměnné datového typu <code>Predek</code> je ve skutečnosti opravdu datového typu <code>Potomek</code>. Pokud by nebyl, běh programu by skončil výjimečný stavem a aplikace by havarovala.</div>

	== Související stránky ==		== Související stránky ==
	* [[Objektově orientované programování]]		* [[Objektově orientované programování]]

Spravce: Přidán příklad z Greenfootu a klíčové slovo '''super'''.

2020-02-24T14:15:57Z

Přidán příklad z Greenfootu a klíčové slovo '''super'''.

← Starší verze		Verze z 24. 2. 2020, 14:15
Řádka 2:		Řádka 2:

	== Dědičnost ==		== Dědičnost ==
−	*Klíčové slovo <code>extends</code>.	+	; Zápis dědičnosti
−	*Třída může mít pouze jednu rodičovskou třídu!	+	* Klíčové slovo <code>extends</code>.
		+	* Třída může mít pouze jednu rodičovskou třídu!
	* Potomek „dědí“ všechny vlastnosti předka.		* Potomek „dědí“ všechny vlastnosti předka.
	* Potomek může kdykoli nahradit předka. Takže pokud máme proměnnou datového typu <code>Predek</code>, můžeme do ní uložit instanci třídy <code>Potomek</code>. Opačně to však nejde!		* Potomek může kdykoli nahradit předka. Takže pokud máme proměnnou datového typu <code>Predek</code>, můžeme do ní uložit instanci třídy <code>Potomek</code>. Opačně to však nejde!

−	; ~~Příklad~~	+	; Překrývání metod
		+	* Potomek automaticky dědí všechny metody předka. Ty může používat jako vlastní metody.
		+	* Potomek ale může metodu nadefinovat znovu, čímž ''překryje'' (''override'') původní chování metody předka.
		+	; Příklady
		+	<div class="Priklad">
		+	public class Zivocich extends Actor {
		+	...
		+	public void act() { this.move(5); } ''// Živočichové se pohybují vpravo.''
		+	...
		+	}
		+	public class Moucha '''extends''' Zivocich {
		+	...
		+	'''@Override'''
		+	public void act() {
		+	this.turn(30);
		+	''// Moucha se nebude pohybovat, jen se bude točit na místě!''
		+	}
		+	...
		+	}
		+	</div>
		+
		+	; Odkaz na kód předka
		+	* Klíčové slovo <code>super</code>.
		+	* Můžeme odkazovat:
		+	** Na konstruktor rodičovské třídy.
		+	** Na překrytou metodu předka.
		+
		+	; Příklady
		+	<div class="Priklad">
	public class Kamion {		public class Kamion {
	int nosnost;		int nosnost;
Řádka 14:		Řádka 43:
	...		...
	}		}
−	public class KamionSPrivesem extends Kamion {	+	public class KamionSPrivesem '''extends''' Kamion {
	Prives prives;		Prives prives;
	...		...
		+	'''@Override'''
	public int getNosnost() {		public int getNosnost() {
−	~~return this~~.~~getHodnota~~()+this.prives.~~getHodnota~~();	+	int nosnostKamionu = '''super'''.getNosnost(); ''// Volání překryté metody předka.''
		+	return nosnostKamionu+this.prives.getNosnost();
	}		}
	...		...
	}		}
−		+	</div>
		+	<div class="Priklad">
		+	public class World {
		+	...
		+	public World(int rozmerX, int rozmerY, int dilek) { ... }
		+	...
		+	}
		+	public class MyWorld '''extends''' World {
		+	...
		+	public MyWorld() {
		+	'''super'''(600, 400, 1); ''// Volání konstruktoru předka.''
		+	}
		+	...
		+	}
		+	</div>

	== Rozhraní ==		== Rozhraní ==

Spravce: Přidáno srovnání konstruktů.

2017-04-07T09:38:12Z

Přidáno srovnání konstruktů.

← Starší verze		Verze z 7. 4. 2017, 09:38
Řádka 54:		Řádka 54:
	* Klíčové slovo <code>abstract</code>.		* Klíčové slovo <code>abstract</code>.
	* Těla některých metod nejsou uvedena.		* Těla některých metod nejsou uvedena.
		+
		+
		+	== Srovnání konceptů ==
		+	; Dědičnost
		+	* Používáme tehdy, kdy potomek přebírá ''všechny'' vlastnosti předka (a případně přidává něco dalšího).
		+	* Třída může mít ''jen jednoho'' předka.
		+	; Rozhraní
		+	* Pouze předepisuje, jaké metody má třída mít.
		+	* Nemůžeme z rozhraní převzít hotový kód.
		+	* Nelze vytvořit instanci rozhraní (nelze volat <code>new Rozhrani()</code>).
		+	* Můžeme implementovat kolik rozhraní chceme.
		+	* Je užitečné, když každá třída má na společnou zprávu reagovat jinak.
		+	; Abstraktní třída
		+	* Je jakýmsi mezistupněm, kdy přebíráme kód jen některých metod.
		+	* Nelze vytvářet instance abstraktní třídy.

Spravce: /* Rozhraní */ Přidán popis rozhraní.

2017-04-07T09:28:54Z

Rozhraní: Přidán popis rozhraní.

← Starší verze		Verze z 7. 4. 2017, 09:28
Řádka 27:		Řádka 27:
	* Klíčové slovo <code>implements</code>.		* Klíčové slovo <code>implements</code>.
	* Může mít pouze hlavičky metod a veřejné konstantní atributy.		* Může mít pouze hlavičky metod a veřejné konstantní atributy.
		+	* Implementací rozhraní garantujeme, že naše třída má určité metody.
		+	* Zajišťujeme například to, aby objekty různých tříd šly umístit do kontejneru.

		+	; Deklarace rozhraní
		+
		+	public interface Zasahnutelne {
		+	public void zasah(Strela s);
		+	''// Neříkáme, '''jak''' se má objekt chovat.''
		+	''// Jen vyžadujeme, že '''bude mít''' tuto metodu.''
		+	}
		+
		+	; Třída, která implementuje rozhraní
		+
		+	public class Prisera {
		+
		+	''...''
		+	''... Může mít různé metody a atributy, ale '''musí''' mít metodu zasah(...)!!!''
		+	''...''
		+
		+	public void zasah(Strela s) {
		+	''// Popíšeme, jak se má reagovat na zprávu/metodu zasah(...).''
		+	this.getWorld().removeObject(this);
		+	}

	== Abstraktní třída ==		== Abstraktní třída ==

Spravce: /* Přetypování */ Přidán příklad přetypování s GUI SWING

2017-02-28T12:32:15Z

Přetypování: Přidán příklad přetypování s GUI SWING

← Starší verze		Verze z 28. 2. 2017, 12:32
Řádka 45:		Řádka 45:
	* V tom případě musíme použít přetypování.		* V tom případě musíme použít přetypování.

−	* Přetypování zapíšeme tak, že do závorky před výraz, který vrací takto uloženého potomka, zapíšeme název třídy předka:	+	* Přetypování zapíšeme tak, že do závorky před výraz, který vrací takto uloženého potomka, zapíšeme název třídy předka.
		+
		+	; Příklady přetypování
		+	* Greenfoot a detekce kolize s konkrétním typem aktéra

	Prekazka prekazka = '''(Prekazka)''' this.getOneIntersectingObject(Prekazka.class);		Prekazka prekazka = '''(Prekazka)''' this.getOneIntersectingObject(Prekazka.class);
Řádka 53:		Řádka 56:
	}		}

−	<div class="Varovani">Pozor, musíme si být stoprocentně jisti, že objekt, který je uložen v proměnné datového typu <code>Predek</code> je ve skutečnosti opravdu datového typu <code>Potomek</code>. Pokud by nebyl, běh programu by skončil výjimečný stavem a aplikace by havarovala.</div>	+	* GUI pomocí knihovny Swing — zjištění zdroje události

		+	public void actionPerformed(ActionEvent event) {
		+	Button zdroj = '''(Button)''' event.getSource();
		+	zdroj.getTitle();
		+	...
		+	}
		+
		+	<div class="Varovani">Pozor, musíme si být stoprocentně jisti, že objekt, který je uložen v proměnné datového typu <code>Predek</code> je ve skutečnosti opravdu datového typu <code>Potomek</code>. Pokud by nebyl, běh programu by skončil výjimečný stavem a aplikace by havarovala.</div>

	== Související stránky ==		== Související stránky ==
	* [[Objektově orientované programování]]		* [[Objektově orientované programování]]

Spravce: Přidáno přetypování a příklad.

2017-02-28T10:15:26Z

Přidáno přetypování a příklad.

← Starší verze		Verze z 28. 2. 2017, 10:15
Řádka 38:		Řádka 38:
	* Pokud potřebujeme v potomkovi přesto použít metodu předka, použijeme k tomu klíčové slovo <code>super</code>.		* Pokud potřebujeme v potomkovi přesto použít metodu předka, použijeme k tomu klíčové slovo <code>super</code>.
	* Klíčovým slovem <code>super</code> lze také zavolat konstruktor předka.		* Klíčovým slovem <code>super</code> lze také zavolat konstruktor předka.
		+
		+
		+	== Přetypování ==
		+	* Potomek může vždy zastoupit předka. Do proměnné datového typu předka tedy můžeme uložit instanci třídy potomka.
		+	* Jsou ale situace, kdy potřebujeme k takto uloženému potomkovi znovu přistupovat jako k potomkovi včetně všech jeho metod a atributů.
		+	* V tom případě musíme použít přetypování.
		+
		+	* Přetypování zapíšeme tak, že do závorky před výraz, který vrací takto uloženého potomka, zapíšeme název třídy předka:
		+
		+	Prekazka prekazka = '''(Prekazka)''' this.getOneIntersectingObject(Prekazka.class);
		+	if (prekazka != null) {
		+	int prekazka.getPruhlednost();
		+	...
		+	}
		+
		+	<div class="Varovani">Pozor, musíme si být stoprocentně jisti, že objekt, který je uložen v proměnné datového typu <code>Predek</code> je ve skutečnosti opravdu datového typu <code>Potomek</code>. Pokud by nebyl, běh programu by skončil výjimečný stavem a aplikace by havarovala.</div>


	== Související stránky ==		== Související stránky ==
	* [[Objektově orientované programování]]		* [[Objektově orientované programování]]

Spravce: Přidána kapitola ke klíčovému slovu super. Přehozeno rozhraní a abstraktní třída.

2017-02-28T10:07:04Z

Přidána kapitola ke klíčovému slovu super. Přehozeno rozhraní a abstraktní třída.

← Starší verze		Verze z 28. 2. 2017, 10:07
Řádka 23:		Řádka 23:
	}		}

−	~~== Abstraktní třída ==~~
−	* Klíčové slovo <code>abstract</code>.
−	* Těla některých metod nejsou uvedena.

	== Rozhraní ==		== Rozhraní ==
Řádka 31:		Řádka 28:
	* Může mít pouze hlavičky metod a veřejné konstantní atributy.		* Může mít pouze hlavičky metod a veřejné konstantní atributy.

−	== ~~Viz~~ také ==	+
		+	== Abstraktní třída ==
		+	* Klíčové slovo <code>abstract</code>.
		+	* Těla některých metod nejsou uvedena.
		+
		+
		+	== Odkaz na předka — <code>super</code> ==
		+	* Jsou situace, kdy potřebujeme změnit chování některé metody předka v potomkovi. Mluvíme o překrývání metod.
		+	* Pokud potřebujeme v potomkovi přesto použít metodu předka, použijeme k tomu klíčové slovo <code>super</code>.
		+	* Klíčovým slovem <code>super</code> lze také zavolat konstruktor předka.
		+
		+
		+	== Související stránky ==
	* [[Objektově orientované programování]]		* [[Objektově orientované programování]]

Spravce: /* Dědičnost */ Doplnění textu, přidán příklad.

2017-02-28T10:01:37Z

Dědičnost: Doplnění textu, přidán příklad.

← Starší verze		Verze z 28. 2. 2017, 10:01
Řádka 4:		Řádka 4:
	*Klíčové slovo <code>extends</code>.		*Klíčové slovo <code>extends</code>.
	*Třída může mít pouze jednu rodičovskou třídu!		*Třída může mít pouze jednu rodičovskou třídu!
		+	* Potomek „dědí“ všechny vlastnosti předka.
		+	* Potomek může kdykoli nahradit předka. Takže pokud máme proměnnou datového typu <code>Predek</code>, můžeme do ní uložit instanci třídy <code>Potomek</code>. Opačně to však nejde!
		+
		+	; Příklad
		+	public class Kamion {
		+	int nosnost;
		+	...
		+	public int getNosnost() { return this.nosnost; }
		+	...
		+	}
		+	public class KamionSPrivesem extends Kamion {
		+	Prives prives;
		+	...
		+	public int getNosnost() {
		+	return this.getHodnota()+this.prives.getHodnota();
		+	}
		+	...
		+	}

	== Abstraktní třída ==		== Abstraktní třída ==

Spravce: Doplněn odkaz na OOP

2014-02-17T10:51:43Z

Doplněn odkaz na OOP

← Starší verze		Verze z 17. 2. 2014, 10:51
Řádka 12:		Řádka 12:
	* Klíčové slovo <code>implements</code>.		* Klíčové slovo <code>implements</code>.
	* Může mít pouze hlavičky metod a veřejné konstantní atributy.		* Může mít pouze hlavičky metod a veřejné konstantní atributy.
		+
		+	== Viz také ==
		+	* [[Objektově orientované programování]]

Spravce: Vytvoření stránky

2014-02-17T10:50:47Z

Vytvoření stránky

Nová stránka

[[Category:VSE]][[Category:Informatika]][[Category:Programování]][[Category:Java]]

== Dědičnost ==
*Klíčové slovo <code>extends</code>.
*Třída může mít pouze jednu rodičovskou třídu!

== Abstraktní třída ==
* Klíčové slovo <code>abstract</code>.
* Těla některých metod nejsou uvedena.

== Rozhraní ==
* Klíčové slovo <code>implements</code>.
* Může mít pouze hlavičky metod a veřejné konstantní atributy.