java interface abstract class tutorial with examples
Denne videoopplæringen forklarer hva som er Java-grensesnitt, hvordan du implementerer det, og flere arv ved bruk av grensesnitt i Java med eksempler:
I en av våre tidligere veiledninger diskuterte vi abstraksjon i detalj. Der diskuterte vi abstrakte klasser og abstrakte metoder. Vi vet at abstrakte klasser gir abstraksjon, da vi også kan ha noen ikke-abstrakt metode i abstraktklassen.
Funksjonen som gir 100% abstraksjon i Java kalles “ Grensesnitt ”. I denne opplæringen vil vi diskutere grensesnitt i Java.
=> Ta en titt på Java Beginners Guide her.
Hva du vil lære:
- Videoopplæring om grensesnitt og abstrakte klasser
- Hva er et grensesnitt i Java
- Flere grensesnitt i Java
- Konklusjon
Videoopplæring om grensesnitt og abstrakte klasser
Introduksjon til grensesnitt og abstrakte klasser i Java - Del 1:
Oversikt over grensesnitt og abstrakte klasser i Java - Del 2:
Abstraksjon og arv i Java:
Hva er et grensesnitt i Java
Et grensesnitt i Java er definert som en abstrakt type som spesifiserer klasseatferd. Et grensesnitt er en slags protokoll som setter opp regler for hvordan en bestemt klasse skal oppføre seg.
Et grensesnitt i Java kan inneholde abstrakte metoder og statiske konstanter. Som standard er alle metodene i grensesnittet offentlige og abstrakte.
Et enkelt eksempel på et grensesnitt i Java er gitt nedenfor.
interface shape{ public static final String color = “Red”; public void calculateArea(); }Ovennevnte eksempel definerer et grensesnitt 'form' som har en statisk variabel og en abstrakt metode 'beregneArea ()'.
Et grensesnitt er en enhet som bare har abstrakte metoder som sin kropp. Det kan også ha statiske endelige variabler.
Så akkurat som klasse, kan et grensesnitt også ha metoder og variabler, men merk at metodene er abstrakte (uten implementering) og variablene er statiske.
Nedenfor er noen egenskaper du bør huske på relatert til grensesnitt:
- Grensesnitt er tegninger for en klasse. De forteller klassen hva de skal gjøre gjennom metodene sine.
- Et grensesnitt spesifiserer abstrakte metoder og klasser som implementerer det grensesnittet, skal også implementere disse metodene.
- Hvis en klasse som implementerer grensesnittet ikke definerer alle metodene for grensesnittet, blir den klassen en abstrakt klasse.
Den generelle syntaksen for grensesnitterklæringen er gitt nedenfor.
interface { //constant or static fields declaration //abstract method declaration //default declarations }Som vist i erklæringen ovenfor bruker vi et Java-nøkkelord 'grensesnitt' som indikerer at vi erklærer et grensesnitt nå.
angularjs intervju spørsmål og svar for erfaren pdf
Et ‘grensesnitt’ nøkkelord blir fulgt av grensesnittnavn og deretter de åpnede krøllete bukkene. Så har vi forskjellige erklæringer om abstrakte metoder, statiske feltdeklarasjoner osv. Til slutt lukker vi krøllete bukseseler.
For eksempel,hvis vi vil erklære et grensesnitt 'TestInterface' med to metoder i det, dvs. method_one og method_two, vil erklæringen om TestInterface være som nedenfor:
interface TestInterface{ void method_one(); void method_two(); }Bruk av grensesnittet i Java
- Grensesnitt i Java gir 100% abstraksjon, da de bare kan ha abstrakte metoder.
- Ved hjelp av grensesnitt kan vi oppnå flere arv i Java, noe som ikke er mulig ved bruk av klasser.
- For å oppnå løs kobling kan et grensesnitt brukes.
Hvordan implementere et grensesnitt i Java
Når grensesnittet er erklært, kan vi bruke det i en klasse ved å bruke nøkkelordet 'implementerer' i klassedeklarasjonen.
Dette 'implementerer' nøkkelordet vises etter kursnavnet som vist nedenfor:
class implements { //class body }Å implementere et grensesnitt er det samme som å signere en kontrakt. Derfor betyr en klasse som implementerer et grensesnitt at den har signert en kontrakt og har avtalt å implementere de abstrakte metodene til grensesnittet eller med andre ord utføre den oppførselen som er angitt av grensesnittet.
Hvis klassen som implementerer grensesnittet ikke implementerer den eksakte oppførselen som er spesifisert i grensesnittet, må klassen erklæres som abstrakt.
Eksempel på implementering av grensesnitt
Nedenfor er et enkelt eksempel på et grensesnitt 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 } }Produksjon:
Ovennevnte program viser det enkle eksemplet på grensesnitt i Java. Her erklærer vi et grensesnitt som heter Polygon_Shape, og deretter implementerer klassen Rektangel det.
Grensesnittnavnkonvensjon i Java
Navnekonvensjoner for Java er navngivningsretningslinjene som vi må følge som programmerere, slik at vi kan produsere lesbar, konsistent kode. Java bruker 'TitleCase' -notasjoner for navngivningsklassene og grensesnittene. Den bruker 'CamelCase' -notasjoner for variabler, metoder osv.
Når det gjelder grensesnitt, er grensesnittnavnet i tittelfasen med den første bokstaven i hvert ord i grensesnittnavnet. Grensesnittnavn er valgt slik at de vanligvis er adjektiv. Men når grensesnitt representerer familien av klasser som kart eller liste, så kan de ha navn etter substantiv.
Noen eksempler på gyldige grensesnittnavn er gitt nedenfor:
public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}Grensesnittkonstruktør
Det neste spørsmålet er om et grensesnitt har en konstruktør?
Vi vet at vi trenger gjenstander for å påkalle metoder. For å lage objekter trenger vi konstruktører. Men når det gjelder grensesnitt i Java, implementeres ikke metodene.
Metodene for grensesnitt er alle abstrakte. Derfor er det ingen nytte å kalle disse metodene fra grensesnittet. For det andre, ettersom grensesnitt som standard er abstrakte, kan vi ikke lage objekter av grensesnittet. Dermed trenger vi ikke konstruktører for grensesnitt.
Grensesnittmetoder
I denne delen vil vi diskutere hvordan man kan erklære grensesnittmetoder. Som regel kan et grensesnitt bare ha offentlige metoder, eller som standard er grensesnittmetoder offentlige. Ingen andre tilgangsmodifikatorer er tillatt å bruke inne i grensesnittet.
Så om vi eksplisitt erklærer det eller ikke, er hver metode i grensesnittet som standard abstrakt med offentlig synlighet.
Derfor, hvis void printMethod () er prototypen som vi har til hensikt å erklære i et grensesnitt, så er følgende erklæringer de samme.
void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();Merk at vi ikke kan bruke følgende modifikatorer inne i grensesnittet for grensesnittmetodene.
- endelig
- statisk
- Privat
- beskyttet
- synkronisert
- innfødt
- strictfp
La oss nå implementere et Java-program for å demonstrere synligheten av grensesnittmetoden.
//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 } } Produksjon:
Som allerede nevnt er grensesnittmetodene som standard offentlige. Derfor når vi ikke spesifiserer noen tilgangsmodifikator for grensesnittmetoden, så er den offentlig som i programmet ovenfor.
Anta at vi endrer grensesnittmetodedeklarasjonen i programmet ovenfor som følger:
privat tomtrykkMetode ();
Da betyr dette at vi spesifiserte grensesnittmetoden printMethod () som privat. Når vi kompilerer programmet, får vi følgende kompilatorfeil.
feil: privat modifikator ikke tillatt her
privat tomtrykkMetode ();
Det andre tilfellet vi kan teste er ved å endre modifikatoren for den implementerte metoden i klassen TestClass fra offentlig til privat. Nå er standardmodifikatoren i klassen privat. Så vi fjerner bare det offentlige nøkkelordet fra prototypen i klassen som følger:
void printMethod() { System.out.println('TestClass::printMethod()'); }Nå hvis vi kompilerer programmet, får vi følgende feil.
error: printMethod () i TestClass kan ikke implementere printMethod () i TestInterface
ugyldig printMethod ()
^
prøver å tildele svakere tilgangsrettigheter; var offentlig
Derfor er poenget som skal bemerkes her at vi ikke kan endre tilgangsmodifikatoren for den implementerte metoden for grensesnittet til noen annen tilgangsmodifikator. Siden grensesnittmetodene som standard er offentlige, bør disse metodene også være offentlige når de implementeres av klasser som implementerer grensesnitt.
Grensesnittfelt i Java
Feltene eller variablene deklarert i et grensesnitt er som standard offentlige, statiske og endelige. Dette betyr at når de er erklært, kan ikke verdien endres.
Merk at hvis grensesnittfeltene er definert uten å spesifisere noen av disse modifikatorene, antar Java-kompilatorer disse modifikatorene. For eksempel, hvis vi ikke spesifiserer en offentlig modifikator når vi erklærer feltet i grensesnittet, antas det som standard.
Når et grensesnitt implementeres av en klasse, gir det en implementering for alle de abstrakte metodene i grensesnittet. På samme måte arves også alle feltene i grensesnittet av klassen som implementerer grensesnittet. Dermed er en kopi av grensesnittfeltet til stede i implementeringsklassen.
Nå er alle feltene i grensesnittet som standard statiske. Derfor kan vi få tilgang til dem ved å bruke grensesnittnavnet direkte som det samme som vi får tilgang til statiske felt i klassen ved hjelp av klassenavnet og ikke objektet.
Eksemplet Java-programmet nedenfor viser hvordan vi får tilgang til grensesnittfeltene.
//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); } }Produksjon:
Som vist i programmet ovenfor, kan du få tilgang til grensesnittfeltene ved å bruke et grensesnittnavn etterfulgt av prikkoperatør (.) Og deretter den faktiske variabelen eller feltnavnet.
Det generiske grensesnittet i Java
Vi har diskutert Java generics i våre tidligere opplæringsprogrammer. Bortsett fra å ha generiske klasser, metoder osv., Kan vi også ha generiske grensesnitt. Generiske grensesnitt kan spesifiseres på samme måte som vi spesifiserer generiske klasser.
Generiske grensesnitt er erklært med typeparametere som gjør dem uavhengige av en datatype.
Den generelle syntaksen til det generiske grensesnittet er som følger:
gratis brannmur nedlasting for Windows 10
interface { //interface methods and variables }Nå hvis vi vil bruke det generiske grensesnittet ovenfor i en klasse, så kan vi ha det klassedefinisjonen som vist nedenfor:
class implements interface_name { //class body }Merk at vi må spesifisere samme param-liste med klassen som med grensesnittet.
Følgende Java-program demonstrerer generiske grensesnitt 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()); } Produksjon:
Ovennevnte program implementerer et grensesnitt som inneholder en metode for å finne minimumsverdien i matrisen. Dette er et generisk grensesnitt. Klassen implementerer dette grensesnittet og overstyrer metoden. I hovedmetoden kaller vi grensesnittmetoden for å finne minimumsverdien i et heltall og en tegnmatrise.
Flere grensesnitt i Java
I vårt arvemne har vi sett at Java ikke tillater at en klasse arver fra flere klasser, da det resulterer i en tvetydighet som kalles 'Diamantproblemet'.
Imidlertid kan en klasse arve eller implementere mer enn ett grensesnitt. I dette tilfellet er det kjent som flere arv. Så selv om vi ikke har lov til å implementere flere arv i Java gjennom klasser, kan vi gjøre det ved hjelp av grensesnitt.
Følgende diagram viser flere arv ved bruk av grensesnitt. Her implementerer en klasse to grensesnitt, dvs. Interface_one og Interface_two.
Merk at når en klasse implementerer flere grensesnitt, blir grensesnittnavnene kommaseparert i klassedeklarasjonen. Vi kan implementere så mange grensesnitt så lenge vi kan takle kompleksiteten.
Java-programmet som viser flere grensesnitt er vist 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(); } } Produksjon:
beste prosjektledelsesappen for iPhone
Som vist ovenfor implementerer vi to grensesnitt. Så overstyrer vi deres respektive metoder og kaller dem i hovedmetoden.
Flere arv i Java gir alle fordelene som flere arv gir i C ++. Men i motsetning til flere arv ved bruk av klasser, er flere arv ved bruk av grensesnitt uten tvetydighet.
Grensesnittarv i Java: Grensesnitt utvider grensesnittet
Når en klasse implementerer et grensesnitt, gjøres det med redskaper ’Nøkkelord. I Java kan et grensesnitt arve et annet grensesnitt. Dette gjøres ved å bruke strekker ’Nøkkelord. Når et grensesnitt utvider et annet grensesnitt, kalles det “ Grensesnittarv ”På Java.
Java-programmet for implementering av grensesnittarv 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(); } } Produksjon:
Vi har endret det samme programmet som vi brukte for flere arv ved hjelp av grensesnitt for å demonstrere grensesnittets arv. Her utvider vi Interface_one i Interface_two og deretter implementerer Interface_two i en klasse. Siden grensesnitt er arvet, er begge metodene tilgjengelige for å overstyre.
ofte stilte spørsmål
Q # 1) Hva er bruken av grensesnittet i Java?
Svar: Et grensesnitt i Java er en enhet som brukes til å oppnå 100% abstraksjon. Den kan bare inneholde abstrakte metoder som kan overstyres av klassen som implementerer grensesnittet.
Grensesnittet fungerer på en måte som en blåkopi av klassen der den gir klassen de abstrakte metoden prototyper og statiske konstanter, og deretter må klassen overstyre disse metodene ved å implementere grensesnittet.
Q # 2) Hva er fordelene med grensesnittet i Java?
Svar: Noen av fordelene med Interface er som følger:
- Grensesnittet fungerer som en blåkopi av klassen.
- Grensesnittet gir 100% abstraksjon i Java, da det har alle de abstrakte metodene.
- Grensesnitt kan brukes til å oppnå flere arv i Java. Java tillater ikke å arve fra mer enn en klasse, men en klasse kan implementere flere grensesnitt.
# 3) Kan et grensesnitt ha metoder?
Svar: Grensesnitt kan ha prototyper av metoder og statiske og endelige konstanter. Men fra og med Java 8, kan grensesnitt inneholde statiske og standardmetoder.
Q # 4) Kan vi erklære grensesnittet som endelig?
Svar: Nei. Hvis vi erklærer et grensesnitt som endelig, vil ikke klassen kunne implementere det. Uten å bli implementert av noen klasse, vil grensesnittet ikke tjene noe formål.
Mer om grensesnitt
Grensesnitt er tegninger som klasse, men det vil bare ha metodedeklarasjonen. Det vil ikke ha noen metode for implementering. Alle metodene i grensesnittet er som standard offentlig abstrakt. Java 1.8-grensesnitt kan ha statiske metoder og standardmetoder.
Grensesnitt brukes hovedsakelig i APIer.
For eksempel: Vurder at du designer motoren til et kjøretøy.
Når du er ferdig med maskinvaredelen, vil du at noen av programvarefunksjonalitetene skal implementeres av en klient som bruker motoren din. Så i så fall kan du definere motorfunksjonalitetene dine i et grensesnitt.
Interface Engine { void changeGear(int a); void speedUp(int a); } Regler som skal følges for grensesnitt
- Klassen som implementerer grensesnittet skal implementere alle metodene i grensesnittet.
- Et grensesnitt kan inneholde 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 kjøretøyklassen underklassen som implementerer motorgrensesnittet.
Hva er abstrakte klasser?
En abstrakt klasse er som en klasse, men den vil ha abstrakte metoder og konkrete metoder. Abstrakte metoder har ingen implementering. Det vil bare ha metodedeklarasjonen.
Regler som skal følges for abstrakt klasse
- Den abstrakte klassen kan ikke instantiseres.
- Barneklasse som utvider den abstrakte klassen, bør implementere alle de abstrakte metodene i foreldreklassen, eller Barneklassen bør erklæres som en abstrakt klasse.
Når du ønsker å 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 som skal utvide den abstrakte klassen.
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'); } } 
Viktige punkter å merke seg:
- I grensesnitt vil ikke alle metodene ha metodeimplementering.
- Klassen som implementerer grensesnittet, bør implementere alle metodene i det aktuelle grensesnittet.
- Abstrakte klasser kan ha både abstrakte metoder og normale konkrete metoder. Abstrakte metoder har ingen implementering.
- Klassen som utvider abstraktklassen, bør ha implementeringen av alle de abstrakte metodene i abstraktklassen.
- Hvis underklassen ikke har nok informasjon til å implementere de abstrakte metodene, bør underklassen erklæres som en abstrakt klasse.
Konklusjon
I denne veiledningen har vi presentert de grunnleggende konseptene for grensesnitt i Java. Vi har diskutert definisjonen av grensesnittet, sammen med behovet for grensesnitt. Vi utforsket deres grunnleggende syntaks og definisjon. Så diskuterte vi hvordan vi bruker grensesnitt som vi bruker nøkkelordet ‘implementerer’ for.
Vi lærte å bruke flere grensesnitt og grensesnittarv i Java. Ved å bruke flere grensesnitt kan vi implementere flere arv i Java. Grensesnittarv er når ett grensesnitt utvider et annet grensesnitt.
=> Besøk her for å se Java Training Series for alle
Anbefalt lesing
- OOP Java: Introduksjon til objektorientert programmering i Java
- Sammenlignbare og komparatorgrensesnitt i Java
- Grensesnittforbedringer i Java 8 - Java-funksjonelt grensesnitt
- Java Kartgrensesnittveiledning med implementering og eksempler
- ListIterator-grensesnitt i Java med eksempler
- Markergrensesnitt i Java: Serialiserbart og klonabelt
- Sett grensesnitt i Java: Java Set Tutorial med eksempler
- Java Reflection Tutorial med eksempler