java interface abstract class tutorial with examples
Denna videohandledning förklarar vad som är Java-gränssnitt, hur man implementerar det och flera arv med gränssnitt i Java med exempel:
I en av våra tidigare handledning diskuterade vi abstraktion i detalj. Där diskuterade vi abstrakta klasser och abstrakta metoder. Vi vet att abstrakta klasser ger abstraktion eftersom vi också kan ha någon icke-abstrakt metod i abstraktklassen.
Funktionen som ger 100% abstraktion i Java kallas “ Gränssnitt ”. I denna handledning kommer vi att diskutera gränssnitt i Java.
=> Ta en titt på Java-nybörjarguiden här.
Vad du kommer att lära dig:
- Videohandledning om gränssnitt och abstrakta klasser
- Vad är ett gränssnitt i Java
- Flera gränssnitt i Java
- Slutsats
Videohandledning om gränssnitt och abstrakta klasser
Introduktion till gränssnitt och abstrakta klasser i Java - Del 1:
Översikt över gränssnitt och abstrakta klasser i Java - Del 2:
Abstraktion och arv i Java:
Vad är ett gränssnitt i Java
Ett gränssnitt i Java definieras som en abstrakt typ som anger klassbeteende. Ett gränssnitt är ett slags protokoll som anger regler för hur en viss klass ska bete sig.
Ett gränssnitt i Java kan innehålla abstrakta metoder och statiska konstanter. Som standard är alla metoder i gränssnittet offentliga och abstrakta.
Ett enkelt exempel på ett gränssnitt i Java ges nedan.
interface shape{ public static final String color = “Red”; public void calculateArea(); }Ovanstående exempel definierar ett gränssnittsform som har en statisk variabel och en abstrakt metod 'calcArea ()'.
Ett gränssnitt är en enhet som endast har abstrakta metoder som sin kropp. Det kan också ha statiska slutliga variabler.
Så precis som klass kan ett gränssnitt också ha metoder och variabler men notera att metoderna är abstrakta (utan implementering) och variablerna är statiska.
Nedan listas några egenskaper som bör hållas i åtanke relaterade till gränssnitt:
- Gränssnitt är ritningar för en klass. De berättar för klassen vad de ska göra genom sina metoder.
- Ett gränssnitt anger abstrakta metoder och klasser som implementerar det gränssnittet bör också implementera dessa metoder.
- Om en klass som implementerar gränssnittet inte definierar alla metoder för gränssnittet, blir den klassen en abstrakt klass.
Den allmänna syntaxen för gränssnittsdeklarationen ges nedan.
interface { //constant or static fields declaration //abstract method declaration //default declarations }Som visas i ovanstående deklaration använder vi ett Java-nyckelord 'gränssnitt' som indikerar att vi deklarerar ett gränssnitt nu.
selen med c # intervjufrågor
Ett ”gränssnittsnyckelord” följs av gränssnittsnamnet och sedan de öppnade lockiga hakparenteserna. Sedan har vi olika deklarationer av abstrakta metoder, statiska fältdeklaration, etc. Slutligen stänger vi de lockiga hakparenteserna.
Till exempel,om vi vill förklara ett gränssnitt 'TestInterface' med två metoder i det, dvs. method_one och method_two så kommer deklarationen av TestInterface att vara som nedan:
interface TestInterface{ void method_one(); void method_two(); }Användning av gränssnittet i Java
- Gränssnitt i Java ger 100% abstraktion eftersom de bara kan ha abstrakta metoder.
- Med gränssnitt kan vi uppnå flera arv i Java, vilket inte är möjligt med klasser.
- För att uppnå lös koppling kan ett gränssnitt användas.
Hur man implementerar ett gränssnitt i Java
När gränssnittet har förklarats kan vi använda det i en klass med hjälp av nyckelordet 'redskap' i klassdeklarationen.
Detta ”implementerar” nyckelord visas efter klassnamnet som visas nedan:
class implements { //class body }Att implementera ett gränssnitt är detsamma som att underteckna ett kontrakt. Därför betyder en klass som implementerar ett gränssnitt att den har undertecknat ett kontrakt och har gått med på att implementera gränssnittets abstrakta metoder eller med andra ord utföra det beteende som anges av gränssnittet.
Om klassen som implementerar gränssnittet inte implementerar det exakta beteende som anges i gränssnittet måste klassen förklaras som abstrakt.
Exempel på implementering av gränssnitt
Nedan följer ett enkelt exempel på ett gränssnitt 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:
Ovanstående program visar det enkla exemplet på gränssnitt i Java. Här förklarar vi ett gränssnitt som heter Polygon_Shape och sedan implementerar klassen Rektangel det.
Gränssnittsnamnkonvention i Java
Java-namngivningskonventioner är de namngivningsriktlinjer som vi måste följa som programmerare så att vi kan producera läsbar konsekvent kod. Java använder 'TitleCase' -noteringar för namngivningsklasserna och gränssnitten. Den använder 'CamelCase' -noteringar för variabler, metoder etc.
När det gäller gränssnittet är gränssnittsnamnet i titelfasen med den första bokstaven i varje ord i gränssnittsnamnet med stort. Gränssnittsnamn väljs så att de vanligtvis är adjektiv. Men när gränssnitt representerar familjen av klasser som karta eller lista, kan de namnges efter substantiv.
Några exempel på giltiga gränssnittsnamn ges nedan:
public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}Gränssnittskonstruktör
Nästa fråga är om ett gränssnitt har en konstruktör?
Vi vet att vi behöver objekt för att åberopa metoder. För att skapa objekt behöver vi konstruktörer. Men när det gäller gränssnitt i Java implementeras metoderna inte.
Gränssnittsmetoderna är alla abstrakta. Därför finns det ingen användning i att anropa dessa metoder från gränssnittet. För det andra, eftersom gränssnitt som standard är abstrakta, kan vi inte skapa objekt av gränssnittet. Således behöver vi inte konstruktörer för gränssnitt.
Gränssnittsmetoder
I detta avsnitt kommer vi att diskutera hur man deklarerar gränssnittsmetoder. Som regel kan ett gränssnitt endast ha offentliga metoder eller som standard är gränssnittsmetoder offentliga. Ingen annan åtkomstmodifierare får användas i gränssnittet.
Så oavsett om vi uttryckligen förklarar det eller inte, är varje metod i gränssnittet som standard abstrakt med allmän synlighet.
Följaktligen, om void printMethod () är prototypen som vi tänker deklarera i ett gränssnitt, är följande deklarationer desamma.
void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();Observera att vi inte kan använda följande modifierare i gränssnittet för gränssnittsmetoderna.
- slutlig
- statisk
- Privat
- skyddade
- synkroniserad
- inföding
- striktfp
Låt oss nu implementera ett Java-program för att visa gränssnittsmetodens synlighet.
//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 redan nämnts är gränssnittsmetoderna som standard offentliga. Därför när vi inte anger någon åtkomstmodifierare för gränssnittsmetoden, så är den offentlig som i ovanstående program.
Antag att vi ändrar gränssnittsdeklarationen i ovanstående program enligt följande:
privat ogiltigt printMethod ();
Då betyder det att vi angav gränssnittsmetoden printMethod () som privat. När vi kompilerar programmet får vi följande kompileringsfel.
fel: modifierare privat tillåts inte här
privat ogiltigt printMethod ();
Det andra fallet vi kan testa är att ändra modifieraren för den implementerade metoden i klassen TestClass från offentlig till privat. Nu är standardmodifieraren i klassen privat. Så vi tar bara bort det offentliga nyckelordet från metodprototypen i klassen enligt följande:
void printMethod() { System.out.println('TestClass::printMethod()'); }Om vi nu kompilerar programmet får vi följande fel.
fel: printMethod () i TestClass kan inte implementera printMethod () i TestInterface
ogiltig printMethod ()
^
försöker tilldela svagare åtkomstbehörigheter; var offentlig
Därför är poängen att notera här att vi inte kan ändra åtkomstmodifieraren för den implementerade metoden för gränssnittet till någon annan åtkomstmodifierare. Eftersom gränssnittsmetoderna som standard är offentliga bör dessa metoder också vara offentliga när de implementeras av klasser som implementerar gränssnitt.
Gränssnittsfält i Java
Fälten eller variablerna som deklarerats i ett gränssnitt är som standard offentliga, statiska och slutgiltiga. Detta innebär att en gång deklarerat kan deras värde inte ändras.
Observera att om gränssnittsfälten definieras utan att någon av dessa modifierare anges, antar Java-kompilatorer dessa modifierare. Till exempel, om vi inte anger en offentlig modifierare när vi deklarerar fältet i gränssnittet antas det som standard.
När ett gränssnitt implementeras av en klass ger det en implementering för alla abstrakta metoder för gränssnittet. På samma sätt är alla deklarerade fälten i gränssnittet också ärvda av klassen som implementerar gränssnittet. Således finns en kopia av gränssnittsfältet i implementeringsklassen.
Nu är alla fält i gränssnittet som standard statiska. Därför kan vi komma åt dem genom att använda gränssnittsnamnet direkt som samma som vi får åtkomst till statiska fält i klassen med hjälp av klassnamnet och inte objektet.
Exemplet Java-program nedan visar hur vi kan komma åt gränssnittsfälten.
//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 visas i programmet ovan kan man komma åt gränssnittsfälten med ett gränssnittsnamn följt av punktoperatör (.) Och sedan den faktiska variabeln eller fältnamnet.
Det generiska gränssnittet i Java
Vi har diskuterat Java generics i våra tidigare tutorials. Förutom att ha generiska klasser, metoder etc. kan vi också ha generiska gränssnitt. Generiska gränssnitt kan specificeras på samma sätt som vi anger generiska klasser.
Generiska gränssnitt deklareras med typparametrar som gör dem oberoende av en datatyp.
Den allmänna syntaxen för det generiska gränssnittet är som följer:
hur man kör Java Jar-filen
interface { //interface methods and variables }Om vi nu vill använda ovanstående generiska gränssnitt i en klass kan vi ha det klassdefinitionen som visas nedan:
class implements interface_name { //class body }Observera att vi måste ange samma param-lista med klassen som med gränssnittet.
Följande Java-program visar de generiska gränssnitten 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:
Ovanstående program implementerar ett gränssnitt som innehåller en metod för att hitta minimivärdet i matrisen. Detta är ett generiskt gränssnitt. Klassen implementerar detta gränssnitt och åsidosätter metoden. I huvudmetoden kallar vi gränssnittsmetoden för att hitta minimivärdet i ett heltal och en teckenmatris.
Flera gränssnitt i Java
I vårt ärftemne har vi sett att Java inte tillåter en klass att ärva från flera klasser eftersom det resulterar i en tvetydighet som kallas 'Diamond Problem'.
En klass kan dock ärva eller implementera mer än ett gränssnitt. I det här fallet är det känt som multipel arv. Så även om vi inte får implementera flera arv i Java genom klasser kan vi göra det med gränssnitt.
Följande diagram visar flera arv med gränssnitt. Här implementerar en klass två gränssnitt, dvs Interface_one och Interface_two.
Observera att när en klass implementerar flera gränssnitt är gränssnittsnamnen kommaseparerade i klassdeklarationen. Vi kan implementera så många gränssnitt så länge vi kan hantera komplexiteten.
Java-programmet som visar flera gränssnitt visas nedan.
//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:
bästa gratis mov till mp4 omvandlare
Som visas ovan implementerar vi två gränssnitt. Sedan åsidosätter vi deras respektive metoder och kallar dem i huvudmetoden.
Flera arv i Java ger alla fördelar som flera arv ger i C ++. Men till skillnad från flera arv med klasser är flera arv med gränssnitt utan tvetydighet.
Gränssnittsarv i Java: Gränssnitt förlänger gränssnittet
När en klass implementerar ett gränssnitt görs det med hjälp av redskap Nyckelord. I Java kan ett gränssnitt ärva ett annat gränssnitt. Detta görs med hjälp av sträcker sig Nyckelord. När ett gränssnitt utökar ett annat gränssnitt kallas det “ Gränssnittsarv ”På Java.
Java-programmet för att implementera gränssnittsarv visas nedan.
//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 modifierat samma program som vi använde för flera arv med gränssnitt för att visa gränssnittsarvet. Här utökar vi Interface_one i Interface_two och sedan implementerar Interface_two i en klass. Eftersom gränssnitt ärvs är båda metoderna tillgängliga för åsidosättande.
Vanliga frågor
F # 1) Vad är användningen av gränssnittet i Java?
Svar: Ett gränssnitt i Java är en enhet som används för att uppnå 100% abstraktion. Den kan bara innehålla abstrakta metoder som kan åsidosättas av klassen som implementerar gränssnittet.
Gränssnittet fungerar på ett sätt som en ritning av klassen där den ger klassen abstrakta metodprototyper och statiska konstanter och sedan måste klassen åsidosätta dessa metoder genom att implementera gränssnittet.
F # 2) Vilka är fördelarna med gränssnittet i Java?
Svar: Några av fördelarna med Interface är följande:
- Gränssnittet fungerar som en ritning av klassen.
- Gränssnittet ger 100% abstraktion i Java eftersom det har alla abstrakta metoder.
- Gränssnitt kan användas för att uppnå flera arv i Java. Java tillåter inte att ärva från mer än en klass men en klass kan implementera flera gränssnitt.
# 3) Kan ett gränssnitt ha metoder?
Svar: Gränssnitt kan ha prototyper av metoder och statiska och slutliga konstanter. Men från och med Java 8 kan gränssnitt innehålla statiska metoder och standardmetoder.
F # 4) Kan vi förklara gränssnittet som slutgiltigt?
Svar: Nej. Om vi förklarar ett gränssnitt som slutgiltigt kommer klassen inte att kunna implementera det. Utan att implementeras av någon klass, kommer gränssnittet inte att tjäna något syfte.
Mer om gränssnitt
Gränssnitt är ritningar som klass, men det kommer bara att ha metoddeklarationen. Det har ingen metod för implementering. Alla metoder i gränssnittet är public abstract som standard. Java 1.8-gränssnittet kan ha statiska metoder och standardmetoder.
Gränssnitt används främst i API: er.
Till exempel: Tänk på att du utformar ett fordons motor.
När du är klar med hårdvarudelen vill du att några av programvarufunktionerna ska implementeras av en klient som använder din motor. Så i så fall kan du definiera dina motorfunktioner i ett gränssnitt.
Interface Engine { void changeGear(int a); void speedUp(int a); } Regler som ska följas för gränssnitt
- Klassen som implementerar gränssnittet ska implementera alla metoder i gränssnittet.
- Ett gränssnitt kan innehålla slutliga 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); } } 
Här är fordonsklassen den underklass som implementerar motorgränssnittet.
Vad är abstrakta klasser?
En abstrakt klass är som en klass men den kommer att ha abstrakta metoder och konkreta metoder. Abstrakta metoder har ingen implementering. Det kommer bara att ha metoddeklarationen.
Regler som ska följas för abstraktklass
- Den abstrakta klassen kan inte instansieras.
- Barnklass som utökar abstraktklassen bör implementera alla abstrakta metoder i moderklassen eller Barnklassen bör förklaras som en abstraktklass.
När du vill utforma partiell implementering kan du gå till en abstrakt klass.
Exempel på abstrakt klassprogram:
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 kommer att utvidga den abstrakta 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'); } } 
Viktiga punkter att notera:
- I gränssnitt kommer alla metoder inte att ha metodimplementering.
- Klassen som implementerar gränssnittet ska implementera alla metoder i det specifika gränssnittet.
- Abstrakta klasser kan ha både abstrakta metoder och normala konkreta metoder. Abstrakta metoder har ingen implementering.
- Klassen som utvidgar abstraktklassen bör ha implementeringen för alla abstraktmetoder i abstraktklassen.
- Om underklassen inte har tillräckligt med information för att implementera de abstrakta metoderna, bör underklassen förklaras som en abstrakt klass.
Slutsats
I denna handledning har vi presenterat de grundläggande begreppen för gränssnitt i Java. Vi har diskuterat definitionen av gränssnittet tillsammans med behovet av gränssnitt. Vi undersökte deras grundläggande syntax och definition. Sedan diskuterade vi hur man använder gränssnitt som vi använder nyckelordet ”implementerar”.
Vi lärde oss hur man använder flera gränssnitt och gränssnittsarv i Java. Med flera gränssnitt kan vi implementera flera arv i Java. Gränssnittsarv är när ett gränssnitt utökar ett annat gränssnitt.
=> Besök här för att se Java Training Series för alla
Rekommenderad läsning
- OOP Java: Introduktion till objektorienterad programmering i Java
- Jämförbara och komparatorgränssnitt i Java
- Gränssnittsförbättringar i Java 8 - Java-funktionellt gränssnitt
- Java Map Interface Tutorial With Implementation & Exempel
- ListIterator-gränssnitt i Java med exempel
- Markörgränssnitt i Java: Serialiserbart och klonbart
- Ställ in gränssnitt i Java: Java Set Tutorial med exempel
- Java Reflection Tutorial med exempel