Tarkempi johdanto Java-kieleen¶

int i = 1000;        // int-muuttuja i = 1000.
int j;               // int-muuttuja j = 0 (lukutyypit oletusalustuvat nollalla).

long k = 3123456789;   // KÄÄNTÄJÄN VIRHE: 3123456789 on liian suuri ollakseen int!
long m = 3123456789L;  // OK: 3123456789L on long-vakio, ja long kykenee esittämään sen.

byte a = 100;        // byte-muuttuja a = 100. Int-vakio 100 --> byte-arvo 100.
byte b = i;          // KÄÄNTÄJÄN VIRHE: arvoa muuttava muunnos int --> byte.
                      // Java muuntaa int-vakion pienempään kokonaislukutyyppiin, JOS
                      // arvon voi esittää pienemmälläkin tyypillä. i = 1000 ei mahdu
                      // byteen vaan muuntuisi byte-arvoksi -24.
byte c = (byte) i;   // OK: pakotettu tyyppimuunnos int --> byte ja tuloksena c = -24.
                      // Javan tyyppimuunnoksen syntaksi on suoraan C-kielestä:
                      // annetaan kohdetyyppi suluissa muunnettavan arvon edessä.

boolean e;                // boolean-muuttuja e = false (oletusalustuu epätodeksi).
boolean f = true;         // boolean-muuttuja f = true.
boolean g = (boolean) i;  // KÄÄNTÄJÄN VIRHE: int-arvoa i ei voi muuntaa totuusarvoksi.
                          // Toisin kuin C/C++/Pythonissa, Javassa totuusarvoja ei voi
                          // sellaisenaan muuntaa lukuarvoiksi tai päinvastoin!
boolean h = i > j;        // h = true, koska ehtolauseen i > j eli 1000 > 0 arvo on true.

float x = 0.0;       // KÄÄNTÄJÄN VIRHE: arvo 0.0 on double-vakio, eikä Java muunna
                      // double-arvoa float-arvoksi ilman erillistä tyyppimuunnosta.

float y = 1.5F;      // OK: 1.5F on float-vakio.
float z = 0;         // OK: implisiittinen muunnos int 0 --> float 0.0F.

double p = 3.14;
float q = p;           // KÄÄNTÄJÄN VIRHE: double-arvon muunnos float-arvoksi!
float r = (float) p;  // OK: pakotettu tyyppimuunnos double --> float.

int s = p;           // KÄÄNTÄJÄN VIRHE: double-arvon muunnos int-arvoksi!
int t = y;           // KÄÄNTÄJÄN VIRHE: float-arvon muunnos int-arvoksi!
int u = (int) y;     // OK: pakotettu tyyppimuunnos float --> int. Tuloksena u = 1 eli
                      // arvo y = 1.5 ilman desimaaliosaa (ei hienoa pyöristystä tms.).

int x = 100;       // int-arvo 100.
Integer y = 200;   // Autoboxingin avulla luotu Integer-olio, joka tallettaa int-arvon 200.
x + y;             // Käärittyihin lukuihin voi soveltaa aritmeettis-loogisia operaatioita
y / 3;             // tavalliseen tapaan. Tässä x + y = 300 ja y / 3 = 66.
x > y;             // false, koska ehto 100 > 200 ei päde.

String s1 = "One";                    // s1 viittaa String-vakio-olioon "One".
String s2 = new String(" to three:"); // s2 uusi String-olio, jonka sisältö on " to three:".
String n1 = " 1";
String n2 = " 2";
String n3 = " 3";

// Jos operaattoria + sovelletaan merkkijonoon, tulkitaan se merkkijonojen yhdistämiseksi:
// tuloksena on uusi String-olio, joka esittää merkkijonojen yhdisteen.
// Toinen yhdistettävä arvo voi olla muukin kuin merkkijono; tällöin Java automaattisesti
// tyyppimuuntaa arvon merkkijonoksi.
// Alla s3 lopulta viittaa uuteen String-olioon, jonka sisältö on "One to three: 1 2 3".
String s3 = s1 + s2 + n1 + n2 + n3;

