# Mitkä ovat Java-kielessä käytettävät eri tietotyypit?

Java tarjoaa kahdeksan primitiivistä tietotyyppiä ja lukuisia monimutkaisia tietotyyppejä. Nämä määrittävät, mitkä arvot voidaan tallentaa ja näyttää muuttujassa. Tietyt tietotyypit on määritetty kaikille muuttujille Java-kielessä.

## Mitä tietotyyppejä Java sisältää?

Jokaisessa ohjelmointikielessä on erilaisia tietotyyppejä, jotka sisältävät tiettyjä objekteja ja määriteltyjä operaatioita. Vaikka eri kielten tarjoamat tietotyyppivaihtoehdot ovat usein keskenään samankaltaisia, joskus niissä on merkittäviä eroja. Jos esimerkiksi [verrataan Python- ja Java-kieliä](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/python-vs-java/) ja niiden tietotyyppejä, huomaa niiden välisiä yhtäläisyyksiä, mutta myös lukuisia eroja, jotka tekevät kielistä sopivia erilaisiin tehtäviin.

Java käyttää kahta erilaista tietotyyppiä: **primitiivisiä ja monimutkaisia**. Monimutkaisia tietotyyppejä kutsutaan myös viitetyypeiksi. Primitiiviset ja monimutkaiset tietotyypit eroavat toisistaan koon suhteen ja määräävät, mitä arvoja muuttujaan voidaan tallentaa. Primitiiviset tietotyypit voivat **tallentaa** vain **yksinkertaisia arvoja**, kun taas viitetyyppejä käytetään **monimutkaisempien rakenteiden luomiseen** sekä **suurten tietomäärien järjestämiseen ja käsittelyyn**.

Jos haluat oppia koodaamaan, on tärkeää tuntea eri tietotyypit ja osata hyödyntää niitä parhaalla mahdollisella tavalla. Tietotyyppien parhaan käytön ymmärtäminen ei ole vain niiden toiminnallisuuden ymmärtämistä, vaan myös niiden käyttämän (tai säästämän) muistin määrän ymmärtämistä.

## Mitkä ovat primitiiviset tietotyypit Java-kielessä?

[Java-kielessä](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-primitiivit/) on yhteensä kahdeksan erilaista [primitiivistä tietotyyppiä](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-primitiivit/), jotka sisältävät tarkasti määritellyt arvoalueet. Ne voidaan jakaa neljään luokkaan: **loogiset tietotyypit, kokonaislukutyypit, liukuluku- ja merkkityypit**. Niillä ei ole lisäominaisuuksia, ja niitä kutsutaan myös elementaarisiksi tietotyypeiksi. Jokaisella tietotyypillä on kiinteä bittimäärä. Seuraavassa käsitellään primitiivisiä tietotyyppejä tarkemmin. Java käyttää seuraavia primitiivisiä tyyppejä:

- boolean
- bitti
- lyhyt
- int tai kokonaisluku
- pitkä
- float
- double
- merkk

### `boolean`

[Java-kielen boolean-tietotyyppi](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-kielen-boolean-primitiivinen-tietotyyppi/) ei ole numeerinen tyyppi. Se tarjoaa vain kaksi mahdollista arvoa: **true** ja **false**. Sitä voidaan käyttää määrittämään, täyttyykö ehto (true) vai ei (false). Se on looginen tietotyyppi, jonka oletusarvo on `false`. Se koostuu yhdestä bitistä ja sen syntaksi on seuraava:

```java
boolean booleanVar;
```

### `byte`

`byte` on kokonaislukutyyppi, joka esitetään kahden komplementin arvona, jonka koko on 8 bittiä tai 1 tavu. Sitä käytetään tyypillisesti muistin säästämiseen suuremmissa taulukoissa. Sen arvoalue on -128–127, ja sen oletusarvo on 0. Sen syntaksi on seuraava:

```java
byte byteVar;
```

### `short`

`short` on myös yksi Java-kielessä käytetyistä integraalidatatyypeistä, ja sitä käytetään pääasiassa muistia säästämään suuremmissa taulukoissa. Kaksinkertaisen komplementin arvo on 16 bittiä tai 2 tavua, ja sen arvoalue ulottuu **-32768:sta 32767:ään**. Oletusarvoisesti sen arvo on 0. Näin `short` käytetään:

