Metody

Metody to kod operujący na polach klasy, lub zewnętrznych danych. Wywołujemy za pomocą operatora . (kropka), poprzedzonego nazwą zmiennej odnośnikowej.

zmienna.metoda(parametry);

Poprzez parametry przekazujemy do metody jakie śparametry , dane (oczywiście nie musimy tego robić). Dodajmy zatem do naszej wcześniejszej klasy Punkt jakieś metody.

public class Punkt
{
   int x, y;
   int getX()
   {
      return x;
   }
      int getY()
   {
      return y;
   }
}

Obiekty i klasy

W javie każdy obiekt to klasa. Jak na razie korzystałem tutaj tylko z jednej klasy o nazwie Main. Klasa definiuje ty obiektu, który jest przypisany do zmiennej, wyrażenia lub innego tworu (programistycznego). Specyfikuje on rodzaj wartości, które może przybierać ten typ.
Jeżeli typem zmiennej jest int, to może ona przybierać tylko pewne określone wartości całkowite, a więc mamy tu też pewne ograniczenie możliwych wartości. Klasa jest więc pewnego rodzaju planem, zgodnie z którym tworzymy obiekty. Te obiekty wykonują zadania lub przechowywać dane (informacje).
Załóżmy, że chcemy gdzieś w programie przechowywać dane o pikselach ekranu. Tworzymy więc klasę punkt, wedle której każdy punkt ma dwa parametry - współrzędne x i y. Będą to oczywiście zmienne typu int.

While oraz foreach

Pętla While.

while (warunek)
{
instrukcje
}

Jak widać budowa dość prosta, no to przejdźmy do przykładów.

package petlawhile;
public class PetlaWhile {
    public static void main(String[] args) {
        int i=0;
        while (i !=10)
        {
            System.out.println("Kocham Javę!"); 
            System.out.println("Licznik wynosi: " + i;
            i++;
        }
    }
}

Poniżej modyfikacja - krok inkrementacji jest zawarty wewnątrz warunku.

package petlawhile;
public class PetlaWhile {
    public static void main(String[] args) {
        int i=0;
        while (i++ !=10)
        {
            System.out.println("Kocham Javę!"); 
            System.out.println("Licznik wynosi: " + i;
        }
    }
}

Uwaga! tak prosty zabieg zmienił nam wyniki, wystarczy prześledzić wartość licznika.

Pętla do ... while.

Pętla ta jest podobna do poprzedniej. Zobaczmy więc jej konstrukcję:

do
{
instrukcje;
}
while (warunek);

Przykłady:

package petlawhile;
public class PetlaWhile {
    public static void main(String[] args) {
        int i=0;
        do
        {
            System.out.println("Kocham Javę!"); 
            System.out.println("Licznik wynosi: " + i);
            i++;
        }
        while (i!=10);
    }
}

Pętla For.

Pętla for.

konstrukcja tej pętli ma postać:

for (wyrażenie_poczatkowe; warunek; modyfikator)
{
operacje w pętli;
}

Wrażenie początkowe inicjuje zmienną używaną do sprawdzania warunku, często nazywa się ją licznikiem. Warunek musi być spełniony aby pętla mogła zostać wykonana po raz kolejny, zaś modyfikator wykonuje operacje na liczniku, coś w rodzaju numerowania kolejnego kroku. Wyrażenie modyfikujące może zostać pominięte, lecz wtedy najczęściej znajduje się ono wewnątrz pętli.

Switch - równanie kwadratowe po raz drugi.

Operacja wyboru Switch ma następującą konstrukcję:

switch (a)
{
   case wartość1:
      {
      instrukce1;
      }
   case wartość2:
      {
      operacje2;
      }
   break;
   default:
      {
      instrukcje_dla_default;
      }
}

No to działamy:

package pierwiastki;

public class Pierwiastki {

