Java Academy · Lekcja

Interfejsy w praktyce

Wykorzystają Państwo interfejsy jako typy, przekażą je do metod i łatwo zamienią implementacje. Przećwiczą Państwo niewielkie wzorce elastycznego kodu.

Interfejsy w praktyce to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 3 lekcji w sumie.

Przegląd

Interfejsy w praktyce: Traktuj możliwości jako typy i uniezależniaj kod wywołujący od konkretnych klas. Można przekazać interfejs do metody, przechowywać go na liście i w razie potrzeby zastąpić inną implementacją.

Interfejs jako parametr

Jeśli metody przyjmują typ interface jako parametr, zyskują elastyczność:

Kod wywołujący pozostaje niezmieniony.
Różne klasy mogą implementować ten sam kontrakt i być używane.
W testach można podstawić Fake lub Stub i szybko przeprowadzać próby.

Kod: możliwość Printable

Metoda korzysta z kontraktu Printable, a nie z klasy konkretnej; nawet gdy implementacje się zmieniają, kod wywołujący pozostaje taki sam.

public class Main {
  // 1) Define a tiny capability
  static interface Printable { void print(); }

  // 2) Two implementations
  static class TextDoc implements Printable {
    public void print() { System.out.println("[TextDoc] Printing text pages"); }
  }
  static class Photo implements Printable {
    public void print() { System.out.println("[Photo] Printing a photo"); }
  }

  // 3) A method that depends on capability, not class
  static void runJob(Printable p) {
    p.print(); // caller does not care which class it is
  }

  public static void main(String[] args) {
    runJob(new TextDoc());
    runJob(new Photo());
  }
}

Interfejs jako typ zwracany

Czasami metoda factory zwraca interfejs. Kod wywołujący widzi tylko dostępne możliwości i nie musi znać rzeczywistej klasy. Zmniejsza to zależności i zwiększa modularność.

Kod: Strategy z Formatter

Ta sama metoda działa z różnymi implementacjami Formatter. Udało się zmienić zachowanie bez modyfikowania klasy.

public class Main {
  // Strategy: different ways to format text
  static interface Formatter { String format(String s); }

  static class UpperFormatter implements Formatter {
    public String format(String s) { return s.toUpperCase(); }
  }
  static class LowerFormatter implements Formatter {
    public String format(String s) { return s.toLowerCase(); }
  }

  // Uses any Formatter
  static String show(String title, Formatter f) {
    return title + " -> " + f.format(title);
  }

  public static void main(String[] args) {
    System.out.println(show("Hello", new UpperFormatter()));
    System.out.println(show("Hello", new LowerFormatter()));
  }
}

Kod: lista interfejsów

Tablica lub lista może być typu interfejsowego. Pętla wykonuje to samo wywołanie, a każdy element uruchamia własną implementację.

public class Main {
  static interface Task { void run(); }

  static class EmailTask implements Task { public void run(){ System.out.println("Send email"); } }
  static class ReportTask implements Task { public void run(){ System.out.println("Generate report"); } }
  static class CleanupTask implements Task { public void run(){ System.out.println("Clean temp files"); } }

  public static void main(String[] args) {
    Task[] queue = { new EmailTask(), new ReportTask(), new CleanupTask() };
    for (int i = 0; i < queue.length; i = i + 1) {
      queue[i].run(); // same call, different behavior
    }
  }
}

Sprawdzenie wiedzy o interfejsach

Szybkie sprawdzenie: Dlaczego warto „programować względem interfejsu”?

Podsumowanie

Podsumowanie: Używanie typu interfejsowego jako parametru, typu zwracanego lub typu kolekcji zwiększa elastyczność kodu. Można zmieniać implementacje i szybko testować kod przy użyciu obiektów zastępczych.

Często zadawane pytania

Czy lekcja „Interfejsy w praktyce” jest bezpłatna?

Tak — pełny tekst „Interfejsy w praktyce” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Interfejsy w praktyce”?

Wykorzystają Państwo interfejsy jako typy, przekażą je do metod i łatwo zamienią implementacje. Przećwiczą Państwo niewielkie wzorce elastycznego kodu. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Interfejsy w praktyce”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy