Paradygmaty programowania

// IMPERATYWNIE - opisuję każdy krok
int[] liczby = {4, 7, 10, 3, 8};
int suma = 0;
for (int i = 0; i < liczby.length; i++) {
  if (liczby[i] % 2 == 0) {
      suma = suma + liczby[i];
  }
}
System.out.println(suma);   // 22

// DEKLARATYWNIE (styl funkcyjny) - opisuję warunek i wynik
int suma2 = Arrays.stream(liczby)
                .filter(n -> n % 2 == 0)
                .sum();

-- DEKLARATYWNIE w SQL - nie ma słowa o pętli
SELECT SUM(wartosc) FROM liczby WHERE wartosc % 2 = 0;

// SEKWENCJA
double brutto = 6000;
double skladki = brutto * 0.1371;
double podstawa = brutto - skladki;

// WYBOR
if (podstawa <= 10000) {
  System.out.println("Pierwszy prog podatkowy");
} else {
  System.out.println("Drugi prog podatkowy");
}

// ITERACJA - wyplaty za 12 miesiecy
double rocznie = 0;
for (int miesiac = 1; miesiac <= 12; miesiac++) {
  rocznie += podstawa;
}

// ITERACJA z warunkiem sprawdzanym PO wykonaniu - zawsze min. 1 przebieg
int proba = 0;
do {
  proba++;
} while (proba < 3);

// PRZED: jeden wielki blok, wszystko wymieszane
double brutto = 6000, godziny = 168, stawka = 40;
double wyplata = brutto + godziny * stawka * 0.5;
System.out.println("Do wyplaty: " + wyplata + " zl");

// PO: podzial na podprogramy - kazdy robi jedna rzecz
static double policzNadgodziny(double godziny, double stawka) {
  return godziny * stawka * 0.5;          // funkcja - zwraca wartosc
}

static void wypisz(String opis, double kwota) {
  System.out.println(opis + ": " + kwota + " zl");   // procedura - void
}

public static void main(String[] args) {
  double wyplata = 6000 + policzNadgodziny(168, 40);
  wypisz("Do wyplaty", wyplata);
}

public class Pracownik {

  // POLA (atrybuty, składowe) - opisują stan obiektu
  private String imie;
  private String nazwisko;
  private double pensjaPodstawowa;
  private static int licznikPracownikow = 0;   // pole klasy, wspólne dla wszystkich

  // KONSTRUKTOR - nazwa taka jak klasy, bez typu zwracanego
  public Pracownik(String imie, String nazwisko, double pensjaPodstawowa) {
      this.imie = imie;                  // this = "ten konkretny obiekt"
      this.nazwisko = nazwisko;
      this.pensjaPodstawowa = pensjaPodstawowa;
      licznikPracownikow++;
  }

  // KONSTRUKTOR PRZECIĄŻONY - inna lista parametrów
  public Pracownik(String imie, String nazwisko) {
      this(imie, nazwisko, 4666.0);      // wywołanie innego konstruktora
  }

  // METODY - opisują zachowanie obiektu
  public double obliczWynagrodzenie() {
      return pensjaPodstawowa;
  }

  public String opis() {
      return imie + " " + nazwisko + ", wynagrodzenie: " + obliczWynagrodzenie();
  }
}

// TWORZENIE OBIEKTÓW - operator new wywołuje konstruktor
Pracownik p1 = new Pracownik("Anna", "Kowalska", 7200);
Pracownik p2 = new Pracownik("Jan", "Nowak");        // pensja domyślna 4666

System.out.println(p1.opis());   // Anna Kowalska, wynagrodzenie: 7200.0
System.out.println(p2.opis());   // Jan Nowak, wynagrodzenie: 4666.0
// p1 i p2 to DWA obiekty jednej klasy - mają własne kopie pól,
// ale współdzielą pole statyczne licznikPracownikow (teraz = 2)

// TEN SAM MECHANIZM W C++ - z destruktorem i wskaźnikiem this
class Pracownik {
private:
  std::string imie;
  double pensjaPodstawowa;

public:
  Pracownik(std::string imie, double pensja) {      // KONSTRUKTOR
      this->imie = imie;
      this->pensjaPodstawowa = pensja;
      std::cout << "Tworze obiekt: " << imie << std::endl;
  }

  ~Pracownik() {                                    // DESTRUKTOR (tylda + nazwa klasy)
      std::cout << "Niszcze obiekt: " << imie << std::endl;
  }

  double obliczWynagrodzenie() { return pensjaPodstawowa; }
};

int main() {
  Pracownik p("Anna", 7200);     // obiekt na stosie - destruktor wywoła się sam
  Pracownik* q = new Pracownik("Jan", 4666);
  delete q;                      // obiekt na stercie - destruktor TYLKO po delete
  return 0;
}

