1

1

Programowanie obiektowe

Wykład I

2

Zaliczenie

• Wykład kończy się zaliczeniem, które

obejmuje:

– ocena pracy na laboratoriach (30%)
– obrona pracy semestralnej w postaci

wykonanej samodzielnie przez studenta
aplikacji (50%)

– sprawdzian znajomości zagadnień

przedstawionych na wykładach (20%)

2

3

Literatura – C#

• Eric Gunnerson: Programowanie w języku

C#. Mikom, 2001.

• Jesse Liberty, Brian MacDonald: C# 2005.

Wprowadzenie. Helion, 2007.

• Marcin Lis: C#. Ćwiczenia. Helion, 2006.
• Marian Mysior: C# w praktyce. Mikom,

2005.

• S. C. Perry, C# i .NET, Helion, Gliwice

2006.

4

Podstawy języka C#

3

5

Podstawy języka C#

• Dane i ich typy
• Operatory
• Podstawowe typy instrukcji

6

Używanie C#

• Wymagana jest jedynie instalacja .NET

Framework, dostępnej bezpłatnie dla
każdego użytkownika ze stron MS

• Kompilacja ręczna:
• MS Windows:

– csc plik.cs
– plik.exe

• Linux/Unix:

– mcs plik.cs
– mono plik.exe

4

7

Środowisko

Visual Studio 2008

• Środowisko Visual Studio 2008

Professional Edition dostępne
bezpłatnie dla studentów poprzez
MSDN AA

• Środowisko Visual Studio 2008

Express Edition dostępne bezpłatnie
dla każdego użytkownika ze stron
MSDN

8

Dane w C#

• C# jest językiem mocno typowanym
• Oznacza to, że, w odróżnieniu np. od

Pythona, tworząc zmienne musimy
określić ich typ, a konwersje między
różnymi typami muszą być
wykonane jawnie

• W C# dostępnych jest szereg typów

prostych oraz liczne typy złożone

5

9

Typy proste

• Logiczny: bool

– Wartości: true, false

• Całkowite

– 8 bitowe: sbyte, byte, 16 bitowe: short, ushort, char

(znak w apostrofach), 32 bitowe: int, uint, 64 bitowe:
long, ulong

• Rzeczywiste

– Zmiennopozycyjne binarne: float, double,

zmiennopozycyjny dziesiętny: decimal

• Napisowy: string

– Napis w cudzysłowach
– Backslash ma znaczenie specjalne, np. ‘\n’
– @ wyłącza znaczenie specjalne, np. @„c:\n”

10

Tworzenie zmiennych typów

prostych

• Składnia: nazwa_typu nazwa_zmiennej;
• Przykłady:
int index;
int i, j, k;
long number_of_seconds_in_a_year;
real x, y, z, pi;
double d;
bool b, is_ok;

6

11

Nazwy zmiennych

• Reguły tworzenia własnych nazw w

C#:

–

Zaczynamy literą lub znakiem
podkreślenia

–

Kontynuujemy cyfrą, literą lub znakiem
podkreślenia

–

Długość nazw jest nieograniczona

–

Wielkość liter ma znaczenie!

12

Konwencje nazewnicze

• Styl Pascala

– pierwsza litera każdego słowa w nazwie

jest dużą literą, np.
SredniaPredkoscNaGodzine

– zalecany do nazywania klas i metod

• Styl Camela

– jak Pascala, z tą róznicą, że pierwsze

słowo identyfikatora jest pisane małymi
literami, np. sredniaPredkoscNaGodzine

– służy do nazywania zmiennych

7

13

Przestrzenie nazw

• Może się zdarzyć, że w tym samym programie używa się

takich samych nazw na określenie zupełnie różnych danych

• Przydatne wtedy są przestrzenie nazw, grupujące dane pod

wspólną nazwą kategorii

• Składnia definicji przestrzeni nazw jest następująca:
namespace NAZWA_PRZESTRZENI {
ZAWARTOŚĆ
}
• Elementy przestrzeni wywołuje się łącząc kropką nazwę

