zajecia2JTP, Java - podstawy
[ Pobierz całość w formacie PDF ]
Języki i techniki programowania 
Zajęcia 2 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Autor: Marcin Orchel 
Spis treści: 
 
Język C++ ............................................................................................................................. 3
 
Przekazywanie parametrów do funkcji ........................................................................... 3
 
Przekazywanie parametrów w Javie. .......................................................................... 3
 
Przekazywanie parametrów w c++ ............................................................................. 3
 
Ogólne zasady przekazywania parametrów ............................................................... 5
 
Przypisanie ...................................................................................................................... 5
 
Porównywanie obiektów ................................................................................................ 5
 
Inicjalizacja obiektów ...................................................................................................... 6
 
Modyfikator const ........................................................................................................... 6
 
Zwracanie wartości przez funkcję ................................................................................... 6
 
Techniki programowania .................................................................................................... 7
 
Zadania ................................................................................................................................ 8
 
 
Język C++ 
 
Przekazywanie parametrów do funkcji 
Przekazywanie parametrów w Javie. 
 
W Javie parametry przekazywane są przez wartość. 
 
Zmienne typów prostych, takich jak int, float odnoszą się bezpośrednio do liczb. 
Zmienne typów złożonych, takich jak tablice, klasy definiowane przez użytkownika, itd.  
odnoszą się do wskaźników do obiektów. 
Przykład 
void foo(int i, Float number1, int [] array1, List<Integer> list1, Triangle triangle1) 
{ 
} 
Wartość i jest kopiowana na stos.  
Wskaźnik do number1 jest kopiowany na stos. 
Wskaźnik do tablicy array1, która jest obiektem jest kopiowany na stos.  
Wskaźnik do list1 jest kopiowany na stos. 
Wskaźnik do triangle1 jest kopiowany na stos. 
 
Przekazywanie parametrów w c++ 
 
1. W c++ parametry mogą być przekazywane przez wartość. 
Zmienne oznaczają bezpośrednio obiekty. 
void foo(int i, int array[10], Triangle triangle1) 
 
Wartość i jest kopiowana na stos. 
Tablice w c++ są w rzeczywistości wskaźnikami na pierwszy element, a więc będzie 
kopiowany na stos tylko wskaźnik. 
Na stos będzie kopiowany obiekt triangle1 zdefiniowany przez użytkownika. 
 
2. W c++ parametry mogą być przekazywane przez referencję. 
void foo(int & i, Triangle & triangle1) 
wywołanie funkcji foo(i, triangle) 
 
Referencja to stały wskaźnik (int *const p). Oznacza to, że nie można zmienić 
wskazywanego obiektu na inny. We funkcji na obiekt triangle mówimy triangle1. Na stos 
kopiowany jest wskaźnik do liczby i, oraz wskaźnik do obiektu triangle. 
 
Dana zmienna w Javie może wskazywać na różne obiekty, w c++ referencje są stałymi 
wskaźnikami, a więc nie może się zmieniać obiekt, na który wskazują. 
 
Przykład: 
Java: 
Triangle triangle1 = new Triangle(); 
Triangle triangle2 = new Triangle(); 
triangle1 = triangle2; 
Wskaźnik triangle1 wskazuje poźniej na triangle2. Obiekt na który wskazywał na 
początku triangle1 zostanie usunięty przez garbage collector. 
 
C++: 
Triangle & triangle1 = Triangle(); 
Triangle & triangle2 = Triangle(); 
Nie można zmienić wskazania triangle1 (triangle1  = triangle2 tutaj zostanie 
uruchomione kopiowanie obiektów) 
 
Przykładowe zastososowanie referencji: 
konieczność zmiany przekazywanego obiektu we funkcji. 
 
 
Referencje w c++ nie zabezpieczają w 100% przed błędami pracy na nieznanym obszarze 
pamięci, ze względu na istnienie wskaźników w c++. 
Do funkcji przyjmującej argument (int & p) można podać p, gdzie p jest zdefiniowane int 
*p, ale nie zostało zainicjalizowane. Przez co p wskazuje na nieznany obszar pamięci. W 
Javie każda zmienna typu złożonego musi zostać zainicjalizowana, dlatego nie ma 
problemu ze wskazaniem na nieznany obszar pamięci. 
  
Stała referencja 
 
Jeśli funkcja przyjmuje argument: int & a, czy można podać do tej funkcji liczbę np. 2 + 
2? 
Wartość wyrażenia jest stała, dlatego można to zrobić pod warunkiem, że argumentem 
funkcji będzie stała referencja: const int & a. 
Jak jest implementowana stała referencja? const int *const p; 
 
 
3. W c++ parametry mogą być również przekazywane za pomocą wskaźników. 
 
void foo(int * i, Triangle * triangle1) 
Na stos kopiowane są wskaźniki (adresy) do liczby i oraz obiektu triangle1. 
 
Porównanie referencji i wskaźników 
W większości wypadków referencje są bezpieczniejsze od wskaźników, ponieważ 
referencje muszą być inicjalizowane adresem obiektu. 
 
Ogólne zasady przekazywania parametrów 
 
Parametry niewielkich rozmiarów można przekazywać przez wartość, 
gdy parametry mają większy rozmiar lepiej przekazywać je przez referencję. 
 
Przypisanie 
 
a = b 
 
W Javie dla typów złożonych kopiowany jest tylko wskaźnik. 
W c++ przypisanie będzie dotyczyło kopiowania obiektów.  
 
Jeśli a i b to są referencjami to podczas przypisania b do a będzie kopiowany obiekt b. 
Referencja nie może być zmieniana. Tutaj modelem referencji, która wyjaśnia to 
kopiowanie jest traktowanie referencji jako przezwiska. Kopiowane są obiekty bo 
referencje są tylko przezwiskami tych obiektów. 
 
Kopiowanie obiektów w Javie. 
Implementacja interfejsu cloneable i nadpisanie metody clone. 
Implementacja metody clone na tablicach: dla każdego elementu są tworzone 
referencje do elementów wyjściowych, chyba, że są to typy proste, wtedy jest robione 
kopiowanie tych liczb. Kopiowanie tylko referencji nazywa się shallow copy, w 
przeciwieństwie do deep copy. 
 
Porównywanie obiektów 
 
W javie porównywanie za pomocą operatora == porównuje zmienne, które są 
wskaźnikami do obiektów. A więc nie ma porównania samych obiektów, tylko ich 
adresów. 
Przykład: 
String a = „a”; 
String b = „a”; 
warunek a == b nie będzie spełniony. 
Jeśli zachodzi konieczność porównania zawartości obiektów to wywołuje się metodę 
equals. 
W C++ aby porównać dwa obiekty konieczne jest zdefiniowanie dla nich operatora ==. 
Dla typu string operator ten zdefniowany jest jako porównanie leksykalne. 
[ Pobierz całość w formacie PDF ]