// Yllä s3 muodostui tosiasiassa askeleittaisesta uusien ja uusien String-olioiden
// luontiketjusta: "One to three:", "One to three: 1", "One to three: 1 2" ja
// "One to three: 1 2 3". Tämä on selvästi tehotonta: luotuihin String-olioihin kopioitiin
// yhteensä 13 + 15 + 17 + 19 = 64 merkkiä, vaikka lopputuloksen pituus on ainoastaan 19.
// Tällaisessa tilanteessa kannattaisi harkita muuttuvan merkkijonon toteuttavan luokan
// StringBuilder käyttöä. StringBuilder-oliota voi muuttaa esim. jäsenfunktiolla append,
// joka lisää merkkejä perään. Alla tehdään samat lisäykset kuin yllä, mutta yhteensä 19
// merkin kopioinnilla: ensin StringBuilder-olion alkuarvoksi s1, ja sitten perään
// s2, n1, n2 ja n3.
StringBuilder b = new StringBuilder(s1);
b.append(s2).append(n1).append(n2).append(n3);

// StringBuilder-olion sisällön pohjalta voi halutessaan luoda tavallisen muuttumattoman
// String-olion kutsumalla jäsenfunktiota toString. Tässä luodaan 19-merkkinen uusi
// merkkijono. Merkkijonon s4 luonti vaati kaikkiaan 19 + 19 = 38 merkin kopioinnin,
// jos mukaan lasketaan ylempänä StringBuilder-olion b avulla tehty työ.
String s4 = b.toString();  // s4 alustuu b:n merkkijonolla "One to three: 1 2 3".

// On hyvä huomata, että kääntäjä voi tehokkaasti yhdistää vakiomerkkijonot yhteen jo
// käännösaikana. Merkkijonojen yhdistämisen mahdollinen tehottomuus koskee nimenomaan
// tilannetta, jossa ainakin toinen yhdistettävä osa on varsinainen String-olio. Esim. alla
// s5 alustuu suoraan merkkijonoksi "One to three: 1 2 3" ilman turhaa kopiointia: kääntäjä
// yhdistää vakiot ensin muotoon "One to three: 1 2 3" ja käyttää sitä String-olion alustukseen.
String s5 = "One" + " to three:" + " 1" + " 2" + " 3";

// HUOM! Jos tavallisia vertailuoperaattoreita != ja == soveltaa viitemuuttujiin,
// tulos kertoo sitä, viittaavatko viitemuuttujat keskenään samaan vai eri olioon.
// Javassa on sopimus, että jos luokan olioiden samanlaisuutta voi olla tarpeen verrata,
// tulisi luokan tarjota samanlaisuutta vertaileva jäsenfunktio nimeltä "equals".
s3 == s4;       // false, koska s3 ja s4 viittaavat eri String-olioihin.
s3 != s4;       // true, koska s3 ja s4 viittaavat eri String-olioihin.
s3.equals(s4);  // true, koska sekä s3 että s4 esittävät merkkijonoa "One to three: 1 2 3".

// Koska merkkijonovakiot ovat String-olioita, voi niidenkin kautta kutsua jäsenfunktioita.
"One two three: 1 2 3".equals(s3);    // true, koska s3:n sisältö on "One to three: 1 2 3".

// Jos vertaat merkkijonovakiota ja String-oliota, kannattaa käyttää yllä esitettyä tapaa,
// koska equals-funktio toimii oikein myös silloin, kun parametri on null-viite!
String s5 = null;
"One two three: 1 2 3".equals(s5);  // false, koska parametri s5 on null.
// Alla sinänsä sama vertailu kuin yllä, mutta nyt OHJELMA KAATUU ajonaikaiseen virheeseen!
s5.equals("One two three: 1 2 3");  // null-viitteen s5 kautta ei voi kutsua jäsenfunktiota...

