Menu

Výukový program pro rozhraní Java a abstraktní třídu s příklady

  • Hlavní
  • Jiný
  • Výukový program pro rozhraní Java a abstraktní třídu s příklady

java interface abstract class tutorial with examples

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Toto video tutoriál vysvětluje, co je rozhraní Java, jak jej implementovat, a vícenásobné dědění pomocí rozhraní v Javě, na příkladech:

V jednom z našich dřívějších tutoriálů jsme podrobně diskutovali o abstrakci. Tam jsme diskutovali o abstraktních třídách a abstraktních metodách. Víme, že abstraktní třídy poskytují abstrakci, protože v abstraktní třídě můžeme mít i nějakou jinou než abstraktní metodu.

Funkce, která poskytuje 100% abstrakci v Javě, se nazývá „ Rozhraní “. V tomto tutoriálu budeme diskutovat rozhraní v Javě.

=> Prohlédněte si příručku Java Beginners Guide zde.

Rozhraní Java a abstraktní třídy

Co se naučíte:

Výukové videonávody o rozhraních a abstraktních třídách

Úvod do rozhraní a abstraktních tříd v Javě - část 1:

Přehled rozhraní a abstraktních tříd v Javě - část 2:

Abstrakce a dědičnost v Javě:

Co je to rozhraní v Javě

Rozhraní v Javě je definováno jako abstraktní typ, který určuje chování třídy. Rozhraní je druh protokolu, který stanoví pravidla týkající se toho, jak by se měla chovat konkrétní třída.

Rozhraní v Javě může obsahovat abstraktní metody a statické konstanty. Ve výchozím nastavení jsou všechny metody v rozhraní veřejné a abstraktní.

Níže je uveden jednoduchý příklad rozhraní v prostředí Java.

interface shape{ public static final String color = “Red”; public void calculateArea(); }

Výše uvedený příklad definuje „tvar“ rozhraní, které má statickou proměnnou a abstraktní metodu „CalcArea ()“.

Rozhraní je entita, která má jako své tělo pouze abstraktní metody. Může také obsahovat statické konečné proměnné.

Stejně jako třída může mít rozhraní také metody a proměnné, ale všimněte si, že metody jsou abstraktní (bez implementace) a proměnné jsou statické.

Níže jsou uvedeny některé vlastnosti, které je třeba mít na paměti v souvislosti s rozhraními:

  • Rozhraní jsou plány pro třídu. Říkají třídě, co mají dělat, pomocí svých metod.
  • Rozhraní určuje abstraktní metody a třídy implementující toto rozhraní by také měly tyto metody implementovat.
  • Pokud třída implementující rozhraní nedefinuje všechny metody rozhraní, stane se tato třída abstraktní třídou.

Obecná syntaxe deklarace rozhraní je uvedena níže.

interface { //constant or static fields declaration //abstract method declaration //default declarations }

Jak je uvedeno ve výše uvedené deklaraci, používáme klíčové slovo Java „interface“, které označuje, že nyní deklarujeme rozhraní.

jak inicializovat generické pole v java

Za klíčovým slovem „interface“ následuje název interface_name a poté úvodní složené závorky. Pak máme různé deklarace abstraktních metod, deklaraci statických polí atd. Nakonec zavřeme složené závorky.

Například,pokud chceme deklarovat rozhraní ‚TestInterface 'se dvěma metodami, tj. method_one a method_two, pak bude deklarace TestInterface vypadat takto:

interface TestInterface{ void method_one(); void method_two(); }

Použití rozhraní v Javě

