Standardmetoder i grensesnitt

Hver ny versjon av Java skiller seg fra de som kom før. Her er et eksempel på endringer i materiale som vi har dekket: før Java 5 hadde ikke språket enums. På samme måte skiller Java 8 seg markant fra Java 7. De fleste av leksjonene våre ble skrevet for den 7. versjonen av språket, men vi vil selvfølgelig ikke ignorere viktige innovasjoner. Siden vi allerede snakker om grensesnitt i denne leksjonen, vil vi vurdere én oppdatering - standardmetoder i grensesnitt . Du vet allerede at et grensesnitt ikke implementerer atferd . Dens oppgave er å beskrive atferden som alle objektene som implementerer den må ha. Men utviklere møtte ofte situasjoner der implementeringen av en metode er den samme i alle klasser. La oss se på vårt gamle bileksempel:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"Etter din mening, hva er hovedproblemet med denne koden? Du har sikkert lagt merke til at vi skrev en haug med gjentatt kode! Dette problemet er vanlig i programmering, og du må unngå det. Det er en annen sak at bestemte løsninger ikke fantes før Java 8 ble utgitt. Med denne versjonen kom muligheten til å spesifisere standardmetoder og implementere dem rett inne i grensesnittet! Slik gjør du det:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Nå er gas()og- brake()metodene, som var like for alle biler, flyttet til grensesnittet. Ingen gjentatt kode er nødvendig. Dessuten er metodene tilgjengelige i hver klasse!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

Hva om det er 100 klasser med gas()metoden, men bare 99 av dem har samme oppførsel? Ødelegger det alt og gjør standardmetoden uegnet for denne situasjonen? Selvfølgelig ikke :) Standardmetoder i grensesnitt kan overstyres på samme måte som vanlige.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Alle de 99 andre typene biler vil implementere standardmetoden, ogUnusualCarklasse, som er et unntak, vil ikke ødelegge helhetsbildet og definerer rolig sin egen oppførsel. Multippel arv av grensesnitt. Som du allerede vet, støtter ikke Java multippel arv. Det er mange grunner til dette. Vi vil se på dem i detalj i en egen leksjon. Andre språk, som C++, støtter det. Uten multippel arv oppstår det et alvorlig problem: ett objekt kan ha flere forskjellige egenskaper og 'atferd'. Her er et eksempel fra livet: vi er barn for foreldrene våre, studenter for lærerne våre og pasienter for legene våre. I livet tar vi på oss forskjellige roller og oppfører oss følgelig annerledes: åpenbart ville vi ikke snakke med lærere på samme måte som vi snakker til våre nære venner. La oss prøve å oversette dette til kode. Tenk deg at vi har to klasser: Dam og voliere. Til dammen trenger vi vannfugler; til volieren trenger vi flygende fugler. For å gjøre dette har vi laget to basisklasser:FlyingBirdog Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Følgelig vil vi sende fugler hvis klasser arver FlyingBirdtil volieren, og vi sender fugler som arver Waterfowltil dammen. Det hele virker veldig enkelt. Men hvor sender vi en and? Den svømmer og flyr. Og vi har ikke multippel arv. Heldigvis støtter Java flere implementeringer av grensesnitt. Selv om en klasse ikke kan arve flere foreldre, kan den enkelt implementere flere grensesnitt! Anda vår kan være både en flygende fugl og en vannfugl :) Vi trenger rett og slett å lage FlyingBirdog Waterfowlgrensesnitt fremfor klasser for å oppnå ønsket resultat.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

Følgelig beholder programmet vårt fleksibiliteten til klasser, og i kombinasjon med standardmetoder blir vår evne til å definere objekters oppførsel nesten ubegrenset! :)