Liht- ja struktuurandmetüübid. Massiivid. 

Lihttüübid (algtüübid) (ingl.k. primitive types)

byte    - 8-bitine täisarv vahemikus -128 kuni 127.
short   - 16-bitine täisarv  -32768 kuni 32767.
int     - 32-bitine täisarv  -2147483648 kuni 2147483647.    
long    - 64-bitine täisarv  -9223372036854775808 kuni
                                     9223372036854775807.
float   - 32-bitine reaalarv ligikaudses vahemikus -3,4x10^38 
                  kuni 3,4x10^38 seitsme tüvekohaga. 
double  - 64-bitine ujukomaarv (reaalarv) ligikaudses vahemikus 
            -1,7x10^308 kuni 1,7x10^308 15 tüvekohaga. 
char    - 16-bitine Unicode sümbol. Näit. 'a', '\n',
boolean - tõeväärtustüüp võimalike väärtustega true ja false. 

Need kaheksa on "lihtsad" andmetüübid ilma riugasteta. Kui sinna tüüpi
muutujasse midagi kirjutada, siis pole karta, et temaga "iseenesest"
midagi juhtuks. Neid saab kasutada sarnaselt, nagu muutujaid pascaliski. 
Tüüpiliselt kasutatavaks täisarvuks on int ning reaalarvuks double. 
Tüüp byte on ühebaidine nagu üks bait kettalgi. Tüüp char on javas 
16-bitine (pascali 8 vastu) ning tal on üle 64 tuhande võimaliku väärtuse. 
Enamik Euroopa keeli saab väikeste mööndustega 256 tähega hakkama, 
mida 8 bitti pakuvad, kuid ka hieroglüüfe sisaldavate ja muid paljutäheliste keelte 
edasiandmiseks on lihtsam kasutada igale sümbolile ühte tähte, siis 
ei pea imenippe rakendama tähtede surumiseks sinna, kuhu need ei mahu.
Tähed kirjutatakse ühekordsete ülakomade vahele nagu näiteks 'm'. "m" on
kompilaatori jaoks juba enam mitte lihttüüp char, vaid struktuurne tüüp
String. Enamasti ongi programmides lihtsam kasutada sõnet kui tähte. 
        Lihttüüpide nimed kirjutatakse väikese tähega, struktuurtüüpide 
omad soovitatavalt suurega. Siis on kirjutamise käigus hea eristada, millega
on tegu.  
        Täisarve saab lisaks kümnendsüsteemile kirjutada ka kaheksand-
ja kuueteistkümnendsüsteemis.  Kaheksandsüsteemis arvule tuleb ette 
kirjutada 0, kuueteistkümnendsüsteemis arvule 0x. Nii et 12, 014 ja 
0xC on java kompilaatori jaoks üks ja seesama asi. Enamasti piisab kasu-
tamisel kümnendsüsteemist, kuid pildi joonistamisel kaheksat värvi
kasutades on hea pildi punkte masinale kaheksandsüsteemis ette kirjutada
või mälust lugeda. 
        Täisarvud loeb kompilaator automaatselt olevaks tüübis int. 
Kui soovime talle rõhutada, et tegu on nimelt tüübist short, siis tuleb
tüübi nimi arvule sulgudes ette kirjutada nt. (short)12 . Sama lugu ka
reaalarvudega, kus automaatselt arvab kompilaator punkti esinemise korral
olevat tegemist kahekordse täpsusega ujukomaarvuga (double). Tüüpi long
saab rõhutada, lisades arvu lõppu tähe l nt. 12345l ning float puhul võib lõppu 
lisada tähe f. 
	Klaviatuurilt saab sisestada vaid sõnena. Juhul kui meil on vaja 
sisestatut intepreteerida mõne teise tüübina, siis tuleb tüüp vastavate meetodite
abil muuta. Sõne püüab täisarvuliseks objektiks muuta klassi Integer meetod valueOf.
Et objektist (kus on lisaks väärtusele ka meetodid) väärtust kätte saada, tuleb 
käivitada ta meetod (ehk saata talle teade) intValue(). 

