java interface abstract class tutorial with examples
Denne videovejledning forklarer, hvad der er Java-interface, hvordan man implementerer det, og flere arv ved hjælp af grænseflader i Java med eksempler:
I en af vores tidligere tutorials diskuterede vi abstraktion i detaljer. Der diskuterede vi abstrakte klasser og abstrakte metoder. Vi ved, at abstrakte klasser giver abstraktion, da vi også kan have en ikke-abstrakt metode i den abstrakte klasse.
Funktionen, der giver 100% abstraktion i Java kaldes “ Interface ”. I denne vejledning vil vi diskutere grænseflader i Java.
=> Se på Java Beginners Guide her.
Hvad du lærer:
- Videoundervisning om grænseflader og abstrakte klasser
- Hvad er et interface i Java
- Flere grænseflader i Java
- Konklusion
Videoundervisning om grænseflader og abstrakte klasser
Introduktion til grænseflader og abstrakte klasser i Java - Del 1:
Oversigt over grænseflader og abstrakte klasser i Java - Del 2:
Abstraktion og arv i Java:
Hvad er et interface i Java
En grænseflade i Java defineres som en abstrakt type, der specificerer klasseadfærd. En grænseflade er en slags protokol, der opstiller regler for, hvordan en bestemt klasse skal opføre sig.
En grænseflade i Java kan indeholde abstrakte metoder og statiske konstanter. Som standard er alle metoderne i grænsefladen offentlige og abstrakte.
Et simpelt eksempel på en grænseflade i Java er angivet nedenfor.
interface shape{ public static final String color = “Red”; public void calculateArea(); }Ovenstående eksempel definerer en interface 'form', som har en statisk variabel og en abstrakt metode 'beregne område ()'.
En grænseflade er en enhed, der kun har abstrakte metoder som sin krop. Det kan også have statiske endelige variabler.
Så ligesom klasse kan en grænseflade også have metoder og variabler, men bemærk at metoderne er abstrakte (uden implementering), og variabler er statiske.
Nedenfor er nogle egenskaber, der skal huskes i forbindelse med grænseflader:
- Grænseflader er tegninger for en klasse. De fortæller klassen, hvad de skal gøre ved hjælp af deres metoder.
- En grænseflade specificerer abstrakte metoder, og klasser, der implementerer grænsefladen, skal også implementere disse metoder.
- Hvis en klasse, der implementerer grænsefladen, ikke definerer alle metoderne til grænsefladen, bliver denne klasse en abstrakt klasse.
Den generelle syntaks for interface-erklæringen er angivet nedenfor.
interface { //constant or static fields declaration //abstract method declaration //default declarations }Som vist i ovenstående erklæring bruger vi et Java-nøgleord 'interface', der indikerer, at vi erklærer en interface nu.
Spørgsmål og svar til test af mobilapplikationer
Et 'nøgleord' interface 'efterfølges af interface_name og derefter de åbne krøllede seler. Så har vi forskellige erklæringer om abstrakte metoder, statiske felter, osv. Endelig lukker vi de krøllede seler.
For eksempel,hvis vi vil erklære en grænseflade 'TestInterface' med to metoder i den, dvs. method_one og method_two, vil erklæringen om TestInterface være som nedenfor:
interface TestInterface{ void method_one(); void method_two(); }Anvendelse af grænsefladen i Java
- Grænseflader i Java giver 100% abstraktion, da de kun kan have abstrakte metoder.
- Ved hjælp af grænseflader kan vi opnå flere arv i Java, hvilket ikke er muligt ved hjælp af klasser.
- For at opnå løs kobling kan der bruges et interface.
Sådan implementeres et interface i Java
Når grænsefladen er erklæret, kan vi bruge den i en klasse ved hjælp af nøgleordet 'implementerer' i klassedeklarationen.
Dette 'implementerer' nøgleord vises efter holdnavnet som vist nedenfor:
class implements { //class body }Implementering af en grænseflade er det samme som at underskrive en kontrakt. Derfor betyder en klasse, der implementerer en grænseflade, at den har underskrevet en kontrakt og er aftalt at implementere de abstrakte metoder i grænsefladen eller med andre ord udføre den adfærd, der er specificeret af grænsefladen.
Hvis klassen, der implementerer grænsefladen, ikke implementerer den nøjagtige adfærd, der er angivet i grænsefladen, skal klassen erklæres som abstrakt.
Eksempel på implementering af interface
Nedenfor er et simpelt eksempel på en grænseflade i 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 } }Produktion:
Ovenstående program demonstrerer det enkle eksempel på grænseflader i Java. Her erklærer vi en grænseflade ved navn Polygon_Shape, og derefter implementerer klassen Rektangel den.
Interface navngivningskonvention i Java
Java-navngivningskonventioner er de navngivningsretningslinjer, som vi skal følge som programmører, så vi kan producere læsbar, ensartet kode. Java bruger 'TitleCase' notationer til navngivningsklasser og grænseflader. Det bruger 'CamelCase' notationer til variabler, metoder osv.
For så vidt angår grænseflade, er grænsefladenavnet i titelfasen med det første bogstav i hvert ord i grænsefladenavnet med store bogstaver. Grænsefladenavne vælges således, at de normalt er adjektiver. Men når grænseflader repræsenterer familien af klasser som kort eller liste, kan de navngives efter substantiver.
Nogle eksempler på gyldige grænsefladenavne er angivet nedenfor:
public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}Interface konstruktør
Det næste spørgsmål er, om en grænseflade har en konstruktør?
Vi ved, at vi har brug for objekter til at påkalde metoder. For at skabe objekter har vi brug for konstruktører. Men i tilfælde af grænseflader i Java implementeres metoderne ikke.
Metoderne til grænseflader er alle abstrakte. Derfor er der ingen brug i at kalde disse metoder fra grænsefladen. For det andet, da grænseflader som standard er abstrakte, kan vi ikke oprette objekter af grænsefladen. Således har vi ikke brug for konstruktører til interface.
Interface Metoder
I dette afsnit vil vi diskutere, hvordan man deklarerer grænseflademetoder. Som regel kan en grænseflade kun have offentlige metoder, eller som standard er grænseflademetoder offentlige. Ingen anden adgangsmodifikator må bruges i interfacet.
Så uanset om vi udtrykkeligt erklærer det eller ej, er hver metode i grænsefladen som standard abstrakt med offentlig synlighed.
Derfor, hvis ugyldig printMethod () er den prototype, som vi agter at erklære i en grænseflade, så er de følgende erklæringer de samme.
void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();Bemærk, at vi ikke kan bruge følgende modifikatorer inde i grænsefladen til interface-metoderne.
- endelig
- statisk
- Privat
- beskyttet
- synkroniseret
- hjemmehørende
- strengfp
Lad os nu implementere et Java-program for at demonstrere synligheden af grænseflademetoden.
//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 } } Produktion:
Som allerede nævnt er interface-metoderne som standard offentlige. Derfor, når vi ikke angiver nogen adgangsmodifikator til interface-metoden, så er den offentlig som i ovenstående program.
Antag, at vi ændrer interface-metadeklarationen i ovenstående program som følger:
privat ugyldigt printMethod ();
Derefter betyder det, at vi har angivet grænseflademetoden printMethod () som privat. Når vi kompilerer programmet, får vi følgende kompilatorfejl.
fejl: modifikator privat ikke tilladt her
privat ugyldigt printMethod ();
Det andet tilfælde, vi kan teste, er ved at ændre modifikatoren for den implementerede metode i klassen TestClass fra offentlig til privat. Nu er standardmodifikatoren i klassen privat. Så vi fjerner bare det offentlige nøgleord fra metodeprototypen i klassen som følger:
void printMethod() { System.out.println('TestClass::printMethod()'); }Hvis vi nu kompilerer programmet, får vi følgende fejl.
error: printMethod () i TestClass kan ikke implementere printMethod () i TestInterface
ugyldig printMethod ()
^
forsøg på at tildele svagere adgangsrettigheder; var offentlig
Derfor er det punkt, der skal bemærkes her, at vi ikke kan ændre adgangsmodifikatoren for den implementerede metode til grænsefladen til nogen anden adgangsmodifikator. Da grænseflademetoderne som standard er offentlige, skal disse metoder også være offentlige, når de implementeres af klasser, der implementerer grænseflader.
Interface felter i Java
Felterne eller variablerne, der er angivet i en grænseflade, er som standard offentlige, statiske og endelige. Dette betyder, at deres værdi ikke kan ændres, når den er erklæret.
Bemærk, at hvis grænsefladesfelterne er defineret uden at angive nogen af disse modifikatorer, antager Java-compilere disse modifikatorer. For eksempel, hvis vi ikke angiver en offentlig modifikator, når vi erklærer feltet i grænsefladen, antages det som standard.
Når en grænseflade implementeres af en klasse, giver den en implementering af alle de abstrakte metoder i grænsefladen. Tilsvarende arves alle felter, der er erklæret i grænsefladen, også af den klasse, der implementerer grænsefladen. Således er en kopi af grænsefladefeltet til stede i implementeringsklassen.
Nu er alle felterne i grænsefladen som standard statiske. Derfor kan vi få adgang til dem ved at bruge grænsefladesnavnet direkte som det samme som vi får adgang til statiske felter i klassen ved hjælp af klassens navn og ikke objektet.
Eksemplet Java-program nedenfor viser, hvordan vi kan få adgang til grænsefladesfelterne.
//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); } }Produktion:
Som vist i ovenstående program kan du få adgang til grænsefladefelterne ved hjælp af et interface-navn efterfulgt af prikoperator (.) Og derefter den aktuelle variabel eller feltnavnet.
Det generiske interface i Java
Vi har diskuteret Java generics i vores tidligere tutorials. Bortset fra at have generiske klasser, metoder osv., Kan vi også have generiske grænseflader. Generiske grænseflader kan specificeres på samme måde som den måde, vi specificerer generiske klasser på.
Generiske grænseflader erklæres med typeparametre, der gør dem uafhængige af en datatype.
Den generelle syntaks for det generiske interface er som følger:
falsk e-mail og adgangskode, der fungerer
interface { //interface methods and variables }Nu hvis vi vil bruge ovennævnte generiske interface i en klasse, så kan vi have klassedefinitionen som vist nedenfor:
class implements interface_name { //class body }Bemærk, at vi skal angive den samme param-liste med klassen som med grænsefladen.
Følgende Java-program demonstrerer de generiske grænseflader i 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()); } Produktion:
Ovenstående program implementerer en grænseflade, der indeholder en metode til at finde minimumsværdien i arrayet. Dette er en generisk grænseflade. Klassen implementerer denne grænseflade og tilsidesætter metoden. I hovedmetoden kalder vi interface-metoden for at finde minimumsværdien i et heltal og et tegnarray.
Flere grænseflader i Java
I vores arvemne har vi set, at Java ikke tillader, at en klasse arver fra flere klasser, da det resulterer i en tvetydighed kaldet 'Diamond Problem'.
En klasse kan dog arve eller implementere mere end en grænseflade. I dette tilfælde er det kendt som flere arv. Så selvom vi ikke har lov til at implementere flere arv i Java gennem klasser, kan vi gøre det ved hjælp af grænseflader.
Følgende diagram viser flere arv ved hjælp af grænseflader. Her implementerer en klasse to grænseflader, dvs. Interface_one og Interface_two.
Bemærk, at når en klasse implementerer de mange grænseflader, er grænsefladesnavne kommasepareret i klassedeklarationen. Vi kan implementere så mange grænseflader, så længe vi kan håndtere kompleksiteten.
Java-programmet, der demonstrerer flere grænseflader, vises nedenfor.
//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(); } } Produktion:
webservices c # interviewspørgsmål
Som vist ovenfor implementerer vi to grænseflader. Derefter tilsidesætter vi deres respektive metoder og kalder dem i hovedmetoden.
Flere arv i Java giver alle de fordele, som flere arv giver i C ++. Men i modsætning til flere arv ved hjælp af klasser er flere arv ved hjælp af grænseflader uden tvetydighed.
Interface arv i Java: Interface udvider interface
Når en klasse implementerer en grænseflade, gøres det ved hjælp af ' redskaber 'Nøgleord. I Java kan en grænseflade arve en anden grænseflade. Dette gøres ved hjælp af ' strækker sig 'Nøgleord. Når en grænseflade udvider en anden grænseflade kaldes den “ Interface arv ”I Java.
Java-programmet til implementering af interface-arv er vist nedenfor.
//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(); } } Produktion:
Vi har ændret det samme program, som vi brugte til flere arv ved hjælp af grænseflader for at demonstrere grænsefladesarven. Her udvider vi Interface_one i Interface_two og derefter implementerer Interface_two i en klasse. Da grænseflader arves, er begge metoder tilgængelige for tilsidesættelse.
Ofte stillede spørgsmål
Q # 1) Hvad er brugen af grænsefladen i Java?
Svar: En grænseflade i Java er en enhed, der bruges til at opnå 100% abstraktion. Det kan kun indeholde abstrakte metoder, der kan tilsidesættes af klassen, der implementerer grænsefladen.
Grænsefladen fungerer på en måde som en tegning af klassen, hvor den giver klassen de abstrakte metode prototyper og statiske konstanter, og derefter skal klassen tilsidesætte disse metoder ved at implementere grænsefladen.
Q # 2) Hvad er fordelene ved grænsefladen i Java?
Svar: Nogle af fordelene ved Interface er som følger:
- Interfacet fungerer som en plan for klassen.
- Interfacet giver 100% abstraktion i Java, da det har alle de abstrakte metoder.
- Grænseflader kan bruges til at opnå flere arv i Java. Java tillader ikke at arve fra mere end en klasse, men en klasse kan implementere flere grænseflader.
# 3) Kan en grænseflade have metoder?
Svar: Grænseflader kan have prototyper af metoder og statiske og endelige konstanter. Men startende fra Java 8 kan grænseflader indeholde statiske metoder og standardmetoder.
Spørgsmål nr. 4) Kan vi erklære grænsefladen som endelig?
Svar: Nej. Hvis vi erklærer en grænseflade som endelig, kan klassen ikke implementere den. Uden at blive implementeret af nogen klasse, vil grænsefladen ikke tjene noget formål.
Mere om grænseflader
Grænseflader er tegninger som klasse, men det vil kun have metodedeklarationen. Det har ingen metode til implementering. Alle metoder i grænsefladen er som standard offentlig abstrakt. Java 1.8 interface kan have statiske metoder og standardmetoder.
Grænseflader bruges hovedsageligt i API'er.
For eksempel: Overvej at du designer et køretøjs motor.
Når du er færdig med hardwaredelen, ønsker du, at nogle af softwarefunktionaliteterne implementeres af en klient, der bruger din motor. Så i så fald kan du definere dine motorfunktioner i en grænseflade.
Interface Engine { void changeGear(int a); void speedUp(int a); } Regler, der skal følges for interface
- Den klasse, der implementerer grænsefladen, skal implementere alle metoderne i grænsefladen.
- En grænseflade kan indeholde endelige variabler.
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); } } 
Her er køretøjsklassen den underklasse, der implementerer motorgrænsefladen.
Hvad er abstrakte klasser?
En abstrakt klasse er som en klasse, men den vil have abstrakte metoder og konkrete metoder. Abstrakte metoder har ikke en implementering. Det vil kun have metodedeklarationen.
Regler, der skal følges for abstrakt klasse
- Den abstrakte klasse kan ikke instantieres.
- Børneklasse, der udvider den abstrakte klasse, skal implementere alle de abstrakte metoder i moderklassen, eller Børnenes klasse skal erklæres som en abstrakt klasse.
Når du vil designe delvis implementering, kan du gå til en abstrakt klasse.
Eksempel på abstrakt klasseprogram:
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); } 
Klassen, der vil udvide den abstrakte klasse.
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'); } } 
Nøglepunkter, der skal bemærkes:
- I grænseflader har alle metoderne ikke metodeimplementering.
- Den klasse, der implementerer grænsefladen, skal implementere alle metoderne i den pågældende grænseflade.
- Abstrakte klasser kan have både abstrakte metoder og normale konkrete metoder. Abstrakte metoder har ikke en implementering.
- Den klasse, der udvider den abstrakte klasse, skal have implementeringen af alle de abstrakte metoder i den abstrakte klasse.
- Hvis underklassen ikke har tilstrækkelig information til at implementere de abstrakte metoder, skal underklassen erklæres som en abstrakt klasse.
Konklusion
I denne vejledning har vi præsenteret de grundlæggende koncepter for grænseflader i Java. Vi har diskuteret definitionen af grænsefladen sammen med behovet for grænseflader. Vi udforskede deres grundlæggende syntaks og definition. Derefter diskuterede vi, hvordan vi bruger grænseflader, som vi bruger nøgleordet 'implementerer' til.
Vi lærte, hvordan man bruger flere grænseflader og grænsefladearv i Java. Ved hjælp af flere grænseflader kan vi implementere flere arv i Java. Interface-arv er, når en grænseflade udvider en anden grænseflade.
=> Besøg her for at se Java Training Series for alle
Anbefalet læsning
- OOP Java: Introduktion til objektorienteret programmering i Java
- Sammenlignelige og komparatorgrænseflader i Java
- Interfaceforbedringer i Java 8 - Java-funktionelt interface
- Java Map Interface Tutorial med implementering og eksempler
- ListIterator-interface i Java med eksempler
- Markørinterface i Java: Serialiserbar og klonbar
- Indstil interface i Java: Java Set-tutorial med eksempler
- Java Reflection Tutorial med eksempler