Javā pieļaujami 3 komentāru veidi:
...programmas teksts... // šis ir rindas beigu komentārs
/* Vienas vai vairāku rindu komentārs */
/** Dokumentējošs komentārs */
Komandas (statement) raksta vienā vai vairākās rindiņās un to beigās raksta semikolu(;):
totals = a + b + c
+ d + e + f;
Bloks (block) ir "salikta komanda" - tajā uzskaitītas viena vai vairākas komandas, un to ietver atverošā un aizverošā figūriekava:
{
x = y + 1;
y = x + 1;
}
Bloks (block) obligāti jālieto klases definīcijā:
public class MyDate {
private int day;
private int month;
private int year;
}
Par tukšumiem uzskata šos 6 ASCII simbolus:
Baita heksadecimāls pierakstsNosaukumsSimbola apzīmējums Javā
Sk. arī tukšuma (jeb predefinētās simbolu kopas \s) jēdzienu regulārajās izteiksmēs - http://java.sun.com/javase/6/docs/api/java/util/regex/Pattern.html un tukšumsimbolu (white space) jēdzienu XML specifikācijā - http://www.w3.org/TR/REC-xml/#NT-S.
Piemēri:
identifier userName user_name _sys_var1 $change
Ne visi vārdi valodā Java var kalpot par identifikatoriem, jo daži no tiem ir rezervēti kā atslēgvārdi (keywords). Sk. Alfabētisku visu atslēgvārdu saraksts. Atslēgvārdus var iegaumēt, iedalot tos vairākās lielās kategorijās:
Javas programmēšanas valodā ir 8 vienkāršie tipi:
Piemēram, komanda:
boolean lastElement = true;
deklarē mainīgo lastElement ar tipu boolean un vienlaikus piešķir tam vērtību true.
Piemēri:
Piemēri:
String s1 = "The quick brown fox jumps over the lazy dog.";
String s2 = "Vajadzētu tik gaišu dziesmu\n"
+ "kā pērkons\n"
+ "pār smaragda zaļo\n"
+ "un pirmo zāli.";
"
Operators "+" apzīmē stringu konkatenāciju.
Veselo skaitļu pierakstam var lietot 3 formas - decimālo, oktālo un heksadecimālo. Piemēram:
public class IntegerTypeSample {
public void f(long x) {
System.out.println("long argument " + x);
}
public void f(int x) {
System.out.println("int argument " + x);
}
public void f(short x) {
System.out.println("short argument " + x);
}
public void f(byte x) {
System.out.println("byte argument " + x);
}
public static void main(String[] args) {
IntegerTypeSample sample = new IntegerTypeSample();
sample.f(217L);
sample.f(217);
short x1 = (short)217;
sample.f(x1);
byte x2 = (byte)217;
sample.f(x2);
}
}
Šīs programmas izvade ir:
long argument 217 int argument 217 short argument 217 byte argument -39
Mainīgā tipa byte gadījumā skaitlis kļuva negatīvs, jo "217" vairs nevar izvietoties viena baita regjistrā, ja tas kodēts ar . papildkodu.
Pēc noklusēšanas literāļu tips ir double. Daļskaitļa literālis satur vai nu decimāldaļskaitlim raksturīgo punktu, vai arī kādu no sekojošiem simboliem:
Daļskaitļu tipiem ir sekojošs atmiņas izlietojums:
1 public class Assign {
2 public static void main (String args []) {
3 // declare integer variables
4 int x, y;
5 // declare and assign floating point
6 float z = 3.414f;
7 // declare and assign double
8 double w = 3.1415;
9 // declare and assign boolean
10 boolean truth = true;
11 // declare character variable
12 char c;
13 // declare String variable
14 String str;
15 // declare and assign String variable
16 String str1 = "bye";
17 // assign value to char variable
18 c = 'A';
19 // assign value to String variable
20 str = "Hi out there!";
21 // assign values to int variables
22 x = 6;
23 y = 1000;
24 }
25 }
Piemērs:
1 public class MyDate {
2 private int day = 1;
3 private int month = 1;
4 private int year = 2000;
5 public MyDate(int day, int month, int year) { ... }
6 public void print() { ... }
7 }
1 public class TestMyDate {
2 public static void main(String[] args) {
3 MyDate today = new MyDate(22, 7, 1964);
4 }
5 }
Izsaukums new Xxx(), kurš dinamiski izdala atmiņu jaunajam objektam noved pie sekojošām darbībām:
Piemērs:
MyDate my_birth = new MyDate(22, 7, 1964);
Deklarācija iedod atmiņu tikai references glabāšanai:
MyDate my_birth = new MyDate(22, 7, 1964);
MyDate my_birth = new MyDate(22, 7, 1964);
Inicializējam atribūtus kā norādīts klases definīcijā (pirms konstruktora)
MyDate my_birth = new MyDate(22, 7, 1964);
MyDate my_birth = new MyDate(22, 7, 1964);
MyDate my_birth = new MyDate(22, 7, 1964);
Aplūkosim šādu koda fragmentu:
int x = 7; int y = x; MyDate s = new MyDate(22, 7, 1964); MyDate t = s; t = new MyDate(22, 12, 1964);
int x = 7; int y = x; MyDate s = new MyDate(22, 7, 1964); MyDate t = s;
Divi mainīgie norāda uz to pašu objektu
t = new MyDate(22, 12, 1964);
Konstruktora izsaukšana var izveidot jaunu objektu:
Ja šajā situācijā mēs vēl izpildām piešķiršanu:
s = t
tad uz objektu MyDate(22, 7, 1964) vairs nav nevienas references un tas kļūst pieejams drazu savācējam. Jaunu objektu, kurš ir identisks kādam jau eksistējošam objektam, parasti var izveidot ar metodi clone(). Piemēram,
t = (MyDate)s.clone();
Šī metode ir definēta klašu hierarhijas saknei - java.lang.Object un veic "seklu" datu lauku piešķiršanu, t.i. jaunā objekta datu laukus inicializē ar tām pašām vērtībām (gan skalārajām, gan referenču vērtībām), kuras ir klonējamajam objektam. Lai varētu saukt metodi clone() objektam ir jādeklarē, ka tas atbalsta Cloneable interfeisu.
1 public class PassTest {
2
3 // Methods to change the current values
4 public static void changeInt(int value) {
5 value = 55;
6 }
7 public static void changeObjectRef(MyDate ref) {
8 ref = new MyDate(1, 1, 2000);
9 }
10 public static void changeObjectAttr(MyDate ref) {
11 ref.setDay(4);
12 }
13
14 public static void main(String args[]) {
15 MyDate date;
16 int val;
17
18 // Assign the int
19 val = 11;
20 // Try to change it
21 changeInt(val);
22 // What is the current value?
23 System.out.println("Int value is: " + val);
24
25 // Assign the date
26 date = new MyDate(22, 7, 1964);
27 // Try to change it
28 changeObjectRef(date);
29 // What is the current value?
30 date.print();
31
32 // Now change the day attribute
33 // through the object reference
34 changeObjectAttr(date);
35 // What is the current value?
36 date.print();
37 }
38 }
39
Javas vienkāršo tipu programmēšanā nav īpaši rūpīgi jāatšķir mainīgā (piemēram, int) attēlojums atmiņā un atbilstošā mainīgā vārds. Turpretī masīviem un objektiem (referenču tipiem), mainīgā vārds jāuztver kā viens no vārdiem (jeb referencēm, norādēm), caur kuru var piekļūt atbilstošā objekta reprezentācijai atmiņā.
int x = 42; int y = x; y = 7; System.out.println(x); // cik ir "x"?
Referenču tipiem nekopē referencējamā objekta saturu, bet gan pašu referenci
Point p = new Point(1.0,2.0); Point q = p; // "p" un "q" ir divas references uz to pašu punktu Point r = p.clone(); // "r" turpretī ir kopija p.x = 13.0; System.out.println(q.x); System.out.println(r.x);
Masīviem tas ir līdzīgi:
char[] sveiciens = { 'h', 'e', 'l', 'l', 'o' };
char[] masivs = sveiciens;
masivs[4] = '!';
System.out.println(sveiciens);
Diviem objektiem, masīviem, utml. var izpildīt operāciju == vai !=, bet rezultāts ir true nevis tad, kad atbilstošo datu struktūru lauki ir vienādi, bet gan tad, kad tiek salīdzinātas references, kuras norāda uz to pašu vietu atmiņā. Referenču tipiem ir īpaša vērtība null, t.i. neinicializēta reference uz objektu vai masīvu.
Primitīvos tipus nodod kopējot vērtību:
private static void changePrimitive(int x) {
while (x>0) x--;
}
public static void main(String[] args) {
int x = 4;
changePrimitive(x);
System.out.println(x);
}
Referenču tipus nodod, kopējot references. T.i. references nodod "pēc vērtības":
private static void changeReference(Point p) {
p.x = p.x - 1;
}
public static void main(String[] args) {
Point p = new Point(4,4);
changeReference(p);
System.out.println(p.x);
}
Sekojošais kods neapmainīs objektus "p" un "q" vietām:
public void swap (Object a, Object b)
{ Object temp = a; a = b; b = temp; }
Button p,q;
p = new Button(); q = new Button();
swap(p,q);
public class SBuf {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer("A");
StringBuffer sb2 = new StringBuffer("B");
operate(sb1, sb2);
System.out.println(sb1 + "," + sb2);
}
public static void operate(StringBuffer sb1, StringBuffer sb2) {
sb1.append(sb2);
sb1 = sb2;
}
}
Analizējot šo piemēru, jāatceras, ka StringBuffer ir modificējama klase, t.i. nepārtaisot referenci var tiešām modificēt stringa buferi. Tātad sb1.append(sb2) tik tiešām nostrādā un sb1 kļūst vienāds ar "AB". Turpretī rindiņai sb1 = sb2 ir nozīme tikai metodes operate() ietvaros. Programma tātad izdrukā rezultātu "AB,B".
Atslēgvārdu this var lietot šādiem mērķiem:
1 public class MyDate {
2 private int day = 1;
3 private int month = 1;
4 private int year = 2000;
5
6 public MyDate(int day, int month, int year) {
7 this.day = day;
8 this.month = month;
9 this.year = year;
10 }
11 public MyDate(MyDate date) {
12 this.day = date.day;
13 this.month = date.month;
14 this.year = date.year;
15 }
16
17 public MyDate addDays(int more_days) {
18 MyDate new_date = new MyDate(this);
19
20 new_date.day = new_date.day + more_days;
21 // Not Yet Implemented: wrap around code...
22
23 return new_date;
24 }
25 public void print() {
26 System.out.println("MyDate: " + day + "-" + month +
27 "-" + year);
28 }
29 }
1 public class TestMyDate {
2 public static void main(String[] args) {
3 MyDate my_birth = new MyDate(22, 7, 1964);
4 MyDate the_next_week = my_birth.addDays(7);
5
6 the_next_week.print();
7 }
8 }
Sk. pilnu dokumentu Code Conventions for the Java Programming Language. Šīs stila vadlīnijas nav vajadzīgas kompilatoram (kurš spēj analizēt un apstrādāt jebkādā veidā pierakstītu kodu), bet gan cilvēkiem, kuri ar programmu strādā. Iemesli, kādēļ jālieto programmēšanas stila vadlīnijas:
Klasei obligāti jābūt failā, kuru sauc tieši tāpat kā pašu klasi (dažās OS var būt svarīgi lielie un mazie burti failu nosaukumos). Vienā failā nevajadzētu būt vairāk par 2000 rindiņām. Rindiņu garumam nevajadzētu pārsniegt 80 simbolus. Rindiņas var pārtraukt šādi:
/** * Klases lv.com.ruksis.MansRuksis apraksts * * @version 1.82 2000. gada 14. septembrī * @author Jānis Līdums */
Javas programmēšanā pieņemts atverošo figūriekavu likt vienā rindā ar cikla vai nosacījuma komandas nosacījumu un cikla/nosacījuma ķermeni rakstīt ar 4 tukšumu atkāpi attiecībā pret sākumu un beigām:
if (<cond>) {
<body>
}
Tas pazīstams kā K&R stils; sk. http://tuxedo.org/jargon/html/entry/indent-style.html.
Sk. http://checkstyle.sourceforge.net/ - šādu programmatūru var būt derīgi attiecīgi konfigurēt un izmantot lielā projektā, kur jāpārbauda daudzu failu atbilstība stila vadlīnijām. To var pievienot Ant vai Maven skriptam, lai gjenerētu brīdinājumus par visiem stila pārkāpumiem.