Klasy. Obiekty i referencje...

---

Definicja Klasy

Na początek przypomnę z czego się składa definicja klasa. Mianowice każda klasa składa się z pól, konstruktora, i metod. Pola i metody klasy nazywa się składowymi klasy.

Klasa: jest to opis takich cech grupy podobnych obiektów, które są dla nich nie zmienne.

Przykładowa definicja klasy:

    public class Osoba{
    // cialo klasy:

   // pola ( atrybuty )
    private String imie;       
    private String nazwisko;
    private char plec;
    private int wiek;

   // konstruktor ( specjalna operacja inicjacji ) 
     public Osoba(String imie, String nazwisko, char plec, int wiek) {
          this.imie  = imie;
          this.nazwisko = nazwisko;
          this.plec = plec;
          this.wiek = wiek;     
     }

   // metody ( uslugi, polecenia )
    public void zmienWiek(){
        wiek++;
    }

    public char getPlec(){
        return plec;
    }

    public String przedstawSie(){
        return imie + " " + nazwisko;
    }

    public void zmienPlec(char plec){
       this.plec = plec;
    }    
}

Teraz mając klasę musimy utworzyć obiekt dla naszej klasy. Obiekty tworzymy przy pomocy wyrażenia new

Osoba osoba = new Osoba("Jacek","Placek",'M',25);

I w ten o to sposób mamy utworzony obiekt naszej klasy, aby wykonać jakieś polecenie do obiektu posługujemy się ".", a wygląda to np tak:

osoba.przedstawSie();
osoba.zmienPlec('K');

Pola i metody w klasie mogą być statyczne i niestatyczne. Co różni te pola ? Jak wiemy pola niestatycznych zawsze wiążą się z istnieniem jakiś obiektów. Czyli jeśli nie utworzymy obiektu danej klasy nie istnieją pola ani metody. Teraz tak składowe stałe charakteryzują się:

• nie dotyczą obiektów, ale całej klasy - są wspólne dla wszystkich obiektów tej klasy
• są deklarowane przy użyciu specyfikatora static
• mogą być używane nawet wtedy gdy nie istnieje żaden obiekt klasy

Do statycznych składowych powinniśmy się odwoływać poprzez:     NazwaKlasy.NazwaSkładowej

Obiekty i referencje

Postaram się opisać tu taj wszystko jak najszybciej i pokazać co różnicę między obiektem a referencją. Więc zaczynamy...
Jak wiemy obiekt jest reprezentacją jakiegoś szablonu czyli klasy. Na przykład mamy klasę Para, to będzie nasza jakaś instancja obiektu która będzie reprezentowana przez jakąś zmienną.
Para p
Jak pisałem wcześniej obiekt tworzymy przy pomocy słowa new
Para p = new Para(1,2)
Więc co to za zmienna 'p', w sumie deklaracja wygląda tak samo jak przy typach prostych. Więc czym się to różni. Deklarując zmienna typu prostego np. int i = 2 wydzielamy dla niej pamięć, aby mogła być ona przechowywana, więc nasza zmienna i jest synonimem dla naszej liczby całkowitej. Zmienna ta w tym przypadku przechowuje liczbę całkowitą 32 bitowa i w miejsce pamięci oznaczone przez 'i' wpisuje 2, wygląda to mniej więcej tak:

        int i; ---> 0000 0000 0000 0000 0000 0000 0000 0000       
        i = 2; ---> 0000 0000 0000 0000 0000 0000 0000 0010     

Przydzielamy pamięć dla zmiennej i, a następnie następuje wpisanie liczby do pamięci. Teraz w przypadku deklaracji zmiennej która będzie wskazywać na obiekt sytuacja wygląda całkiem inaczej. W przypadku obiektów zastosowanie słowa new przydziela dynamiczną pamięć, która ulega zmianie w czasie działania programu. Wynikiem tego słowa jest przydzielenie adresu w pamięci która została przydzielona obiektowi. Więc:
Referencja to wartość, która oznacza lokalizację obiektu w pamięci.
Otóż w Javie oprócz typów numerycznych i typu boolowskiego istnieje jeszcze tylko jeden typ - typ referencyjny.

public class Roznica {

  public static void main(String[] args) {

    // Operacje na zmiennych typów prostych
    int x, y, z;
    x = 3;
    y = 4;
    x = y;
    y = 5;
    z = 5;
    System.out.println("x = " + x);
    System.out.println("y = " + y);
    System.out.println("z = " + z);
    if (x == y) 
        System.out.println ("x i y równe.");
    else 
        System.out.println ("x i y nierówne.");

    if (y == z) 
        System.out.println ("y i z równe.");
    else 
       System.out.println ("y i z nierówne."); 

    // Podobne operacje na zmiennych typu referencyjnego
    Para px = new Para(), py = new Para(), pz = new Para();
    px.set( 3, 3 );
    py.set( 4, 4 );
    pz.set( 5, 5 );
    px = py;
    py.set( 5, 5 );
    System.out.print("Para px: "); px.show();
    System.out.print("Para py: "); py.show();
    System.out.print("Para pz: "); pz.show();
    if (px == py) 
        System.out.println ("px i py równe.");
    else 
        System.out.println ("px i py nierówne.");

    if (py == pz) 
        System.out.println ("py i pz równe.");
    else 
       System.out.println ("py i pz nierówne.");

  }
}

To tyle na temat referencji, wszystko powiedziane w szybkim skrócie. Wyjątkiem są obiekty klasy String. Ze względu na to że operacje na łańcuchach znaków są dość częstymi operacjami kompilator zapewnia pewne ułatwienia.
String s = "Ala ma kota";
Zapis ten spowoduje stworzenie obiektu klasy String z zawartością "Ala ma kota" i przypisanie referencji do tego obiektu zmiennej s. Zatem, wyjątkowo, tworząc obiekty klasy String nie musimy używac wyrażenia new.

---