  • Rozhraní v Javě poskytují 100% abstrakci, protože mohou mít pouze abstraktní metody.
  • Pomocí rozhraní můžeme dosáhnout více dědičností v Javě, což není možné pomocí tříd.
  • K dosažení uvolněné vazby lze použít rozhraní.

Jak implementovat rozhraní v Javě

Jakmile je rozhraní deklarováno, můžeme ho použít ve třídě pomocí klíčového slova „nářadí“ v deklaraci třídy.

Toto klíčové slovo „implementuje“ se zobrazí za názvem třídy, jak je uvedeno níže:

class implements { //class body }

Implementace rozhraní je stejná jako podepsání smlouvy. Třída implementující rozhraní tedy znamená, že podepsala smlouvu a souhlasila s implementací abstraktních metod rozhraní nebo jinými slovy prováděla chování určené rozhraním.

Pokud třída implementující rozhraní neimplementuje přesné chování uvedené v rozhraní, musí být třída deklarována jako abstraktní.

Příklad implementace rozhraní

Níže je uveden jednoduchý příklad rozhraní v Javě.

//interface declaration interface Polygon_Shape { void calculateArea(int length, int breadth); } //implement the interface class Rectangle implements Polygon_Shape { //implement the interface method public void calculateArea(int length, int breadth) { System.out.println('The area of the rectangle is ' + (length * breadth)); } } class Main { public static void main(String() args) { Rectangle rect = new Rectangle(); //declare a class object rect.calculateArea(10, 20); //call the method } }

Výstup:

Příklad výstupu obdélníku

Výše uvedený program ukazuje jednoduchý příklad rozhraní v Javě. Zde deklarujeme rozhraní s názvem Polygon_Shape a poté ho implementuje třída Rectangle.

Konvence pojmenování rozhraní v Javě

Konvence pojmenování Java jsou pokyny pro pojmenování, které musíme dodržovat jako programátoři, abychom mohli vytvářet čitelný konzistentní kód. Java používá pro pojmenování tříd a rozhraní notace „TitleCase“. Používá notace „CamelCase“ pro proměnné, metody atd.

Pokud jde o rozhraní, je název rozhraní v nadpisu a první písmeno každého slova názvu rozhraní je velké. Názvy rozhraní jsou vybírány tak, aby se obvykle jednalo o adjektiva. Ale když rozhraní představují rodinu tříd, jako je mapa nebo seznam, mohou být pojmenována podle podstatných jmen.

Níže jsou uvedeny některé příklady platných názvů rozhraní:

public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}

Konstruktor rozhraní

Další otázkou je, zda má rozhraní konstruktor?

Víme, že k vyvolání metod potřebujeme objekty. K vytváření objektů potřebujeme konstruktory. Ale v případě rozhraní v Javě nejsou metody implementovány.

Metody rozhraní jsou všechny abstraktní. Proto není použití těchto metod z rozhraní k ničemu. Zadruhé, protože rozhraní jsou ve výchozím nastavení abstraktní, nemůžeme vytvářet objekty rozhraní. Nepotřebujeme tedy konstruktory pro rozhraní.

Metody rozhraní

V této části probereme, jak deklarovat metody rozhraní. Podle pravidla mohou mít rozhraní pouze veřejné metody nebo ve výchozím nastavení jsou metody rozhraní veřejné. V rozhraní není povoleno použití žádného jiného modifikátoru přístupu.

Takže ať už to výslovně deklarujeme nebo ne, každá metoda v rozhraní je ve výchozím nastavení abstraktní s veřejnou viditelností.

Proto pokud je void printMethod () prototyp, který hodláme deklarovat v rozhraní, pak jsou následující deklarace stejné.

void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();

Všimněte si, že nemůžeme použít následující modifikátory uvnitř rozhraní pro metody rozhraní.