String s6;  // Viitemuuttuja ilman alustusarvoa alustuu null-viitteeksi.
s5 == s6    // true, koska sekä s5 että s6 ovat null-viitteitä.

// Kunkin primitiivityypin "tyyppi" kääreluokka tarjoaa tapaan "parseTyyppi" nimetyn
// luokkafunktion, joka tulkitsee merkkijonon kyseisen primitiivityypin arvoksi. Merkkijonon
// voi siis esim. tulkita int-arvoksi funktiolla Integer.parseInt, float-arvoksi
// funktiolla Float.parseFloat ja boolean-arvoksi funktiolla Boolean.parseBoolean.
int i = Integer.parseInt("2021");                       // i = 2021.
float pi = Float.parseFloat("3.1415926535");            // pi = 3.1415926535F.
boolean t = Boolean.parseBoolean("tRuE");               // t = true (kirjainkoolla ei väliä).

// Kukin kääreluokka tarjoaa myös luokkafunktion toString, joka muuntaa sille parametrina
// annetun kääreluokan primitiivityyppisen arvon String-merkkijonoksi. Näiden avulla voi
// muuntaa primitiiviarvoja merkkijonoiksi. Jos arvo sen sijaan on jo kääreluokan oliossa,
// tee muunnos merkkijonoksi suoremmin kutsumalla olion toString-jäsenfunktiota.
String piStr = Float.toString(pi);           // piStr = "3.1415927"  (float on epätarkka!)
String weekHourStr = Integer.toString(24*7); // weekHourStr = "168"
String yStr = y.toString();                  // yStr = "200", tässä y oli Integer-olio.

// Javan taulukkomäärityksen syntaksi on varsin samanlainen, kuin esim. C-kielessä:
// muuttujamäärityksen yhteydessä annetaan yksi hakaslukupari per taulukon ulottuvuus.
// Tässä on kuitenkin kaksi selkeää eroa:
//   1) hakasulut tulee antaa muuttujan tyypin perässä eikä muuttujan nimen perässä.
//      (Java sinänsä sallii hakasulut nimenkin perässä, mutta sitä tapaa ei suositella.)
//   2) Muuttujan tyyppimäärityksen hakasuluissa ei anneta taulukon kokoa: taulukon koko
//      määräytyy joko implisiittisesti taulukon alustusarvojen mukaiseksi tai koko annetaan
//      hakasulkujen sisällä tehtäessä taulukon luovan new-operaattorin kutsu.

// Määritetään vals viitemuuttujaksi, joka voi viitata int-taulukkoon.
// Ellei anneta alustusarvoa, alustuu viite null-viitteeksi: tässä siis it = null.
int[] it;

// Asetetaan it viittaamaan uuteen new-operaattorilla luotuun 100-alkioiseen
// int-taulukkoon. Javassa kaikkien lukutyyppien alkiot alustuvat nolliksi.
it = new int[100];

// Taulukon voi luonnollisesti luoda suoraan taulukkomuuttujamäärityksen yhteydessä.
// Kaikkien viitetyyppien alkiot alustuvat null-viitteiksi, joten alla tuloksena
// 1000 null-viitettä sisältävä Double-taulukko.
Double[] dt = new Double[1000];

// Alla tuloksena dt[172] = 0.0, koska it[5] on 0. Tässä tarvitaan pakotettu tyyppi-
// muunnos int-arvosta double-arvoksi, jotta Java voi suorittaa autoboxing-muunnoksen
// double -> Double. Esimerkiksi yritys muuntaa int-arvo suoraan Double-arvoksi johtaisi
// kääntäjän virheilmoitukseen.
dt[172] = (double) it[5];

// Taulukon sisällön voi alustaa suoraan taulukkomuuttujamäärityksen yhteydessä
// samanlaisella notaatiolla kuin C-kielessä: alkiot aaltosulkeissa pilkuilla eroteltuina.
// Autoboxingia sovelletaan alustusalkioihinkin, joten esim. alla Integer-taulukon
// alkiot voi alustaa int-vakioilla, jotka Java automaattisesti muuntaa Integer-olioiksi.
Integer[] it2 = {1, 2, 3, 4};

