java interface abstract class tutorial with examples
Aquest vídeo tutorial explica què és la interfície Java, com implementar-la i l'herència múltiple mitjançant interfícies a Java amb exemples:
En un dels nostres tutorials anteriors, vam discutir amb detall l’abstracció. Allà vam discutir classes abstractes i mètodes abstractes. Sabem que les classes abstractes proporcionen abstracció, ja que també podem tenir algun mètode no abstracte a la classe abstracta.
La característica que proporciona un 100% d’abstracció a Java s’anomena “ Interfície ”. En aquest tutorial, en parlarem interfícies a Java.
=> Feu una ullada a la guia per a principiants de Java aquí
Què aprendreu:
- Videotutorials sobre interfícies i classes abstractes
- Què és una interfície a Java
- Múltiples interfícies a Java
- Conclusió
Videotutorials sobre interfícies i classes abstractes
Introducció a les interfícies i classes abstractes a Java - Part 1:
Visió general de les interfícies i les classes abstractes a Java - Part 2:
Abstracció i herència a Java:
Què és una interfície a Java
Una interfície a Java es defineix com un tipus abstracte que especifica el comportament de la classe. Una interfície és una mena de protocol que estableix regles sobre com s’ha de comportar una classe en particular.
Una interfície a Java pot contenir mètodes abstractes i constants estàtiques. Per defecte, tots els mètodes de la interfície són públics i abstractes.
A continuació es mostra un exemple senzill d’interfície a Java.
interface shape{ public static final String color = “Red”; public void calculateArea(); }
L'exemple anterior defineix una 'forma' de la interfície que té una variable estàtica i un mètode abstracte 'calculateArea ()'.
Una interfície és una entitat que només té com a cos mètodes abstractes. També pot contenir variables finals estàtiques.
Així, com la classe, una interfície també pot tenir mètodes i variables, però tingueu en compte que els mètodes són abstractes (sense implementació) i que les variables són estàtiques.
A continuació, es detallen algunes propietats que cal tenir en compte relacionades amb les interfícies:
- Les interfícies són plànols per a una classe. Expliquen a la classe què han de fer mitjançant els seus mètodes.
- Una interfície especifica mètodes abstractes i classes que implementen aquesta interfície també haurien d'implementar aquests mètodes.
- Si una classe que implementa la interfície no defineix tots els mètodes de la interfície, llavors aquesta classe es converteix en una classe abstracta.
A continuació es mostra la sintaxi general de la declaració de la interfície.
interface { //constant or static fields declaration //abstract method declaration //default declarations }
Com es mostra a la declaració anterior, fem servir una paraula clau Java 'interfície' que indica que declarem una interfície ara.
convertidor de youtube a mp3 que funciona
A una paraula clau 'interfície' li segueix el nom_interfície i, a continuació, les claus d'obertura. Després tenim diverses declaracions de mètodes abstractes, declaració de camps estàtics, etc. Finalment, tanquem les claus.
Per exemple,si volem declarar una interfície 'TestInterface' amb dos mètodes, és a dir, method_one i method_two, la declaració de TestInterface serà la següent:
interface TestInterface{ void method_one(); void method_two(); }
Usos de la interfície a Java
- Les interfícies a Java proporcionen un 100% d'abstracció, ja que només poden tenir mètodes abstractes.
- Mitjançant interfícies, podem aconseguir múltiples herències a Java, cosa que no és possible mitjançant classes.
- Per aconseguir un acoblament fluix, es pot utilitzar una interfície.
Com implementar una interfície a Java
Un cop declarada la interfície, la podem utilitzar en una classe mitjançant la paraula clau 'implementos' a la declaració de classe.
Aquesta paraula clau 'implementa' apareix després del nom de la classe, tal com es mostra a continuació:
class implements { //class body }
Implementar una interfície és el mateix que signar un contracte. Per tant, una classe que implementa una interfície significa que ha signat un contracte i ha acceptat implementar els mètodes abstractes de la interfície o, en altres paraules, realitzar el comportament especificat per la interfície.
Si la classe que implementa la interfície no implementa el comportament exacte especificat a la interfície, cal declarar la classe com a abstracta.
Exemple d'implementació d'interfície
A continuació es mostra un exemple simple d’una interfície a 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 } }
Sortida:
El programa anterior mostra un exemple senzill d'interfícies a Java. Aquí declarem una interfície anomenada Polygon_Shape i després la classe Rectangle la implementa.
Convenció de denominació d’interfícies a Java
Les convencions de denominació de Java són les directrius de denominació que hem de seguir com a programadors perquè puguem produir un codi coherent llegible. Java utilitza notacions 'TitleCase' per a les classes de noms i les interfícies. Utilitza notacions “CamelCase” per a variables, mètodes, etc.
Pel que fa a la interfície, el nom de la interfície apareix al títol amb la primera lletra de cada paraula del nom de la interfície en majúscules. Els noms de la interfície es seleccionen de manera que solen ser adjectius. Però quan les interfícies representen la família de classes com el mapa o la llista, es poden anomenar noms.
A continuació es donen alguns exemples de noms d'interfície vàlids:
public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}
Constructor d'interfície
La següent pregunta és si una interfície té un constructor?
Sabem que necessitem objectes per invocar mètodes. Per crear objectes necessitem constructors. Però en el cas d’interfícies a Java, els mètodes no s’implementen.
Els mètodes d'interfícies són abstractes. Per tant, no serveix de res cridar aquests mètodes des de la interfície. En segon lloc, com que les interfícies són abstractes per defecte, no podem crear objectes de la interfície. Per tant, no necessitem constructors per a la interfície.
Mètodes d'interfície
En aquesta secció, analitzarem com declarar els mètodes de la interfície. Per regla general, una interfície només pot tenir mètodes públics o, per defecte, els mètodes d'interfície són públics. No es permet utilitzar cap altre modificador d'accés a la interfície.
Per tant, tant si ho declarem explícitament com si no, tots els mètodes de la interfície són abstractes per defecte amb visibilitat pública.
Per tant, si void printMethod () és el prototip que pretenem declarar en una interfície, les declaracions següents són les mateixes.
void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();
Tingueu en compte que no podem utilitzar els següents modificadors a la interfície per als mètodes de la interfície.
- final
- estàtic
- Privat
- protegit
- sincronitzada
- nadiu
- strictfp
Ara implementem un programa Java per demostrar la visibilitat del mètode de la interfície.
//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 } }
Sortida:
Com ja s’ha esmentat, per defecte, els mètodes d’interfície són públics. Per tant, quan no especifiquem cap modificador d’accés per al mètode d’interfície, serà públic com al programa anterior.
Suposem que canviem la declaració del mètode de la interfície al programa anterior de la manera següent:
private void printMethod ();
Llavors això significa que hem especificat el mètode d'interfície printMethod () com a privat. Quan compilem el programa, obtenim el següent error del compilador.
error: modificador privat no permès aquí
private void printMethod ();
El segon cas que podem provar és canviant el modificador del mètode implementat a la classe TestClass de públic a privat. Ara, el modificador per defecte de la classe és privat. Per tant, només eliminem la paraula clau pública del mètode prototip de la classe de la manera següent:
void printMethod() { System.out.println('TestClass::printMethod()'); }
Ara, si compilem el programa, obtindrem el següent error.
error: printMethod () a TestClass no pot implementar printMethod () a TestInterface
void printMethod ()
^
intentar assignar privilegis d'accés més febles; era públic
Per tant, el punt que cal assenyalar aquí és que no podem canviar el modificador d'accés del mètode implementat de la interfície per cap altre modificador d'accés. Com que els mètodes d'interfície són públics per defecte, quan són implementats per classes que implementen interfícies, aquests mètodes també haurien de ser públics.
Camps d'interfície a Java
Els camps o variables declarats en una interfície són públics, estàtics i finals per defecte. Això significa que un cop declarat el seu valor no es pot canviar.
Tingueu en compte que si els camps de la interfície es defineixen sense especificar cap d'aquests modificadors, els compiladors Java assumeixen aquests modificadors. Per exemple, si no especifiquem un modificador públic en declarar el camp a la interfície, s'assumeix per defecte.
Quan una classe implementa una interfície, proporciona una implementació per a tots els mètodes abstractes de la interfície. De la mateixa manera, tots els camps declarats a la interfície també són heretats per la classe que implementa la interfície. Per tant, hi ha una còpia del camp de la interfície a la classe d'implementació.
Ara tots els camps de la interfície són estàtics per defecte. Per tant, podem accedir-hi utilitzant el nom de la interfície directament igual que accedim als camps estàtics de la classe mitjançant el nom de la classe i no l'objecte.
L'exemple del programa Java següent mostra com podem accedir als camps de la interfície.
//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); } }
Sortida:
Com es mostra al programa anterior, es pot accedir als camps de la interfície mitjançant un nom d’interfície seguit de l’operador de punts (.) I, a continuació, la variable o el nom del camp real.
La interfície genèrica a Java
Hem comentat els genèrics de Java en els nostres tutorials anteriors. A part de tenir classes genèriques, mètodes, etc., també podem tenir interfícies genèriques. Les interfícies genèriques es poden especificar de la mateixa manera que especifiquem les classes genèriques.
Les interfícies genèriques es declaren amb paràmetres de tipus que les fan independents d'un tipus de dades.
La sintaxi general de la interfície genèrica és la següent:
sistemes de punt de venda per a ipad
interface { //interface methods and variables }
Ara bé, si volem utilitzar la interfície genèrica anterior en una classe, podem tenir la definició de classe que es mostra a continuació:
class implements interface_name { //class body }
Tingueu en compte que hem d’especificar la mateixa llista de paràmetres amb la classe que amb la interfície.
El següent programa Java mostra les interfícies genèriques a 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()); }
Sortida:
El programa anterior implementa una interfície que conté un mètode per trobar el valor mínim a la matriu. Es tracta d’una interfície genèrica. La classe implementa aquesta interfície i anul·la el mètode. Al mètode principal, anomenem el mètode de la interfície per trobar el valor mínim en un nombre enter i una matriu de caràcters.
Múltiples interfícies a Java
Al nostre tema sobre l'herència, hem vist que Java no permet que una classe hereti de diverses classes, ja que resulta en una ambigüitat anomenada 'Problema del diamant'.
No obstant això, una classe pot heretar o implementar més d'una interfície. En aquest cas, es coneix com a herència múltiple. Per tant, tot i que no se’ns permet implementar múltiples herències a Java mitjançant classes, ho podem fer mitjançant interfícies.
El diagrama següent mostra diverses herències mitjançant interfícies. Aquí una classe implementa dues interfícies, és a dir, Interface_one i Interface_two.
Tingueu en compte que quan una classe implementa diverses interfícies, els noms de la interfície se separen per comes a la declaració de classe. Podem implementar tantes interfícies sempre que puguem gestionar la complexitat.
A continuació es mostra el programa Java que mostra diverses interfícies.
//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(); } }
Sortida:
per a què serveixen els fitxers apk
Com es mostra anteriorment, implementem dues interfícies. A continuació, substituïm els seus mètodes respectius i els anomenem al mètode principal.
L'herència múltiple a Java proporciona tots els avantatges que proporciona l'herència múltiple a C ++. Però, a diferència de l'herència múltiple que utilitza classes, l'herència múltiple que utilitza interfícies no té cap ambigüitat.
Herència de la interfície a Java: la interfície amplia la interfície
Quan una classe implementa una interfície, es fa amb eines 'Paraula clau. A Java, una interfície pot heretar una altra interfície. Això es fa mitjançant s’estén 'Paraula clau. Quan una interfície amplia una altra interfície es diu ' Herència de la interfície ”A Java.
A continuació es mostra el programa Java per implementar l’herència de la interfície.
//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(); } }
Sortida:
Hem modificat el mateix programa que hem utilitzat per a l'herència múltiple mitjançant interfícies per demostrar l'herència de la interfície. Aquí, ampliem Interface_one a Interface_two i després fem la implementació de Interface_two en una classe. A mesura que les interfícies s’hereten, els dos mètodes estan disponibles per substituir.
Preguntes freqüents
P # 1) Què utilitza la interfície a Java?
Resposta: Una interfície a Java és una entitat que s'utilitza per aconseguir un 100% d'abstracció. Només pot contenir mètodes abstractes que la classe que implementa la interfície pot anul·lar.
La interfície actua en certa manera com un pla de la classe en què proporciona a la classe prototips de mètode abstracte i constants estàtiques i, a continuació, la classe ha de substituir aquests mètodes implementant la interfície.
Q # 2) Quins avantatges té la interfície a Java?
Resposta: Alguns dels avantatges d'Interface són els següents:
- La interfície actua com un pla de la classe.
- La interfície proporciona un 100% d'abstracció a Java, ja que té tots els mètodes abstractes.
- Les interfícies es poden utilitzar per aconseguir una herència múltiple a Java. Java no permet heretar de més d'una classe, però una classe pot implementar diverses interfícies.
# 3) Una interfície pot tenir mètodes?
Resposta: Les interfícies poden tenir prototips de mètodes i constants finals i estàtiques. Però a partir de Java 8, les interfícies poden contenir mètodes estàtics i predeterminats.
Q # 4) Podem declarar la interfície com a final?
Resposta: No. Si declarem una interfície com a final, la classe no la podrà implementar. Sense ser implementada per cap classe, la interfície no servirà per a cap propòsit.
Més informació sobre les interfícies
Les interfícies són plans com la classe, però només tindrà la declaració del mètode. No tindrà cap mètode d'implementació. Tots els mètodes de la interfície són abstractes públics per defecte. La interfície Java 1.8 pot tenir mètodes estàtics i predeterminats.
Les interfícies s’utilitzen principalment a les API.
Per exemple: Penseu que esteu dissenyant el motor d’un vehicle.
Quan hàgiu acabat la part de maquinari, voleu que algunes de les funcionalitats del programari siguin implementades per un client que utilitza el vostre motor. Per tant, en aquest cas, podeu definir les funcionalitats del motor en una interfície.
Interface Engine { void changeGear(int a); void speedUp(int a); }
Regles a seguir per a la interfície
- La classe que implementa la interfície hauria d'implementar tots els mètodes de la interfície.
- Una interfície pot contenir variables finals.
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); } }
Aquí la classe Vehicle és la subclasse que implementa la interfície del motor.
Què són les classes abstractes?
Una classe abstracta és com una classe, però tindrà mètodes abstractes i mètodes concrets. Els mètodes abstractes no tenen cap implementació. Només tindrà la declaració del mètode.
Normes a seguir per a la classe abstracta
- La classe abstracta no es pot instanciar.
- La classe infantil que amplia la classe abstracta hauria d’implementar tots els mètodes abstractes de la classe pare o la classe Child s’hauria de declarar com a classe abstracta.
Quan vulgueu dissenyar una implementació parcial, podeu optar a una classe abstracta.
Exemple de programa de classe resum:
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); }
La classe que ampliarà la classe abstracta.
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'); } }
Punts clau que cal tenir en compte:
- A Interfaces, tots els mètodes no tindran implementació de mètodes.
- La classe que implementa la interfície hauria d'implementar tots els mètodes d'aquesta interfície en particular.
- Les classes abstractes poden tenir mètodes abstractes, així com mètodes concrets normals. Els mètodes abstractes no tenen cap implementació.
- La classe que estén la classe abstracta hauria de tenir la implementació de tots els mètodes abstractes de la classe abstracta.
- Si la subclasse no té prou informació per implementar els mètodes abstractes, s’hauria de declarar la subclasse com a classe abstracta.
Conclusió
En aquest tutorial, hem presentat els conceptes bàsics de les interfícies a Java. Hem discutit la definició de la interfície, juntament amb la necessitat d'interfícies. Hem explorat la seva sintaxi i definició bàsiques. A continuació, vam discutir com utilitzar interfícies per a les quals utilitzem la paraula clau 'implementos'.
Hem après a utilitzar diverses interfícies i l'herència de la interfície a Java. Mitjançant diverses interfícies podem implementar diverses herències a Java. L'herència de la interfície és quan una interfície estén una altra interfície.
=> Visiteu aquí per veure la sèrie d'entrenaments de Java per a tothom
Lectura recomanada
- OOP Java: Introducció a la programació orientada a objectes a Java
- Interfícies comparables i comparadores a Java
- Millores de la interfície a Java 8: interfície funcional de Java
- Tutorial de la interfície de mapa de Java amb implementació i exemples
- Interfície ListIterator a Java amb exemples
- Interfície de marcador a Java: serialitzable i clonable
- Configuració de la interfície a Java: Tutorial de configuració de Java amb exemples
- Tutorial de reflexió de Java amb exemples