Część trzecia - konstruktory z parametrami, pętle, tablice

[javaman]

Na początek, chciałbym Was serdecznie przeprosić za dość długi czas nieobecności, wynikało to po prostu z nawału różnych spraw które zwaliły mi się na raz na głowę.

Zaczynajmy więc, dzisiaj zaczniemy od kontynuacji poprzedniego tematu - tj. konstruktorów. Do czego służą, i jak się ich używa już wiecie, kto nie wie, zapraszam do drugiej części. Przypomnę ogólną deklarację konstruktora domyślnego:

public class Klasa{
int pole1;
int pole2;
String pole3;
// Tutaj konstruktor:
Klasa(){
//to jest konstruktor domyślny, możemy tutaj przeprowadzić jakieś operacje
}
}

Jeśli nie zdeklarujemy konstruktora domyślnego, nic się nie stanie. Po prostu zostanie dodany przez JVM. Deklarując taki konstruktor, przesłaniamy konstruktor domyślny. Oznacza to, że ten który jest przez JVM dodawany, przestaje funkcjonować, a w jego miesce wskakuje ten zadeklarowany przez nas, i to właśnie działania określone w nim zostaną przeprowadzone. Pola oczywiście inicjowane są w.g zasad określonych w poprzedniej lekcji. Jednak aby tak się stało muszą zostać spełnione pewne warunki:

-Konstruktor musi być bezparametrowy - czyli postaci Konstruktor()
-Konstruktor o jednej postaci może być tylko jeden - o tym kawałek dalej, na ten moment przyjmijcie, że konstruktor postaci Konstruktor() możecie zdeklarować tylko raz.

Konstruktor może też przyjmować parametry, jak kazda inna metoda. Różni się jednak od zwyczajnej metody tym, że wywołując go, tworzymy nowy obiekt, podczas gdy zwyczajna metoda jest wywoływana z istniejącego juz obiektu.
Poniżej przykłady:

public class Klasa{
int pole1;
int pole2;
String pole3;
// Tutaj konstruktor domyślny:
Klasa(){
//jakieś operacje
}
Klasa(int param1, int param2, String param3){
//to jest konstruktor z parametrami
}
}

Mamy tutaj dwa różne konstruktory. Po czym poznać że są to konstruktory a nie zwykłe metody? Po tym, że nazywają się tak samo jak klasa. Jeśli jakaś metoda nazywa się tak samo jak klasa, uwzględniając wielkość liter, to automatycznie staje się ona konstruktorem. Mamy tutaj dwa konstruktory. Jeden nie przyjmuje żadnych parametrów, drugi przyjmuje trzy. Możemy więc stworzyć obiekt na dwa różne sposoby. Stworzyć z domyślną inicjalizacją pól (patrz roz. 2), lub stworzyć podając do konstruktora parametry. Te przekazane parametry mogą postłużyć do zainicjalizowania pól. Nie jest to jednak zasada, oczywiście możemy z tymi parametrami zrobić co sobie życzymy. Możemy nawet wcale nic z nimi nie robić. Poniżej przykłady użycia.

Klasa klasa = new Klasa(); // konstruktor bez parametrów
Klasa klasa = new Klasa(1,2,"jakiś tekst"); //konstruktor z parametrami

Zdefiniujmy od razu działanie drugiego konstruktora:

public class Klasa{
int pole1;
int pole2;
String pole3;

Klasa(int param1,int param2,String param3){
pole1=param1;
pole2=param2;
pole3=param3;
}
}

Powyżej wywołania. Co się dzieje z polami obiektów przy wywoływaniu tych dwóch konstrutorów? Pokazuję i obiaśniam:

Konstruktor bez parametrów :
pole1=0 (int)
pole2=0 (int)
pole3="" (String)

Konstruktor z parametrami:
pole1=1
pole2=2
pole3="jakiś tekst"