przestrzeni i nazwę jej elementu, np.:

NAZWA_PRZESTRZENI.NAZWA_ELEMENTU
• Przy pomocy słowa using możemy wskazać używane

przestrzenie nazw:

using NAZWA_PRZESTRZENI;

14

Instrukcja przypisania

• Instrukcja przypisania ma postać:

zmienna = wyrażenie;

• Jej działanie polega na nadaniu zmiennej

o podanej nazwie (lewa strona)
obliczonej wartości wyrażenia (prawa
strona), np.:

• Jeżeli wyrażenie zawiera nazwę funkcji,

zostanie ona wykonana, np.:

Instrukcja

Wynik

a=1;

a równe 1

b=2+3;

b równe 5

c=a+b;

c równe sumie a i b

Instrukcja

Wynik

a=Console.ReadLine(); wczyta warto

ść

a z klawiatury

8

15

Konwersja typów

• Dane typów węższych mogą być konwertowane

niejawnie na typy szersze, np.:

byte b = 5;
int i = b;
long l = i;

• Każda inna konwersja może prowadzić do

zniekształcenia informacji, musi mieć więc postać
jawną, z podaniem nazwy typu docelowego
w nawiasach, np.:

int i = (int) l;
double d = 5.3;
int i = (int) d;

16

Podstawowe operatory

+

Dodawanie

||

Logiczne LUB

-

Odejmowanie

&&

Logiczne I

*

Mno

ż

enie

!

Logiczne NIE

/

Dzielenie

<

Mniejszy

%

Reszta z dzielenia

>

Wi

ę

kszy

&

Iloczyn bit

ó

w

<=

Mniejszy r

ó

wny

|

Suma bit

ó

w

>=

Wi

ę

kszy r

ó

wny

^

R

óż

nica symetryczna

==

R

ó

wny

~

Negacja bit

ó

w

!=

Nier

ó

wny

<<

Przesuni

ę

cie bit

ó

w w lewo

is

To

ż

samy

>>

Przesuni

ę

cie bit

ó

w w prawo

? :

Operator ternarny

9

17

Instrukcje modyfikacji

• Odmianą instrukcji przypisania są instrukcje

modyfikacji, służące do zmiany wartości
zmiennych

• Instrukcje modyfikacji mają postać

zmienna

?

= wyrażenie;

gdzie

?

oznacza operator, np.: +, -, *

• Instrukcje modyfikacji wprowadzono dla

wygody programisty, każdą instrukcję
modyfikacji można zapisać jako instrukcję
przypisania, np.:

Instrukcja

Wynik

Odpowiednik

a+=1;

zwi

ę

kszy a o 1

a=a+1;

b-=a;

odejm ie od b zawarto

ść

a

b=b-a;

18

Instrukcje in/dekrementacji

• Odmianą instrukcji modyfikacji są instrukcje

inkrementacji i dekrementacji, służące do zwiększenia

lub zmniejszenia wartości zmiennych o 1

• Są cztery takie instrukcje:

– zmienna++;
– ++zmienna;
– zmienna--;
– --zmienna;

• Instrukcje inkrementacji i dekrementacji nie tylko

zmieniają wartość zmiennej, ale, w odróżnieniu od

instrukcji modyfikacji, zwracają ją, mogą być zatem

użyte w złożonych wyrażeniach

Instrukcja

Wynik

++a;

zwi

ę

kszy a o 1, zwróci warto

ść

zwi

ę

kszon

ą

b--;

zmniejszy b o 1, zwróci warto

ść

oryginaln

ą

10

19

Separatory

20

Komentarze

• Do końca linii

// komentarz

• Wieloliniowe

/* komentarz1
Komentarz2 */

11

21

Program główny

class NazwaProgramu {

public static void Main() {

...

}

}

22

Wywołanie podprogramów

• Podprogramy (funkcje) wywołuje się poprzez podanie ich

nazwy koniecznie zakończonej parą nawiasów
okragłych (wewnątrz których można zamieścić ewentualne
parametry)

• Funkcje, które zwracają wartości wywołuje się w większym

wyrażeniu, np. przy okazji przypisania:

• Funkcje, które nie zwracają wartości lub nie interesują nas

one (tzw. procedury), wywołuje się samodzielnie:

Instrukcja

Efekt

a=Console.ReadLine();

Wprowadzi do a rezultat Console.ReadLine();

(wczyta warto

ść

a z klawiatury)

Console.ReadLine();

Czeka na wci

ś

ni

ę

cie ENTER

Obowiązkowe nawiasy

12

23

Wyświetlanie

• Do wyświetlania danych na ekranie tekstowym służy

instrukcja Console.WriteLine

• Do oddzielania danych do wyświetlenia służy przecinek
• Po wyświetleniu tekstu, kursor przechodzi do nowej linii

– Aby tego uniknąć, używamy Console.Write

Instrukcja

Efekt

Console.WriteLine();

Pusta linia

Console.WriteLine(1);

Wy

ś

wietlona 1

Console.WriteLine(a);

Wy

ś

wietlona zawarto

ść

zmiennej a

Console.WriteLine("a");

Wy

ś

wietlona litera a

Console.WriteLine(a+2); Wy

ś

wietlona warto

ść

a zwi

ę

kszona o 2

24

Instrukcja skoku

int a = 0;
start:
System.Console.WriteLine(a);
a++;
goto start;

• Instrukcja skoku powoduje przejście

do podanej linii programu (etykiety)

13

25

Typy konstrukcji

programistycznych

• Zgodnie z teorią programowania

strukturalnego, każdy program da się
przedstawić używając
tylko trzech rodzajów konstrukcji:

– Sekwencji (ciąg instrukcji wykonywany zawsze

tylko jeden raz, niezależnie od sytuacji)

– Wyboru (ciąg instrukcji, zależnie od sytuacji

wykonywany tylko jeden raz lub wcale)

– Pętli (ciąg instrukcji, wykonywany nieznaną

liczbę razy)

• Elementem konstrukcji mogą być

zarówno instrukcje proste, jak i złożone

– A zatem, można tworzyć dowolnie

skomplikowane konstrukcje hierarchiczne

26

Instrukcje złożone

• sekwencja
• wyrażenia warunkowe:

– wybór prosty
– wybór pełny
– wybór wielokrotny

• pętle:

– z testem na początku cyklu
– z testem na końcu cyklu
– o ustalonej liczbie cykli
– po elementach sekwencji

14

27

Sekwencja

• Sekwencja to ciąg instrukcji wykonywanych niezależnie

od okoliczności i tylko jeden raz

• W C# sekwencję tworzymy umieszczając instrukcje

wewnątrz nawiasów klamrowych:

Sekwencja1.Instrukcja1
Sekwencja1.Instrukcja2

{

Sekwencja1.2.Instrukcja1

{

Sekwencja1.2.1.Instrukcja1

}

}

Sekwencja1.Instrukcja3

• Sekwencje są wykorzystywane jako zawartość (ciało)

definicji funkcji i innych instrukcji złożonych (to jest

wyborów i pętli)

28

Wybór prosty

• Polega na wykonaniu instrukcji tylko

przy spełnieniu podanego warunku

• W C# zapiszemy go następująco:

if (WARUNEK)
{

Instrukcja_pod_warunkiem1;
Instrukcja_pod_warunkiem2;

}
Instrukcja_bez_warunku;

• Instrukcje w klamrach wykonają się tylko wtedy,

gdy wartość wyrażenia WARUNEK będzie
prawdziwa

15

29

Wybór prosty - przykład

if (a == 5)

System.Console.WriteLine("A to 5");

30

Wybór pełny

• Polega na wykonaniu przy spełnieniu

podanego warunku instrukcji A, a przy

jego niespełnieniu instrukcji B

• W Pythonie zapiszemy go następująco:

