Leksika, tipi un objektu semantika

Mērķi

  • Lietot komentārus Javas izejas tekstā
  • Atšķirt pareizus identifikatorus no nepareiziem
  • Atpazīt Javas atslēgvārdus
  • Zināt visus 8 vienkāršos tipus
  • Rakstīt literāļus jeb konstantes skaitliskajiem un teksta tipiem
  • Definēt jēdzienus vienkāršs mainīgais (primitive variable) un references mainīgais (reference variable)
  • Deklarēt klašu mainīgos
  • Konstruēt objektus, lietojot atslēgvārdu new
  • Aprakstīt mainīgo noklusēto inicializāciju
  • Aprakstīt referenču mainīgo nozīmi
  • Aprakstīt klašu mainīgo piešķiršanas sekas

Javas sintakses elementi

Komentāri

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 
*/

Semikoli, bloki un tukšumi

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;
}

Semikoli, bloki un tukšumi

Bloks (block) obligāti jālieto klases definīcijā:

public class MyDate {
  private int day;
  private int month;
  private int year;
}
  • Viens bloks var saturēt citus blokus
  • Javas programma var saturēt jebkuru daudzumu tukšumu (whitespace)

Tukšumi (whitespace)

Par tukšumiem uzskata šos 6 ASCII simbolus:

Baita heksadecimāls pierakstsNosaukumsSimbola apzīmējums Javā

#x20
Atstarpe (space) ' '
#x09
Tabulācija (horizontal tabulation) '\t'
#x0D
Rakstatgrieze (carriage return) '\r'
#x0A
Rindpadeve (line feed) '\n'
#x0C
Formas padeve (form feed) '\f'

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.

Identifikatori

  • Tie ir klašu, mainīgo vai metožu vārdi
  • Mainīgā nosaukums sākas ar Unikoda burtu, pasvītrojumzīmi (_) vai dolāru ($)
  • Mainīgie ir reģistrjūtīgi un to garums nav ierobežots

    Piemēri:

    identifier
    userName
    user_name
    _sys_var1
    $change
    

Javas atslēgvārdi

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 faila struktūrai:
package, import, class, enum, interface
Mantošanas attiecībām:
implements, extends
Vadības komandām:
if, else, for, while, do, break, continue, switch, case, default
Izņēmumiem:
try, catch, finally, throw, throws
Citām komandām:
assert, return
Pamattipu apzīmēšanai:
boolean, char, byte, short, int, long, float, double (kā arī "tukšā tipa" apzīmējums void)
Konstruktoru izsaukšanai:
new, this, super
Tipu pārbaudes operators:
instanceof
Piekļuves modifikatori:
public, protected, private
Dažādi citi modifikatori:
abstract, final, static, synchronized, transient, volatile, native, strictfp
Neizmantotie atslēgvārdi:
const, goto

Vienkāršie tipi

Javas programmēšanas valodā ir 8 vienkāršie tipi:

  • Loģiskais tips - boolean
  • Teksta tips - char
  • Veselo skaitļu tipi - byte, short, int, and long
  • Daļskaitļu tipi - double and float

Loģiskais tips - boolean

  • Datu tipam boolean ir divas iespējamās vērtības - true un false.

Piemēram, komanda:

boolean lastElement = true;

deklarē mainīgo lastElement ar tipu boolean un vienlaikus piešķir tam vērtību true.

Teksta tipi - char un String

char
char var glabāt 16-bitu Unikoda simbolu. Tipa char konstantes jeb literāļus liek apostrofos (' ').

Piemēri:

  • 'a' - Burts a
  • '\t' - Tabulācijas simbols
  • '\u????' - Unikoda simbols, ???? ir aizstājams ar tieši četriem heksadecimālajiem cipariem. Piemēram, 'Φ' ir grieķu burts "phi" [Φ], 'Ф' ir kirilicas burts "Ф", bet 'ā' ir modificētais latīņu burts "a macron" jeb "ā" ("a" ar garumzīmi).
String
String (atšķirībā no char) nav vienkāršs datu tips. Tas nav arī char-u masīvs, bet gan neizmaināmu stringu objektu klase. Stringu literāļus liek pēdiņās (" ").

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 tipi - byte, short, int un long

Veselo skaitļu pierakstam var lietot 3 formas - decimālo, oktālo un heksadecimālo. Piemēram:

  • 2 - Decimālā forma skaitlim 2.
  • 077 - Sākšanās ar 0 liecina, ka izmantota oktālā forma. Atbilstošā vērtība decimālajā sistēmā ir 7*8+7 = 63.
  • 0xBAAC - Sākšanās ar 0x liecina, ka izmantota heksadecimālā forma. Atbilstošā vērtība heksadecimālajā sistēmā ir 11*(16*16*16) + 10*(16*16) + 10*16 + 12. Sk. Heksadecimālā sistēma.
  • Skaitliskiem literāļiem noklusētais tips ir int. Savukārt long tipa literāļiem beigās raksta burtu L vai l.
    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.

