Mitä ovat primitiiviset tyypit verrattuna viitetyppeihin Javassa?

Question

Accepted Answer

Javassa on kaksi perustyyppiluokkaa: **primitiiviset tyypit** (yksinkertaiset arvot, jotka on tallennettu suoraan) ja **viitetyypit** (objektit, joissa muuttuja sisältää viitteen/osoittimen objektiin). Ne käyttäytyvät hyvin eri tavalla muistissa, sijoituksessa ja vertailussa. ## 8 primitiivista tyyppiä ```java int i = 42; // 32-bit integer long l = 100L; // 64-bit integer double d = 3.14; // 64-bit floating point float f = 1.5f; // 32-bit floating point boolean b = true; // true/false char c = 'A'; // 16-bit Unicode character byte by = 127; // 8-bit short s = 1000; // 16-bit ``` Primitiviiviset tyypit varaavat **todellisen arvon** suoraan, ne ovat kiinteän kokoisia, ne eivät voi olla null, ja ne sijaitsevat pinossa (paikallisille muuttujille). Ne ovat nopeat ja muistin kannalta tehokkaat. ## Viitetyypit — objektit ```java String name = "Ann"; // reference to a String object int[] arr = {1, 2, 3}; // reference to an array object List list = new ArrayList<>(); // reference to a List object Person p = new Person("Bob"); // reference to a Person object ``` Viitemuuttujat sisältävät **viitteen** (muistin osoitteen) kekoon tallennettuun objektiin — eivät objektia itseään. Ne voivat olla `null`. ## Kriittinen ero: sijoitus ja vertailu ```java // primitives — assignment COPIES the value (independent) int a = 5; int b = a; // b is a COPY b = 10; // a is still 5 // references — assignment COPIES the reference (both point to the SAME object) int[] x = {1, 2, 3}; int[] y = x; // y points to the SAME array y[0] = 99; // x[0] is now 99 too! (shared object) ``` ```java // == compares VALUES for primitives, but REFERENCES (identity) for objects String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — different objects (different references) s1.equals(s2); // true — equals() compares CONTENT ``` Tämä on suuri ansa: **`==` objekteilla vertaa identiteettiä (sama objekti?), ei sisältöä** — käytä `.equals()` sisällön vertailuun. ## Wrapper-luokat yhdistävät molemmat ```java Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing) int unboxed = boxed; // auto-unboxing back to primitive List nums; // collections need objects, not primitives ``` Jokaisella primitiivisellä tyypillä on wrapper-luokka (`int`→`Integer`, jne.) niin, että primitiivisiä voidaan käyttää siellä missä objekteja vaaditaan (kokoelmat, generiikka). ## Miksi se on tärkeää Primitiviivisen ja viitteen välinen ero on olennaista Javassa ja monien hienovaraisten buggien ja käyttäytymisen lähde: sijoitus kopioi arvot primitiiveille mutta jakaa viitteet objekteille (joten jaetun objektin muuttaminen vaikuttaa kaikkiin viitteisiin), ja erityisesti se, että **`==` vertaa identiteettiä objekteille** (klassinen virhe — käytä `.equals()` sisällön vertailuun). Tämän ymmärtäminen vaikuttaa oikeellisuuteen vertailuissa, metodin argumenteissa (objektit välitetään käytännössä viitteen arvon mukaan), null-käsittelyssä (vain viitteet voivat olla null) ja suorituskykyssa (primitiiviset tyypit ovat kevyempiä). Se on perusosaamista oikean Javan kirjoittamiselle.