Jedná se o moderní metodiku vývoje softwaru, kterou podporuje většina programovacích jazyků jako jsou c#, c++.

Mělo by se používat vždy, ať už děláme malou utilitku nebo složitý databázový systém.

1. Třída
2. Instance
3. Vlastnosti
4. Zapouzdření
5. Modifikátory přístupu
6. Konstruktor a destruktor
   • Výchozí
   • Parametrizovaný
   • Kopírovací
   • Statický
   • Soukromý

S pojmem třída jsme se již také setkali, chápali jsme ji jako soubor příkazů. Třída však umožňuje mnohem více. Třída je VZOR , podle kterého se objekty vytváří. Definuje jejich vlastnosti a schopnosti

public class Person
{
    // Vlastnosti
    public int Age { get; set; }
    public string Name { get; set; }

    // Metoda
    public void WhatsMyName()
    {
        Console.WriteLine("My name is " + Name);
    }

    // Konstruktor
    public Person(string name,int age)
    {
        Name = name;
        Age = age;
    }
}
    

Objekt, který se vytvoří podle třídy, se nazývá INSTANCE. Instance mají stejné rozhraní jako třída, podle které se vytváří, ale navzájem se liší svými daty (atributy).
Jedná se datový typ, který je referenční.

Mějme příklad třídy Person, kterou jsme si definovali výše. Nyní si vytvoříme dvě instance této třídy. Josefa a Karela.

Person Josef = new Person("Josef", 15);
Person Karel = new Person("Karel", 16);

Console.WriteLine(Josef.Name); // Josef
Console.WriteLine(Karel.Name); // Karel

Console.WriteLine(Josef.Age); // 15
Console.WriteLine(Karel.Age); // 16

Person StejnyJosef = Josef; // Jedná se o referenci

StejnyJosef.Age += 1; 

Console.WriteLine(StejnyJosef.Name); // Josef
Console.WriteLine(StejnyJosef.Age); 
// 17, protože jsme přičetli 1 k referenci
    

Vlastnost je člen, který poskytuje flexibilní mechanismus pro čtení, zápis nebo výpočet hodnoty privátního pole. Vlastnosti se dají použít, jako by to byly veřejné datové členy, ale jedná se o speciální metody označované jako přístupové objekty. Tato funkce umožňuje snadný přístup k datům a stále pomáhá podporovat bezpečnost a flexibilitu metod.

//Nejlepsi možný zápis
public int Age { get; set; }


//Delší zápis nejlepšího zápisu
private int age;

public int Age
{
    get
    {
        return age;
    }
    set
    {
        age = value;
    }
}

// Dřívejší zápis proměnné (nepoužívat)
private int _age;

public void SetAge(int age)
{
    _age = age;
}

public int GetAge()
{
    return _age;
}



//Pouze čtení
public int Age { get; private set; }

//Pouze zápis
public int Age { private get; set; }

/*Init settery
Nelze ji mimo konstruktor změnit ani ve třídě, kde je definována.
Avšak lze ji měnit, když ji děláme jako Instanci třídy
*/
public int Age { get; init; }

Person Jaromir = new Person()
{
    Age = 15
};


/*
Pokud zapíšeme delším zápisem, můžeme udělat třeba nějakou kontrolu, nebo výpočet
*/

    
public int Age
{
    get
    {
        return age;
    }
    set
    {
        if(value > 18)
        {
            Console.WriteLine("Nemůžeš mít víc jak 18 let");
        }
        else
        {
            age = value;
        }
        throw new Exception("Nemůžeš mít víc jak 18 let");
    }
}

    

Způsob, jakým se skrývají vnitřní členy třídy před vnějším světem.
Zabezpečuje, že vnější svět nemůže změnit stav objektu, aniž by bylo možné kontrolovat změnu. užitečné pro bezpečnost a flexibilitu kódu.