Konstruktorów z parametrami możemy mieć dowolną ilość, jednak muszą różnić się pewnymi cechami. Mogą robić dokładnie to samo, diabeł jak zwykle tkwi w szczegółach. Otóż muszą one różnić się parametrami. Możecie mieć konstruktory o różnej liczbie parametrów. Możecie też mieć dwa konstruktory o takiej samej ilości parametrów. Parametry w takim wypadku muszą mieć różne typy. Nazwy mogą mieć różne, to nie ma znaczenia.

Tak jest ok:

Klasa(int param1, int param2){
//cośtam
}

Klasa(int param1, int param2,int param3){
//cośtam
}

tak też jest ok:

Klasa(int param1, int param2){
//cośtam
}

Klasa(int param1, String param2){
//cośtam
}

Ale tak już nie jest dobrze:

Klasa(int param1, int param2){
//cośtam
}
//tak być nie może! konstruktory mają te same typy parametrów!
Klasa(int param3, int param4){
//cośtam
}

Dlaczego? Jeśli zachcielibyście wywołać taki konstruktor ( stworzyć przy jego pomocy obiekt ) to z kąd JVM miałoby wiedzieć którego konstruktora użyć?
Mam nadzieję, że to wam przejaśni nieco istotę działania konstruktorów. Ze względu na ograniczenie ilości znaków w poście, dalsza część będzie dostępna w następnym poście.

[javaman]

Jak widzicie, staram się teraz iść za waszymi wskazówkami, dawać więcej przykładów i szerzej omawiać pojedyńcze tematy. Będziemy dalej śróbować tak, by to było dokładnie to, czego oczekujecie. Tak więc standardowo czekam na głosy !konstruktywnej! krytyki . Zastanawiam się nad pewnymi aspektami nie związanymi z samą javą, a raczej z pewnymi aspektami programowania omawianymi np. na studiach. W sumie niedługo będziemy w momencie, kiedy będziemy mogli pogadać o rekurencji. To trudny temat. Nawet kiedyś słyszałem coś takiego: "Żeby zrozumieć rekurencję, trzeba zrozumieć rekurencję" . Ci z Was którzy studiują/studiowali informatykę, będą wiedzieli o co chodzi Czy chcecie by tego typu tematy również były omawiane na przykładzie javy? Tutaj pytanie zasadniczo nie tylko do biorących udział w kursie, ale również do tych, którzy muszą przez takie pojęcia przebrnąć, a które ja szczęśliwie mam już za sobą.

Teraz przerobimy trochę pętle. Pętle niewiele się zmieniły od czasów C, właściwie pozostały w dużej części takie same. Ot taki przykład - pętla for, zawsze ma taką samą konstrukcję, w C, w C++, w Javie, w PHP, no w assemblerze nie. Zauważyliście to kiedyś? Duża część składni języków programowania jest bezpardonowo kopiowana. Możecie więc na ogół nawet strzelać, i pisać pętle tak jak w swoim ulubionym języku, z reguły będzie działać.
Najszerzej omówię pętlę FOR, na niej poznacie ogólną zasadę działania pętli. Pozostałe pętle to zasadniczo różne wersje FORa. For jest pętlą najprostszą, używaną najczęściej do operacji, których ilość powtórzeń jesteśmy w stanie określić. Tzn. np. wiemy, że chcemy by na ekranie była przykładowo 5 krotnie wypisana jakaś wiadomość.
For ma kontrukcję następującą:

for(int x=0;x<10;x++){
}

Czyli z javy na nasze: "zacznij powtarzać od x równe zero (int x=0), powtarzaj
tak długo, jak długo x jest mniejsze od 10 (x<10), za każym powtórzeniem pętli zwiększ wartość x o jeden (x++). "
a teraz po kolei:

