java_podstawy 182 Kb May 31 2008 05:31:47 PM

Komentarze
W Javie istnieją dwa rodzaje komentarze:
Komentarz wierszowy:
// to jest komentarz wierszowy
Komentarz blokowy:
/*
To jest komentarz blokowy
Może zawierać wiele linii tekstu
Komentarze blokowe nie mogą być
zagnieżdżone
*/
Typy danych – typy całkowite
Java jako język opisowy musi mieć
zadeklarowane typy danych – istnieje osiem tzw.
prymitywnych typów danych.
Typy całkowite:
int
short
long
byte
4 bajty
2 bajty
8 bajtów
1 bajt
od -2147483648 do 2143483647
od -32768 do 32767
obejmuje zakres 2 do potęgi 64
od -128 do 127
W jeżyku Java brak jest typów UNSIGNED (bez znaku)
Typy danych – typy zmiennoprzecinkowe
Istnieją dwa typy zmienno przecinkowe:
float
4 bajty
double 8 bajtów
(7 cyfr dziesiętnych)
(15 cyfr dziesiętnych)
Istnieją dodatkowo trzy specjalne wartości
zmiennoprecinkowe:
Dodatnia nieskończoność
● Ujemna nieskończoność
● NaN (wartość nie liczbowa – not a number)
●
Typy danych – typ znakowy
Typ ten określa pojedynczy znak – w języku Java
jest do tego standard Unicode.
Do określenia tego typu używamy słowa
kluczowego char.
Aby określić stałą znakową używamy apostrofów
– cudzysłów określa łańcuch znakowy.
Typy danych - typ boolean
Typ ten zwany również typem logicznym
przyjmuje dwie wartości prawdę (true) lub fałsz
(false). Zmienne tego typu definiujemy za pomocą
słowa kluczowego boolean.
Deklaracja zmiennych
W jeżyku Java każda zmienna ma swój typ. Typ
zmiennej określamy przez podanie nazwy typu
przed nazwą zmiennej:
int liczba;
double podatek;
long zarnaPiasku;
char znak;
boolean zalogowany;
Inicjalizacja
Inicjalizacja – czyli przypisanie wartości do
zmiennej.
int wiek;
//deklaracja zmiennej
wiek = 25; //inicjalizacja zmiennej
można wykonać to razem:
int wiek = 25; //deklaracja + przypisanie
Stałe
Do oznaczania wyrażeń stałych używamy słowa final.
Słowo to oznacza, że raz przypisanej wartości nie można już
nigdy zmieniać.
Przyjęto konwencję, że stałe piszemy wielkimi literami.
public class Stale
{
public static void main(String[] args)
{
final double PI = 3.14;
double promien = 2.0;
System.out.println(”Obwód koła o promieniu 2
wynosi : ” + 2 * promien*PI);
}
}
Operator + służy w przykładzie do dodawania łańcuchów
znakowych.
Funkcje i stałemklasy Math
Język Java dostarcza nam za pośrednictwem klasy Math
całym asortyment funkcji matematycznych. Podstawowe to:
●
●
●
●
●
●
●
●
Math.sqrt(x)
Math.pow(x, a)
Math.sin(x)
Math.cos(x)
Math.tan(x)
Math.atan(x)
Math.exp(x)
Math.log(x)
oraz stałe:
- pierwiastek kwadratowy z x
- x do potęgi a
- sinus
- cosinus
- tangens
- arkustangens
- funkcja ekspotencjalna
- logarytm naturalny
Math.PI
● Math.E
a także funkcję generującą liczby pseudolosowe:
● Math.random()
- z zakresu [0 - 1)
●
Łańcuchy
Java nie posiada typu łańcuchowego, posiada za
to predefiniowaną klasę String. Każdy opatrzony
cudzysłowami łańcuch jest instancją klasy String.
String lancuch = ””; //łańcuch pusty
String imie = ”Ala”;
UWAGA: 'a' – to nie łańcuch – to char (znak)
Konkatencja łańcuchów
String lancuch1 = ”Ala”;
String lancuch2 = ”Ma kota”;
String zdanie = lancuch1 + lancuch2;
Użycie powyższego:
System.out.println(”Znane wszystkim zdanie to : ”
+lancuch1 +lancuch2);
Wybrane metody klasy String
char charAt(int index) – zwraca znak na pozycji index
boolean endsWith(String sufix) – zwraca true jeżeli dany
łańcuch kończy się łańcuchem sufiks
boolean equals(String inny) – zwraca true jeżeli dany
łańcuch jest równy łańcuchowi inny
boolean equalsIgnoreCase(String inny) – j.w
int length() - zwraca długość łańcucha
String repalce(char startZnak, char nowyZnak) –
zwraca łańcuch powstały w wyniku zamiany w danym łańcuchów
wszystkich wystąpień „starZnak” na „nowyZnaki”.
Wybrane metody klasy String cd.
Boolean startsWith(String prefix) – zwraca true jeżeli
łańcuch zachyna się od ciągu prefix
String substring(int poczatek, int koniec) – zwraca
nowy łańcuch będący wycinkiem danego łańcucha od indeksu
początek do indeksu koniec lub do końca danego łańcucha
jeżeli nie podano końca
String toLowerCase(), String toUpperCase –
zamieniają wszystkie znaki łańcucha na odpowiednio małe lub
duże litery
String trim() - obcina tzw. „białe” znaki występujące na
początku lub końcu łańcucha.
Tablice w języku Java
Aby utworzyć tablicę używamy operatora new:
int[] tablica = new int[10];
Wypełniamy taką tablicę w np. W pętli:
for (int i=0; i<10;i++)
tablica[i]=i;
Aby wyświetlić taką tablicę:
for (int j=0; j<tablica.length);j++)
System.out.println(tablica[j]);
Tablice – inny sposób inicjalizacji
W jeżyku Java możemy również inicjalizować
tablice w następujący sposób:
int[] tablica = {1,2,3,4,5,6,7,8,9};
inicjalizując w ten sposób nie używamy słowa new
Tablice wielowymiarowe
int[][] tablica2D = new int[wymiar][wymiar];
lub jeżeli nie chcemy aby była to tablica równej długości to
możemy:
int[][] tablica2D = new int[wymiar][];
for (int i=0;i<wymiar;i++)
tablica2D[i] = new int[inny_wymiar];
Kopiowanie tablic
int tablica1 = {1, 2, 3, 4, 5 };
int tablica2 = {6,7,8};
Kopiowanie tablic odbywa się z użyciem metody arraycopy klasy
System
Składnia wywołania wygląda w następujący sposób:
System.arraycopy( źródło, indeksŹródła, cel,
indeksCelu, ilość);
Przykład na naszych tablicach:
System.arraycopy(tablica2, 0, tablica1, 5,
tablica2.length);
Kopiowanie tablic - przykład
public class Main {
public static void main(String[] args) {
int[] tablica1 = {1,2,3,4,5};
int[] tablica2 = {6,7,8,9};
for(int i=0; i<tablica1.length;i++)
System.out.println(tablica1[i]);
System.out.println("------------");
System.arraycopy(tablica2,0,tablica1,0,tablica2.length);
for(int i=0; i<tablica1.length;i++)
System.out.println(tablica1[i]);
}
}
Blok instrukcji
Ciąg poleceń otoczonych parą nawiasów klamrowych
nazywamy blokiem instrukcji. Bloki instrukcji mogą być
zagnieżdżone w innych blokach.
{
int a = 10;
{
String tekst = ”Ala ma kota”;
} //definicja zmiennej tekst obowiązuje tylko dotąd !
} //koniec bloku zewnętrznego zmienna a nie istnieje poza
tym blokiem
Blok instrukcji - uwaga
W języku JAVA nie ma możliwości przekrywania zmiennych,
zmienne wewnątrz bloków nie mogą mieć identycznych nazw
jak zmienne w blokach otaczających.
{
}
int b = 10;
{
int b = 15;
}
powyższy kod wygeneruje błąd podczas kompilacji !
Instrukcje warunkowe
Ogólna postać instrukcji warunkowej wygląda następująco:
if (warunek logiczny) polecenie;
lub
if (warunek logiczny)
{
blok instrukcji;
}
if (warunek logiczny)
{
blok instrukcji;
}else
{
blok instrukcji;
}
lub
Instrukcje warunkowe - przykład
im p o r t ja v a x .s w in g .*;
p u b lic c la s s W ie k
{
p u b lic s ta tic v o id m a in (S tr in g [] a r g s )
{
fin a l in t d o r o s ly = 1 8 ;
S tr in g tm p = J O p tio n P a n e .s h o w In p u tD ia lo g ("ile m a s z la t?");
in t w ie k = In te g e r .p a r s e In t(tm p );
if (w ie k < d o r o s ly ) S y s te m .o u t.p r in tln ("to n ie je s t d la d z ie c i !");
els e S y s te m .o u t.p r in tln ("D la d o r o s ły c h te ż to n ie je s t ");
}
}
Pętla while oraz do while
Ogólna postać pętli while:
while (warunek logiczny)
{
blok instrukcji;
}
do
{
blok instrukcji;
}while (warunek logiczny)
Pętla while - przykład
im p o r t ja v a x .s w in g .*;
p u b lic c la s s E m e r y tu r a {
p u b lic s ta tic v o id m a in (S tr in g [] a r g s ) {
S tr in g tm p = J O p tio n P a n e .s h o w In p u tD ia lo g ("Ile p o tr z e b u je s z n a
e m e r y tu r ę ?");
in t k a p ita l = In t e g e r .p a r s e In t (tm p );
tm p = J O p tio n P a n e .s h o w In p u t D ia lo g ("J a k ą k w o t ę b ęd z ie s z o d k ła d a ł
c o r o k ?");
in t k w o ta W p la ty = I n te g e r .p a r s e In t(tm p );
in t s ta n K o n t a = 0 ;
in t la ta = 0 ;
while (s ta n K o n ta < k a p ita l)
{
s ta n K o n ta + = k w o ta W p la ty ;
la ta + + ;
}
S y s te m .o u t .p r in tln ("N a e m e r y t u r e p r z e jd z ie s z z a : "+ la t a + " la t");
}
Pętla do while - przykład
im p o r t ja v a x .s w in g .*;
p u b lic c la s s G r a {
p u b lic s ta tic v o id m a in ( S tr in g [] a r g s ){
in t z a k r e s = 1 0 ;
in t w y lo s o w a n a = (in t)(M a th .r a n d o m () * z a k r e s );
in t lic z b a = 0 ;
S tr in g tm p ;
do
{
tm p = J O p tio n P a n e .s h o w In p u tD ia lo g ("P o d a j lic z b ę ");
if (tm p .e q u a ls ("K ")) b r e a k ;
lic z b a = In te g e r .p a r s e In t(tm p );
if (lic z b a > w y lo s o w a n a ) S y s te m .o u t.p r in tln ("Z a d u ż a !");
e ls e if (lic z b a < w y lo s o w a n a ) S y s te m .o u t.p r in tln ("Z a m a ła !
");
} while (lic z b a != w y lo s o w a n a );
}
}
Pętla for
for (int i=0; i<10;i++)
{
System.out.println(i);
}