No tak, bo w połowie zaczynają się informacje o klasach... :P
OK, małe podsumowanie o czym jest programowanie w C# w ogóle
Klasy
Klasy służą jako 'pojemniki' na różne rzeczy. W C# nic nie może się znajdować 'poza klasą', wszystko należy do którejś klasy. Przykład klasy:
class C
{
// ...
}
Zapis new C()
oznacza wywołanie konstruktora klasy C, czyli stworzenie nowej instancji tej klasy. Np. jeśli masz klasę Ciastko to zapis new Ciastko()
da ci dostęp do kolejnego ciastka (bo mogłeś wcześniej stworzyć jakieś inne). Bez użycia konstruktora nie da się stworzyć żadnego obiektu.
Metody
Najmniejszą jednostką z jakiej składa się twój kod są metody. Przykład metody:
class C // każda metoda musi być w jakiejś klasie.
{
void Metoda() // tu się zaczyna metoda
{
// ...
} // tu się kończy metoda
}
W metodzie umieszczasz kod programu. Co charakteryzuje kod programu nie będę nawet się starał opisywać bo to chyba oczywiste.
Wywołanie tej metody wygląda po prostu tak: Metoda()
.
Metoda może przyjmować parametry. Może też zwracać wartość. Wtedy wygląda tak:
class C // klasa
{
int Metoda(float parametr1, bool parametr2)
{
return 1;
}
}
To jest metoda przyjmująca parametry typu float (parametr1) i bool (parametr2) i zwracająca wartość typu int. W tym przypadku widać że zawsze zwraca 1. Do tego też jeszcze wrócimy...
Tymczasem mały program pokazujący o co mi chodzi:
class C
{
static void Main(string[] args)
{
C c = new C(); // tworzymy nowy obiekt typu C. Bez tego nie moglibyśmy używać jego metod.
c.Metoda1(); // zwykłe wywołanie metody.
c.Metoda2(1); // ta metoda wymaga parametru (patrz w dół) więc go przekazujemy
c.Metoda2(5); // ta sama metoda ale z innym parametrem.
c.Metoda3(); // ta metoda wykonuje trochę bardziej skomplikowane rzeczy, przyjrzyj się jej.
}
void Metoda1()
{
Console.WriteLine("Wywołano metodę 1!");
}
void Metoda2(int param)
{
Console.WriteLine("Wywołano metodę 2 z parametrem " + param.ToString());
}
void Metoda3()
{
int i = MetodaZwracajacaWartosc1(); // jeszcze nie omówiłem zmiennych, ale chyba wiesz czym są. Przypisujemy to co zwróciła metoda do zmiennej.
Console.WriteLine("MetodaZwracajaca zwróciła wartość " + i.ToString()); // i wypisujemy tą zmienną
Metoda2(MetodaZwracajacaWartosc1()); // Wow, co się tu dzieje?
// wywołujemy metodę2 z parametrem który sam jest wywołaniem metody... Będzie to wykonywane
// mniej więcej tak:
// zmienna_tymczasowa = MetodaZwracajacaWartosc1();
// Metoda2(zmienna_tymczasowa);
int j = MetodaZwracajacaWartosc2(2); // ta metoda wymaga parametru.
Console.WriteLine("MetodaZwracajaca zwróciła : " + j.ToString()); // wypisujemy wynik
// jeszcze jedno - w tej metodzie nie trzeba było pisać c.Metoda2, wystarczyło Metoda2(). W sumie to nie można było. Dlaczego?
// c to **obiekt klasy** C. Jeśli chcemy wywołać metodę tej klasy to musimy wiedzieć na jakim obiekcie ją wywołać. Zapis c.Metoda2()
// oznacza że wywołujemy Metodę2 na zmiennej c. Za to w tej metodzie już nie musimy tak robić bo... Już jesteśmy w obiekcie c.
// Wszystko co tam robimy odnosi się właśnie do tego obiektu c. Wiem że to by wymagało chyba dalszego tłumaczenia, ale nie mam siły :)
}
int MetodaZwracajacaWartosc1() // ta metoda zawsze zwraca 2
{
return 2;
}
int MetodaZwracajacaWartosc2(int parametr) // ta metoda zwraca **swój parametr pomnożony przez 2**.
{
return parametr * 2;
}
}
Zmienne
To jest właśnie część na której poległeś. O zmiennej możesz myśleć jak o nazwie jakiejś wartości. Na przykład (żeby to działało cały kod musi być umieszczony w metodzie która z kolei jak pisałem musi być umieszczona w klasie.)
int i; // czytając - deklarujemy zmienną typu int (liczba całkowita) i nazywamy ją i
float f; // czytając - deklarujemy zmienną typu float (liczba rzeczywista) i nazywamy ją f
i = 1; // przypisujemy zmiennej i wartość 1. Dopóki zmienna nie miała wartości nie możemy z nią niczego zrobić.
f = 2; // chyba oczywiste?
Console.WriteLine(i); // wypisanie zmiennej i na ekran.
To były przykłady prostych zmiennych lokalnych. W C# (i każdym innym języku C-like... W sumie to prawie w każdym języku. Albo i każdym.) istnieje coś takiego jak zasięg zmiennych. Objawia się to tym że zmienna o nazwie a w metodzie Met1() jest inną zmienną niż zmienna a w metodzie Met2(). Przykład:
class C
{
static void Main(string[] args)
{
C c = new C(); // tworzymy nowy obiekt typu C. Bez tego nie moglibyśmy używać jego metod.
int i = 1; // wiadomo.
Console.WriteLine(i);
Metoda1();
Metoda2();
Metoda3();
Metoda4(i); // Wywołujemy tą metodę z parametrem i
}
void Metoda1()
{
Console.WriteLine(i); // To NIE ZADZIAŁA (błąd kompilacji) bo nie ma w zasięgu takiej zmiennej jak i.
// żeby skompilować kod po prostu usuń tą instrukcję.
}
void Metoda2()
{
int i;
Console.WriteLine(i); // To NIE ZADZIAŁA (błąd kompilacji) bo zmienna i nie ma przypisanej wartości a takiej zmiennej **nie można używać**.
// żeby skompilować kod po prostu usuń tą instrukcję.
}
void Metoda3()
{
int i = 123;
Console.WriteLine(i); // To zadziała - i wypisze 123. Ta zmienna i nie ma nic wspólnego ze zmienną i w metodzie Main i są kompletnie niezależne.
}
void Metoda4(int a)
{
Console.WriteLine(a); // Tutaj wypisujemy zmienną którą dostaliśmy w parametrze. Tylko w tym przypadku metoda dostaje tą samą zmienną jaka jest w innym miejscu programu.
}
}
Mam nadzieję że chociaż trochę ci to wyjaśni pewne podstawy. Wiem że w sumie niedużo tutaj opisałem, ale te prawa po można rozszerzać na coraz bardziej skompikowane zagadnienia. Na przykład twój oryginaly kod jest oczywistym błędem:
public void wpsak()
{
Jezyk J = new Jezyk();
Start S = new Start();
if (S.jezyk == "1") J.jezykPL();
if (S.jezyk == "2") J.jezykENG();
I może, jeśli umiem tłumaczyć chociaż trochę, już wiesz dlaczego. Metoda wspak tworzy sobie NOWE obiekty typu Jezyk i Start. Za to ty oczekujesz że S będzie zmienną która znajdowała się w poprzedniej metodzie. Żeby to osiągnąć, musisz zmienną S jakoś przekazać do tej metody, a do tego służą patametry:
public void wpsak(Jezyk J, Start S)
{
if (S.jezyk == "1") J.jezykPL();
if (S.jezyk == "2") J.jezykENG();
Musisz wtedy też zmienić wywołanie tej metody:
P.wpsak(); // NIE!
P.wpsak(J, S); // tak!