// Alustuksen ja new-operaattorin voi halutessaan yhdistää. Tällöin new-operaattorille
// ei kuitenkaan anneta taulukon kokoa. Alla it3 on samanlainen kuin edellä it2.
Integer[] it3 = new Integer[]{1, 2, 3, 4};

// Javan taulukoilla on jäsenmuuttuja length, joka kertoo taulukon koon.
it2.length == 4;            // true, koska it2-taulukko alustettiin 4-alkioiseksi.

// Java ei salli viittausta laittomaan taulukon indeksiin. Esimerkiksi alla yritys
// kasvattaa arvoa it2[4] yhdellä johtaa ajonaikaiseen virheeseen, koska 4-alkioisen
// taulukon lailliset indeksit ovat 0...3.
it2[4] += 1;

// Jos haluat testata tätä koodia koneellasi, aseta se tiedostoon LegalDate.java,
// käännä tapaan "javac LegalDate.java" ja aja tapaan "java LegalDate pp.kk.vvvv",
// missä pp.kk.vvvv on jokin päivämäärä (esim. 29.2.2021).
public class LegalDate {
  // Huomaa, että kaikki luokan LegalDate jäsenet on tässä määritetty staattisiksi.

  // Funktiomääritys kuin C-kielessä: paluuarvon tyyppi funktion nimen eteen,
  // parametrien tyypit ja nimet suluissa pilkuilla eroteltuina funktion nimen perään.
  // Funktio isLeapYear palauttaa totuusarvon, joka kertoo, onko year karkausvuosi.
  static boolean isLeapYear(int year) {
    // Karkausvuosi: jaollinen 4:llä ja ei jaollinen 100:lla tai jaollinen 400:lla.
    // Javan loogisaritmeettiset operaatiot ja return-lause kuin C-kielessä.
    return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
  }

  // Kuukausien päivien määrittämisen voi tehdä monella tavalla. Tässä käytetään
  // taulukkosyntaksin lisähavainnollistamiseksi kaksiulotteista esitäytettyä
  // int-taulukkoa: kullekin kuukaudelle 2-alkioinen alitaulukko, jossa päivien määrä
  // tavallisena ja karkausvuonna (ainoa ero helmikuussa eli toisessa alitaulukossa).
  static int[][] mDays = {{31, 31}, {28, 29}, {31, 31}, {30, 30}, {31, 31}, {30, 30},
                          {31, 31}, {31, 31}, {30, 30}, {31, 31}, {30, 30}, {31, 31}};

  // Funktio monthDays palauttaa tiedon, kuinka monta päivää kuukaudessa
  // month vuonna year on. Palautusarvo -1 vastaa virheellistä kuukautta.
  static int monthDays(int month, int year) {
    int days = -1;
    if(1 <= month && month <= 12) {
      // Ehdollinen operaattori kuin C-kielessä.
      days = isLeapYear(year) ? mDays[month-1][1] : mDays[month-1][0];
    }
    return days;
  }

  // Funktio isLegalDate tutkii, onko parametrien day, month ja year kuvaama
  // päivämäärä laillinen. Tässä vuosiluvun oletetaan olevan aina laillinen.
  static boolean isLegalDate(int day, int month, int year) {
    // Tuloksen laskenta on suoraviivaista, koska monthDays
    // palauttaa -1, jos kuukausi on laiton.
    return (1 <= day) && (day <= monthDays(month, year));
  }

