Grensesnitt

"Hei, Amigo! I dag skal du gjøre noen oppdagelser. Temaet for i dag - trommerull, takk - er grensesnitt. "

"Jepp. En dag så fantastisk at jeg drar hjem for å ta et bad."

" Et grensesnitt er barnet til abstraksjon og polymorfisme. Grensesnittet er veldig likt en abstrakt klasse der alle metodene er abstrakte. Det er deklarert på samme måte som en klasse, men med nøkkelordet . Her er noen eksempler: interface"

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"Interessant. Men hvorfor trenger vi grensesnitt? Når brukes de?"

"Grensesnitt har to sterke fordeler fremfor klasser:"

1) Separasjon av "metodedefinisjoner" fra metodeimplementeringer.

Jeg har tidligere fortalt deg at hvis du vil tillate andre klasser å kalle metodene til klassen din, må du merke dem sompublic . Hvis du vil at visse metoder kun skal kalles fra din egen klasse, må de merkes private. Med andre ord deler vi klassens metoder inn i to kategorier: «for alle» og «bare for meg».

Vi kan bruke grensesnitt for å styrke denne separasjonen enda mer. Vi vil lage en spesiell "klasse for alle" som vil arve en andre "bare-for-meg-klasse". Det vil se omtrent slik ut:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

Vi deler klassen vår i to deler: et grensesnitt og en klasse som implementerer grensesnittet.

"Så hva er fordelen?"

"Det samme grensesnittet kan implementeres av (arve) forskjellige klasser. Og hver klasse kan ha sin egen oppførsel. Akkurat som ArrayList og LinkedList er to forskjellige implementeringer av List-grensesnittet. "

Dermed skjuler vi ikke bare de forskjellige implementeringene, men også klassene som inneholder implementeringene (vi kan bare bruke grensesnitt overalt i koden). Dette lar oss veldig fleksibelt erstatte noen objekter med andre objekter mens programmet kjører, og endre et objekts oppførsel uten at noen av klassene som bruker det, vet om det.

I kombinasjon med polymorfisme er dette en veldig kraftig teknikk. For øyeblikket er det langt fra åpenbart hvorfor vi må gjøre dette. Du må først møte programmer som består av dusinvis eller hundrevis av klasser for å forstå hvordan grensesnitt kan forenkle livet ditt.

2) Multippel arv.

I Java kan hver klasse bare ha én overordnet klasse. I andre programmeringsspråk kan klasser ofte ha flere foreldreklasser. Dette er veldig praktisk, men det skaper også mange problemer.

Java tilbyr et kompromiss:   du kan ikke arve flere klasser, men du kan implementere flere grensesnitt. Et grensesnitt kan ha flere overordnede grensesnitt.  En klasse kan implementere flere grensesnitt og arve bare én overordnet klasse.