C# tutorial | třídy a konstruktor

Třídy a konstruktory

V .NETu máme tyto druhy tříd:

1) Class

2) Abstract Class (někdy nazývané jako: Pure Virtual Class)

3) Partial Class

4) Sealed Class

5) Static Class

Abstract Class

Abstraktní třída znamená, že žádný objekt z této třídy nemůže být instantiován (vytvořen), ale můžeme provést dědičnost. Většinou používáme, když vytváříme Base třídy. Zadáváme pouze hlavičky metod. Nejedná se však o rozhraní! Rozdíl si povíme později.

Příklad:

abstract class myClass
{
    public myClass()
    {
		// kód...
    }

	abstract public void anyMethod_01();
	abstract public void anyMethod_02(int anyVariable);
	abstract public int anyMethod_03(int anyvariable);
}

Je nutné poznamenat, že abstraktní třídy mohou mít neabstraktní metody!

Příklad:

abstract class myclass
{
	public void nonAbstractMethod ()
	{
		// code…
	}
}

Tedy, abstraktní třída může být poděděna další abstraktní třídou. V této skutečnosti pak máme na výběr (ne nutně) implementovat metody z rodičovské třídy (base class).

Příklad:

// Base abstraktní třída
abstract class baseClass
{
	public abstract int addNumbers (int a, int b);
	public abstract int multiplyNumbers(int a, int b);
}

// zděděná abstraktní třída
abstract class derivedClass:baseClass
{
	// implementujeme metodu addnumbers
	public override int addnumbers(int a, int b) {
		return a+b;
	}
}

// a zdědíme normální třídu abstraktní třídou
class anyClass: derivedClass
{
	// imeplementujeme metodu multiplyNumbers
	public override int multiplyNumbers(int a, int b)
	{
		return a*b;
	}
}

Abstraktní třída zaměstnanec


using System;

// nadefinujeme si abstraktní třídu zaměstnance (obecný nadhled)
public abstract class Zamestnanec
{
  // protected proto, protože tyto proměnné budeme používat pouze u zděděného objektu
  protected string jmeno;
  protected string prijmeni;
  
  // abstraktní metoda, kterou budeme muset nadefinovat v odvozené třídě
  public abstract string GetPovolani();
  
  // metoda, která nám vrátí jméno zaměstnance
  public string GetJmeno()
  {
    return string.Format("{0}, {1}",jmeno,prijmeni);
  }
    
  // metoda, která nám nastaví jméno zaměstnance
  public void SetJmeno(string j, string p)
  {
    jmeno    = j;
    prijmeni = p;
  }
}

// zdědíme
public class Elektrikar : Zamestnanec
{
  // a předefinujeme povolání  
  public override string GetPovolani()
  {
    return ("Elektrikář");
  }
}

Partial Class

Speciální typ třídy se nazývá Partial Class. Je naimplementována s .NET Frameworkem 2.0. Partial class dovoluje rozdělit členy třídy na zdrojové soubory (.cs). V kompilační době se tyto soubory (.cs) zakombinují do jednotné třídy.

Příklad:

public partial class myPartialClass
{
	public void firstMethod()
	{
		// code…
	}
}

public partial class myPartialClass
{
	public void secondMethod()
	{
		// code…
	}
}

Sealed Class

Sealed třída nemůže být poděděna. Sealed třída nemůže být base třída. Modifikátor abstract nemůže být aplikován do sealed třídy. Je to tam poslední třída v hierarchii. Pro přístup k členům sealed třídy se musí vytvořit objekt této třídy.

Příklad:

sealed class mySealedClass
{
	int a;
	int b;
}

Class mainClass
{
	public static void Main()
	{
		mySealedClass obj = new mySealedClass();
		obj.a = 5;
		obj.b = 7;
		Console.WriteLine("a = {0}, b = {1}", obj.a, obj.b);
	}
}

Static Class

