Upload files to "/"

ObiektowaTeoria.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

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");
+        }
+    }
+}

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.

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);
+        }
+    }
+}

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.");
+            }
+        }
+    }
+}
+

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
+}

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;
+        }
+    }
+
+}

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}");
+        }
+    }
+}

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