Veselo skaitļu tipu vērtību apgabali

byte
Regjistra garums 8 biti (1 baits). Iespējamās vērtības no -2^7 (-128) līdz 2^7-1 (127).
short
Regjistra garums ir 16 biti (2 baiti). Iespējamās vērtības no -2^15 (-32768) līdz 2^15-1 (32767).
int
Regjistra garums ir 32 biti (4 baiti). Iespējamās vērtības no -2^31 līdz 2^31-1.
long
Regjistra garums ir 64 biti (8 baiti). Iespējamās vērtības no -2^63 līdz 2^63-1.

Daļskaitļu tipi - float un double

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:

  • E vai e (pievieno reizinājumu ar desmitnieka pakāpi - peldošo punktu)
  • F vai f (float literālis)
  • D vai d (double literālis)
  • 3.14 - Vienkāršs daļskaitlis (double konstante)
  • 6.02E23 - Liels daļskaitlis
  • 2.718F - Vienkārša float konstante
  • 123.4E+306D - Liela double konstante ar (nevajadzīgu) "D"

    Daļskaitļu tipiem ir sekojošs atmiņas izlietojums:

    float
    32 biti
    double
    64 biti

Mainīgie, deklarācijas un piešķiršanas

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  }

Javas referenču tipi

  • Izņemot vienkāršos tipus, visi citi tipi ir referenču tipi
  • referenču mainīgais (reference variable) satur norādi (handle) uz objektu

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  }

Objektu konstruēšana un inicializācija

Izsaukums new Xxx(), kurš dinamiski izdala atmiņu jaunajam objektam noved pie sekojošām darbībām:

  • Atmiņas piešķiršana: Jaunajam objektam izdala atmiņu un tā instanču mainīgos inicializē uz noklusētajām vērtībām (veselo skaitļu tipi - 0, daļskaitļu tipi - 0.0, boolean - false, referenču un masīvu tipi - null)
  • Izpildās atribūtu inicializācijas darbības, kuras rakstītas, deklarējot šos atribūtus
  • Izpildās konstruktors
  • Konstruktora atgrieztā objekta referenci piešķir mainīgajam

Piemērs:

MyDate my_birth = new MyDate(22, 7, 1964);

Atmiņas izdalīšana un izvietojums

Deklarācija iedod atmiņu tikai references glabāšanai:

MyDate my_birth = new MyDate(22, 7, 1964);
Atmiņas stāvoklis pēc deklarācijas sastapšanas
  • Lietojiet operatoru new, lai iedotu atmiņu pašam objektam MyDate:
MyDate my_birth = new MyDate(22, 7, 1964);
Atmiņas stāvoklis pēc objekta rezervēšanas un noklusētajām inicializācijām

Atklāta atribūtu inicializācija

Inicializējam atribūtus kā norādīts klases definīcijā (pirms konstruktora)

MyDate my_birth = new MyDate(22, 7, 1964);
Atmiņas stāvoklis pēc klases mainīgo atklātajām inicializācijām
  • Noklusētās vērtības var būt minētas klases atribūtu deklarācijās

Izpildām konstruktoru

  • Izpildām atbilstošo konstruktoru:
MyDate my_birth = new MyDate(22, 7, 1964);
Atmiņas stāvoklis pēc konstruktora ķermeņa izpildes
  • Konstruktora pārslogošanas gadījumā, viens konstruktors var saukt citu konstruktoru.

Vērtības piešķiršana mainīgajam

  • Piešķirt jaunradīto objektu references mainīgajam
MyDate my_birth = new MyDate(22, 7, 1964);
Atmiņas stāvoklis pēc piešķiršanas operatora izpildes

Referenču tipu piešķiršana

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);

Referenču tipu piešķiršana

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

Pamattipu un referenču tipu piešķiršanas salīdzinājums
t = new MyDate(22, 12, 1964);

Konstruktora izsaukšana var izveidot jaunu objektu:

Divas references un divi objekti

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.

Parametru nodošana pēc vērtības (pass-by-value)

  • Java programmēšanas valodā metožu parametrus nodot tikai pēc vērtības (to sauc arī par pass by value jeb copy-in).
  • Ja metodes arguments ir objekta instance, tad argumenta vērtība ir šī objekta reference
  • Objekta saturu izsauktā metode var izmainīt, bet pašu objekta referenci nevar izmainīt tā, lai šīs izmaiņas redzētu arī metodes izsaucēja kontekstā

Parametru nodošana "pēc vērtības"

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  

Piemēri par referencēm

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); 

Referenču tipu salīdzināšana

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.

Parametru nodošana funkcijām

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);

StringBuffer piemērs

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".

Reference this