  public static void main(String[] args) {
    // Javan String-luokan jäsenfunktio split palauttaa String-taulukon, jossa on
    // merkkijono ositettuna parametriksi annetun välimerkin perusteella. Tässä
    // pilkotaan komentoriviparametri args[0] osiin pisteen "." perusteella.
    // Pisteen edessä on kenoviivat teknisistä syistä: split tulkitsee parametrinsa
    // ns. säännölliseksi lausekkeeksi, jossa piste sellaisenaan olisi erikoismerkki.
    String[] dayMonthYear = args[0].split("\\.");
    boolean dateOk = false;
    if(dayMonthYear.length == 3) {
      // Tulkitaan merkkijonot kokonaisluvuiksi funktiolla Integer.parseInt.
      int day = Integer.parseInt(dayMonthYear[0]);
      int month = Integer.parseInt(dayMonthYear[1]);
      int year = Integer.parseInt(dayMonthYear[2]);
      dateOk = isLegalDate(day, month, year);
    }
    System.out.println("The date " + args[0] + (dateOk ? " is legal." : " is illegal!"));
  }
}

// Jos kokeilet esim. suoritusta "java TuniSearch use your opportunities", pitäisi
// ohjelman löytää merkkijono "tuni" parametrin args[2] = "opportunities" sisältä
// ja tulostaa Found "tuni" at index 5 of opportunities.
public class TuniSearch {
  // Tässä esimerkissä kaikki toiminnallisuus on rumahkosti suoraan main-funktiossa.
  public static void main(String[] args) {
    // Muuttuja key on etsittävä merkkiono. Tässä aina "tuni". Lisämääre final on Javan
    // vastine C-kielen const-määreelle: muuttujaan key ei saa enää asettaa uutta arvoa.
    final String key = "tuni";

    // Iteroitavan alkiojoukon läpikäyvä for-silmukka on samanlainen kuin C++11:ssa
    // (ja se oli Javassa jo aikaisemmin kuin C++:ssa). C-kieli ei tällaista tunne.
    // Muuttuja word käy läpi kaikki komentoriviparametritaulukon args alkiot.
    // Tässä on lisäksi annettu uloimmalle silmukalle nimi "SEARCH_LOOP". Nimen
    // avulla on helppoa poistua sisäkkäisestä silmukasta nimetyllä break-lauseella.
    SEARCH_LOOP:
    for(String word : args) {
      // Tavanomainen indeksipohjainen for-silmukka, joka käy läpi kaikki
      // potentiaaliset key:n esiintymäkohdat merkkijonon word sisällä.
      // String-olion pituus saadaan kutsumalla sen jäsenfunktiota length.
      // Huomaa ero taulukoihin: taulukoiden length on jäsenmuuttuja eikä -funktio.
      for(int i = 0; i <= word.length() - key.length(); i++) {
        // Vaihtelun vuoksi while-silmukka, joka tutkii merkki kerrallaan,
        // löytyykö key:n esiintymä alkaen indeksistä i.
        // String-olion jäsenfunktiokutsu charAt(x) palauttaa indeksin x merkin.
        int j = 0;
        while(j < key.length() && word.charAt(i+j) == key.charAt(j)) {
          j += 1;
        }
        // Saatiinko täsmättyä kaikki key.length() merkkiä?
        if(j == key.length()) {
          // Tulostetaan vaihtelun vuoksi format-funktiolla. Se toimii
          // varsin samantapaisesti, kuin C-kielen printf-funktio. Yksi alla
          // näkyvä ero on, että format-funktiossa %n tarkoittaa rivinvaihtoa.
          System.out.format("Found \"tuni\" at index %d of %s%n", i, word);
          // Hypätään pois ulkosilmukasta käyttäen nimettyä break-lausetta.
          // Tavallinen break hyppäisi ulos vain lähimmästä ympäröivästä silmukasta,
          // mutta nimetty break annetun nimen mukaisesta ympäröivästä silmukasta.
          break SEARCH_LOOP;
        }
      }
    }
  }
}

import java.util.Arrays;  // Testikoodi käyttää luokkaa java.util.Arrays.

public class Max {

  // Otetaan kaksi ensimmäistä arvoa tavallisina parametrina, jotta funktiolle
  // on pakko välittää vähintään kaksi parametria eli on jotain laskettavaa.
  public static int max(int first, int second, int... rest) {
    int maxVal = (first > second) ? first : second;
    for(int val : rest) {
      if(maxVal < val) {
        maxVal = val;
      }
    }
    return maxVal;
  }