import java.io.*;
public class Sisse1{
  public static void main(String argumendid[]) throws Exception{
    int arv;
    double distants;
    String s;
    PrintWriter valja=new PrintWriter(System.out, true);
    BufferedReader sisse=new BufferedReader(
      new InputStreamReader(System.in)
    );
    valja.println("Osalejate arv:");
    s=sisse.readLine();
    arv=Integer.valueOf(s).intValue();
    valja.println("Vahemaa:");
    distants=Double.valueOf(sisse.readLine()).doubleValue();
    valja.println("Kokku läbiti "+arv*distants+" km");
  }
} 

Käsklus import java.io.* lubab kasutada paketti java.io kuuluvaid kõiki klasse.
Siin programmis on neist kasutatud PrintWriter, BufferedReader ja InputStreamReader.
InputStreamReader'it kasutatakse selles progammis sisendvoost System.in saabuva
BufferedReader'ile "söödavaks muutmiseks". 


	Hulga ühetüübiliste andmete hoidmiseks ja kasutamiseks saab kasutada
massiive. 

---

public class Massiiv1{
  public static void main(String argumendid[]){
    int[] ruudud = new int[5];
    for(int i=0; i<5; i++){
      ruudud[i]=i*i;
    }
    System.out.println("Arvu 2 ruut on "+ruudud[2]);
  }
}

---


     Massiivi elemendid hakkavad lugema numbrist 0. Korraldus new int[5] loob viie-
elemendilise täisarvumassiivi, mille esimeseks elemendiks on element järjenumbriga
0 ning viimase elemendi järjenumbriks on 4. Esimeses kümnes võib selline lähenemine
paista harjumatuna, kuid alustades nullist, algab järgmine kümme arvust 10 (mitte 11).
Tegemist on sama probleemiga, et kas uut aastatuhandet hakata lugema aastast 2000
või 2001. Java (ning ka C  ja mõnes muuski) keeles loetakse numbreid alates nullist
nagu sündinud lapsel, kes saab aastaseks alles pärast ühe aasta möödumist sünnist.
	Massiivi elemendid võib ka massiivi loomisel algväärtustada.

public class Massiiv2{
  public static void main(String argumendid[]){
    String nimed[]={"Juku", "Kati", "Siim"};
    System.out.println("Nimekirja alguses on "+nimed[0]);
    System.out.println("Kogu nimekiri koosneb nimedest:");
    for(int nr=0; nr<nimed.length; nr++){
      System.out.println(nr+1+". "+nimed[nr]);
    }
  }
}    

	Massiivi juurde kuuluv väli length näitab massiivi elementide arvu. Siinses
näites oli elementide arvuks kolm. Massiivi tunnus võib kirjeldamisel olla nii 
muutuja tüübi kui nime taga. String nimed[] ning String[] nimed tähendavad sama. 
Massiivid võivad olla ka mitmemõõtmelised. Niipalju, kui soovitakse mõõtmeid, niipalju
tuleb ka sulupaare kirjutada. Näiteks 
   int tulemused[][]=new int[5][3]
loob kahemõõtmelise massiivi viie rea ja kolme veeruga. 



	Lihttüüpe on kaheksa ning need on keelde sisse ehitatud, programmeerija neid
muuta ei saa. Vajadusel saab lihttüüpidest luua stuktuurse andmetüübi.  Näide:

class Punkt{
  int x, y;
}

Niimoodi kirjeldame vaid tüübi. Tüübist saame luua isendeid. 

public class Punktid1{
  public static void main(String argumendid[]){
    Punkt a=new Punkt();
    a.x=5;
    a.y=3;
    System.out.println("a="+a+" a.x="+a.x+" a.y="+a.y);
  }
}

annab oma töö tulemuseks rea

a=Punkt@1fa4d40b a.x=5 a.y=3

