Interface i Java

Interface i Java är ett sätt att förbestämma vilka metoder en klass ska innehålla.

Vad är ett interface i Java?

Ett interface är ett sätt att förbestämma vilka metoder en klass ska ha. Detta är väldigt effektivt när man vill skapa många klasser med liknande egenskaper. I större projekt kanske man sitter i olika projektgrupper som programmerar i samma program. Då är det viktigt att ha förbestämda krav så att alla programmerare utgår från samma bestämmelse.

Interface är ett sätt att förbestämma vilka metoder en klass ska innehålla.

Interface i Java:

  • Är en mall över vilka egenskaper/metoder en klass ska innehålla.
  • Ett sätt att fördefinera en klass, så att alla klasser håller samma struktur.
  • Används till klasser med liknande struktur.
  • Man skapar ett interface i Java med det reserverade order interface. 
  • För att skapa en klass från ett interface använder man sig av det reserverade ordet implements.

Skapa ett interface i Java – Syntax

Syntaxen för ett interface ser ut såhär:

public interface Namn {
    datatyp metod1(inparametrar);
    datatyp2 metod2(inparametrar);

    ...
}
  • Man skapar ett interface i Java med det reserverade ordet interface.
  • Inom måsvingar anger man vilka metoder, det vill säga, vilka egenskaper klassen har.
  • Man anger enbart vilka metoder som klassen ska ha, inte vad metoderna ska göra.
  • Praxis är att klassnamnet börjar med stor bokstav.
  • När man implementerar en klass från ett interface, får klassen automatiskt alla metoder som angivits i interfacet.
  • Man skapar en klass från ett interface genom det reserverade kommandot implements.

Hur skapar man ett interface i Java – Exempel

Vi vill i detta exempel programmera flera olika djur. Djur har många liknande egenskaper, så det är perfekt att använda ett interface som varje djur kan utgå ifrån. På detta sätt kan varje nytt djur vi skapar, utgå från samma mall (interface) och få samma egenskaper, vilket innebär att man inte behöver programmera samma sak flera gånger!

Implements en klass i Java
Implements en klass i Java

I detta exempel skapar vi interfacet Animals enligt:

public interface Animal {
    String whatDoesTheAnimalDo();
    String whatDoesTheAnimalSay();
    void setName(String name);
    void setAge(int age);
}

I detta interface bestämmer vi att alla klasser som är av typen “Animal” ska ha fyra stycken metoder:

  • whatDoesTheAnimalDo()
  • whatDoesTheAnimalSay()
  • setName()
  • setAge()

Nu kan vi använda interfacet Animals, som en mall för att skapa flera djur!

Först skapar vi klassen Cow enligt:

public class Cow implements Animal { 

  //Klassvariabler 
  String name; 
  int age; 

  //Definierar konstruktorn 
  Cow(String name, int age){ 
    this.name = name; 
    this.age = age; 
  } 

  @Override 
  public String whatDoesTheAnimalDo() { 
    return null; 
  } 

  @Override 
  public String whatDoesTheAnimalSay() { 
    return null; 
  } 

  @Override 
  public void setName(String name) { 
    return null;
  } 

  @Override 
  public void setAge(int age) { 
    return null;
  } 

}
  • I vissa IDE, exempelvis IntelliJ, blir metoderna automatiskt skapade när kommandot implements bli specificerat.
  • Alla metoderna som är specificerade i interfacet måste finnas i klassen som blir implementerat, annars kommer vi få ett kompileringsfel.
  • Att metoderna har implementeras korrekt visas av kompilatorn med “@override“. Det gör det enklare att hitta eventuella fel, exempelvis om en metod skulle råka vara felstavad.

Alla metoderna som är specificerade i interfacet måste finnas i klassen som implementeras, annars kommer vi få ett kompileringsfel.

När IDE:t skapar metoderna automatiskt, är metoderna tomma eller returnerar null. Det ska vi förstås ändra på nu.

Vi skapar även klassen Pig på motsvarande sätt och skriver in information för varje metod i respektive klass.

public class Cow implements Animal {
    //Klassvariabler
    String name;
    int age;

    //Definierar konstruktorn
    Cow(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String whatDoesTheAnimalDo() {
        return "The cow is eating";
    }

    @Override
    public String whatDoesTheAnimalSay() {
        return "The cow says Moo";
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }
}
public class Pig implements Animal {
    //Klassvariabler
    String name;
    int age;

    //Definierar konstruktorn
    Pig(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String whatDoesTheAnimalDo() {
        return "The pig is sleeping";
    }

    @Override
    public String whatDoesTheAnimalSay() {
        return "The pig says oink oink";
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }
}

Avslutningsvis skapar vi en huvudklass och skapar ett objekt från varje klass.

public class Farm {

    public static void main(String args[]){
        Cow cow = new Cow("Rosa", 3);
        Pig pig = new Pig("Piggy", 1);

        System.out.println(cow.whatDoesTheAnimalSay());
        System.out.println(pig.whatDoesTheAnimalSay());
    }
}

Utskriften då metoden whatDoesTheAnimalSay() anropas från respektive objekt blir då:

The cow says Moo 
The pig says oink oink

Vad tyckte du om sidan?

Lämna gärna feedback och hjälp oss göra sidan bättre

Feedback gör oss bättre!

Lämna gärna feedback om vad du tyckte om avsnittet!