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:

1.  public class Osoba{  
2.  // cialo klasy:  
3.   
4. // pola ( atrybuty )  
5.  private String imie;         
6.  private String nazwisko;  
7.  private char plec;  
8.  private int wiek;  
9.   
10. // konstruktor ( specjalna operacja inicjacji )   
11.   public Osoba(String imie, String nazwisko, char plec, int wiek) {  
12.        this.imie  = imie;  
13.        this.nazwisko = nazwisko;  
14.        this.plec = plec;  
15.        this.wiek = wiek;       
16.   }  
17.   
18. // metody ( uslugi, polecenia )  
19.  public void zmienWiek(){  
20.      wiek++;  
21.  }  
22.   
23.  public char getPlec(){  
24.      return plec;  
25.  }  
26.   
27.  public String przedstawSie(){  
28.      return imie + " " + nazwisko;  
29.  }  
30.   
31.  public void zmienPlec(char plec){  
32.     this.plec = plec;  
33.  }      

    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

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

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:

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

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.

1. public class Roznica {  
2.   
3.   public static void main(String[] args) {  
4.   
5.     // Operacje na zmiennych typów prostych  
6.     int x, y, z;  
7.     x = 3;  
8.     y = 4;  
9.     x = y;  
10.     y = 5;  
11.     z = 5;  
12.     System.out.println("x = " + x);  
13.     System.out.println("y = " + y);  
14.     System.out.println("z = " + z);  
15.     if (x == y)   
16.         System.out.println ("x i y równe.");  
17.     else   
18.         System.out.println ("x i y nierówne.");  
19.   
20.     if (y == z)   
21.         System.out.println ("y i z równe.");  
22.     else   
23.        System.out.println ("y i z nierówne.");   
24.   
25.     // Podobne operacje na zmiennych typu referencyjnego  
26.     Para px = new Para(), py = new Para(), pz = new Para();  
27.     px.set( 3, 3 );  
28.     py.set( 4, 4 );  
29.     pz.set( 5, 5 );  
30.     px = py;  
31.     py.set( 5, 5 );  
32.     System.out.print("Para px: "); px.show();  
33.     System.out.print("Para py: "); py.show();  
34.     System.out.print("Para pz: "); pz.show();  
35.     if (px == py)   
36.         System.out.println ("px i py równe.");  
37.     else   
38.         System.out.println ("px i py nierówne.");  
39.   
40.     if (py == pz)   
41.         System.out.println ("py i pz równe.");  
42.     else   
43.        System.out.println ("py i pz nierówne.");  
44.   
45.   }  
46. }  

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.

---