java interface abstract class tutorial with examples
Acest tutorial video explică ce este interfața Java, cum să o implementați și moștenirea multiplă folosind interfețe în Java cu exemple:
Într-unul dintre tutorialele noastre anterioare, am discutat în detaliu despre abstractizare. Acolo am discutat clase abstracte și metode abstracte. Știm că clasele abstracte oferă abstracție, deoarece putem avea și o metodă non-abstractă în clasa abstractă.
Funcția care oferă abstracție 100% în Java se numește „ Interfață ”. În acest tutorial, vom discuta interfețe în Java.
=> Consultați aici Ghidul pentru începători Java.
Ce veți învăța:
- Tutoriale video despre interfețe și cursuri abstracte
- Ce este o interfață în Java
- Interfețe multiple în Java
- Concluzie
Tutoriale video despre interfețe și cursuri abstracte
Introducere în interfețe și cursuri abstracte în Java - Partea 1:
Prezentare generală a interfețelor și claselor abstracte în Java - Partea 2:
Abstracție și moștenire în Java:
Ce este o interfață în Java
O interfață în Java este definită ca un tip abstract care specifică comportamentul clasei. O interfață este un fel de protocol care stabilește reguli privind modul în care ar trebui să se comporte o anumită clasă.
O interfață în Java poate conține metode abstracte și constante statice. În mod implicit, toate metodele din interfață sunt publice și abstracte.
Un exemplu simplu de interfață în Java este dat mai jos.
interface shape{ public static final String color = “Red”; public void calculateArea(); }Exemplul de mai sus definește o „formă” a interfeței care are o variabilă statică și o metodă abstractă „calculateArea ()”.
O interfață este o entitate care are ca corp doar metode abstracte. Poate avea, de asemenea, variabile statice finale.
Deci, la fel ca clasa, o interfață poate avea și metode și variabile, dar rețineți că metodele sunt abstracte (fără implementare) și variabilele sunt statice.
Mai jos sunt enumerate câteva proprietăți care trebuie reținute în legătură cu interfețele:
- Interfețele sunt planuri pentru o clasă. Ei spun clasei ce să facă prin metodele lor.
- O interfață specifică metode abstracte și clase care implementează acea interfață ar trebui să implementeze și aceste metode.
- Dacă o clasă care implementează interfața nu definește toate metodele interfeței, atunci acea clasă devine o clasă abstractă.
Sintaxa generală a declarației interfeței este dată mai jos.
interface { //constant or static fields declaration //abstract method declaration //default declarations }După cum se arată în declarația de mai sus, folosim un cuvânt cheie Java „interfață” care indică faptul că declarăm o interfață acum.
întrebări de interviu j2ee pentru dezvoltatori seniori
Un cuvânt cheie „interfață” este urmat de numele_interfață și apoi de acoladele deschise. Apoi avem diverse declarații de metode abstracte, declarații de câmpuri statice etc. În cele din urmă, închidem acoladele.
De exemplu,dacă dorim să declarăm o interfață „TestInterface” cu două metode, adică method_one și method_two, atunci declarația TestInterface va fi după cum urmează:
interface TestInterface{ void method_one(); void method_two(); }Utilizări ale interfeței în Java
- Interfețele din Java oferă 100% abstracție, deoarece pot avea doar metode abstracte.
- Folosind interfețe, putem obține mai multe moșteniri în Java, ceea ce nu este posibil folosind clase.
- Pentru a realiza o cuplare slabă, poate fi utilizată o interfață.
Cum să implementați o interfață în Java
Odată ce interfața este declarată, o putem folosi într-o clasă folosind cuvântul cheie „unelte” în declarația de clasă.
Acest cuvânt cheie „implementează” apare după numele clasei, după cum se arată mai jos:
class implements { //class body }Implementarea unei interfețe este la fel ca semnarea unui contract. Prin urmare, o clasă care implementează o interfață înseamnă că a semnat un contract și a acceptat să implementeze metodele abstracte ale interfeței sau, cu alte cuvinte, să efectueze comportamentul specificat de interfață.
Dacă clasa care implementează interfața nu implementează comportamentul exact specificat în interfață, atunci clasa trebuie declarată ca abstractă.
Exemplu de implementare a interfeței
Dat mai jos este un exemplu simplu de interfață în Java.
//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 } }Ieșire:
Programul de mai sus demonstrează exemplul simplu de interfețe în Java. Aici declarăm o interfață numită Polygon_Shape și apoi o implementează clasa Rectangle.
Convenția de denumire a interfeței în Java
Convențiile de denumire Java sunt liniile directoare de numire pe care trebuie să le urmăm în calitate de programatori, astfel încât să putem produce un cod lizibil și coerent. Java folosește notații „TitleCase” pentru clasele de nume și interfețe. Folosește notații „CamelCase” pentru variabile, metode etc.
În ceea ce privește interfața, numele interfeței se află în titlecase cu prima literă din fiecare cuvânt al numelui interfeței cu majuscule. Numele interfeței sunt selectate astfel încât să fie de obicei adjective. Dar când interfețele reprezintă familia de clase precum harta sau lista, atunci ele pot fi numite după substantive.
Câteva exemple de nume de interfețe valide sunt date mai jos:
public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}Constructor de interfață
Următoarea întrebare este dacă o interfață are un constructor?
Știm că avem nevoie de obiecte pentru a invoca metode. Pentru a crea obiecte avem nevoie de constructori. Dar în cazul interfețelor în Java, metodele nu sunt implementate.
Metodele interfețelor sunt toate abstracte. Prin urmare, nu este util să apelați aceste metode din interfață. În al doilea rând, întrucât interfețele sunt în mod implicit abstracte, nu putem crea obiecte ale interfeței. Astfel, nu avem nevoie de constructori pentru interfață.
Metode de interfață
În această secțiune, vom discuta despre modul de declarare a metodelor de interfață. De regulă, o interfață poate avea numai metode publice sau implicit, metodele de interfață sunt publice. Niciun alt modificator de acces nu poate fi utilizat în interiorul interfeței.
Deci, indiferent dacă o declarăm în mod explicit sau nu, fiecare metodă din interfață este în mod implicit abstractă cu vizibilitate publică.
Prin urmare, dacă void printMethod () este prototipul pe care intenționăm să îl declarăm într-o interfață, atunci următoarele declarații sunt aceleași.
void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();Rețineți că nu putem utiliza următorii modificatori în interiorul interfeței pentru metodele de interfață.
- final
- static
- Privat
- protejat
- sincronizat
- nativ
- strictfp
Acum să implementăm un program Java pentru a demonstra vizibilitatea metodei interfeței.
//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 } } Ieșire:
După cum sa menționat deja, implicit, metodele de interfață sunt publice. Prin urmare, atunci când nu specificăm niciun modificator de acces pentru metoda interfeței, atunci acesta este public ca în programul de mai sus.
Să presupunem că schimbăm declarația metodei interfeței în programul de mai sus, după cum urmează:
private void printMethod ();
Apoi, aceasta înseamnă că am specificat metoda interfeței printMethod () ca fiind privată. Când compilăm programul, obținem următoarea eroare a compilatorului.
eroare: modificatorul privat nu este permis aici
private void printMethod ();
Al doilea caz pe care îl putem testa este schimbarea modificatorului metodei implementate în clasa TestClass de la public la privat. Acum modificatorul implicit din clasă este privat. Deci, eliminăm doar cuvântul cheie public din metoda prototip din clasă după cum urmează:
void printMethod() { System.out.println('TestClass::printMethod()'); }Acum, dacă compilăm programul, vom primi următoarea eroare.
eroare: printMethod () în TestClass nu poate implementa printMethod () în TestInterface
void printMethod ()
^
încercarea de a atribui privilegii de acces mai slabe; a fost public
Prin urmare, punctul de remarcat aici este că nu putem schimba modificatorul de acces al metodei implementate a interfeței cu niciun alt modificator de acces. Deoarece metodele de interfață sunt publice în mod implicit, atunci când sunt implementate de clase care implementează interfețe, aceste metode ar trebui să fie, de asemenea, publice.
Câmpuri de interfață în Java
Câmpurile sau variabilele declarate într-o interfață sunt implicit publice, statice și finale. Aceasta înseamnă că, odată declarată, valoarea lor nu poate fi modificată.
Rețineți că, dacă câmpurile de interfață sunt definite fără a specifica niciunul dintre acești modificatori, atunci compilatoarele Java își asumă acești modificatori. De exemplu, dacă nu specificăm un modificator public atunci când declarăm câmpul din interfață, atunci acesta este presupus în mod implicit.
Când o interfață este implementată de o clasă, atunci aceasta oferă o implementare pentru toate metodele abstracte ale interfeței. În mod similar, toate câmpurile declarate în interfață sunt moștenite și de clasa care implementează interfața. Astfel, o copie a câmpului de interfață este prezentă în clasa de implementare.
Acum toate câmpurile din interfață sunt statice în mod implicit. Prin urmare, le putem accesa folosind numele interfeței direct la fel cum accesăm câmpurile statice ale clasei folosind numele clasei și nu obiectul.
Exemplul de program Java de mai jos arată cum putem accesa câmpurile interfeței.
//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); } }Ieșire:
Așa cum se arată în programul de mai sus, câmpurile interfeței pot fi accesate folosind un nume de interfață urmat de operatorul punct (.) Și apoi de variabila reală sau numele câmpului.
Interfața generică în Java
Am discutat despre genericele Java în tutorialele noastre anterioare. În afară de a avea clase generice, metode etc., putem avea și interfețe generice. Interfețele generice pot fi specificate în mod similar în modul în care specificăm clasele generice.
Interfețele generice sunt declarate cu parametri de tip care le fac independente de un tip de date.
Sintaxa generală a interfeței generice este următoarea:
lista de linkuri în c ++
interface { //interface methods and variables }Acum, dacă vrem să folosim interfața generică de mai sus într-o clasă, atunci putem avea definiția clasei așa cum se arată mai jos:
class implements interface_name { //class body }Rețineți că trebuie să specificăm aceeași listă de parametri cu clasa ca și cu interfața.
Următorul program Java demonstrează interfețele generice în Java.
//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()); } Ieșire:
Programul de mai sus implementează o interfață care conține o metodă pentru a găsi valoarea minimă în matrice. Aceasta este o interfață generică. Clasa implementează această interfață și anulează metoda. În metoda principală, apelăm metoda interfeței pentru a găsi valoarea minimă într-un număr întreg și o matrice de caractere.
Interfețe multiple în Java
În subiectul nostru de moștenire, am văzut că Java nu permite unei clase să moștenească din mai multe clase, deoarece rezultă o ambiguitate numită „Problema diamantului”.
Cu toate acestea, o clasă poate moșteni sau implementa mai multe interfețe. În acest caz, este cunoscută sub numele de moștenire multiplă. Deci, deși nu avem voie să implementăm moștenirea multiplă în Java prin clase, putem face acest lucru folosind interfețe.
Următoarea diagramă prezintă moștenirea multiplă folosind interfețe. Aici o clasă implementează două interfețe, adică Interface_one și Interface_two.
Rețineți că atunci când o clasă implementează mai multe interfețe, numele interfeței sunt separate prin virgulă în declarația clasei. Putem implementa cât mai multe interfețe atât timp cât putem gestiona complexitatea.
Programul Java care demonstrează mai multe interfețe este prezentat mai jos.
//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(); } } Ieșire:
faza de implementare în ciclul de viață al dezvoltării software-ului
După cum se arată mai sus, implementăm două interfețe. Apoi le anulăm metodele respective și le numim în metoda principală.
Moștenirea multiplă în Java oferă toate avantajele pe care moștenirea multiplă le oferă în C ++. Dar, spre deosebire de moștenirea multiplă folosind clase, moștenirea multiplă folosind interfețe este fără nicio ambiguitate.
Moștenirea interfeței în Java: Interfața extinde interfața
Când o clasă implementează o interfață, aceasta se face folosind „ unelte 'Cuvânt cheie. În Java, o interfață poate moșteni o altă interfață. Acest lucru se face folosind se extinde 'Cuvânt cheie. Când o interfață extinde o altă interfață, se numește „ Moștenirea interfeței ”În Java.
Programul Java pentru implementarea moștenirii interfeței este prezentat mai jos.
//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(); } } Ieșire:
Am modificat același program pe care l-am folosit pentru moștenirea multiplă folosind interfețe pentru a demonstra moștenirea interfeței. Aici, extindem Interface_one în Interface_two și apoi continuăm să implementăm Interface_two într-o clasă. Deoarece interfețele sunt moștenite, ambele metode sunt disponibile pentru suprascriere.
întrebări frecvente
Q # 1) La ce folosește interfața în Java?
Răspuns: O interfață în Java este o entitate care este utilizată pentru a obține 100% abstractizare. Poate conține doar metode abstracte care pot fi suprascrise de clasa care implementează interfața.
Interfața într-un fel acționează ca un plan al clasei în care oferă clasei prototipurile metodei abstracte și constantele statice și apoi clasa trebuie să suprascrie acele metode prin implementarea interfeței.
Q # 2) Care sunt avantajele interfeței în Java?
Răspuns: Unele dintre avantajele interfeței sunt următoarele:
- Interfața acționează ca un plan al clasei.
- Interfața oferă 100% abstractizare în Java, deoarece are toate metodele abstracte.
- Interfețele pot fi utilizate pentru a obține moștenirea multiplă în Java. Java nu permite să moștenească de la mai multe clase, dar o clasă poate implementa mai multe interfețe.
# 3) Poate avea o interfață metode?
Răspuns: Interfețele pot avea prototipuri de metode și constante statice și finale. Dar pornind de la Java 8, interfețele pot conține metode statice și implicite.
Q # 4) Putem declara interfața ca fiind finală?
Răspuns: Nu. Dacă declarăm o interfață finală, atunci clasa nu o va putea implementa. Fără a fi implementată de nicio clasă, interfața nu va avea niciun scop.
Mai multe despre interfețe
Interfețele sunt planuri precum clasa, dar va avea doar declarația metodei. Nu va avea nicio metodă de implementare. Toate metodele din interfață sunt abstracte publice în mod implicit. Interfața Java 1.8 poate avea metode statice și implicite.
Interfețele sunt utilizate în principal în API-uri.
De exemplu: Luați în considerare că proiectați motorul unui vehicul.
Când ați terminat cu partea hardware, doriți ca unele dintre funcționalitățile software să fie implementate de un client care vă folosește motorul. Deci, în acest caz, puteți defini funcționalitățile motorului într-o interfață.
Interface Engine { void changeGear(int a); void speedUp(int a); } Reguli care trebuie respectate pentru interfață
- Clasa care implementează interfața ar trebui să implementeze toate metodele din interfață.
- O interfață poate conține variabile finale.
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); } } 
Aici clasa Vehicle este subclasa care implementează interfața motorului.
Ce sunt clasele abstracte?
O clasă abstractă este ca o clasă, dar va avea metode abstracte și metode concrete. Metodele abstracte nu au o implementare. Va avea doar declarația de metodă.
Reguli care trebuie respectate pentru clasa abstractă
- Clasa abstractă nu poate fi instanțiată.
- Clasa Child care extinde clasa abstractă trebuie să implementeze toate metodele abstracte ale clasei părinte sau clasa Child trebuie declarată ca o clasă abstractă.
Când doriți să proiectați implementarea parțială, puteți alege o clasă abstractă.
Exemplu de program de clasă abstractă:
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); } 
Clasa care va extinde clasa abstractă.
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'); } } 
Puncte cheie care trebuie remarcate:
- În interfețe, toate metodele nu vor avea implementarea metodei.
- Clasa care implementează interfața ar trebui să implementeze toate metodele din acea interfață.
- Clasele abstracte pot avea metode abstracte, precum și metode concrete normale. Metodele abstracte nu au o implementare.
- Clasa care extinde clasa abstractă ar trebui să aibă implementarea tuturor metodelor abstracte din clasa abstractă.
- Dacă subclasa nu are suficiente informații pentru a implementa metodele abstracte, atunci subclasa ar trebui declarată ca o clasă abstractă.
Concluzie
În acest tutorial, am prezentat conceptele de bază ale interfețelor în Java. Am discutat despre definiția interfeței, împreună cu nevoia de interfețe. Le-am explorat sintaxa și definiția de bază. Apoi am discutat despre modul de utilizare a interfețelor pentru care folosim cuvântul cheie „instrumente”.
Am învățat cum să folosim mai multe interfețe și moștenirea interfeței în Java. Folosind mai multe interfețe putem implementa mai multe moșteniri în Java. Moștenirea interfeței este atunci când o interfață extinde o altă interfață.
=> Vizitați aici pentru a vedea seria de antrenament Java pentru toți
Lectură recomandată
- OOP Java: Introducere în programarea orientată pe obiecte în Java
- Interfețe comparabile și comparatoare în Java
- Îmbunătățiri ale interfeței în Java 8 - Interfață funcțională Java
- Tutorial de interfață Java Map cu implementare și exemple
- Interfață ListIterator în Java cu exemple
- Interfață Marker în Java: Serializabilă și clonabilă
- Setați interfața în Java: Tutorial de setare Java cu exemple
- Tutorial de reflecție Java cu exemple