1. Sintaksė ir semantika Identifikatoriai ir unikodas Komentarai
Raktiniai žodžiai
Duomenų tipai
Pirminiai duomenų tipai ◊ Sveikieji skaičiai ◊ Slankaus kablelio skaičiai ◊ Simboliai ◊ Loginiai kintamieji
Pirminių duomenų tipų konvertavimas ◊ Slankaus kablelio į sveikąjį skaičių
◊ double tipo į float
◊ Loginis į arba iš bet kurio tipo
Kintamųjų paskelbimas ◊ Galiojimas ◊ Kintamųjų pavadinimai
Operacijos ◊Operacijos su skaičiais
◊Unarinės operacijos
◊Binarinės operacijos
◊Operacijos su objektais
◊Operacijos su eilutėmis

2. Galimi Java komentarų stiliai:
// tekstas Visas tekstas toliau už // ženklo iki eilutės
pabaigos bus ignoruojamas.
/* tekstas */ Visas komentarų tekstas ignoruojamas. Jis gali susidaryti iš daugelio eilučių.
/** tekstas */
Komentarai skirti įtraukti į javadoc generuojamą dokumentaciją
Komentarų pvz:
class test{
public static final void main (String[] S){
/* normalūs komentarai su // /*
/** simboliai viduje.
komentarai pasibaigia čia */
System.out.println(“Sveikas, Pasauli!”); }

3. Java kalbos raktiniai žodžiai
abstract do
implements
package
throw
boolean
double
import
private
throws
break
else
*inner
protected
transient
byte
extends
instanceof
public
try
case
final
int
*rest
*var
*cast
finally
interface
return
void
catch
float
long
short
volatile
char
for
native
static
while
class
*future
new
super
** strictfp
*const
*generic
null***
switch
continue
*goto
operator
synchronized
default if
*outer
this
* - rezervuoti ateičiai,
** - buvo pridėti Java 2
*** - null yra specialus kintamasis ir Java 2 versijoje nevadinamas raktiniu.

4. short i = 0x7fff; // šešioliktaine forma
Sveikieji skaičiai:
Vardas
Dydis
Minimumas
Maksimumas
Pavyzdys
byte   8
-128
127
16,-16
short   16
-32768
32767
99, -99
int   32
99999,
long   64
-9223…808
9223…807
Pavyzdžiai:
short i = 0x7fff; // šešioliktaine forma
short j = 07777; // tas pats aštuntaine forma
short k = // tas pats dešimtaine forma
Cikliškas perkėlimas:
byte i=(byte)127;
boolean b=(byte)(i+1) == -128; // !Keista

5. Slankaus kablelio skaičiai:
Yra dviejų tipų: float ir double
Nutylimieji visuomet double tipo
float num = 1.0; //! Kompiliavimo klaida
// nes 1.0 yra double tipo
Teisingai:
float num = 1.0f; //arba
float num = (float)1.0;
Galimos specifinės reikšmės:
Float.MAX_VALUE
Float.MIN_VALUE
Float.NaN
Float.NEGATIVE_INFINITY
Float.POSITIVE_INFINITY
Analogiškai Double
Daugiaženklius lyginti pavojinga!
Pvz.: Rezultatas !=
bus sunkiai prognozuojamas

6. Simboliai (characters)
Perėjimas į unikodo simbolius:
Perėjimo sekos
Paskirtis
Unikodas \b
Tarpas
\u0008 \t
Horizontalus tarpas
\u0009 \n
Eilutės perdavimas
\u000a \f
Eilutės perstūma
\u000c \r
Karietėlė
\u000d
\"
Dviguba kabutė
\u0022 \'
Vienguba kabutė
\u0027 \\
Pasviras brūkšnys
\u005c
Pavyzdžiai:
'a' - simbolis .
'\n' - eilutės perdavimas.
'\\' - unikodo pasviras brūkšnys.
'\u0042' - unikodas seka.
Unikodo koncsorciumo Web puslapis:

7. Tik dvi reikšmės true ir false
Loginiai kintamieji
Tik dvi reikšmės true ir false
Galima naudoti santykio operacijas. Pvz:
boolean tiesa=1==1, netiesa=1==0;
Tipų konvertavimas:
Prad.   tipas
Paskirties tipas
  byte  
short  
int  
long  
float  
double
char  
boolean C X
  short  
C, L
  int  
  long   CL
  float  
 double
  char  
C - kad konvertuoti jūs turite naudoti (cast)operatorių;
L - konvertavimo metu galima prarasti tikslumas;
X - konvertavimas draudžiamas.
Pavyzdys: int i = 1; short j = 1; // ! Klaida

8. Kintamųjų paskelbimo taisyklės:
Kintamieji gali būti pirminių tipų,
objektai ir interfeisai;
Kintamojo paskelbimas gali būti pratęstas pradinės
reikšmės priskyrimu;
Kintamųjų paskelbimo vietą pasirenkate laisvai.
Kintamųjų paskelbimo pavyzdžiai:
int i=42;
String it="Hello World";
float pi=3.14f;
boolean cont;
Kintamieji galioja kol neišeinama iš jų paskelbimo
bloko {}. Pavyzdžiui
class foo {
int cnt;
public void test1() {
int num; }
public void test2() {
for( int cnt=0; cnt< 5; cnt++)
System.out.println(cnt);

9. Kintamųjų vardai ir jų paskelbimas:
Kintamųjų galiojimo medis:
Kintamųjų užgožimo efektas ir sprendimas:
this.cnt = 4;
Kintamųjų vardai ir jų paskelbimas:
Turi prasidėti raide;
Toliau gali būti ir skaitmenys bei skyrybos ženklai;
Vardai negali dubliuotis to paties lygio bloke;
Simboliai laikomi vienodais tada ir tik tada, kai sutampa jų unikodo reikšmės.

10. Operacijos . [] () ++ -- ! ~ instanceof * / % + - << >>
>>>
<
>
<=
>= == !=
& ^ |
&& || ?: =
Op= ,
Operacijų eiliškumo tvarka yra iš viršaus į apačią.
Tos pačios eilutės operacijos yra lygaus pirmumo.
Pvz. x = 2+4*3 rezultatas dėl eilišk. bus x=14, bet ne 18.
Operacijos su skaičiais:
1 tipas
2 tipas
Rezultatas
byte  
int  
short  
long  
1 tipas
2 tipas
Rezultatas
int  
long  
float  
double

11. Pvz: i++; ++i; i--; ~i; +i Netikėtas rezultatas -128:
Unarinės operacijos:
Operacija
Aprašymas -
Unarinis minus +
Unarinis plius ~
Bitinis papildinys ++
Padidinimas vienetu --
Sumažinimas vienetu
Pvz: i++; ++i; i--; ~i; +i
Netikėtas rezultatas -128:
byte i=(byte)-128;
System.out.println(-i);
Bitinis papildinys:
Paskalyje: ~(byte)0 == 255
Javoje: ~(byte)0 == -1
Apibrėžimas: ~x=-(x-1)
Padidinimas ir sumažinimas vienetu:
int i=0, j=0;
System.out.println(++i);
System.out.println(j++);
Spausdinimo rezultatas:
1 ir 0;
galutinės i ir j reikšmės:
i=j=1

12. Binarinės operacijos:
Operacija
Aprašymas +
Sudėtis -
Atimtis *
Daugyba /
Dalyba %
Modulis
&
Bitinis AND |
Bitinis OR ^
Bitinis XOR
<<
Su ženklu poslinkis į kairę
>>
Su ženklu poslinkis į dešinę
>>>
Be ženklo poslinkis į dešinę
Op=
Kombinacija priskyrimas ir operacija
Adityvios operacijos: +, -
Dauginimo operacijos: *,/,%
Neasociatyvios. Pvz.
float v = 1f;
float max = 2^24e104;
v +max - v == max - v + v yra false
Apibrėžimas: (a/b) * b + (a%b) = a
pvz: 11 % 4 == 3, 11 % (-4) == -3
Bitiniai operatoriai: &, |, ^ . Pvz:
byte flags=0xff; // inicijuoja
byte mask=0xfe; // trafaretas
flags = flags & mask; // eilės 8 pozicija
flags = flags | mask; // išvalo 8 poziciją
flags = flags ^ mask; // =

13. Santykio (palyginimo) operacijos:
Postūmiai: <<, >>, >>>
int i = 129; // dvejetainis
i = i >> 1; // dabar arba 64
Kombinacija priskyrimas ir operacija. Pvz:
int i = 7;
i *= 3; // i = 21
i +=5; // i =26
i += --i; // i = 51, bet ne 50
Santykio (palyginimo) operacijos:
Operatorius
Aprašymas
<
Mažiau kaip
>
Didesnis kaip
<=
Mažiau kaip arba lygus
>=
Didesnis kaip arba lygus ==
Yra lygūs !=
Nelygūs
Kuo skiriasi = ir == operacijos?
C/C++ kompiliatorius tokio operacijų sumaišymo nepastebės!

14. Operacijos su simboliais
Loginės operacijos
Operatorius
Aprašymas !
Neiginys
&
Loginis AND |
Loginis OR ^
Loginis XOR
&&
Sąlyginis AND ||
Sąlyginis OR ==
Lygus !=
Nelygus
Op=
Kombinacija priskyrimas ir operatorius ?:
Sąlygos operatorius
Sąlygos op. vienintelis naudoja tris operandus:
a?b:c Pvz:
int i; boolean salyga=false;
// įprasta if komanda
if (salyga) i=5; else i=6;
// tas pats naudojant sutrumpinimą:
i = (salyga?5:6);
Operacijos su simboliais
char c='B';
c = (char) (c - ('A' - 'a'));

15. Operacijos su objektais: =, ==, != ir instanceof foo test = new foo();
foo test2 = null;
test2 = test;  // test2 pasidaro test sinonimas
foo test1 = new foo();
foo test2 = new foo();
foo test3 = test1;
test1
test2
test3 == !=
Instanceof naudojamas patikrinti objekto tipą. Pvz:
shape shapeHolder;
if (shapeHolder instanceof polygonShape) {
polygonShape polygon = (polygonShape) shapeHolder;
// darome ką nors su polygon }
Operacijos su eilutėmis. Hibridinės savybės.
String foo = "Sveikas ";
String bar = "Pasauli"; int i = 42;
boolean cont = false; String rezultatas = null;
result = foo + bar; // = "Sveikas Pasauli"
result = foo + i; // = "Sveikas 42"
result = foo + cont; // = "Sveikas false"

16. + operacijos su eilute ir kito tipo kintamuoju:
String S=“Mano tekstas papildytas: “ + i;
Operandas i
Taisyklė
 null  kintamieji
Kiekvienas kintamieji kurios reikšmė bus  null  bus pakeistas eilute "null ".
Sveikasis skaičius
Sveikasis skaičius bus konvertuotas į eilutę vaizduojančią dešimtainę skaičiaus išraišką. - ženklas pradės neigiamą skaičių ir nebus rašomi vedantieji nuliai, išskyrus 0 atvejį.
Slankaus kablelio
Slankaus kablelio skaičiai bus konvertuojami į kompaktišką formą. Jeigu užrašo ilgis viršija 10 simbolių, jis bus užrašytas eksponentine forma. Neigiamas skaičius prasidės - ženklu.
Simbolis
Simbolis bus konvertuotas į jai ekvivalenčią 1 simbolio ilgio eilutę.
Loginis
Rezultatas bus arba "true"  arba "false"   eilutė priklausomai nuo loginio kintamojo reikšmės.
Objektas
Objektams bus keičiamas toString() metodas.