if (WARUNEK)
{

Instrukcja_pod_spelnionym_warunkiem;

}
else
{

Instrukcja_pod_niespelnionym_warunkiem;

}

16

31

Wybór pełny - przykład

if (a == 5)

System.Console.WriteLine("A to 5");

else

System.Console.WriteLine("A to nie 5");

System.Console.WriteLine(

a==5 ? "A to 5" : "A to nie 5");

To samo z użyciem operatora ternarnego:

32

Wybór wielokrotny

• Polega na wykonaniu przy spełnieniu podanego

warunku instrukcji A, przy spełnieniu innego

podanego warunku instrukcji B, ...,

a przy niespełnieniu żadnego z podanych

warunków instrukcji Z

• W C# zapiszemy go następująco:

switch (WYRAŻENIE)
{

case WARTOŚĆ1:

Instrukcja1;
break;

case WARTOŚĆ2:

Instrukcja2;
break;

default:

Instrukcja_inna;
break;

}

17

33

Wybór wielokrotny - przykład

switch(a)

{

case 0:

Console.WriteLine("a to 0");

break;

case 1:

case 2:

Console.WriteLine("a to 1 lub 2");

break;

default:

Console.WriteLine(

"a jest wi

ę

ksze ni

ż

2 ");

break;

}

34

Pętla

z testem na początku cyklu

• Polega na powtarzaniu wykonywania instrukcji

tak długo, jak zachodzi podany warunek

• W C# zapiszemy ją następująco:

while (WARUNEK)
{

Instrukcja_w_pętli

}

• Instrukcje w pętli wykonywane będą wiele razy,

aż warunek przestanie być spełniony

18

35

Pętla z testem na początku

cyklu - przykład

using System;

class WhileLoop

{

public static void Main()

{

int myInt = 0;

while (myInt < 10)

{

Console.Write("{0} ", myInt);

myInt++;

}

Console.WriteLine();

}

}

36

Pętla

z testem na końcu cyklu

• Polega na powtarzaniu wykonywania instrukcji

tak długo, jak zachodzi podany warunek, ale co
najmniej jeden raz

• W C# zapiszemy ją następująco:

do
{

Instrukcja_w_pętli

} while (WARUNEK)

• Instrukcje w pętli wykonywane będą wiele razy,

aż warunek przestanie być spełniony

19

37

Pętla z testem na końcu cyklu -

przykład

using System;

class WhileLoop

{

public static void Main()

{

int myInt = 0;

do {

Console.Write("{0} ", myInt);
myInt++;

} while (myInt < 10)

Console.WriteLine();

}

}

38

Pętla

o ustalonej liczbie cykli

• Polega na powtarzaniu wykonywania

instrukcji zadaną liczbę razy

• W C# zapiszemy ją następująco:
for (INICJACJA; WARUNEK;

MODYFIKACJA)

{

Instrukcja_w_pętli1

}

• Instrukcje w pętli

wykonane zostaną
zadaną liczbę razy

n

20

39

Pętla o ustalonej liczbie cykli -

przykład

using System;

class ForLoop

{

public static void Main()

{

for (int i=0; i < 20; i++)

{

if (i == 10)

break;

if (i % 2 == 0)

continue;

Console.Write("{0} ", i);

}

Console.WriteLine();

}

}

40

Pętla

po elementach sekwencji

• Polega na powtarzaniu wykonywania

instrukcji dla każdego elementu
sekwencji

• W C# zapiszemy ją następująco:
foreach (ZMIENNA in LISTA_WARTOŚCI)
{

Instrukcja_w_pętli

}

• Instrukcje w pętli

wykonane zostaną tyle razy, ile jest
elementów sekwencji

n

21

41

Pętla po elementach sekwencji

- przykład

using System;

class ForEachLoop

{

public static void Main()

{

string[] names = {"Cheryl", "Joe", "Matt",

"Robert"};

foreach (string person in names)

{

Console.WriteLine("{0} ", person);

}

}

}