public class Pracownik {
  private String imie;              // ukryte przed swiatem
  protected double pensjaPodstawowa; // widoczne dla klas pochodnych
  private static final double MINIMALNA = 4666.0;

  public Pracownik(String imie, double pensja) {
      this.imie = imie;
      setPensjaPodstawowa(pensja);   // walidacja juz w konstruktorze
  }

  // GETTER - tylko odczyt, brak parametrow, zwraca wartosc pola
  public String getImie() {
      return imie;
  }

  public double getPensjaPodstawowa() {
      return pensjaPodstawowa;
  }

  // SETTER - zapis Z WALIDACJA, typ void, jeden parametr
  public void setPensjaPodstawowa(double pensja) {
      if (pensja < MINIMALNA) {
          throw new IllegalArgumentException("Pensja ponizej minimalnej krajowej");
      }
      this.pensjaPodstawowa = pensja;
  }
}

// Proba obejscia hermetyzacji:
Pracownik p = new Pracownik("Anna", 7200);
// p.pensjaPodstawowa = -500;   // BLAD KOMPILACJI - pole nie jest public
p.setPensjaPodstawowa(-500);    // wyjatek w czasie wykonania - obiekt sie broni

public class Programista extends Pracownik {

  private String jezykGlowny;      // POLE WŁASNE klasy pochodnej

  public Programista(String imie, double pensja, String jezykGlowny) {
      super(imie, pensja);         // WYWOŁANIE KONSTRUKTORA KLASY BAZOWEJ
      this.jezykGlowny = jezykGlowny;   // musi być PIERWSZĄ instrukcją
  }

  public String getJezykGlowny() {
      return jezykGlowny;
  }

  public void przeglądKodu() {      // METODA WŁASNA - Pracownik jej nie ma
      System.out.println("Recenzuję kod w " + jezykGlowny);
  }
}

public class Menedzer extends Pracownik {
  private int liczbaPodwladnych;

  public Menedzer(String imie, double pensja, int liczbaPodwladnych) {
      super(imie, pensja);
      this.liczbaPodwladnych = liczbaPodwladnych;
  }

  public int getLiczbaPodwladnych() { return liczbaPodwladnych; }
}

// KLASA BAZOWA - wersja domyślna metody
public class Pracownik {
  protected String imie;
  protected double pensjaPodstawowa;

  public double obliczWynagrodzenie() {
      return pensjaPodstawowa;
  }
}

// PRZESŁONIĘCIE (override): ta sama nazwa, te same parametry, inna treść
public class Programista extends Pracownik {
  private int liczbaNadgodzin;

  @Override
  public double obliczWynagrodzenie() {
      return super.obliczWynagrodzenie() + liczbaNadgodzin * 80.0;
  }
}

public class Menedzer extends Pracownik {
  private int liczbaPodwladnych;

  @Override
  public double obliczWynagrodzenie() {
      return pensjaPodstawowa * 1.2 + liczbaPodwladnych * 150.0;
  }
}

// POLIMORFIZM W AKCJI - jedna tablica, jedna pętla, trzy różne wyniki
Pracownik[] zespol = {
  new Pracownik("Anna",  5000),
  new Programista("Jan", 6000, 10),
  new Menedzer("Ewa",    8000, 4)
};

double kosztFirmy = 0;
for (Pracownik p : zespol) {
  System.out.println(p.imie + ": " + p.obliczWynagrodzenie());
  kosztFirmy += p.obliczWynagrodzenie();
}

// Anna: 5000.0            -> wersja z klasy Pracownik
// Jan:  6800.0            -> 6000 + 10 * 80,  wersja z klasy Programista
// Ewa:  10200.0           -> 8000 * 1.2 + 4 * 150, wersja z klasy Menedzer
// kosztFirmy = 22000.0

// Kluczowe: typ ZMIENNEJ to Pracownik, ale wykonuje się metoda
// z klasy OBIEKTU. To jest późne wiązanie (dynamiczne, w czasie wykonania).

// PRZECIĄŻANIE - trzy metody o tej samej nazwie, różne parametry.
// Kompilator wybiera wersję po TYPACH ARGUMENTÓW, już podczas kompilacji.
public class Kalkulator {
  public int dodaj(int a, int b)             { return a + b; }
  public double dodaj(double a, double b)    { return a + b; }
  public int dodaj(int a, int b, int c)      { return a + b + c; }

  // BŁĄD KOMPILACJI - sam typ zwracany nie odróżnia przeciążeń:
  // public double dodaj(int a, int b) { return a + b; }
}

Kalkulator k = new Kalkulator();
k.dodaj(2, 3);         // 5    -> wersja (int, int)
k.dodaj(2.5, 3.5);     // 6.0  -> wersja (double, double)
k.dodaj(1, 2, 3);      // 6    -> wersja (int, int, int)

