Sdílet prostřednictvím

Objektově orientované programování (C# a Visual Basic)

  • Článek

Všechny spravované jazyky v rozhraní .NET Framework, jako například Visual Basic a C#, poskytují úplnou podporu pro objektově orientované programování včetně zapouzdření, dědičnosti a polymorfismu.

Zapouzdření znamená, že skupina souvisejících vlastností, metod a dalších členů je považována za jednu jednotku nebo objekt.

Dědičnost popisuje schopnost vytvářet nové třídy na základě existující třídy.

Polymorfismus znamená, že můžete mít více tříd, které jsou zaměnitelné, i když každá třída implementuje stejné vlastnosti nebo metody různými způsoby.

Tato část popisuje následující pojmy:

  • Třídy a objekty

    • Členové třídy

      Vlastnosti a pole

      Metody

      Konstruktory

      Destruktory

      Události

      Vnořené třídy

    • Modifikátory přístupu a úrovně přístupu

    • Vytvoření instance třídy

    • Statické (sdílené) třídy a členové

    • Anonymní typy

  • Dědičnost

    • Obejití členů

  • Rozhraní

  • Obecné typy

  • Delegáti

Třídy a objekty

Podmínky třídy a objektu se někdy používají ke vzájemné záměně, ale ve skutečnosti třídy popisují typ objektů, zatímco objekty jsou použitelné instance tříd.Vytvoření objektu se nazývá vytváření instancí.Při použití analogie matric, třída je matricí, a objekt je vytvořen z této matrice.

Definování třídy:

Class SampleClass
End Class

class SampleClass
{
}

Oba jazyky Visual Basic a C# také poskytují jednodušší verzi tříd pojmenovanou struktury, které jsou užitečné, pokud je zapotřebí vytvořit velké pole objektů a nechcete k tomu spotřebovat příliš mnoho paměti.

Definování struktury:

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Další informace naleznete v části:

Členové třídy

Každá třída může mít různé členy třídy obsahující vlastnosti, které popisují data třídy, metody, které určují chování třídy a události, které umožňují komunikaci mezi různými třídami a objekty.

Vlastnosti a pole

Pole a vlastnosti představují informace, které obsahuje objekt.Pole jsou jako proměnné, protože mohou být čtena nebo nastavena přímo.

Definování pole:

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

Vlastnosti využívají postupy get a set, které poskytují větší kontrolu toho, jak jsou hodnoty nastaveny nebo vráceny.

Jazyky C# i Visual Basic umožňují buď vytvořit soukromé pole k uložení hodnoty vlastnosti nebo použít takzvané automaticky implementované vlastnosti, které toto pole vytvoří automaticky na pozadí a poskytnou základní logiku operací s vlastností.

Chcete-li definovat automaticky implementovanou vlastnost:

Class SampleClass
    Public Property SampleProperty as String
End Class

class SampleClass
{
    public int SampleProperty { get; set; }
}

Pokud je třeba provést některé další operace čtení a zápisu hodnoty vlastnosti, definujte pole pro uložení hodnoty vlastnosti a poskytněte základní logiku pro jeho ukládání a načítání:

Class Samplelass
    Private m_Sample As String
    Public Property Sample() As String
        Get
            ' Return the value stored in the field.
            Return m_Sample
        End Get
        Set(ByVal Value As String)
            ' Store the value in the field.
            m_Sample = Value
        End Set
    End Property
End Class

class SampleClass
{
    private int _sample;
    public int Sample
    {
        // Return the value stored in a field.
        get { return _sample; }
        // Store the value in the field.
        set { _sample = value; }
    }
}

Většina vlastností má metody nebo postupy, jak nastavit a získat hodnotu vlastnosti.Můžete však vytvořit vlastnosti jen pro čtení nebo jen pro zápis, abyste omezili je číst nebo upravovat.V jazyce Visual Basic můžete použít klíčová slova ReadOnly a WriteOnly.V jazyce C# můžete vynechat metodu vlastnosti get nebo set.V jazyce Visual Basic i C# však automaticky implementované vlastnosti nemohou být jen pro čtení nebo jen pro zápis.

Další informace naleznete v části:

Metody

Metoda je akce, kterou může objekt provádět.

[!POZNÁMKA]

V jazyce Visual Basic existují dva způsoby, jak vytvořit metodu: příkaz Sub se používá, pokud metoda nevrací hodnotu a příkaz Function se používá, pokud metoda hodnotu vrátí.

Chcete-li definovat metodu pro třídu:

Class SampleClass
    Public Function SampleFunc(ByVal SampleParam As String)
        ' Add code here
    End Function
End Class

class SampleClass
{
    public int sampleMethod(string sampleParam)
    {
        // Insert code here
    }
}

Třída může mít několik implementací, případně přetížení, stejné metody, které se liší v počtu parametrů nebo typů parametrů.

Chcete-li přetížit metodu:

Overloads Sub Display(ByVal theChar As Char)
    ' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
    ' Add code that displays Integer data.
End Sub

public int sampleMethod(string sampleParam) {};
public int sampleMethod(int sampleParam) {}

Ve většině případů deklarujete metodu v rámci definice třídy.Visual Basic a C# však také podporují rozšiřující metody, který umožňují přidat metody do existující třídy mimo skutečnou definici třídy.

Další informace naleznete v části:

Konstruktory

Konstruktory jsou metody třídy, které jsou spouštěny automaticky, když je vytvořen objekt daného typu.Konstruktory obvykle inicializují datové členy nového objektu.Konstruktor lze spustit pouze jednou při vytvoření třídy.Kromě toho kód v konstruktoru se vždy spouští před ostatním kódem ve třídě.Můžete však vytvořit více přetížení konstruktoru stejným způsobem jako u jakékoli jiné metody.

Chcete-li definovat konstruktor pro třídu:

Class SampleClass
    Sub New(ByVal s As String)
        // Add code here.
    End Sub
End Class

public class SampleClass
{
    public SampleClass()
    {
        // Add code here
    }
}

Další informace naleznete v části:

Destruktory

Destruktory se používají k destrukci instancí tříd.V rozhraní .NET Framework automaticky systém uvolňování paměti spravuje přidělování a uvolňování paměti pro spravované objekty ve vaší aplikaci.Můžete však stále potřebovat destruktory pro vyčištění všech nespravovaných prostředků, které vytvoří aplikace.Může existovat pouze jeden destruktor třídy.

Další informace o destruktorech a uvolňování paměti v rozhraní .NET Framework naleznete v tématu Uvolňování paměti.

Události

Události umožňují třídám nebo objektům upozornit ostatní třídy nebo objekty, když dojde k něčemu, co je pro ně zajímavé.Třída, která pošle (nebo vyvolává) událost, je nazývána vydavatel a třídy, které událost přijímají (nebo zpracování), se nazývají účastníci.Další informace o událostech, jejich vyvolávání a zpracování viz Zpracování a generování událostí.

Vnořené třídy

Třída definována v rámci jiné třídy se nazývá vnořená.Standardně je vnořená třída soukromá.

Class Container
    Class Nested
    ' Add code here.
    End Class
End Class

class Container
{
    class Nested
    {
        // Add code here.
    }
}

Chcete-li vytvořit instanci vnořené třídy, použijte název třídy kontejneru následovaného tečkou a pak následovaného názvem vnořené třídy:

Dim nestedInstance As Container.Nested = New Container.Nested()

Container.Nested nestedInstance = new Container.Nested()

Modifikátory přístupu a úrovně přístupu

Všechny třídy a členy tříd mohou určovat, jakou úroveň přístupu poskytují dalším třídám, pomocí modifikátorů přístupu.

K dispozici jsou následující modifikátory přístupu:

Visual Basic modifikátor

Modifikátor C#

Definice

Public (Visual Basic)

public

Tento typ nebo člen je přístupný libovolnému jinému kódu ve stejném sestavení nebo libovolnému sestavení která na něj odkazuje.

Private (Visual Basic)

private

Tento typ nebo člen je přístupný pouze pomocí kódu ve stejné třídě.

Protected (Visual Basic)

chráněno

Tento typ nebo člen je přístupný pouze kódu ve stejné třídě nebo v odvozené třídě.

Friend (Visual Basic)

vnitřní

Tento typ nebo člen je přístupný libovolnému kódu ve stejném sestavení, nikoli však z jiného sestavení.

Protected Friend

protected internal

Tento typ nebo člen je přístupný libovolnému kódu ve stejném sestavení, nebo kterékoli odvozené třídě v jiném sestavení.

Další informace naleznete v tématu Úrovně přístupu v jazyce Visual Basic a Modifikátory přístupu (Průvodce programováním v C#).

Vytvoření instance třídy

K vytvoření objektu je nutné iniciovat instanci třídy, nebo vytvořit instanci třídy.

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Po vytvoření instance třídy můžete přiřadit hodnoty vlastnostem a polím instance a volat metody třídy.

' Set a property value.
sampleObject.SampleProperty = "Sample String"
' Call a method.
sampleObject.SampleMethod()

// Set a property value.
sampleObject.sampleProperty = "Sample String";
// Call a method.
sampleObject.sampleMethod();

Chcete-li přiřadit hodnoty vlastností během procesu vytváření instance třídy, použijte inicializátory objektů:

Dim sampleObject = New SampleClass With 
    {.FirstProperty = "A", .SecondProperty = "B"}

// Set a property value.
SampleClass sampleObject = new SampleClass 
    { FirstProperty = "A", SecondProperty = "B" };

Další informace naleznete v části:

Statické (sdílené) třídy a členové

Statický (sdílený v jazyce Visual Basic) člen třídy je vlastnost, procedura nebo pole, které jsou sdíleny všemi instancemi třídy.

Chcete-li definovat statický (sdílený) člen:

Class SampleClass
    Public Shared SampleString As String = "Sample String"
End Class

static class SampleClass
{
    public static string SampleString = "Sample String";
}

Pro přístup ke statickému členu (sdílenému) použijte název třídy bez vytvoření objektů této třídy:

MsgBox(SampleClass.SampleString)

Console.WriteLine(SampleClass.SampleString);

Statické (sdílené) třídy v jazyce C# a moduly v jazyce Visual Basic mají pouze statické (sdílené) členy a nelze pro ně vytvořit instanci.Statičtí (sdílené) členové zároveň nemohou získat přístup k nestatickým (nesdíleným) vlastnostem, polím nebo metodám

Další informace naleznete v části:

Anonymní typy

Anonymní typy umožňují vytvářet objekty bez psaní definice třídy pro datový typ.Namísto toho kompilátor pro vás vygeneruje třídu.Třída nemá žádný použitelný název a obsahuje vlastnosti, které jste zadali v rámci deklarace objektu.

Chcete-li vytvořit instanci anonymního typu:

' sampleObject is an instance of a simple anonymous type.
Dim sampleObject = 
    New With {Key .FirstProperty = "A", .SecondProperty = "B"}

// sampleObject is an instance of a simple anonymous type.
var sampleObject = 
    new { FirstProperty = "A", SecondProperty = "B" };

Další informace naleznete v části:

Dědičnost

Dědičnost umožňuje vytvořit novou třídu, která opakovaně používá, rozšiřuje a upravuje chování, které je definováno v jiné třídě.Třídy, jejíž členové jsou zdědění, se nazývají základní třídy, a třídy, která dědí tyto členy, se nazývají odvozené třídy.Nicméně všechny třídy v jazyce C# a Visual Basic implicitně dědí z třídy Object, která podporuje hierarchii tříd .NET a poskytuje služby nižší úrovně všem třídám.

[!POZNÁMKA]

Spravované jazyky v rozhraní .NET Framework nepodporují vícenásobnou dědičnost, tj. můžete zadat pouze jednu základní třídu odvozené třídy.

Chcete-li dědit ze základní třídy:

Class DerivedClass
    Inherits BaseClass
End Class

class DerivedClass:BaseClass{}

Ve výchozím nastavení mohou být všechny třídy děděny.Můžete však určit, zda třída nesmí být použita jako základní třída, nebo vytvořit třídu, která může být použita pouze jako základní třída.

Určení, zda třídu nelze použít jako základní třídu:

NotInheritable Class SampleClass
End Class

public sealed class A { }

Určení, zda třídu lze použít jako základní třídu a nelze vytvořit instanci:

MustInherit Class BaseClass
End Class

public abstract class B { }

Další informace naleznete v části:

Obejití členů

Ve výchozím nastavení dědí odvozená třída všechny členy své základní třídy.Pokud chcete změnit chování zděděného člena, musíte ho potlačit.To znamená, že můžete definovat novou implementaci metody, vlastnosti nebo události v odvozené třídě.

Následující modifikátory umožňují určit, jak přepsat vlastnosti a metody:

Visual Basic modifikátor

Modifikátor C#

Definice

Overridable (Visual Basic)

virtual (Referenční dokumentace jazyka C#)

Povoluje, aby byl člen třídy přepsán v odvozené třídě.

Overrides (Visual Basic)

override (Referenční dokumentace jazyka C#)

Obejde virtuálního člena (s možností přepsání) definovaného v základní třídě.

NotOverridable (Visual Basic)

Není podporováno

Zabrání přepsání člena v dědičné třídě.

MustOverride (Visual Basic)

abstract (Referenční dokumentace jazyka C#)

Vyžaduje, aby byl člen třídy přepsán v odvozené třídě.

Shadows (Visual Basic)

new – modifikátor (Referenční dokumentace jazyka C#)

Skryje člena zděděného ze základní třídy

Rozhraní

Rozhraní jako např. třídy definují sadu vlastností, metody a události.Ale na rozdíl od tříd, rozhraní neposkytují implementace.Jsou implementované třídami a definovány jako samostatné subjekty ze tříd.Rozhraní představuje smlouvu v tom smyslu, že třída, která implementuje rozhraní, musí implementovat všechny aspekty tohoto rozhraní přesně, jak jsou definovány.

Definování rozhraní:

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

interface ISampleInterface
{
    void doSomething();
}

Chcete-li implementovat rozhraní ve třídě:

Class SampleClass
    Implements ISampleInterface
    Sub DoSomething
        ' Method implementation.
    End Sub
End Class

class SampleClass : ISampleInterface
{
    void ISampleInterface.doSomething()
    {
        // Method implementation.
    }
}

Další informace naleznete v části:

Obecné typy

Třídy, struktury, rozhraní a metody v rozhraní .NET Framework mohou typovat parametry, které definují typy objektů, které lze uložit nebo použít.Nejběžnějším příkladem obecných typů je kolekce, kde můžete zadat typ objektů, které mají být uloženy v kolekci.

Chcete-li definovat obecnou třídu:

Class SampleGeneric(Of T)
    Public Field As T
End Class

Public class SampleGeneric<T> 
{
    public T Field;
}

Vytvoření instance generické třídy:

Dim sampleObject As New SampleGeneric(Of String)
sampleObject.Field = "Sample string"

SampleGeneric<string> sampleObject = new SampleGeneric<string>();
sampleObject.Field = "Sample string";

Další informace naleznete v části:

Delegáti

Delegát je typ, který definuje podpis metody a může poskytnout odkaz na jakoukoli metodu s kompatibilním podpisem.Můžete vyvolat (nebo volat) metodu prostřednictvím delegáta.Delegáti se používají pro předávání metod jako argumentů jiných metod.

[!POZNÁMKA]

Obslužné rutiny události nejsou nic jiného než metody, které jsou vyvolány prostřednictvím delegátů.Další informace o použití delegátů při zpracování událostí naleznete v tématu Zpracování a generování událostí.

Vytvoření delegáta:

Delegate Sub SampleDelegate(ByVal str As String)

public delegate void SampleDelegate(string str);

Tvorba odkazu na metodu, která odpovídá podpisu zadanému delegátem:

Class SampleClass
    ' Method that matches the SampleDelegate signature.
    Sub SampleSub(ByVal str As String)
        ' Add code here.
    End Sub
    ' Method that instantiates the delegate.
    Sub SampleDelegateSub()
        Dim sd As SampleDelegate = AddressOf SampleSub
        sd("Sample string")
    End Sub
End Class

class SampleClass
{
    // Method that matches the SampleDelegate signature.
    public static void sampleMethod(string message)
    {
        // Add code here.
    }
    // Method that instantiates the delegate.
    void SampleDelegate()
    {
        SampleDelegate sd = sampleMethod;
        sd("Sample string");
    }
}

Další informace naleznete v části:

Viz také

Koncepty

Průvodce programováním v C#

Další zdroje

Příručka k programování v jazyce Visual Basic