Statická třída nemůže být instantiována (tedy nelze vytvořit objekt). Klíčové slovo new nemůže být použito právě se statickou třídou. Statická třída má pouze statické členy. Statická třída je ve skutečnosti sealed, ale může být zdědena. Statická třída nemůže mít klasický konstruktor, pouze statický konstruktor.

Příklad:

// static třída definice
public static class myclass
{
	public static int addNumbers(int a, int b)
	{
		return (a + b);
	}
}

// pro statického použití, stačí zavolat pouze jméno třídy, tečku a jména metody
Console.WriteLine("The addition of 5 and 7 is: " + myClass.addNumbers(5, 7));

Klasické třídy a konstruktory

Když vytvoříme nový objekt operátorem new, příklad: jmenoTridy odkaz = new jmenoTridy();, tak vlastně zavoláme metodu, která se nazývá konstruktor. Konstruktor je tedy metoda, která má stejné jméno, jako třída.

Příklad:

using System;

public class MyClass
{
    private int prvniParametr;
    private float druhyParametr;

    // Konstruktorem nastavíme proměnné - tím zabezpečíme zapouzdření
    public MyClass(int _prvniParametr, float _druhyParametr)
    {
        this.prvniParametr = _prvniParametr;
        this.druhyParametr = _druhyParametr;
    }
    
    public void nejakaMetoda()
    {
        Console.WriteLine("Zde jsou obdržené parametry konstruktorem {0} a {1}", this.prvniParametr, this.druhyParametr);
    }
}

public class Tester
{
    // Metoda, která se po spuštění programu zavolá jako první
    static void Main()
    {
        int kolikLidi = 5;
        float pi = 3.141f;
        // Zavoláme konstruktor
        MyClass t = new MyClass(kolikLidi, pi);
        t.nejakaMetoda();
    } 
}

Ještě jednou konstruktor

Zde máme další ukázku konstruktoru:

using System;

public class Konstruktor
{
    // Implicitní konstruktor
    public Konstruktor()
    {
        Console.WriteLine("Vykuř prdel hadovi! (implicitní text)");
    }

    // Explicitní konstruktor se String parametrem (přetížený)
    public Konstruktor(string textik)
    {
        Console.WriteLine("Toto je tvůj text: {0} ", textik);
    }
    
    // Explicitní konstruktor s int parametrem (přetížený)
    public Konstruktor(int hodnota)
    {
        Console.WriteLine("Toto je tvoje hodnota: {0} ", hodnota);     
    }
}

public class Tester
{
    static void Main(string[] args)
    {
        // Co nám vypíše?
        Konstruktor k1 = new Konstruktor();
        // Co nám vypíše?
        Konstruktor k2 = new Konstruktor("Jelen");
        // Co nám vypíše?
        Konstruktor k3 = new Konstruktor(69);
    }
}

Další program na třídy v C# - jak na počet instancí

Někdy je potřeba spočítat, kolik máme objektů v paměti (nebo můžeme tomu říkat odborněji instance). Od toho nám slouží klíčové slovo static (uděláme statickou proměnnou). Pokaždé, když vytvoříme/adoptujeme novou kočku (použijeme operátor new), tak se nám jednoduše tato proměnná zvýší o jednu (vidíme tak v konstruktoru). Jak se tyto věci přesně volají (statické) můžeme vidět ve třídě Tester.

Příklad:

using System;

public class Cat
{
    private static int pocetInstanci = 0;

    public Cat()
    {
        pocetInstanci++;
    }

    public static void HowManyCats()
    {
        Console.WriteLine("{0}. kočka byla adoptována!", pocetInstanci);
    }
}

public class Tester
{
    static void Main()
    {
        // Zeptáme se kolik máme koček adoptovaných
        Cat.HowManyCats();
        // Adoptujeme novou kočku
        Cat.frisky = new Cat();
        // Zeptáme se kolik máme koček adoptovaných
        Cat.HowManyCats();
        // Adoptujeme novou kočku
        Cat.whiskers = new Cat();
        // Zeptáme se kolik máme koček adoptovaných
        Cat.HowManyCats();
    }
}