From 489ab30620cdae3ffb3190c92c760da427265120 Mon Sep 17 00:00:00 2001 From: Krzysztof Smaga Date: Thu, 16 Jul 2026 12:19:17 +0200 Subject: [PATCH] Upload files to "/" --- ObiektowaTeoria.csproj | 10 +++++++ Program.cs | 24 ++++++++++++++++ README.md | 15 ++++++++++ abstrakcja_interfejsy.cs | 54 ++++++++++++++++++++++++++++++++++++ definicja_klas.cs | 25 +++++++++++++++++ dziedziczenie_polimorfizm.cs | 33 ++++++++++++++++++++++ hermetyzacja.cs | 42 ++++++++++++++++++++++++++++ konstruktor_dekonstruktor.cs | 41 +++++++++++++++++++++++++++ modifykatory.md | 15 ++++++++++ 9 files changed, 259 insertions(+) create mode 100644 ObiektowaTeoria.csproj create mode 100644 Program.cs create mode 100644 README.md create mode 100644 abstrakcja_interfejsy.cs create mode 100644 definicja_klas.cs create mode 100644 dziedziczenie_polimorfizm.cs create mode 100644 hermetyzacja.cs create mode 100644 konstruktor_dekonstruktor.cs create mode 100644 modifykatory.md diff --git a/ObiektowaTeoria.csproj b/ObiektowaTeoria.csproj new file mode 100644 index 0000000..fd4bd08 --- /dev/null +++ b/ObiektowaTeoria.csproj @@ -0,0 +1,10 @@ + + + + Exe + net9.0 + enable + enable + + + diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..b4b122c --- /dev/null +++ b/Program.cs @@ -0,0 +1,24 @@ +namespace ObiektowaTeoria +{ + public class Program + { + public static void Main(string[] args) + { + // Tworzenie obiektu klasy Samochod + Samochod samochod = new Samochod(); + samochod.Marka = "Renualt"; + samochod.RokProdukcji = 2007; + + // Wywołanie metody uruchomienia silnika + samochod.UruchomSilnik(); + samochod.UruchomSilnik(); // Próba ponownego uruchomienia silnika + + Zwierze zwierze = new Kot(); + zwierze.WydajDzwiek(); // Wywołanie metody przesłoniętej + + // Tworzenie obiektów klasy Pracownik przy użyciu różnych konstruktorów + Pracownik pracownik1 = new("Jan"); + Pracownik pracownik2 = new("Anna", "Kowalska"); + } + } +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..6239fb7 --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +# Obiektowa Teoria + +Repozytorium to przedstawia jak najprościej wyjaśnione elementy związane z programowaniem obiektowym. Każdy plik przedstawia dane zagadnienie: + +* **abstrakcja_interfejsy.cs** - tam znajdziemy wytłumaczenie zapisu Abstrakcji oraz Interfejsów. + +* **definicja_klas.cs** - zawiera ona zapis tworzenia nowej klasy wraz z polami i metodami oraz sposób jak tworzyć nowe obiekty z wykorzystaniem klasy naszej klasy; + +* **dziedziczenie_polimorfizm.cs** - zawiera ona tłumaczenie dot. pojęcia dziedziczenia oraz polimorfizmu w programowaniu obiektowym; + +* **hermetyzacja.cs** - przedstawia ona definicje hermetyzacji wraz z przykładem zapisu; + +* **konstruktor_dekonstruktor.cs** - definicja tłumacząca pojęcie wraz z przykładem konstruktora oraz dekonstruktora; + +* **modyfikatory.md** - opisuje wszystkie najważniejsze modyfikatory dostępu, które znajdziemy w pojęciu programowania obiektowego. diff --git a/abstrakcja_interfejsy.cs b/abstrakcja_interfejsy.cs new file mode 100644 index 0000000..8ff3c1d --- /dev/null +++ b/abstrakcja_interfejsy.cs @@ -0,0 +1,54 @@ +namespace ObiektowaTeoria +{ + // Klasa abstrakcyjna - a, która nie może być bezpośrednio + // zainstancjonowana (nie można tworzyć jej obiektów). Deklaruje się + // ją za pomocą słowa kluczowego za pomocą "abstract". Może zawierać zarówno + // metody abstrakcyjne (bez implementacji), jak i metody z implementacją. + // Służy jako szablon dla klas dziedziczących, zapewniając wspólny interfejs i + // bazową funkcjonalność. Klasy dziedziczące muszą implementować wszystkie metody + // abstrakcyjne. + public abstract class Figura + { + public abstract double Pole(); + } + + // Klasa dziedzicząca implementująca abstrakcyjną metodę + public class Kwadrat : Figura + { + public double Bok; + + public Kwadrat(double bok) + { + Bok = bok; + } + + public override double Pole() + { + return Bok * Bok; + } + } + + // Interfejs - czysty kontrakt, który definiuje metody i właściwości, ale nie zawiera ich implementacji. + // Definiuje się go za pomocą słowa kluczowego interface. Klasy implementujące interfejs muszą dostarczyć implementację + // wszystkich jego metod. Pozwala na tworzenie luźno powiązanych komponentów i ułatwia wielodziedziczenie zachowań. + public interface IRysowalny + { + void Rysuj(); + } + + // Klasa implementująca interfejs + public class Kolo : IRysowalny + { + public double Promien; + + public Kolo(double promien) + { + Promien = promien; + } + + public void Rysuj() + { + Console.WriteLine("Rysuję koło o promieniu " + Promien); + } + } +} \ No newline at end of file diff --git a/definicja_klas.cs b/definicja_klas.cs new file mode 100644 index 0000000..8c3777a --- /dev/null +++ b/definicja_klas.cs @@ -0,0 +1,25 @@ +namespace ObiektowaTeoria +{ + /** + * Definicja klasy Samochod + * Zobacz w pliku Program.cs:8 jak używać tej klasy + */ + + public class Samochod() { + // Pola klasy + public string Marka = ""; + public int RokProdukcji; + public bool StanSilnika = false; + + // Metoda klasy + public void UruchomSilnik() { + if (!StanSilnika) { + StanSilnika = true; + Console.WriteLine("Silnik uruchomiony."); + } else { + Console.WriteLine("Silnik jest już uruchomiony."); + } + } + } +} + diff --git a/dziedziczenie_polimorfizm.cs b/dziedziczenie_polimorfizm.cs new file mode 100644 index 0000000..10b886c --- /dev/null +++ b/dziedziczenie_polimorfizm.cs @@ -0,0 +1,33 @@ +namespace ObiektowaTeoria +{ + // Klasa bazowa + public class Zwierze + { + /* + virtual umieszczamy przy deklaracji metody w klasie bazowej, aby zaznaczyć, + że ta metoda może być nadpisana w klasach pochodnych. bez virtual metody nie + pozwalają na dynamiczne przesłonięcie. + */ + public virtual void WydajDzwiek() + { + Console.WriteLine("Zwierzę wydaje dźwięk."); + } + } + + // Klasa pochodna + public class Kot : Zwierze + { + /* + override używamy w klasie dziedziczącej, aby powiadomić kompilator oraz środowisko + uruchomieniowe, że metoda zamierzenie przesłania wersję metody wirtualnej z klasy bazowej. + Pozwala to na dynamiczne wywołanie właściwej dla konkretnego typu metody, nawet jeśli + odwołujemy się do obiektu przez zmienną typu bazowego. + */ + public override void WydajDzwiek() + { + Console.WriteLine("Miau"); + } + } + + // Zobacz plik Program.cs:16 jak używać tych klas +} \ No newline at end of file diff --git a/hermetyzacja.cs b/hermetyzacja.cs new file mode 100644 index 0000000..8acb26c --- /dev/null +++ b/hermetyzacja.cs @@ -0,0 +1,42 @@ +namespace ObiektowaTeoria +{ + public class KontoBankowe + { + /* + Hermetyzacja polega na ukrywaniu pól (zmiennych) i implementacji + klasy przez uczynienie ich niedostępnymi z zewnątrz. Pozwala to na ochronę + danych przed nieuprawnioną modyfikacją i zabezpieczenie integralności obiektu. + Użytkownik klasy operuje na niej tylko przez dostępne publiczne metody + (np. gettery/settery), które kontrolują sposób dostępu i zmiany danych. + */ + + // Prywatne pole przechowujące saldo konta + // inaczej pole hermetyzowane + private decimal saldo; + + // Publiczna właściwość z metodami dostępu + public decimal Saldo + { + get { return saldo; } + private set { saldo = value; } // modyfikacja salda tylko wewnątrz klasy + } + + public KontoBankowe(decimal poczatkoweSaldo) + { + saldo = poczatkoweSaldo; + } + + public void Wplac(decimal kwota) + { + if (kwota > 0) + saldo += kwota; + } + + public void Wyplac(decimal kwota) + { + if (kwota > 0 && kwota <= saldo) + saldo -= kwota; + } + } + +} \ No newline at end of file diff --git a/konstruktor_dekonstruktor.cs b/konstruktor_dekonstruktor.cs new file mode 100644 index 0000000..c3383fe --- /dev/null +++ b/konstruktor_dekonstruktor.cs @@ -0,0 +1,41 @@ +namespace ObiektowaTeoria +{ + // Definicja klasy Pracownik + // Zobacz w pliku Program.cs:20 jak używać tej klasy + public class Pracownik + { + public string Imie; + public string Nazwisko; + + // Konstruktor klasy - metoda, która ma taką samą nazwę jak klasa + // i jest wywoływana automatycznie w momencie tworzenia obiektu + // (przy użyciu słowa kluczowego new). Jego zadaniem jest inicjalizacja + // pól i właściwości obiektu, czyli nadanie mu początkowego stanu. + // Jeżeli nie zdefiniujemy żadnego konstruktora, kompilator doda + // konstruktor domyślny bez parametrów + + public Pracownik(string imie) + { + Imie = imie; + Nazwisko = "bez nazwiska"; + Console.WriteLine($"Konstruktor wywołany dla: {imie} bez nazwiska"); + } + + // Można tworzyć wiele konstruktorów z różną listą parametrów (przeciążanie konstruktorów) + public Pracownik(string imie, string nazwisko) + { + Imie = imie; + Nazwisko = nazwisko; + Console.WriteLine($"Konstruktor wywołany dla: {imie} {nazwisko}"); + } + + // Destruktor klasy - metoda wywoływana podczas usuwania obiektu z pamięci przez mechanizm + // zbierania śmieci (garbage collector). Umożliwia zwalnianie zasobów niezarządzanych (np. + // uchwytów do plików, połączeń sieciowych). Destruktor jest wywoływany w sposób niejawny i + // nie można jednoznacznie przewidzieć momentu jego wywołania. + ~Pracownik() + { + Console.WriteLine($"Destruktor wywołany dla: {Imie} {Nazwisko}"); + } + } +} \ No newline at end of file diff --git a/modifykatory.md b/modifykatory.md new file mode 100644 index 0000000..921ac43 --- /dev/null +++ b/modifykatory.md @@ -0,0 +1,15 @@ +# Modyfikatory dostępu + +Modyfikatory te określają, które części kodu mogą uzyskać dostęp do pól, właściwości lub metod klasy: + +* **public** – dostęp jest całkowicie otwarty, dowolny kod może odwołać się do takich elementów. + +* **private** – dostęp do elementu ograniczony jest tylko do wnętrza deklarującej go klasy; pola lub metody są niedostępne na zewnątrz. + +* **protected** – dostęp do elementu mają również klasy dziedziczące po klasie bazowej, ale nie inne klasy spoza hierarchii. + +* **internal** – dostęp ograniczony do bieżącego zestawu kompilacji (np. cały projekt/dll). + +* **protected internal** – łączone działanie protected oraz internal. + +* **private protected** – dostęp tylko w obrębie klasy i jej dziedziczących w tym samym zestawie