Obiekty: co i jak

Obiekty:
co i jak
Wykonał:
Piotr Pięda
dla koła naukowego KNI
Co to jest klasa
Klasa definuje nowy typ, na jej podstawie budujemy obiekty. Można
powiedzieć że jest swego rodzaju matryca dzięki której tworzymy obiekt.
Klasa posiada swoje pola i metody, może także dziedziczyć pola i metody
po innych klasach. Klasa może także występować w formie uproszczonej
Po prawej widzimy przykładową klasę w języku C# z wyszczególnionym,
konstruktorem, polami i metodami.
Modyfikatory dostępu
Protected - Oznacza że takie elementy będą dostępne dla danej
klasy oraz na potrzeby klas dziedziczonych. Nie będą natomiast
widoczne na zewnątrz klasy
Public - Oznacza że elementy stają się elementami publicznymi,
dostępnymi na zewnątrz klasy. Inne klasy będą mogły odwoływać
się do owych elementów
Private - Elementy z tym modyfikatorem będą oznaczone jako
prywatne, a dostęp do nich z poza klasy, będzie niemożliwy.
Internal - Elementy z tym modyfikatorem są dostępne tylko z
wnętrza złożenia, w którym nastąpiła ich deklaracja (podczas
kompilacji pliki .cs z kodem źródłowym programu są kompilowane
w moduły, zgodnie z podziałem na przestrzenie nazw, a następnie
grupowane w złożenia, ang. assembly)
protected internal - Element zadeklarowana z takim rodzajem
dostępu jest widoczna z wnętrza klasy, w której została
zadeklarowany (lub klasy pochodnej od niej) oraz z wnętrza
złożenia, w którym się znajduje.
Obiekt
Sama klasa nic jeszcze nam nie daje, musimy zadeklarować element takiej klasy.
Obiekt budujemy zgodnie z konstruktorem podając w nawiasie() konieczne wartości,
jeśli klasa nie posiada konstruktora to znaczy ze pozostawiamy nawias pusty.
Na obiekcie wywołujemy także pewne metody zadeklarowane w klasie metody o ile
pozwala na to jej modyfikator dostępu.
Możemy także uzyskać dostęp do pól naszych metod o ile pozwala na to
modyfikator dostępu.
Mając klasę z poprzedniego przykładu tworzymy więc obiekt i trochę go przerabiamy
static void Main(string[] args)
{
PierwszaKlasa pr = new PierwszaKlasa(2,2); //deklarujemy obiet o nazwie pr
pr.WyswietlAB(); // wywołujemy metodę dla obiektu
System.Console.ReadKey(); // pauza
pr.a = 3; // Uzyskujemy dostęp do pola „a”
pr.WyswietlAB(); // ponownie wyświetlamy
System.Console.ReadKey();
}
Metody tak samo jak konstruktor mogą wymagać podania
pewnych parametrów, i ich właściwa budowa bardzo
przypomina budowę konstruktora z tym że metoda może
zwracać jakąś wartość np. jeśli dopiszemy do naszej klasy
następującą metodę.
public int Dodaj(int d) // zamiast void podajemy typ zwracany
{
a = a + d;
b = b + d;
d = a + b;
return d; // wyrażenie zwraca wartość zmiennej d
}
To widzimy że powiększa ona wartości w polach a i b oraz
zwraca ich sumę, czyli można traktować ją jako argument.
Istnieją w języku pola i metody statyczne deklarowane z użyciem słowa
kluczowego static. Do metod statycznych możemy się odwoływać bez potrzeby
deklarowania obiektu klasy z której metoda pochodzi. Zaletą jest możliwość
napisania metody która policzy nam np. sumę 2 liczb bez deklarowania jakichś
obiektów, wadą jest to że nie możemy metody wywołać na rzecz jakiegoś
obiektu.
class Dodawanie
{
// <metoda zwykla>
public int Metoda (int b, int a)
{
return (a + b);
}
// <metoda statyczna>
public static int MetodaStatyczna(int a, int b)
{
return (a + b);
}
}
Próba wywołania Metoda(1,2); nie powiedzie się bez zadeklarowania
Oprócz metod także zmienne mogą być
statyczne. Różnią się one standardowych
zmiennych tym, że są wspólne dla
wszystkich obiektów klasy, w której znajdują
się deklaracje owych zmiennych. Mówiąc
prościej pole statyczne będzie miała taką
samą wartość dla wszystkich
zadeklarowanych obiektów Klasy
Sytuacje tę obrazuje kod z następnego
slajdu
class KlasaP
{
public static string napis;
public void Napisz()
{
System.Console.WriteLine(napis);
}
}
class Program
{
static void Main(string[] args)
{
KlasaP o1 = new KlasaP();
KlasaP o2 = new KlasaP();
KlasaP.napis = "pierwszy napis„;
o1.Napisz();
o2.Napisz();
System.Console.ReadKey();
KlasaP.napis = "napis po zmianie";
o1.Napisz();
o2.Napisz();
System.Console.ReadKey();
}
Dziedziczenie
Jak już wiemy klasy posiadają pola ale np. mając
klasę 2D która to posiada pola x i y odnoszące się
do współrzędnych cichlibyśmy uzyskać klasę dla
obiektów 3D
Wiemy że obiekty 3D także mają współrzędne x i
y, ale posiadają takę współrzędna z. I tu właśnie
wkracza dziedziczenie, można napisać klasę która
odziedziczy po 2D pola i metody i w tejże nowej
klasie dodać nowe pole zamiast przepisywać kod
starej klasy.
public class P2d
{
public int x;
public int y;
public virtual void Wyswietl()
{
System.Console.WriteLine("x = {0} a y
= {1}", x, y + ".");
}
}
public class P3d : P2d
{
public int z;
public override void Wyswietl()
{
System.Console.WriteLine("x = {0} y =
{1} z = {2}", x, y, z + ".");
}
class Program
{
static void Main(string[] args)
{
P2d o1 = new P2d();
P3d o2 = new P3d();
o1.x = 1;
o1.y = 2;
o1.Wyswietl();
System.Console.ReadKey();
o2.x = 3;
o2.y = 4;
o2.z = 5;
o2.Wyswietl();
System.Console.ReadKey();
}
}
W poprzednim przykładzie mieliśmy ciekawą
deklarację drugiej klasy
public class P3d : P2d
Dwukropek i nazwa innej klasy oznaczają że
klasa P3d dziedziczy po klasie P2d pola i
metody. Jak widać mimo że nie ma w jej
kodzie bezpośrednio zadeklarowanych pól x
i y oraz metody do ich wyświetlania to udało
się je wyświetlić.
Ale czy zauważyliście te dziwne
modyfikatory virtual i override przy
metodach?
Przesłanianie
Dzieki słowu kluczowemu virtual mogę stworzyć metodę jako wirtualną
a dzięki temu mogę w przyszłości w klasach dziedziczących przesłonić
ją tworząc nową metodę o identycznej nazwie ale z modyfikatorem
override.
Taka metoda wirtualna może być w zasadzie pusta i nie robić nic, czyli
stanowić szkielet dla metod budowanych w przyszłości
Oczywiście czasem się zdarza że chcemy w takiej przesłoniętej
metodzie wywołać starą metodę, można tego łatwo dokonać wpisując
base.Wyswietl();
public override void Wyswietl()
{
base.Wyswietl();
System.Console.WriteLine("x = {0} y = {1} z = {2}", x, y, z + ".");
}
Tak jak w przypadku powyżej. Teraz wywołanie wyśietli nam najpierw
Wspomniałem o konstruktorach klasy dzięki którym pewne działania jak np.
deklaracje pól obiektu można załatwić w już przy deklaracji obiektu tak jak tu
PierwszaKlasa pr = new PierwszaKlasa(2,2);
Nasz konstruktor także można przesłnić w sposób pokazany poniżej
public class PierwszaKlasa
{
public int a;
public int b;
//konstruktor klasy A, ktory przyjmuje dwie liczby calkowite
public PierwszaKlasa(int a, int b)
{
this.a = a;
this.b = b;
}
}
public class DrugaKlasa : PierwszaKlasa
{
public int c;
//dodatkowy parametr w konstruktorze, wywolujemy rowniez konstruktor klasy
bazowej
public DrugaKlasa(int a, int b, int c) : base(a, b)
Przeciążanie metod
A co zrobić gdy chcemy aby jedna metoda
statyczna dodawała nam 2 liczy lub 3 liczby.
Jest to całkiem możliwe dzięki przeciązaniu.
Przeciążenie pozwala na zadeklarowanie
kilku metod o takiej samej nazwie ale o
zmienionej liczbie parametrów jaką ta
metoda przyjmuje, lub zmianie typu
parametrów metody. Dzieki temu program
sam wybierze rodzaj metody najbardziej
odpowiedni dla przyjętych parametrów
class Prz
{
public void Dodaj(int a)
{
System.Console.WriteLine("Brak drugiej
liczby do dodania.");
}
public void Dodaj(int a, int b)
{
System.Console.WriteLine("a+b="+a+b);
}
public void Dodaj(double a, double b)
{
System.Console.WriteLine("liczby
rzeczywiste a ={0} i b ={1}", a, b);
}
}
class Program
{
static void Main(string[] args)
{
Prz obiekt = new Prz();
obiekt.Dodaj(1);
System.Console.ReadKey();
obiekt.Dodaj(1, 2);
System.Console.ReadKey();
obiekt.Dodaj(1.1, 2.3);
System.Console.ReadKey();
}
}
Dziękuję za uwagę:
Polecam zapoznać się z serią artykułów o
C#
http://www.centrumxp.pl/dotNet/1040,1,01
_Zmienne_sta%C5%82e_wyra%C5%
BCenia_i_odst%C4%99py.aspx
Jest to link do pierwszego artykułu pozostałe
można znaleźć na stronie www po prawej.
Wykonał: Piotr Pięda
Dla koła naukowego KNI
Bibliografia:
http://www.centrumxp.pl
http://4programmers.net/C_sharp/Wprowadzenie