Java- ja C++-ohjelmointikielten vertailu
Kielen ominaisuudet > Syntaksi

Javassa on kontekstivapaa kielioppi, jonka jäsentäminen voidaan suorittaa yksinkertaisella LALR-parserilla. C++ jäsentäminen on monimutkaisempaa, esimerkiksi, Foo<1>(3); on sarja vertailuja, jos Foo on muuttuja, mutta se luo olion, jos Foo on luokkamallin nimi.
C++ mahdollistaa nimiavaruus-tason vakiot, muuttujat ja funktiot. Vastaavasti Javassa vastaavien olioiden on kuuluttava johonkin tiettyyn tyyppiin ja ne on määriteltävä tyypin määrityksen sisällä, joko luokassa tai rajapinnassa.
C++:ssa oliot ovat arvoja, kun taas Javassa ne eivät ole. C++ käyttää arvo semantiikkaa oletuksena, kun taas Java käyttää viittaussemantiikkaa. Osoitinta tai viittausta voidaan käyttää viittaussemantiikan valitsemiseen C++:ssa.
| C++ | Java |
| --- | --- |
class Foo {          // Luokan julistus     int x = 0;       //  Yksityinen jäsenmuuttuja. Alustetaan                      //  0:ksi.     public:       Foo() : x(0)     //  Luokan Foo rakentaja; alustaa       {}               //  x:n nollaksi. Mikäli alustaja jätetään pois,                      //  muuttuja alustettaisiin arvoon, joka                       //  on annettu x:n julistuksessa.        int bar(int i) { // Jäsenfunktio bar()           return 3*i + x;       } }; : class Foo {               // Määrittää luokan Foo     private int x;        // Jäsenmuuttuja, yleensä julistetaan                           // yksityiseksi kapsuloinnin pakottamiseksi                           // alustetaan arvoon 0 oletuksena      public Foo() {        // Foo:n rakentaja     }                     // argumentiton rakentaja luodaan oletuksena     public int bar(int i) {        // Jäsenmetodi bar()         return 3*i + x;     } } 
Foo a; // julistaa Foo-olion arvon, // alustetaan käyttäen oletusrakentajaa  // Toista rakentajaa voidaan kutsua seuraavasti Foo a(args); // tai (C++11): Foo a{args}; : Foo a = new Foo(); // Julistaa viittauksen uuteen Foo-olioon // alustus tapahtuu oletusrakentajaa käyttämällä  // Toista rakentajaa voidaan käyttää seuraavasti Foo a = new Foo(args); 
Foo b = a; // Kopioi a:n sisällön uuteen Foo-olioon b // Vaihtoethoinen syntaksi on "Foo b(a)" : // Foo b = a; // julistaisi b:n a:n osoittaman olion viittaukseksi Foo b = a.clone(); // kopioi a:n osoittaman olion sisällön uuteen Foo-olioon // asettaa viittauksen b osoittamaan tähän olioon // Foo luokan tulee implementoida "Cloneable" rajapintaa, jotta koodi kääntyy 
a.x = 5; // Muokkaa oliota a : a.x = 5; // Muokkaa a:n viittaamaa oliota 
std::cout << b.x << std::endl; // Tulostaa 0, sillä b on eri olio kuin a : System.out.println(b.x); // Tulostaa 0, sillä b on eri olio kuin a 
Foo *c; // Julistaa c:n a:n osoittimeksi // Foo olio (alustettu määrittelemättömäksi, voi osoittaa minne tahansa) : Foo c; // Julistaa c:n Foo-olion viittaukseksi // (alustettu null-arvoon, jos c on luokan jäsen; on tarpeen alustaa c ennen käyttöä jos se on paikallinen muuttuja) 
c = new Foo; // c on asetettu new-operaattorin luomaan Foo-olion osoitteeseen : c = new Foo(); // kiinnittä c:n viittaamaan uutta Foo-oliota 
Foo &d = *c; // kiinnittää d:n osoittaamaan samaan objektiin mihin c osoittaa : Foo d = c; // kiinnittää d:n viittaamaan samaan olioon kuin c 
c->x = 5; // muokkaa c:n osoittmaa oliota : c.x = 5; // muokkaa c:n viittaamaa oliota 
d.bar(5);  // kutsuu Foo::bar() metodia kohteeelle a c->bar(5); // kutsuu Foo::bar() metodia kohteelle *c : d.bar(5); // kutsuu Foo.bar() metodia kohteelle a c.bar(5); // kutsuu Foo.bar() metodia kohteelle c 
std::cout << d.x << std::endl; // Tulostaa arvon 5, koska d viittaa samaan objektiin, mihin c osoittaa : System.out.println(d.x); // Tulostaa arvon 5, koska d viittaa samaan objektiin kuin c