Atslēgvārdu this var lietot šādiem mērķiem:

  • Lai vērstos pie instances atribūtiem kādā metodē vai konstruktorā: Atslēgvārds this ļauj atšķirt instances mainīgos no metodes vai konstruktora lokālajiem mainīgajiem
  • Lai tekošo objektu nodotu kā parametru citai metodei vai konstruktoram

Reference this

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  }

Javas programmēšanas stila vadlīnijas

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:

  • Programmatūras izmaksu lielākā daļa saistīta ar uzturēšanu un to parasti koda dzīves laikā attīsta dažādi autori. Noteikts, vispāratzīts kodēšanas stils uzlabo programmatūras lasāmību.
  • Atvērtā koda pasaulē pats Javas kods (t.i. nekompilēts izejas teksts) bieži vien ir piegādājams produkts. Tam jābūt kvalitatīvi noformētam, kā jebkuram citam produktam.
  • Ja projekta gaitā kāds programmētājs pielieto automatizētu formatizācijas rīku (piemēram Eclipse vidē var klikšķināt Javas izejas teksta logā ar labo peles pogu un izvēlnē paņemt Source -> Format), tad visās rindiņās var izmainīties koda atkāpes (indentation) un Subversion vai citi versiju kontroles rīki vairs nevar viegli izsekot tam, kādas bijušas saturīgās izmaiņas programmā. Tādēļ ir svarīgi, lai visiem programmētājiem, kuri labo konkrēto kodu, būtu vienādi atkāpju iestatījumi. Eclipse vides gadījumā noklusētā atkāpe ir tabulācija (\t simbols), kura redzamais platums ir 4 atstarpes (tas, starp citu, ir pretrunā ar Sun koda stila vadlīnijām, kur teikts, ka tabulācijai jābūt 8 simbolus platai).
Mainīgo nosaukšana (naming conventions)
Pakotnes:
Visi ar punktiem atdalītie identifikatori sākas ar mazajiem burtiem. Piemēram, package banking.domain vai package lv.mydomain.myproject.dao.
Klases:
Klašu un interfeisu nosaukumi sākas ar lielajiem burtiem. Ja nosaukumā ietilpst vairāki vārdi, tad arī katru nākamo vārdu raksta ar lielo burtu. Piemēram, class SavingsAccount vai interface Account.
Metodes:
Metožu nosaukumi sākas ar mazajiem burtiem. Piemēram, balanceAccount()
Mainīgie:
Gan klašu, gan lokālie mainīgie sākas ar mazajiem burtiem. Piemēram, currentCustomer
Konstantes:
Konstantes (ko deklarē ar atslēgvārdu "final") rakstāmas ar visiem lielajiem burtiem. Ja tās sastāv no vairākiem vārdiem, katru nākamo vārdu atdala ar pasvītrojumzīmi. Piemēram, HEAD_COUNT.
Faila izskats

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:

  • Pārtraukt pēc komata
  • Pārtraukt pirms operatora
  • Pārtraukt vislabāk tur, kur mainās lielāka apakšizteiksme
  • Pārnesto rindiņu izlīdzināt ar izteiksmes sākumu iepriekšējā rindiņā
  • Ja kods pārnestajās rindiņās ir par daudz nobīdīts pa labi, tad atkāpties tieši 8 atstarpes.
Klases un interfeisa definēšana
  • Klases/interfeisa dokumentācijas galvenais komentārs: /**...*/. Piemēram,
    /**
    * Klases lv.com.ruksis.MansRuksis apraksts
    *
    * @version 1.82 2000. gada 14. septembrī
    * @author Jānis Līdums
    */
    
  • Klases vai interfeisa deklarācija
  • Klases/interfeisa implementācijas komentārs, ja tāds vajadzīgs /*...*/, info par implementāciju nevajadzētu iekļaut klases publiski redzamajā dokumentācijā.
  • Klases statiskie mainīgie: publiskie, aizsargātie, paketes līmeņa un privātie.
  • Instanču mainīgie tai pašā secībā.
  • Konstruktori
  • Metodes grupētas pēc funkcionalitātes
Atkāpju stils (indent style)

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.

Koda stila pārbaudīšanas rīki

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.

Jautājumi paškontrolei

  • Javas izejas tekstos rakstīt komentārus
  • Atšķirt derīgus identifikatorus no nederīgiem
  • Atpazīt Javas atslēgvārdus
  • Uzskaitīt astoņus pamattipus
  • Definēt literāļus skaitliskajiem un teksta tipiem
  • Definēt jēdzienus vienkāršs mainīgais (primitive variable) un referenču mainīgais (reference variable)
  • Deklarēt mainīgos, kuru tips ir klase
  • Konstruēt objektu, izmantojot new
  • Aprakstīt noklusēto inicializāciju
  • Aprakstīt referenču mainīgo nozīmi
  • Aprakstīt darbību virkni, ja notiek klašu tipu mainīgo piešķiršana