```java
short shortVar
```

### `int` tai kokonaisluku

`int` tai kokonaisluku on myös kahden komplementin arvo ja kokonaislukutyyppi, jonka koko on 4 tavua tai 32 bittiä. Sen arvoalue sisältää kokonaisluvut **välillä -2147483648 ja 2147483647**, ja sen oletusarvo on 0. Sen syntaksi on seuraava:

```java
int intVar
```

### `long`

Suurin kokonaislukutyyppi on `long`. Tämä koskee ensinnäkin sen arvoaluetta, joka on **välillä -9223372036854775808 ja 9223372036854775807**, ja toiseksi sen kokoa, joka on 8 tavua tai 64 bittiä. Kaksin komplementtiarvoa käytetään siis, jos muut kokonaislukutyypit eivät riitä. Se vaatii kuitenkin myös selvästi eniten muistia. Sen oletusarvo on 0. Sen syntaksi on seuraava:

```java
lomg longVar
```

### `float`

`float` on liukulukuinen tietotyyppi, jota käytetään reaalilukujen tallentamiseen. Sen koko on 32 bittiä ja se noudattaa IEEE 754 -standardia, joka määrittelee binääri- ja desimaaliliukulukuisten lukujen standardiesityksen tietokoneissa. Standardiarvo `float` on 0,0 ja sen arvoalueella voidaan esittää enintään **seitsemän desimaalia**. Verrattuna double-tyyppiin `float` ei kuitenkaan ole yhtä tarkka, joten sitä ei tulisi käyttää arvoissa, joissa tarkkuudella on ratkaiseva merkitys. Jos näin ei ole, voit käyttää `float` tilan säästämiseksi. `float` n syntaksi on seuraava:

```java
float floatVar;
```

### `double`

`double` on noin kaksi kertaa tarkempi kuin float ja täyttää samanlaisen tarkoituksen. Sen koko on 64 bittiä ja se voi edustaa **jopa 16 desimaalia**. Sen oletusarvo on myös 0,0. Jos tarvitset tarkempia arvoja, sinun tulee aina käyttää `double`, vaikka tämä tietotyyppi ei olekaan kovin tarkka. Jos haluat työskennellä täysin tarkkojen arvojen kanssa, sinun tulisi käyttää sen sijaan BigDecimal-luokkaa. `double` n syntaksi on seuraava:

```java
double doubleVar;
```

### `char`

`char` on merkkitietotyyppi. Se tallentaa merkkejä Unicode-merkistöön perustuen, mikä mahdollistaa siirrettävyyden useille eri alustoille. Jokainen merkki vaatii 2 tavua muistia. Sen arvoalue vastaa ASCII-merkistöä (American Standard Code for Information Interchange) ja sijaitsee **välillä ‘\\u0000’ (eli 0) ja ‘\\uffff’ (vastaa 65535)**. Char-tyypin oletusarvo on ‘\\u0000’ ja sen syntaksi on seuraava:

```java
char charVar
```

## Mitä ovat monimutkaiset tietotyypit Java-kielessä?

Toinen Java-tietotyyppien tyyppi ovat viitetyypit, joita kutsutaan myös monimutkaisiksi tietotyypeiksi. Niitä kutsutaan viitetyypeiksi, koska ne **viittaavat objekteihin.** Toisin kuin primitiiviset tietotyypit, ne eivät yleensä ole ennalta määriteltyjä, vaan ohjelmoija määrittelee ne (poikkeuksena merkkijono). Ne voivat käyttää metodeja ja niillä voi olla myös arvo 0 (tyhjänä). Primitiiviset tietotyypit alkavat pienellä kirjaimella, mutta viitetyypit alkavat isolla kirjaimella. Tässä tarkastellaan tärkeimpiä viitetyyppejä.

### Jouset