základní vliv na platnost proměnné má její umístění v programu. Přesně řečeno její umístění vzhledem k begin a end ({ a }).
Tyto složené závorky neboli begin a end mají prostý význam. Označují vždy nějaký blok kódu a obecně platí, že deklarované proměnné platí pouze uvnitř tohoto a podřízených blocích tj. dalších blocích begin a end v něm vložených.

V jazyce C# existují čtyři přístupové operátory, které určují, jakým způsobem mohou být členy třídy přístupné z jiných částí programu

1. public - Členy třídy s tímto modifikátorem jsou přístupné z jakéhokoli místa v programu.
2. private - Členy třídy s tímto modifikátorem jsou přístupné pouze z této třídy.
3. protected - Členy třídy s tímto modifikátorem jsou přístupné z této třídy a z odvozených tříd.
4. internal - Členy třídy s tímto modifikátorem jsou přístupné pouze z těch částí programu, které jsou v rámci stejného sestavení

Přístupové operátory se používají k řízení přístupu k členům třídy, jako jsou proměnné, metody a vlastnosti. Přístupové operátory jsou důležité pro zachování bezpečnosti a správného fungování programu
Například:

    
        // public class:
        public class Tricycle
        {
            // protected method:
            protected void Pedal() { }

            // private field:
            private int _wheels = 3;

            // protected internal property:
            protected internal int Wheels
            {
                get { return _wheels; }
            }
        }
        
    

Konstruktor je metoda, která se volá, když je třída instancována. Konstruktor může mít parametry a může být více konstruktorů v jedné třídě. Konstruktor může mít modifikátory přístupu a výchozí je veřejný. Název konstruktoru je stejný jako název třídy.

Destruktor je metoda, která se volá, když objekt třídy přestane existovat. Destruktor nemůže mít parametry ani modifikátory přístupu. V jedné třídě může být pouze jeden destruktor. Název destruktoru je stejný jako název třídy, ale začíná tildou (~).

    
class Member
{
    // Konstruktor
    public Member()
    {
        Console.WriteLine("Default Constructor was called.");
    }
    
    // Destruktor
    ~Member()
    {
        Console.WriteLine("Destructor was called.");
    }
}
        
    

1. Výchozí
2. Parametrizovaný
3. Kopírovací
4. Statický
5. Soukromý

Konstruktor bez jakýchkoli parametrů se nazývá výchozí konstruktor. Pokud nevytvoříme konstruktor, třída automaticky zavolá výchozí konstruktor při vytváření objektu.

    
public class Customer
{
    public string firstName;
    public string lastName;

    public Customer()
    {
        // Výchozí konstruktor
    }
}
        
    

Konstruktor s alespoň jedním parametrem se nazývá parametrizovaný konstruktor1.

    
public class Customer
{
    public string firstName;
    public string lastName;

    public Customer(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    /* Pretizeni konstruktoru s tim,
     že se to pošle zpět do prvního konstruktoru 
     s parametry firstName a "stepan"
    */
    public Customer(string firstName) : this(firstName, "stepan")
    {

    }

    public Customer()
    {
    // Muže tu být kolik chce přetížených konstruktorů, ale musí mít jiný parametry 
    }
}
        
    

Konstruktor, který vytváří objekt kopírováním proměnných z jiného objektu, se nazývá kopírovací konstruktor.

    
public class Customer
{
    public string firstName;
    public string lastName;

    public Customer(Customer customer)
    {
        this.firstName = customer.firstName;
        this.lastName = customer.lastName;
    }
}
        
    

Statický konstruktor je konstruktor, který inicializuje statické členy typu. Statické konstruktory jsou bezparametrové.

    
public class Customer
{
    public static int customerCount;

    static Customer()
    {
        // Statický konstruktor
        customerCount = 0;
    }
}
        
    

Soukromý konstruktor je konstruktor, který má soukromý modifikátor přístupu. Používá se k omezení vytváření instancí třídy (Například singlton).

    
public class Singleton
{
    private static Singleton instance;

    private Singleton()
    {
        // Soukromý konstruktor
    }

    public static Singleton GetInstance()
    {
        if (instance == null)
        {
            instance = new Singleton();
        }
        return instance;
    }
}