// C++ - BEZ virtual NIE MA POLIMORFIZMU. Klasyczna pułapka.
class Pracownik {
protected:
  double pensja;
public:
  Pracownik(double p) : pensja(p) {}
  virtual double obliczWynagrodzenie() { return pensja; }   // METODA WIRTUALNA
  virtual ~Pracownik() {}                 // destruktor bazowy TEŻ wirtualny
};

class Menedzer : public Pracownik {
public:
  Menedzer(double p) : Pracownik(p) {}
  double obliczWynagrodzenie() override { return pensja * 1.2; }
};

Pracownik* p = new Menedzer(8000);
std::cout << p->obliczWynagrodzenie();   // 9600 - bo metoda jest virtual
                                       // bez virtual byłoby 8000 (wiązanie statyczne)
delete p;                                // wirtualny destruktor -> sprząta CAŁY obiekt

// KLASA ABSTRAKCYJNA - nie da się z niej utworzyć obiektu
public abstract class Pracownik {
  protected String imie;
  protected double pensjaPodstawowa;      // POLA - klasa abstrakcyjna je ma

  public Pracownik(String imie, double pensja) {   // KONSTRUKTOR - też ma
      this.imie = imie;
      this.pensjaPodstawowa = pensja;
  }

  // METODA ABSTRAKCYJNA - sama deklaracja, bez ciała, zakończona średnikiem.
  // Każda klasa pochodna MUSI ją zaimplementować.
  public abstract double obliczWynagrodzenie();

  // METODA ZWYKŁA - z gotową implementacją, dziedziczona bez zmian
  public String opis() {
      return imie + ": " + obliczWynagrodzenie() + " zl";
  }
}

// Pracownik p = new Pracownik("Anna", 5000);   // BŁĄD KOMPILACJI!
Pracownik p = new Programista("Jan", 6000, 10); // OK - obiekt klasy konkretnej

// INTERFEJS - kontrakt, czysty zbiór metod bez stanu
public interface Premiowalny {
  double STAWKA_PREMII = 0.10;      // pola tylko public static final (stałe)
  double obliczPremie();            // metody domyślnie public abstract
}

public interface Szkolacy {
  void przeprowadzSzkolenie(String temat);
}

// JEDNA klasa bazowa + DOWOLNIE WIELE interfejsów
public class Menedzer extends Pracownik implements Premiowalny, Szkolacy {

  private int liczbaPodwladnych;

  public Menedzer(String imie, double pensja, int podwladni) {
      super(imie, pensja);
      this.liczbaPodwladnych = podwladni;
  }

  @Override
  public double obliczWynagrodzenie() {          // z klasy abstrakcyjnej
      return pensjaPodstawowa * 1.2 + obliczPremie();
  }

  @Override
  public double obliczPremie() {                 // z interfejsu Premiowalny
      return pensjaPodstawowa * STAWKA_PREMII * liczbaPodwladnych;
  }

  @Override
  public void przeprowadzSzkolenie(String temat) {   // z interfejsu Szkolacy
      System.out.println(imie + " prowadzi szkolenie: " + temat);
  }
}

// KOMPOZYCJA - Umowa powstaje WEWNĄTRZ Pracownika i ginie razem z nim
public class Pracownik {
  private Umowa umowa;

  public Pracownik(String rodzajUmowy, double stawka) {
      this.umowa = new Umowa(rodzajUmowy, stawka);   // tworzone w środku
  }
}

// AGREGACJA - Zespół dostaje gotowych pracowników z zewnątrz;
// po usunięciu zespołu obiekty Pracownik nadal istnieją
public class Zespol {
  private List<Pracownik> czlonkowie;

  public Zespol(List<Pracownik> czlonkowie) {
      this.czlonkowie = czlonkowie;                  // przekazane z zewnątrz
  }
}

// ASOCJACJA - obiekt tylko chwilowo korzysta z innego obiektu
public class Programista extends Pracownik {
  public void wypisz(Drukarka d, String dokument) {
      d.drukuj(dokument);        // zna Drukarkę, ale jej nie posiada
  }
}

// STYL FUNKCYJNY w Javie - lambda + strumień, zero pętli i zmiennych pomocniczych
List<Pracownik> zespol = List.of(
      new Programista("Jan", 6000, 10),
      new Menedzer("Ewa", 8000, 4));

double kosztFirmy = zespol.stream()
      .mapToDouble(Pracownik::obliczWynagrodzenie)   // map
      .sum();                                        // reduce

List<String> dobrzeOplacani = zespol.stream()
      .filter(p -> p.obliczWynagrodzenie() > 7000)    // filter
      .map(Pracownik::getImie)
      .toList();

// STYL ZDARZENIOWY - rejestruję procedurę obsługi, nie wywołuję jej sam
przyciskZapisz.addActionListener(e -> {
  kadry.zapisz(zespol);
  System.out.println("Zapisano " + zespol.size() + " pracownikow");
});
// Kod w nawiasach wykona się dopiero wtedy, gdy użytkownik kliknie przycisk.