`String` on luokka, jota voidaan käyttää **merkkijonon** esittämiseen, mikä erottaa tämän monimutkaisen tietotyypin primitiivisestä tietotyypistä `char` sekä muista tietotyypeistä. Merkkijono on objekti luokassa `java.lang`. String-luokan eri menetelmillä voit tarkastella merkkijonon yksittäisiä merkkejä, verrata merkkijonoja keskenään, etsiä merkkijonoja ja kopioida merkkijonoja. Merkkijonot tunnistetaan lainausmerkeillä. Tämän viitetyypin syntaksi on seuraavanlainen:

```java
<string_type> <string_variable> = "<string_sequence>";
```

Tässä on esimerkki merkkijonojen toiminnasta:

```java
// How to create a string without a new operator
String a = "This is your new string";
/ / How to create a string with a new operator
String a1 = new string ("This is your new string");
```

### Taulukot

Taulukoita käytetään **useiden arvojen** tallentamiseen **muuttujaan** sen sijaan, että luotaisiin eri muuttujia jokaiselle yksittäiselle arvolle. Ne luodaan hakasulkeilla. Tallennetut arvot sijoitetaan aaltosulkeisiin ja erotetaan toisistaan pilkuilla. Tässä on taulukoiden syntaksi:

```java
dataType[] arrayName = {value1, value2, value3,…};
```

Jos haluat luoda merkkijonoista koostuvan taulukon, voit tehdä sen seuraavasti:

```java
String[] colors = {"blue", "red", "yellow", "purple"};
```

Näin luot taulukon kokonaisluvuilla:

```java
int[] figures = {5, 10, 15, 20};
```

### Luokat

Java-kielessä luokat ovat tietotyyppejä, jotka **toimivat mallina** objektien luomisessa. Ne sisältävät erilaisia komponentteja, kuten luokan nimen, muokkaimet ja aaltosulkeissa olevan rungon. Tässä on esimerkki siitä, miltä luokka näyttää Java-kielessä:

```java
public class Main {
	int a = 10;
}
```

### Rajapinnat

Java-kielessä rajapinta on **abstrakti luokka**. Se toimii rajapintana, jonka kautta luokka voi käyttää erilaisia toimintoja. Tätä varten sen on kuitenkin ensin toteutettava ne. Rajapinnat sisältävät vain vakioita ja abstrakteja metodeja. Niiden syntaksi näyttää tältä:

```java
interface {
	abstract methods
}
```

Esitämme tässä yksinkertaisen esimerkin, joka havainnollistaa rajapintojen toimintaa:

```java
interface Pizza {
	public void ingredientsList();
	public void preparation();
}
class Mushroom implements Pizza {
	public void ingredientsList() {
		System.out.println("mushrooms, tomato sauce, oregano, mozzarella");
}
public void preparation() {
	System.out.println("The pizza will be ready in 15 minutes.");
}
}
class Main {
	public static void main(String[] args) {
		Mushroom myMushroom = new Mushroom();
		myMushroom.ingredientsList();
		myMushroom.preparation();
	}
}
```

Java-komennon `System.out.println` vastaava tulos näyttää tältä:

```java
mushrooms, tomato sauce, oregano, mozzarella
The pizza will be ready in 15 minutes.
```

### Esineet

Java-kielessä objektit ovat myös monimutkainen tietotyyppi. Objektit ovat **luokkien instansseja**, jotka voivat olla vuorovaikutuksessa keskenään menetelmien avulla. Seuraavassa esimerkissä luomme useita objekteja Main-luokkaan:

```java
public class Main {
	int a = 10;
public static void main(String[] args) {
	Main myObj1 = new Main();
	Main myObj2 = new Main();
	System.out.println(myObj1.a);
	System.out.println(myObj2.a);
	}
}
```

Tulostus näyttää tältä:

```java
10
10
```

### Enumit

[Enumit](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-luettelot/) ovat erityinen luokka, jonka avulla voit sisällyttää **muuttumattomia vakioita koodiisi**. Näille muuttujille annetaan kiinteät arvot, joita ei voi muuttaa. Tämä tietotyyppi on erityisen hyödyllinen, jos tarvitset muuttujia, joilla voi olla vain muutama mahdollinen tila. Enumin syntaksi näyttää tältä:

```java
enum NameOfTheClass {
	VALUE1,
	VALUE2,
	VALUE3
}
```


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-tietotyypit/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/java-tietotyypit/) for AI/LLM consumption.