  • finále
  • statický
  • Soukromé
  • chráněný
  • synchronizované
  • rodák
  • strictfp

Nyní provedeme program Java, abychom demonstrovali viditelnost metody rozhraní.

//declare an interface interface TestInterface { void printMethod(); //default visibility is public. } //interface implementation class TestClass implements TestInterface { //if the access modifier is changed to any other, compiler generates error public void printMethod() { System.out.println('TestClass::printMethod()'); } } class Main { public static void main(String() args) { TestClass tc = new TestClass(); //create an object tc.printMethod(); //call concrete method } }

Výstup:

TestClass printMethod

Jak již bylo zmíněno, ve výchozím nastavení jsou metody rozhraní veřejné. Pokud tedy nezadáme pro metodu rozhraní žádný modifikátor přístupu, je veřejný jako ve výše uvedeném programu.

Předpokládejme, že deklaraci metody rozhraní ve výše uvedeném programu změníme takto:

private void printMethod ();

To znamená, že jsme zadali metodu rozhraní printMethod () jako soukromou. Když kompilujeme program, dostaneme následující chybu kompilátoru.

chyba: modifikátor soukromý zde není povolen

private void printMethod ();

Druhým případem, který můžeme otestovat, je změna modifikátoru implementované metody ve třídě TestClass z veřejného na soukromý. Nyní je výchozí modifikátor ve třídě soukromý. Prostě tedy odstraníme veřejné klíčové slovo z prototypu metody ve třídě následujícím způsobem:

void printMethod() { System.out.println('TestClass::printMethod()'); }

Nyní, když kompilujeme program, dostaneme následující chybu.

chyba: printMethod () v TestClass nemůže implementovat printMethod () v TestInterface
void printMethod ()
^
pokus o přiřazení slabších přístupových oprávnění; byl veřejný

Zde je tedy třeba poznamenat, že nemůžeme změnit modifikátor přístupu implementované metody rozhraní na žádný jiný modifikátor přístupu. Protože metody rozhraní jsou ve výchozím nastavení veřejné, pokud jsou implementovány třídami, které implementují rozhraní, měly by být tyto metody také veřejné.

Pole rozhraní v Javě

Pole nebo proměnné deklarované v rozhraní jsou ve výchozím nastavení veřejné, statické a konečné. To znamená, že jednou deklarovanou hodnotu nelze změnit.

Všimněte si, že pokud jsou pole rozhraní definována bez zadání kteréhokoli z těchto modifikátorů, kompilátoři jazyka Java tyto modifikátory předpokládají. Například, pokud neurčíme veřejný modifikátor při deklaraci pole v rozhraní, pak se předpokládá ve výchozím nastavení.

Když je rozhraní implementováno třídou, poskytuje implementaci pro všechny abstraktní metody rozhraní. Podobně všechna pole deklarovaná v rozhraní zdědí také třída, která implementuje rozhraní. V implementační třídě je tedy kopie pole rozhraní.

Všechna pole v rozhraní jsou nyní ve výchozím nastavení statická. Proto k nim můžeme přistupovat pomocí názvu rozhraní přímo, stejně jako přistupujeme ke statickým polím třídy pomocí názvu třídy a ne objektu.

Níže uvedený příklad Java programu ukazuje, jak můžeme přistupovat k polím rozhraní.

//interface declaration interface TestInterface{ public static int value = 100; //interface field public void display(); } //Interface implementation class TestClass implements TestInterface{ public static int value = 5000; //class fields public void display() { System.out.println('TestClass::display () method'); } public void show() { System.out.println('TestClass::show () method'); } } public class Main{ public static void main(String args()) { TestClass testObj = new TestClass(); //print interface and class field values. System.out.println('Value of the interface variable (value): '+TestInterface.value); System.out.println('Value of the class variable (value): '+testObj.value); } }

Výstup:

Příklad pole rozhraní

Jak je znázorněno v programu výše, do polí rozhraní lze přistupovat pomocí názvu rozhraní následovaného tečkovým operátorem (.) A poté skutečným názvem proměnné nebo pole.

Obecné rozhraní v Javě

V našich dřívějších výukových programech jsme diskutovali o generických prostředích Java. Kromě obecných tříd, metod atd. Můžeme mít také obecná rozhraní. Obecná rozhraní lze určit podobně způsobem, jakým určujeme obecné třídy.

Obecná rozhraní jsou deklarována s parametry typu, díky nimž jsou nezávislá na datovém typu.

Obecná syntaxe obecného rozhraní je následující:

nejlepší bezplatný nástroj pro opravu systému Windows 7
interface { //interface methods and variables }

Nyní, pokud chceme ve třídě použít výše uvedené obecné rozhraní, pak můžeme mít definice třídy, jak je uvedeno níže:

class implements interface_name { //class body }

Všimněte si, že musíme specifikovat stejný seznam parametrů s třídou jako s rozhraním.

Následující program Java demonstruje obecná rozhraní v Javě.

//generic interface declaration interface MinInterface>{ T minValue(); } //implementation for generic interface class MinClassImpl> implements MinInterface { T() intArray; MinClassImpl(T() o) { intArray = o; } public T minValue() { T v = intArray(0); for (int i = 1; i intMinValue = new MinClassImpl (intArray); MinClassImpl charMinValue = new MinClassImpl(charArray); //call interface method minValue for int type array System.out.println('Min value in intOfArray: ' + intMinValue.minValue()); //call interface method minValue for char type array System.out.println('Min value in charOfArray: ' + charMinValue.minValue()); }

Výstup:

Ukázkový výstup obecného rozhraní

Výše uvedený program implementuje rozhraní obsahující metodu k nalezení minimální hodnoty v poli. Toto je obecné rozhraní. Třída implementuje toto rozhraní a přepíše metodu. V hlavní metodě voláme metodu rozhraní, abychom našli minimální hodnotu v celočíselném a znakovém poli.

Více rozhraní v Javě

V našem tématu dědičnosti jsme viděli, že Java neumožňuje třídě dědit z více tříd, protože vede k nejednoznačnosti zvané „Diamond Problem“.

Třída však může zdědit nebo implementovat více než jedno rozhraní. V tomto případě se to nazývá vícenásobné dědictví. I když nám není povoleno implementovat více dědičností v Javě prostřednictvím tříd, můžeme to udělat pomocí rozhraní.

Následující diagram ukazuje více dědičnosti pomocí rozhraní. Zde třída implementuje dvě rozhraní, tj. Interface_one a Interface_two.

Více rozhraní v Javě

Všimněte si, že když třída implementuje více rozhraní, názvy rozhraní jsou v deklaraci třídy odděleny čárkami. Můžeme implementovat tolik rozhraní, dokud dokážeme zvládnout složitost.

Níže je uveden program Java, který demonstruje více rozhraní.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration interface Interface_Two{ void show(); } //multiple inheritance - DemoClass implementing Interface_One&Interface_Two class DemoClass implements Interface_One,Interface_Two{ public void print(){ //Override Interface_One print() System.out.println('Democlass::Interface_One_Print ()'); } public void show(){ //Override Interface_Two show() System.out.println('DemoClass::Interface_Two_Show ()'); } } public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Výstup:

příklad více rozhraní

najděte příkaz v unixu s příklady

Jak je uvedeno výše, implementujeme dvě rozhraní. Pak přepíšeme jejich příslušné metody a zavoláme je hlavní metodou.

Vícenásobná dědičnost v Javě poskytuje všechny výhody, které vícenásobná dědičnost poskytuje v C ++. Ale na rozdíl od vícenásobné dědičnosti pomocí tříd je vícenásobná dědičnost pomocí rozhraní bez jakékoli nejednoznačnosti.

Dědičnost rozhraní v Javě: Rozhraní rozšiřuje rozhraní

Když třída implementuje rozhraní, provádí se pomocí ‚ nářadí „Klíčové slovo. V Javě může rozhraní zdědit jiné rozhraní. To se provádí pomocí ‚ rozšiřuje „Klíčové slovo. Když rozhraní rozšiřuje další rozhraní, nazývá se „ Dědičnost rozhraní ”V Javě.

interface rozšiřuje interface

Níže je uveden program Java pro implementaci dědičnosti rozhraní.

//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration; inherits from Interface_One interface Interface_Two extends Interface_One{ void show(); } //multiple inheritance - DemoClass implementing Interface_Two class DemoClass implements Interface_Two{ public void print(){ //Override Interface_Two print() System.out.println('Democlass public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } }

Výstup:

ukázkový výstup ukázkové třídy

Upravili jsme stejný program, který jsme použili pro vícenásobnou dědičnost pomocí rozhraní, abychom předvedli dědičnost rozhraní. Zde rozšiřujeme Interface_one v Interface_two a poté pokračujeme v implementaci Interface_two ve třídě. Jak se rozhraní dědí, obě metody jsou k dispozici pro přepsání.

Často kladené otázky

Otázka 1) Jaké je použití rozhraní v Javě?

Odpovědět: Rozhraní v Javě je entita, která se používá k dosažení 100% abstrakce. Může obsahovat pouze abstraktní metody, které mohou být přepsány třídou implementující rozhraní.

Rozhraní svým způsobem funguje jako plán třídy, kde poskytuje třídě prototypy abstraktní metody a statické konstanty a poté musí třída tyto metody přepsat implementací rozhraní.

Otázka 2) Jaké jsou výhody rozhraní v Javě?

Odpovědět: Některé z výhod rozhraní jsou následující:

  1. Rozhraní funguje jako plán třídy.
  2. Rozhraní poskytuje 100% abstrakci v Javě, protože má všechny abstraktní metody.
  3. K dosažení vícenásobné dědičnosti v Javě lze použít rozhraní. Java neumožňuje dědit z více než jedné třídy, ale třída může implementovat více rozhraní.

# 3) Může mít rozhraní metody?

Odpovědět: Rozhraní mohou mít prototypy metod a statické a konečné konstanty. Ale počínaje prostředím Java 8 mohou rozhraní obsahovat statické a výchozí metody.

Otázka č. 4) Můžeme rozhraní prohlásit za konečné?

Odpovědět: Ne. Pokud deklarujeme rozhraní jako konečné, třída jej nebude moci implementovat. Bez implementace jakoukoli třídou nebude rozhraní sloužit žádnému účelu.

Více o rozhraních

Rozhraní jsou plány jako třída, ale bude mít pouze deklaraci metody. Nebude mít žádný způsob implementace. Všechny metody v rozhraní jsou ve výchozím nastavení veřejné. Rozhraní Java 1.8 může mít statické a výchozí metody.

Rozhraní se používají hlavně v API.

Například: Zvažte, že navrhujete motor vozidla.

Po dokončení hardwarové části chcete, aby některé softwarové funkce implementoval klient, který používá váš engine. V takovém případě tedy můžete definovat funkce svého motoru v rozhraní.