    public static void main(String[] args) {
        
      int paramA = 1, paramB = 4, paramC = -6;
      System.out.println("parametr a = " + paramA);
      System.out.println("\nparametr b = " + paramB);
      System.out.println("\nparametr c = " + paramC + "\n\n");
      switch (paramA)
       case 0:
       {
            System.out.println("To nie jest równanie kwadratowe gdyż " + paramA);
            System.out.println(" jest równy zero\n\n");
       }
       break;
       default:
       {
           double delta;
           delta = Math.pow(paramB,2) - 4 * paramA * paramC;
           if (delta < 0)
         {
            System.out.println("Brak rozwiązań, gdyż delta < 0.\n");
         }
         else
         {
            if (delta == 0)
            {
               long wynik;
               wynik = -1 * paramA * paramB /2;
               System.out.println("Jedno rozwiązanie o wartości x = " + wynik + "\n\n");
            }
            else
            {
               double wynik;
               wynik = (- paramB + Math.sqrt(delta)) / (2 * paramA);
               System.out.println("Pierwszy pierwiastek wynosi: " + wynik + "\n");
               wynik = (- paramB - Math.sqrt(delta)) / (2 * paramA);
               System.out.println("Drugi pierwiastek wynosi: " + wynik + "\n");
            }
         }        
       }    
    } 
}

Wyznaczamy pierwiastki równania kwadratowego.

Potrzebna nam będzie tutaj instrukcja warunkowa if ... else. Wygląda ona tak:

if (a>0) 
{
zestaw operacji gdy warunek ma wartość true;
}
else
{
operacje dla wartości false;
}

Jak zatem wygląda nasze rozwiązania kwadratowego (podaje kod niestety nie sprawdzony w kompilatorze)?

Operatory, czyli podstawy matematyki.

Operatory arytmetyczne.

Operatory pozwalają na wykonywanie operacji na obiektach. Najprostszym przykładem są operatory arytmetyczne:

• dodawanie +
• odejmowanie -
• mnożenie *
• dzielenie /
• dzielenie modulo %

Dzielenie modulo to oczywiście wyłuskanie reszty z dzielenia. Do tego kompletu mamy operary inkrementacji i dekrementacjji. Oba w wersji przedrostkowej i przyrostkowej. 

++x najpierw inkrementacja potem użycie x

x++ najpierw używa x potem inkrementacja.

Należy pamiętać też, że dzielenie / w zakresie liczb całkowitych daje wynik całkowity. Jeśli nawet wynik jest obarczony jakimś ułamkiem, to zostanie on zaokrąglony w dół, np 5/2=2.

Z pomocą przychodzi dzielenie modulo, które odpowiednio wykorzystane, może nam uratować wynik, 5%2=1.

Zmienne odnośnikowe i pierwsza tablica.

Typy odnośnikowe deklaruje się jak wszystkie inne. Nie ma więc co się rozpisywać. Deklarujemy jednak nie sam obiekt lecz odniesienie do niego - referencję. Referencji takiej jest domyślnie przypisywana wartość null, przez co nie można z nią prawie nic zrobić. Dopiero po powołaniu do życia obiektu i powiązaniu go z zadeklarowaną zmienną możemy coś zdziałać. Na przykład:

int a;

daje nam gotową do użycia zmienną. Możemy jej nadać wartość np. 10. Żeby jednak móc korzystać z dobrodziejstw tablic musimy zadeklarować zmienną odnośnikową typu tablicowego. Potem tworzymy obiekt tablicy i powiązujemy go ze zmienną. Po tym wszystkim możemy swobodnie odwoływać się do kolejnych elementów tablicy. A więc po kolei, deklaracja odniesienia do tablicy:

Deklarowanie zmiennych

Aby móc użyć zmiennej, trzeba ją zadeklarować. Poniżej kilka przykładów deklaracji zmiennych.

Dwie zmienne.

public class Main
{
   public static void main (String args[])
   {
      int liczbaPierwsza;
      int liczbaDruga;
      liczbaPierwsza = 1;
      liczbaDruga = 10;
      System.out.println(:Pierwsza nasza liczba: " + liczbaPierwsza);
      System.out.println("druga zas to: " + liczbaDruga);
   }
}

Zmienne.

Jak wiadomo, każdy program potrzebuje miejsca, gdzie zapisywane będą wyniki i dane potrzebne do jego pracy. Aby to miejsce zapewnić korzystamy ze zmiennych.
Każda zmienna musi mieć swoją nazwę oraz jasno określony typ. Podstawowe typy to:

• całkowitoliczbowe
• zmiennopozycyjne
• logiczny
• znakowy

Typy całkowite.

Zebrane są one w poniższej tabeli:

JAVA - język obiektowy.

Java to język w pełni obiektowy. Oznacza to, że mamy w nim do czynienia z obiektami i metodami powiązanymi z obiektami. Co to jest obiekt? Na co dzień mamy do czynienia z drzewami, samochodami itp. To są obiekty, ale piksel na ekranie, lub inna nieco bardziej abstrakcyjna forma, wymyślona przez nas na potrzeby programu też nią może być. Ważne jest to, ze każdy obiekt ma swoje właściwości opisywane przez pola obiektu i operujące na nim metody.

Obiekt przechowuje dane i wykonuje zaprogramowane czynności.

Klasa to opis obiektu. Obiekt to instancja klasy (wystąpienie, zaistnienie klasy). Metody zaś to funkcje, które można na danym obiekcie wykonywać - np. piksel - zapal (obiekt i jego funkcja).

Prosty program i komentarze.

Zbadajmy co nieco prosty program w Javie, np. taki jak w ostatnim poście. Jego kod może wyglądać tak:

package javaapplication5;

public class JavaApplication5 {

    public static void main(String[] args) {
        // TODO code application logic here
        
        System.out.println("program przykładowy");
    }
}

Na tym schemacie opierają się wszystkie aplikacje. Uwaga! Wielkość liter ma znaczenie!
Słowo kluczowe public oznacza tutaj nazwę modyfikatora dostępu. Określa ono jaki dostęp do kodu mają inne części programu.
Class oznacza odwołanie do jakiejś klasy (więcej w swoim czasie). W Javie wszystko opiera się na klasach. Są to zbiory mechanizmów programu, dzięki którym może on działać.

Hellou Swiecie! - pierwszy program w Javie pod NetBeans.

Zakładam, że każdy kto czyta ten wpis, jest ciekawy języka JAVA. Pierwsze kroki powinny zaś zatem skierować wprost na strony projekty NetBeans, skąd pobieramy i instalujemy niezbędne środowisko programistyczne. Po dokończeniu procesu instalacji mozemy zacząć naukę JAVA.