Nagu näha, peitub meie jaoks mõistlik info Punkti a väljadel x ja y, a enese
väljatrükkimisel näeme vaid tema räsikoodi. Struktuurse tüübi muutuja näitab
kohale, kust leida tema välju. See on sarnane Pascali ja C viidatüüpi muutujale,
mille väärtuseks oli mäluaadress. Kuna java-programm töötab virtuaalmasinas 
ning ta pole otseselt seotud arvuti enese füüsilise mäluga, siis käib ka tehniline
pool teisiti. 
	Struktuurse tüübi muutujat nimetatakse osutitüüpi muutujaks ehk osutiks. 
	Java keeles saab nii väärtus- kui osutimuutjaid kasutada ilma probleemideta
ka meetodite parameetritena ning tagastusväärtustena. 
	
	Näite juures võib imelikuna tunduda rida
Punkt a=new Punkt();
mille juures ju vaid luuakse uus isend tüübist Punkt ning pannakse talle osutama 
muutuja a. Kui kirjutaksime vaid Punkt a; , siis kirjeldatakse vaid muutuja a, 
ilma tema jaoks mälu eraldamata. Sõna Punkt kaks korda kirjutamine võib tunduda 
liiasus, kuid ei ole. Edaspidi selgub, et juhul, kui oleme kirjeldanud PuutePunkti
erinevused Punktist, siis omab tähendust ka näiteks lause
Punkt ristmik=new PuutePunkt(asfalttee, kruusatee);

	Loodud isendile aitab väärtusi sisestada konstruktor.

class Punkt2{
  int x, y;
  public Punkt2(int uus_x, int uus_y){
    x=uus_x;
    y=uus_y;
  }
}      
	
Konstruktoril peab olema klassiga sama nimi. Ta käivitatakse isendi loomisel new abil. 
Piiritleja public näitab, et konstruktorit on võimalik käivitada ka väljastpoolt.

public class Punktid2{
  public static void main(String argumendid[]){
    Punkt2 a=new Punkt2(5, 3);
    Punkt2 b=new Punkt2(1, 1);
    System.out.println(b.x-a.x);
  }
}

annab käivitamisel vastuseks -4 (ehk 1-5).

Nagu ennist kirjas oli, "sisaldavad" vaid lihttüüpi (8 tk) muutujad neisse pandud 
väärtusi. Ülejäänud muutujad osutavad vastavat tüüpi isendile (või ei osuta kuhugi, 
sellisel juhul on selle muutuja väärtuseks null (sõnana)). Järgnevas näites pannakse
kaks osutit osutama ühele isendile. 


public class Punktid3{
  public static void main(String argumendid[]){
    Punkt2 a=new Punkt2(5, 3);
    Punkt2 b=new Punkt2(1, 1);
    a=b; // ka a hakkab osutama b jaoks loodud kohale
    b.x=7;
    System.out.println(a.x+"  "+a.y);
  }
}   

kirjutab välja a väljade väärtusteks 7 ja 1. Esialgu luuakse kaks isendit. Ühe 
väljade väärtusteks saavad 5 ja 3, teisele 1 ja 1. Esimesele pannakse osutama
a, teisele b. Siis pannakse ka a osutama teisele isendile, esimene isend jääb
sootuks tähelepanuta ning ta koristatakse mälust. Teise isendi väljad on endiselt
1 ja 1. Kui nüüd kirjutatakse b.x=7, siis pannakse teise isendi x-väljale 7. 
Kuna ka a viitab nüüd teisele isendile, siis kirjutatakse välja 7 ja 1. 



Kokkuvõte

	Lihtandmetüüpideks java-s on byte, short, int, long, float, double, 
char ja boolean. Nendest saab kombineerida struktuurtüüpe. Lihttüübi muutujas
on väärtus, struktuurtüübi omas osuti isendile. Struktuurtüübist muutuja
tühivääruseks on null. Nii liht- kui struktuurtüüpi andmeid saab paigutada
massiivi.