Interface Engine { void changeGear(int a); void speedUp(int a); }

Pravidla, která je třeba dodržovat pro rozhraní

  • Třída, která implementuje rozhraní, by měla implementovat všechny metody v rozhraní.
  • Rozhraní může obsahovat konečné proměnné.
public class Vehicle implements Engine { int speed; int gear; @Override public void speedUp(int a) { this.speed=a; System.out.println('speed'+speed); } @Override public void changeGear(int a) { this.gear=a; System.out.println('gear'+gear); } public static void main(String() args) { // TODO Auto-generated method stub Vehicle objv=new Vehicle(); objv.changeGear(3); objv.speedUp(70); } }

Pravidla, která je třeba dodržovat pro rozhraní

Tady je třída vozidla podtřídou, která implementuje rozhraní motoru.

Co jsou abstraktní třídy?

Abstraktní třída je jako třída, ale bude mít abstraktní metody a konkrétní metody. Abstraktní metody nemají implementaci. Bude mít pouze deklaraci metody.

Pravidla, která je třeba dodržovat pro abstraktní třídu

  • Nelze vytvořit instanci abstraktní třídy.
  • Podřízená třída, která rozšiřuje abstraktní třídu, by měla implementovat všechny abstraktní metody nadřazené třídy nebo Child třídy by měla být deklarována jako abstraktní třída.

Pokud chcete navrhnout částečnou implementaci, můžete přejít na abstraktní třídu.

Příklad abstraktního třídního programu:

EmployeeDetails.java

public abstract class EmployeeDetails { private String name; private int emp_ID; public void commonEmpDetaills() { System.out.println('Name'+name); System.out.println('emp_ID'+emp_ID); } public abstract void confidentialDetails(int s,String p); }

Podrobnosti o zaměstnanci

Třída, která rozšíří abstraktní třídu.

HR.java

public class HR extends EmployeeDetails { private int salary; private String performance; @Override public void confidentialDetails(int s,String p) { this.salary=s; this.performance=p; System.out.println('salary=='+salary); System.out.println('performance=='+performance); } public static void main(String() args) { HR hr =new HR(); hr.confidentialDetails(5000,'good'); } }

hr-java

Klíčové body, které je třeba poznamenat:

  • V rozhraních nebudou mít všechny metody implementaci metod.
  • Třída, která implementuje rozhraní, by měla implementovat všechny metody v daném rozhraní.
  • Abstraktní třídy mohou mít abstraktní metody i běžné konkrétní metody. Abstraktní metody nemají implementaci.
  • Třída, která rozšiřuje abstraktní třídu, by měla mít implementaci pro všechny abstraktní metody v abstraktní třídě.
  • Pokud podtřída nemá dostatek informací k implementaci abstraktních metod, měla by být podtřída deklarována jako abstraktní třída.

Závěr

V tomto tutoriálu jsme představili základní koncepty rozhraní v Javě. Diskutovali jsme o definici rozhraní spolu s potřebou rozhraní. Prozkoumali jsme jejich základní syntaxi a definici. Poté jsme diskutovali o tom, jak používat rozhraní, pro která používáme klíčové slovo ‘implementuje’.

Naučili jsme se, jak používat více rozhraní a dědičnost rozhraní v Javě. Pomocí více rozhraní můžeme v Javě implementovat více dědičností. Dědičnost rozhraní je, když jedno rozhraní rozšiřuje další rozhraní.

=> Navštivte zde a prohlédněte si sérii školení Java pro všechny

Doporučené čtení

^