for(int x=0;.......

definiujemy zmienną x jako zmienną typu int, i od razu inicjalizujemy ją wartością 0. Iterator (zmienna którą używamy do kontroli pętli) musi być typu int.

...x<10...

To jest warunek pętli. Określa on jak długo ma być powtarzana pętla. W tym wypadku do momentu, aż x osiągnie 9 (bo < od 10). Zauważcie, że po każdym wykonaniu pętli, x zwiększy się o 1. Warunek może mieć też wartość >= (większy równy) <= (mniejszy równy) != (różny od) > (większy). Musicie uważać przy stawianiu warunku zakończenia, bo można popaść w niekończącą się pętlę.
Np. (tak nie róbcie!!!!):

for(x=0;x>0;x++){
}

Ta pętla będzie się powtarzać w nieskończoność. Jeśli lubicie kiedy wiesza Wam się komp, to zastosujcie to w swoim programie .

...x++);

To oznacza po prostu - zwiększ x o 1. ( z tąd z resztą nazwa C++ - po krótce można powiedzieć - "kolejna wersja C"). Iterator możecie oczywiście równie dobrze zmniejszać np.

...x--);

Nie możecie niestety zwiększać na zasadzie "x+2". Zapis poniższy byłby błędny:

for(int x=0;x<10;x+2){
}

Problem w tym, że w tym miejscu, nie może być wyrażenia jako takiego, nie może być działania bez przypisania do konkretnej zmiennej. W tym miescu powinna się znaleźć wartość X.Jak wszystko w informatyce da się to jednak obejść:

for(int x=0;x<10;x+=2){
}

Co oznacza dokładnie to samo co:

for(int x=0;x<10;x=x+2){
}

I to też da się skompilować. Musicie pamiętać, że w tego typu wyrażeniach, trzeba umieszczać wyrażenia w ten sposób, by w efekcie działań wyrażenia trafi na to miesce wynik przypisany do iteratora.

Kolejna pętla to pętla WHILE. Używana jest wtedy, gdy nie jesteśmy w stanie określić dokładnie ile razy pętla ma się powtórzyć, ale jesteśmy w stanie określić, że ma się powtarzać tak długo, jak długo określony warunek jest spełniony.

int x=0;
while (x!=10)
{
Random rand = new Random();
x = rand.nextInt();
}

Ten fragment kodu losuje liczby całkowite. Pętla będzie wykonywana tak długo, jak długo nie zostanie wylosowane 10.

Jest też inna odmiana pętli WHILE. Mianowicie DO WHILE.

int x=0;
do{
Random rand = new Random();
x = rand.nextInt();
}while(x!=10);

Pętla ta robi zasadniczo to samo... Czym więc różnią się te dwa rodzaje pętli? W pierwszej najpierw jest sprawdzany warunek, a dopiero wtedy wykonywany kod, w drugiej najpierw wykonywany kod a dopiero wtedy sprawdzany warunek. Ot szczegół, ale w praktyce przekonacie się, że warto znać obydwie te pętle.
Teraz co warto zrobić aby poćwiczyć? Bedziemy kontynuować tworzenie naszej gry, którą zaczęliśmy na ostatnnich lekcjach.
-Stwórzcie konstruktory z parametrami, które umożliwią tworzenie obiektów klasy Samochod, które umożliwią jednoczesne inicjalizowanie ich pól, oraz wyrzucanie na ekran informacji o ich parametrach. Stwórzcie kilka konstruktorów, które pozwolą na generowanie obiektów o różnych własnościach.
-Aby poćwiczyć pętle, spróbójcie napisać kod który oblicza wartość silni, przy użyciu tych trzech pętli - czyli na 3 różne sposoby. Od razu mówię. Przy jednym rodzaju pętli będziecie z tym mieli problem. Pomoże to zrozumiec na czym polegają te drobne różnice.

Teraz muszę to wszystko doprowadzić do ładu i składu, i sklecić z tego artykuł, który niedługo będzie dostępny na stronie.
Następnym razem będziemy omawiać instrukcje warunkowe. To będzie dość krótki temat. Zaraz po nim omówię tablice listy obiektów, macierze.

[javaman]

PS. ile osób pisze na bierząco tą grę?

[TQM]

