PIERWSZY PROGRAM - C#
Kod programu należy przepisać i poddać kompilacji.
/*
Przykładowy program napisany
w C#.
*/
using System ;
class Pokaz {
public static void Main()
{
//Wyświetlanie tekstu.
Console.WriteLine(„Pierwszy program”);
}
OBJAŚNIENIA:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
OPERATORY LOGICZNE - C#
Operatory logiczne pozwalają na sprawdzenie w wyjątkowy sposób dwóch warunków, jest to nam pomocne przy budowaniu bardziej złożonych instrukcji warunkowych. Jest bardzo ważne, abyś zrozumiał zależności między nimi, nie da się już więcej na ten temat powiedzieć, najlepiej będzie jak prześledzisz poniższą tabelkę gdzie są rozpisane operatory logiczne:
P Q & | ^ !P
true true true true false false
false true false true true true
true false false true true false
false false false false false true
Jak działają operatory.
Początek kodu:
using System ;
class Pokaz
{
public static void Main()
{
bool P = true, Q = false ;
if(P&Q)
Console.WriteLine(“To sie nie wyświetli”);
if(P|Q)
Console.WriteLine(“Tak zgadza się P | Q daje wartość true”);
if(P^Q)
Console.WriteLine(“To zobaczysz”);
if(!P)
Console.WriteLine(“To sie nie wyświetli”);
}
}
Koniec kodu:
W warunku gdzie jest P&Q się nie wykona bo jego wartość jest false, dlatego tak jest, ponieważ & jest prawdą (ture) wtedy i tylko wtedy gdy obydwa argumenty (P i Q w tym przypadku) są true. W warunku gdzie jest P|Q instrukcja if się wykona ponieważ | jest true wtedy gdy przynajmniej jeden z argumentów jest równy prawdzie (czyli true).
W warunku P^Q instrukcja się wykona ponieważ operator ^ jest prawdą, wtedy i tylko wtedy gdy tylko jeden z argumentów jest prawdą.
Operator ! jest to po prostu przeciwieństwo argumentu, jeżeli wynosi on P = true to !P będzie wynosiło false.
Warto wspomnieć że istnieją tak zwane skrócone operatory logiczne, a dokładnie && i || czym się one różną, a no tym, że && jeżeli pierwszy argument jest równy false to drugi nawet nie będzie sprawdzany bo bez względu na wynik drugiego argumentu to i tak && nie będzie równe true, bo pierwszy argument jest równy false. Jeżeli pierwszy argument jest równy true to wtedy w przypadku && drugi argument jest obliczany. W || sprawa wygląda tak samo sprawdzany jest pierwszy argument jeżeli jest on równy true to nie jest sprawdzany drugi, a jeżeli pierwszy jest równy false to jest sprawdzany drugi. Skrócone operatory są używane w wyjątkowych przypadkach, aczkolwiek dość często, na przykład aby się uchronić przed dzieleniem przez zero. Jeżeli tego nie wymaga sytuacja powinieneś korzystać z normalnych operatorów logicznych, a nie z skróconych, jest to wydajniejsze i bezpieczniejsze. Poniżej zamieszczono jak nazywa się poszczególne operatory:
& -> AND
| -> OR
^ -> XOR
! -> NOT
&& -> skrócony AND
|| -> skrócony OR
Zmienne - c#
Zmienna to taki obszar w pamięci komputera , gdzie możemy przypisać wartość np. tekstową , logiczną itp. Każdej nowej zmiennej musimy nadać nazwę i , możemy przypisać wartość . Zmienne są różnych rodzajów dlatego zmienna liczbowa np. int nie może przechowywać łańcuchów tekstowych . Każda zmienna ma określony rozmiar np. zmienna typu byte przechowuje wartości liczbowe z zakresu 0-255 . Działanie zmiennych ukażę ci na konkretnym przykładzie , rozpatrz następujący program .
/*
Prezentacja zmiennych
*/
using System ;
class Pokaz {
public static void Main()
{
int a ; //Utworzenie zmiennej `a' typu int , bez przypisywania wartości
byte parzysta = 10 ; //Utworzenie zmiennej `parzysta' typu byte, przypisuję jej wartość 10
Console.WriteLine(„Zmienna parzysta ma wartość :” + parzysta );
a = 453 //Przypisanie zmiennej `a' wartości 453 .
Console.WriteLine(„Zmienna a ma wartość :” + a );
}
Ogólnie deklaracja zmiennej wygląda następująco : typ nazwa_zmiennej ; . Gdzie typ jest typem wbudowanym (jak nie rozumiesz za bardzo to nie szkodzi). Typy w C# są kompatybilne z innymi typami języków takich jak C++ , C i innych . Jest to potrzebne do tego aby twój program mógł używać wielu języków , oraz po to by mógł używać bibliotek *.dll . Nazwa zmiennej jest nazwą której będziesz używać do przypisywania zmiennej wartości lub jej wyświetlania itp.. Nazwa zmiennej może być dowolna ale są wyjątki , nie należy nazywać zmiennych słowami kluczowymi C# , oraz nie powinna się zaczynać liczbami np. takie nazwy są nie prawidłowe : 22Max , 2 , 32mala4 . Nazwa też nie może się zaczynać znakami specjalnymi np.: @Min , ++sd , $stop . ! W nazwie zmiennej i innych składników klas nie może być spacji.
Oto tabela typów C#.NET oraz biblioteki NET FrameWork wraz z ich zakresem :
Skoro podstawowe wiadomości o zmiennych macie powinniście wiedzieć ,że na zmiennych możecie wykonywać działania arytmetyczne spójrz na poniższy przykład który ilustruje działanie operatorów arytmetycznych na zmiennych.
/*
Prezentacja operatorów arytmetycznych
*/
using System ;
class Pokaz {
public static void Main()
{
int a = 10 , b = 25 ; //Deklaracja dwóch zmiennych ,aby je tak zadeklarować trzeba je oddzielić przecinkiem
double c = 0.25 , d = 0.05 ;
double wynik ;
wynik = c + d ; //To jest właśnie działanie arytmetyczne teraz zmienna `wynik' będzie posiadać wartość 0.25 + 0.05 czyli
// 0.30
Console.WriteLine(„c + d =„ + wynik);
}
Poniżej znajduje się tabela wszystkich operatorów arytmetycznych:
INSTRUKCJA IF - C#
Jak wiemy instrukcje w naszych programach dotychczas były wykonywane jedna po drugiej. Jednak często zachodzi potrzeba zamiany kolejności wykonywania instrukcji, jak to zrobić. Istnieje wiele instrukcji nam w tym pomagających, teraz zapoznasz się z jedną z nich, jest to instrukcja if która sprawdza jakiś warunek czy jest prawdą po czym wykonuje instrukcje w niej zawarte.
Ogólna deklaracja instrukcji if wygląda następująco:
if (warunek)
instrukcja ;
LUB
if(warunek)
{
instrukcje;
…
}
Gdzie warunek jest typem boolean, czyli bool (true lub false).
Przykład:
using System ;
class Pokaz_if
{
public static void Main()
{
int a = 10 ;
Console.WriteLine(“Teraz nastąpi pokaz instrukcji warunkowej if”);
if (a == 10)
{
Console.WriteLine(“Zgadza się! a jest równe 10″);
Console.WriteLine(“więc jest to prawdą”);
}
if( a < 10 )
Console.WriteLine(“A nie jest mniejsze od 10″); // A instrukcja się nigdy nie wykona
}
}
Przy pierwszym if jako warunek wpisujemy „a” równe 10. Można to odczytać tak, jeżeli „a” jest równe 10 to wykonaj instrukcje. Przy drugim jako warunek wpisujemy „a” < 10 czyli a mniejsze od 10, odczytujemy to w taki sposób: jeżeli „a” jest mniejsze od 10 to wykonaj instrukcję. Ta instrukcja się nie wykona z prostego powodu, ponieważ „a” jest równe 10, więc jest to nie prawdą dla warunku a < 10. Więc operator < zwróci nam wartość false, a znowu operator == dla pierwszego if zwróci nam wartość true.
Zadanie:
Jako trening napisz program, który w zmiennej „lata” przechowuje wiek, oraz dwie instrukcje if mówiące nam czy skończyło się 18 lat. Napisze słownie że program powinien sprawdzić w pierwszej instrukcji czy wiek jest większy lub równy 18, a w drugiej czy jest mniejszy. Oraz trzeba napisać odpowiedni tekst który będzie się wyświetlał podczas.
Po niżej znajdują się wszystkie operatory porównań:
> Większy
< Mniejszy
== Równy
!= Różny
<= Mniejszy lub równy
>= Większy lub równy
SWITCH - C#
W tej lekcji poznasz wyrażenie kontrolne switch, jest nam ono wtedy pomocne, gdy wiemy jakie wartości może przyjąć zmienna, zamiast używać kilku instrukcji if(zmienna == wartość) stosujemy instrukcję switch co jest wyjątkowo wydaje, bo pozwala nam jeszcze, na zadeklarowanie przypadku w którym zmienna posiadała by nie przewidywalną wartość, czyli default. Ogólna deklaracja switch wygląda następująco:
switch(zmienna) {
case wartość1 :
instrukcje;
break; lub instrukcja skoku;
case wartość2 :
instrukcje;
break; lub instrukcja skoku;
…
default:
instrukcje;
break; lub instrukcja skoku;
}
Działanie instrukcji switch prześledź na poniższym przykładzie:
Początek kodu:
using System ;
class Pokaz
{
public static void Main()
{
int wartosc = 10 ;
switch(wartosc)
{
case 1 :
Console.WriteLine(“To się nie wyświetli”);
break ;
case 2 :
Console.WriteLine(“To również się nie wyświetli”);
break ;
case 10 :
Console.WriteLine(“Tak jest zmienna wartosc jest równa 10″);
break ;
default :
Console.WriteLine(“Nie uwzględniono przypadku”);
break ;
}
}
}
Koniec kodu:
Przebieg wykonywania programu w instrukcji switch jest mniej więcej następujący: program sprawdza do którego przypadku case pasuje wartość zmiennej „wartość” w tym wypadku pasuje do case 10 a więc wykonuje od części case 10 : program aż do napotkania break; lub instrukcji skoku, instrukcja skoku może wyglądać tak goto case 1 ; wtedy program przeniesie wykonywanie do przypadku case 1 : a tam analogicznie będzie wykonywać instrukcje aż do napotkania break lub jakiejś instrukcji skoku. Jeżeli program wykonując się w instrukcji switch nie napotka break lub instrukcji skoku to przeniesie wykonywanie na przypadek znajdujący się poniżej. Prześledź to na poniższym przykładnie w którym to program sprawdza czy dana litera to samogłoska czy spółgłoska.
Początek kodu:
using System ;
class Pokaz
{
public static void Main()
{
char litera = `i' ;
switch(litera)
{
case `i' :
case `e' :
case `a' :
case `o' :
case `u' :
case `y' :
Console.WriteLine(“Litera ” + litera + ” jest samogłoską”);
break ;
default :
Console.WriteLine(“Litera ” + litera + ” jest spółgłoską”);
break ;
}
}
}
Koniec kodu:
Sam widzisz co się dzieje, gdy litera jest samogłoską. Jednak działanie default może być dla ciebie nie znajome, otóż jeżeli wartość zmiennej „litera” nie pasuje do żadnego przypadku case wtedy jest wykonywane instrukcje zawarte w default, aż do napotkania break; lub instrukcji skoku.
ZŁOŻONE OPERATORY PRZYPISANIA - C#
Teraz zajmiemy się złożonymi operatorami przypisania.
Jak zauważyłeś, i słusznie, operatorem przypisania nazywamy `='. W poprzednich przykładach tego nie było, ale przypisywać zmiennym wartość, możesz dokonywać w następujący sposób:
Początek kodu:
class Pokaz
{
public static void Main()
{
int a = 120 ;
int b ;
int c = 7 ;
int d = 12 ;
a = b = c = d = 100 ;
Console.WriteLine(a) ;
Console.WriteLine(b) ;
Console.WriteLine(c) ;
Console.WriteLine(d) ;
}
}
Koniec kodu:
Jak widzisz wszystkie zmienne: a,b,c,d będą posiadały wartość 100, zawsze ta wartość na końcu będzie przypisywana do wszystkich zmiennych.
To był operator przypisania. Teraz poznasz złożone operatory przypisania. Otóż często stosujesz taki zapis w swoich programach:
x = x + 120 ;
lub
a = a / 10 ;
Język C# pozwala ci znacząco skrócić w elegancji sposób tez zapis oraz go ułatwić. Otóż zamiast pisać:
x = x + 1576 ;
To piszesz:
x += 120;
Zamiast pisać dodatkowo x +120, zastępuje wszystko skrócony operator, który mówi kompilatorowi że ma do zmiennej x dodać wartość, w tym przypadku 120. Skraca to zapis przez co zyskujemy na wydajności.
Poniżej znajdują się wszystkie złożone operatory przypisania:
*=
+=
-=
/=
%=
&=
|=
^=
Pętle
INKREMENTACJA, DEKREMENTACJA I CONTINUE - C#
W tej lekcji zajmiemy się trzema pojęciami: inkrementacja, dekrementacja oraz poleceniem continue. Zacznę od pojęcia inkrementacja.
A więc operator inkrementacji (++) powoduje zwiększenie wartości operandu o 1. Operator inkrementacji może być umieszczony przed lub za operandem.
Ogólna deklaracja operatora inkrementacji wygląda następująco:
zmienna++ ;
LUB
++zmienna;
Gdzie zmienna jest wyrażeniem oznaczającym zmienną, własność lub indeksem.
Formą przedrostkową (++zmienna) i przyrostkową(zmienna++) zajmiemy się za chwilę. Tym czasem prześledź poniższy przykład, jak działa polecenie inkrementacji.
Początek kodu:
class Pokaz
{
public static void Main()
{
for (int i = 0 ; i < 10 ; i++)
{
Console.WriteLine(“PĘTLA”);
}
}
}
Koniec kodu:
Jak widzisz w polu interacji jest zastosowany operator inkrementacji czyli zwiększania operandu o 1. Po każdym przejściu pętli zmienna „i” jest zwiększana o 1.
Prześledź teraz poniższy program, aby zobaczyć działanie formy przedrostkowej i przyrostkowej operatora inkrementacji.
Początek kodu:
class Pokaz
{
public static void Main()
{
int y,x ;
x = 100 ;
y = x ;
Console.WriteLine(“X wynosi : ” + x + ” ,a Y wynosi : ” + y);
y = x++ ;
Console.WriteLine(“Y wynosi : ” + y);
x = 100 ;
y = ++x ;
Console.WriteLine(“Y wynosi : ” + y);
}
}
Koniec kodu:
Na pewno pojawia się z twojej strony pytanie dlaczego gdy przypisujemy do „y” wartość zmiennej „x” poddanej inkrementacji otrzymujemy „y” równe 100, a „x” równe 101 ? Otóż do zmiennej „y” jest przypisana wartość „x” w sposób przyrostkowy czyli „x++”, działa to tak że na samym początku do zmiennej „y” jest przypisywana wartość „x” czyli 100 poczym dopiero potem jest wykonywany operator ++, czyli zwiększający o 1. Dalej w programie masz napisane zastosowanie formy przedrostkowej, czyli „++x”, gdzie najpierw jest wykonywana inkrementacja zmiennej „x” poczym wartość „x” w tym wypadku już 101, jest dopiero wtedy przypisywana do „y”.
Oczywiście poprawne było używanie w poprzednich przykładach zwiększania zmiennej w taki sposób : i = i + 1 jednak jest to mało eleganckie i mało wydajne, dlatego do zwiększania zmiennej używaj inkrementacji
Teraz zajmiemy się pojęciem dekrementacji, jest to nic innego jak odwrotność inkrementacji, czyli zmniejszanie wartości operandu o 1. Uzyskujemy to za pomocą operatora (-). Wszystko jest tak samo jak w operatorze inkrementacji, włącznie z formą przedrostkową i przyrostkową. Działanie dekrementacji zobacz na poniższym przykładzie:
Początek kodu:
class Pokaz
{
public static void Main()
{
for (int i = 10 ; i > 0 ; i-)
{
Console.WriteLine(“PĘTLA”);
}
}
}
Koniec kodu:
Wszystko w tym przykładzie powinno być zrozumiane.
Przechodzimy do instrukcji continue. Instrukcja continue jest wykorzystywana do przekazywania sterowania do następnej iteracji, występującej w danej instrukcji iteracyjnej (pętli). Deklaracja instrukcji continua wygląda następująco:
continue;
Aby przybliżyć sobie działanie tej instrukcji prześledź następujący przykład:
Początek kodu:
using System ;
class Pokaz
{
public static void Main()
{
for(int i = 0; i <= 20 ; i++)
{
if (i%2 == 0 )
continue;
Console.WriteLine(i);
}
}
}
Koniec kodu:
W powyższym przykładnie, w instrukcji if, jeżeli reszta dzielenia przez 2 zmiennej „i” jest równa zero to jest wykonywana instrukcja continue, która przenosi wykonywanie programu do wyrażenia iteracyjnego pętli, gdzie zmienna „i” jest inkrementowana poczym wykonywanie programu jest przenoszone do warunku pętli for, jeżeli jest on prawdą to pętla wykonuję się dalej. W ten oto sposób mamy wyświetlana same liczby nieparzyste.
Tobie pozostawiam za zadanie napisać program który wyświetla liczby parzyste, za pomocą polecenia continue. Rozwiązanie zadania znajduje się poniżej:
Początek kodu:
using System ;
class Pokaz
{
public static void Main()
{
for(int i = 0; i <= 20 ; i++)
{
if (i%2 != 0 )
continue ;
Console.WriteLine(i);
}
}
}
Koniec kodu:
KLASY - C#
Teraz zajmiemy się klasami, jest to temat bardzo bardzo szeroki, w tej lekcji poznasz na razie tylko ogólne mechanizmy działania klas oraz podstawy ich używania. Trudno jest podać jako taką definicję klasy, aby była ona zrozumiana dla początkujących programistów. Ale spróbuję wytłumaczyć tobie czym jest klasa posługując się prostym przykładem z życia wziętym. Najogólniej mówiąc klasa to zbiór wartości, metod i innych składników klas, których własną kopię przechowuje każdy utworzony obiekt. Jak to wytłumaczyć obrazowo? Spróbujmy. Załóżmy, że utworzyliśmy klasę o nazwie „Pojazd” klasa ta będzie posiadała takie pola wartości jak: liczba pasażerów, pojemność baku z paliwem, spalanie na 100 km i inne. Teraz tworząc obiekt typu Pojazd, np. Maluch nadajemy mu poszczególne wartości tych pól. Jest to pożyteczne i bardzo wydajne, ponieważ nie musimy za każdym razem pisać dla nowego utworzonego Pojazdu nowych wartości pól, ani ich deklarować oddzielnie. Przecież każdy pojazd posiada takie właściwości jak np. liczba pasażerów, tylko że wartość dla każdego pojazdu liczby pasażerów będzie inna, np. Autobus będzie miał 95, a Polonez 5 to samo się tyczy innych pól. Jak widzisz klasa tworzy ogólny „zapis” obiektu. Spróbuj to przećwiczyć sposób tworzenia klas rozglądając się dookoła. Może klasa mebel? Jakie byś w niej dał pola wartości: materiał, waga… itp.
To na razie tyle wiedzy teoretycznej, teraz spróbujemy napisać program z klasą Pojazd.
Ogólna deklaracja klasy wygląda następująco:
class nazwa_klasy {
typ_dostępu typ nazwa_zmiennej1 ;
typ_dostępu typ nazwa_zmiennej2 ;
…
typ_dostępu typ_zwracany nazwa_metody1(parametry)
{
ciało metody…
}
…
}
A więc zaczynamy tworzyć:
class Pojazd
{
public int liczba_pasarzerow ;
public int pojemnosc ;
public int spalanie ;
}
Deklarujemy tutaj klasę o nazwie pojazd, potem deklarujemy kolejne zmienne. Słowo public to specyfikator dostępu, oznacza w tym wypadku że dostęp do tej zmiennej można mieć z zewnątrz klasy, a raczej obiektu. Są jeszcze inne specyfikatory dostępu takie jak: private, internal i protected , ale ich działanie omówimy w dalszych kursach. Teraz napiszmy program który wykorzystywał by naszą klasę Pojazd:
Początek kodu:
using System;
class Pojazd
{
public int liczba_pasazerow ;
public int pojemnosc ;
public double spalanie ;
}
class Pokaz
{
public static void Main()
{
double zasieg ;
Pojazd maluch = new Pojazd() ;
maluch.liczba_pasazerow = 5 ;
maluch.pojemnosc = 25 ;
maluch.spalanie = 3.5 ;
Pojazd polonez = new Pojazd() ;
polonez.liczba_pasazerow = 5 ;
polonez.pojemnosc = 47 ;
polonez.spalanie = 9.7 ;
Console.WriteLine(“Maluch pomieści ” + maluch.liczba_pasazerow + ” pasażerów”);
zasieg = (maluch.pojemnosc * 100) / maluch.spalanie ;
Console.WriteLine(“Zasięg malucha na pełnym baku wynosi: {0:#.##} km\n\n”,zasieg);
Console.WriteLine(“Polonez pomieści ” + polonez.liczba_pasazerow + ” pasażerów”);
zasieg = (polonez.pojemnosc * 100) / polonez.spalanie ;
Console.WriteLine(“Zasięg poloneza na pełnym baku wynosi: {0:#.##} km”,zasieg);
}
}
Koniec kodu:
Zapis: Pojazd maluch = new Pojazd(); oznacza deklarację nowego obiektu typu Pojazd. Od tego momentu jest tworzony obiekt maluch, a dokładnie od wywołania new. Aby mieć odstęp do składników klasy, musisz użyć operatora „.” Kropki. Bez tego nie miał byś dostępu do liczby pasażerów. Jeżeli w klasie pojazd byśmy nie użyli jako specyfikatora dostępu public przy którymkolwiek ze składników, to też nie mieli byś my do niego dostępu z poziomu innej klasy poprzez użycie operatora „.”. Myślę, że ta lekcja jest dla ciebie zrozumiała, w następnej zajmiemy się metodami.
7