Grænseflader

"Hej, Amigo! I dag skal du gøre nogle opdagelser. Emnet for i dag - trommeslag, tak - er grænseflader. "

"Jep. En dag så vidunderlig, at jeg er på vej hjem for at tage et bad."

" En grænseflade er barnet af abstraktion og polymorfi. Interfacet minder meget om en abstrakt klasse, hvor alle metoder er abstrakte. Den erklæres på samme måde som en klasse, men med nøgleordet . Her er nogle 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 har vi brug for grænseflader? Hvornår bruges de?"

"Grænseflader har to stærke fordele i forhold til klasser:"

1) Adskillelse af "metodedefinitioner" fra metodeimplementeringer.

Jeg har tidligere fortalt dig, at hvis du vil tillade andre klasser at kalde metoderne i din klasse, så skal du markere dem sompublic . Hvis du ønsker, at bestemte metoder kun skal kaldes fra din egen klasse, skal de markeres private. Med andre ord deler vi klassens metoder op i to kategorier: «for alle» og «bare for mig».

Vi kan bruge grænseflader til at styrke denne adskillelse endnu mere. Vi vil lave en særlig "klasse for alle", der vil arve en anden "bare-til-mig-klasse". Det ville se sådan ud:

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 vores klasse op i to dele: en grænseflade og en klasse, der implementerer grænsefladen.

"Så hvad er fordelen?"

"Den samme grænseflade kan implementeres af (arve) forskellige klasser. Og hver klasse kan have sin egen adfærd. Ligesom ArrayList og LinkedList er to forskellige implementeringer af List-grænsefladen. "

Således skjuler vi ikke kun de forskellige implementeringer, men også de klasser, der indeholder implementeringerne (vi kan bare bruge grænseflader overalt i koden). Dette lader os meget fleksibelt erstatte nogle objekter med andre objekter, mens programmet kører, og ændrer et objekts adfærd uden kendskab til nogen af ​​de klasser, der bruger det.

I kombination med polymorfi er dette en meget kraftfuld teknik. I øjeblikket er det langt fra indlysende, hvorfor vi skulle gøre dette. Du skal først støde på programmer bestående af snesevis eller hundredvis af klasser for at forstå, hvordan grænseflader i høj grad kan forenkle dit liv.

2) Multipel arv.

I Java kan hver klasse kun have én overordnet klasse. I andre programmeringssprog kan klasser ofte have flere forældreklasser. Dette er meget praktisk, men det skaber også mange problemer.

Java tilbyder et kompromis:   du kan ikke arve flere klasser, men du kan implementere flere grænseflader. En grænseflade kan have flere forældregrænseflader.  En klasse kan implementere flere grænseflader og kun arve én overordnet klasse.