  // Testausta varten main-funktio, joka muuntaa komentoriviparametrit
  // int-arvoiksi ja laskee niiden maksimeja.
  public static void main(String[] args) {
    int[] it = new int[args.length];
    for(int i = 0; i < args.length; i++) {
      it[i] = Integer.parseInt(args[i]);
    }

    // Ensin muutama testi, joissa maksimi lasketaan erillisiä parametreja
    // käyttäen: kutsut max(it[0], it[1]), max(it[0], it[1], it[2]) ja
    // max(it[0], it[1], it[2], it[3]).
    if(it.length >= 2) {
    System.out.format("Max(%d, %d) = %d%n", it[0], it[1],
                                        max(it[0], it[1]));
    }
    if(it.length >= 3) {
      System.out.format("Max(%d, %d, %d) = %d%n", it[0], it[1], it[2],
                                              max(it[0], it[1], it[2]));
    }
    if(it.length >= 4) {
      System.out.format("Max(%d, %d, %d, %d) = %d%n", it[0], it[1], it[2], it[3],
                                                  max(it[0], it[1], it[2], it[3]));
    }

    // Sitten vielä lopuksi testi, jossa lasketaan kaikkien parametrien
    // (jos niitä ainakin kaksi) maksimi yhdellä funktiokutsulla. Koska parametrien
    // määrää ei tiedetä etukäteen, ei tätä voi tehdä luettelemalla parametrit yksitellen.
    // Annetaan sen sijaan kahden ensimmäisen jälkeiset parametrit valmiina taulukkona.
    if(it.length >= 2) {
      // Arrays.copyOfRange(t, a, b) kopioi taulukon t osan a..b-1 uuteen taulukkoon.
      int[] rest = Arrays.copyOfRange(it, 2, it.length);
      // Arrays.toString luo primitiivitaulukosta järkevähkön merkkijonoesityksen.
      System.out.format("Max(%d, %d, %s) = %d%n", it[0], it[1], Arrays.toString(rest),
                                                              max(it[0], it[1], rest));
    }
  }
}

// Huomio: tämä koodi pitäisi asettaa tiedostoon WhatDayIsIt.java.

// Määritetään tiedoston sisältö kuulumaan
// pakkaukseen "fi.tuni.itc.programming3".
// Tiedostossa saa olla korkeintaan yksi pakkausmääritys.
package fi.tuni.itc.programming3;

// Kooditiedostossa käytetään Javan standardikirjaston pakkauksen
// java.text luokkaa DateFormat ja pakkauksen java.util luokkia Date ja
// Locale. Ne pitää tuoda erikseen näkyviin import-lauseilla.
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

// Päätason luokkamääritys.
// Suositus: vain yksi päätason luokka/rajapinta per tiedosto.
public class WhatDayIsIt {
  public static void main(String[] args) {
    Date now = new Date();  // Alustetaan Date-olio, joka vastaa nykyhetkeä.
    // Esimerkissä käytetättävät localet: Saksa, Japani, Korea ja USA
    Locale[] locales = {Locale.GERMANY, Locale.JAPAN,
                        Locale.KOREA, Locale.US};
    System.out.println("What day is it now in different locales?");
    // Käydään läpi edellä locales-taulukkoon asetetut neljä localea.
    for(Locale locale : locales) {
      // Tulostetaan rivin alkuun localen nimi amerikanenglanniksi (= Locale.US).
      System.out.print("In " + locale.getDisplayName(Locale.US) + ": ");
      // Alustetaan DateFormat-olio df, joka muotoilee Date-olion esittämän
      // päivämäärän sille parametrina annetun localen mukaisesti
      DateFormat df = DateFormat.getDateInstance(DateFormat.FULL, locale);
      // Kutsu df.format(now) muotoilee Date-olion now esittämän päivämäärän.
      System.out.println(df.format(now));
    }
  }
}