Hmmm w sumie ja pisze, choc przesiadlem sie z samochodow na nieco inne obiekty hihi ale zaraz pewnie do tego wroce i zrobie implementacje. Najgorsze to to ze brakuje pomyslow co dodawac do (akurat) samochodow

No zawsze mozna dodac kolor, mozna dac rok produkcji itd

P.S.
Na razie dobrnalem we wlasnym zakresie do appletow i udalo mi sie zrobic banalny hello world z prymitywna (niby)animowana linia ktora rysuje sie pod tekstem :-) Ogolnie moja wiedza to porazka ale tak czy inaczej w koncu ruszylem nieco z materialem i czegos sie w tym zakresie nauczylem.

P.S. 2
Czy mam podeslac kod do przegladu jak zrobie implementacje?


EDIT:
Obie prace domowe wykonane... co prawda mialem nieco problemow z przyjmowaniem parametrow i ArrayIndexOutOfBoundsException (jeszcze nie nauczylem sie dziada lapac poprawnie - szczegolnie zwracac zrozumialych dla ludzi errorkow) ale liczy... Jak ktos chce to moge kod wrzucic gdzies. Samochodziki tez smigaja :P a calosc zajela zupelnie od zera okolo 30 minut.

Before we start race, let's get a few cars...
New car created
New car created - make Dodge
New car created - color red make Porshe
<unknown color> UNKNOWN car from year 1995 does 0 to 100km/h in 12.2
black Dodge from year 1995 does 0 to 100km/h in 9.8
red Porshe from year 1995 does 0 to 100km/h in 7.2

Program obliczy wartosc 7! na 3 rozne sposoby...
Liczymy w petli FOR:
  Ruch 1 --> wynik 1
  Ruch 2 --> wynik 2
  Ruch 3 --> wynik 6
  Ruch 4 --> wynik 24
  Ruch 5 --> wynik 120
  Ruch 6 --> wynik 720
  Ruch 7 --> wynik 5040
Liczymy w petli WHILE:
  1<=7 --> wynik 1
  2<=7 --> wynik 2
  3<=7 --> wynik 6
  4<=7 --> wynik 24
  5<=7 --> wynik 120
  6<=7 --> wynik 720
  7<=7 --> wynik 5040
Liczymy w petli DO-WHILE:
  wynik 1
  wynik 2
  wynik 6
  wynik 24
  wynik 120
  wynik 720
  wynik 5040

[javaman]

NIe, nie trzeba podsyłać koniecznie, to tak tylko gdyby ktoś miał jakieś kłopoty, nie rozumiał czegoś.
Co do wyjątków. Wyjątki wywodzą się(a właściwie rozszerzają) z jednego korzenia - Exception. Wszystko inne to rozszerzenia tego właśnie wyjątku. Jeśli złapiesz wyjątek wyższy w hierarchii to złapiesz wszystkie leżące niżej. np:

... catch (IOException e) { ....

spowoduje łapanie wszystkich wyjątków związanych z wejściem/wyjściem, np. zapisem lub odczytem. Możesz wtedy wywołać:

System.out.println("Wystąpił jakiś błąd związany z IO");

[TQM]

Aaaa no to teraz jasne Tutaj mniej wiecej juz bylem ale chcialem dodac cos jak e.getMessage() albo podobne do komunikatu bledu. Mniejsza o to - tyle mi wystarcza

Same cwiczenia niby banalne ale przyznam ze wyniklo po drodze kilka innych ciekawostek, ktore po prostu nie przyszly mi wczesniej do glowy. Kompilacja zdychala caly czas ze wzgledu na zasiegi zmiennych - jesli zmienna jest deklarowana w public static void main(String args[]) i wywoluje metody z parametrem (prztyklad liczenia silni) zdefiniowane jako public void petlaFor(int silnia) to petlaFor tez musi byc static - co w sumie jest logiczne i wystarczy dokladnie czytac co kompilator zwraca.

Genrealnie lekcja bardzo wartosciowa... a moze ja po prostu za bardzo skomplikowalem sobie zadanie?