Javas ievads

Last modified by superadmin on 2018-01-12 20:24

ItemSet: Javas ievads

Pamatzināšanas par valodu Java - vienkārši jautājumi par Javas tehnoloģijām un valodas sintaksi.

New item:

Skills

  1. Objektorientācija

    Prast pierakstīt iekapsulēšanas, mantošanas attiecības; saprast klašu, abstraktu klašu un interfeisu mijiedarbību, pārveidot objektu tipus uz šaurāku/platāku mantošanas hierarhijā, atpazīt polimorfisma izpausmes.

    1. Deklarācijas, inicializācija

    Deklarēt klases, klašu atribūtus un metodes, lokālus mainīgos. Noteikt redzamības apgabalus, lietot deklarācijās dažādus atslēgvārdus - modifikatorus, saprast konstruktoru deklarēšanu un izpildes secību. 

    1. Vadības plūsma

    Prast pierakstīt vadības komandas, zarošanās un cikli, lietot <tt>assert</tt> komandu. Pierakstīt izņēmumu apstrādi un prast atšķirt dažādus izņēmumu tipus.

    1. Javas API

    Pārzināt pakotņu <tt>java.lang</tt>, <tt>java.io</tt>, <tt>java.text</tt> izplatītāko klašu un metožu uzvedību; Javas regulāras izteiksmjes, datu formatēšanas un izvades komandas.

    1. Pavedieni

    Definēt un sākt pavedienus daudzpavedienu programmā, zināt pavedienu stāvokļus, prast lietot sinhronizāciju, <tt>wait</tt> un <tt>notify</tt> komandas.

    1. Kolekcijas

    Pārzināt Javas kolekciju API iespējas, definēt un lietot kopas, sarakstus, asociatīvus masīvus (<tt>Map</tt>).

    1. Pamattipi, masīvi, operatori

    Zināt pamattipu pieļaujamās vērtības, prast pierakstīt literāļus. Deklarēt un inicializēt masīvus. Saprast operatoru darbību un prast pierakstīt un aprēķināt izteiksmes.

    1. Javas tehnoloģiju pamati

    Pazīt pareizus apgalvojumus par klasēm, kas izpildāmas no komandrindas, zināt izstrādes vides direktoriju izvietojumu un JAR failu struktūru, Javas pirmkoda faila uzbūvi, atmiņas modeli un drazu savācēja uzvedību.

1. Objektorientācija

  1. BasicJava_1001: Kas notiks, ja kompilē šādu kodu: {code} class MyString extends String { } {code}

    1. Kods kompilējas veiksmīgi

    2. Kods nekompilējas, jo nav definēta <tt>main()</tt> metode

    3. Kods nekompilējas, jo <tt>String</tt> ir <tt>abstract</tt> klase

    4. Kods nekompilējas, jo <tt>String</tt> ir <tt>final</tt> klase

  2. BasicJava_1002: Dotas šādas klašu definīcijas: {code} abstract class Figura { abstract double laukums(); } class Kvadrats extends Figura { } {code} Kas notiek šo klašu kompilācijas laikā?

    1. Abas klases kompilēsies

    2. <tt>Figura</tt> kompilēsies, bet <tt>Kvadrats</tt> nekompilēsies

    3. <tt>Kvadrats</tt> kompilēsies, bet <tt>Figura</tt> nekompilēsies

    4. Ne <tt>Figura</tt>, ne <tt>Kvadrats</tt> nekompilēsies

  3. BasicJava_1003: Dotas sekojošas klašu definīcijas: {code} class Bridge { Road road; } class Road { String name; } {code} Kāda veida attiecība definēta starp šīm klasēm:

    1. Starp klasēm ir "is-a" jeb ~mantošanas~ attiecība

    2. Starp klasēm ir "has-a" jeb ~piederības~ attiecība

    3. Starp klasēm pastāv abas šīs attiecības

    4. Koda paraugs nedefinē nevienu no šīm attiecībām

  4. BasicJava_1004: Kas jāraksta daudzpunkta vietā klases deklarācijā: {code} package xpack; ... class X { klases ķermenis } {code} lai panāktu sekojošu efektu: Tās klases, kuras nepieder pakotnei xpack, nevar izsaukt klases X metodes?

    1. nekas nav jāraksta

    2. <tt>private</tt>

    3. <tt>final</tt>

    4. <tt>protected</tt>

  5. BasicJava_1005: Kurš no sekojošiem apgalvojumiem ir aplams?

    1. Instanču metode var būt reizē <tt>protected</tt> un <tt>abstract</tt>

    2. <tt>static</tt> mainīgais var būt vienlaikus <tt>final</tt>

    3. <tt>static</tt> metode var būt vienlaikus <tt>protected</tt>

    4. <tt>static</tt> metode var būt vienlaikus <tt>abstract</tt>

2. Deklarācijas, inicializācija

  1. BasicJava_2001: Kāds būs rezultāts, mēģinot kompilēt un palaist sekojošu kodu? {code} class Ex { public static void main(String[] args) { Fx f = new Fx(); } Ex(int i) { } }class Fx extends Ex { } {code}

    1. Kodu neizdosies kompilēt, jo <tt>Ex</tt> klasē nav konstruktora bez argumentiem

    2. Kodu neizdosies kompilēt, jo <tt>Fx</tt> klasē nav konstruktora bez argumentiem</var>

    3. Kodu neizdosies kompilēt, jo <tt>Ex(int i)</tt> konstruktors ir tukšs

    4. Kodu izdosies veiksmīgi kompilēt un palaist

  2. BasicJava_2002: Kāds būs rezultāts, mēģinot kompilēt un palaist sekojošu kodu? {code} class Ex { public static void main(String[] args) { Fx f = new Fx(5); } Ex() { System.out.println("Ex, no-args"); } Ex(int i) { System.out.println("Ex, int"); } }class Fx extends Ex { Fx() { super(); System.out.println("Fx, no-args"); } Fx(int i) { super(i); this(); System.out.println("Fx, int"); } } {code}

    1. Standarta izvadā parādīsies rindiņas "Ex, int," "Fx, no-args" un "Fx, int"

    2. Standarta izvadā parādīsies rindiņas "Ex, no-args," "Ex, int" "Fx, no-args" un "Fx, int"

    3. Kodu neizdosies kompilēt, jo konstruktors <tt>Fx(int i)</tt> nav pareizi definēts

    4. Kodu neizdosies kompilēt, jo konstruktors <tt>Fx()</tt> nav pareizi definēts

  3. BasicJava_2003: Kāds būs rezultāts, mēģinot kompilēt un palaist sekojošu kodu? {code} class Ex { public static void main(String[] args) { Fx f= new Fx(5); } Ex() { System.out.println("Ex, no-args"); } Ex(int i) { System.out.println("Ex, int"); } } class Fx extended Ex { Fx() { super(); System.out.println("Fx, no-args"); } Fx(int i) { this(); System.out.println("Fx, int"); } } {code}

    1. Standarta izvadā parādīsies rindiņas "Fx, int", "Fx, no-args" un "Ex, no-args".

    2. Standarta izvadā parādīsies rindiņas "Ex, no-args", "Fx, no-args" un "Fx, int".

    3. Kodu neizdosies kompilēt, jo konstruktors <code>Fx(int i)</code> nav pareizi definēts.

    4. Kodu neizdosies kompilēt, jo konstruktors <code>Fx()</code> nav pareizi definēts.

  4. BasicJava_2004: Kāds ir rezultāts, ja mēģina kompilēt un darbināt sekojošu programmu {code} class Q3 { int instVar1 = 1; int instVar2; public static void main(String[] args) { int localVar = 3; System.out.println(instVar1 + instVar2 + localVar); } } {code}

    1. 4

    2. Kods kompilējas, bet, to palaižot, rodas <tt>ArithmeticException</tt>

    3. Kods nekompilējas, jo <tt>localVar</tt> nav pareizi inicializēts

    4. Kods nekompilējas, jo <tt>instVar2</tt> vispār nav inicializēts

  5. BasicJava_2005: Kā inicializēt masīvu ar trim boolean vērtībām, kuras visas ir true?

    1. <tt>boolean\[\] b =  new boolean\[3\];</tt>

    2. <tt>boolean\[\] b =  {true, true, true};</tt>

    3. <tt>boolean\[3\] b =  {true, true, true};</tt>

    4. <tt>boolean\[\] b =  new boolean\[3\]; b = {true, true, true};</tt>

3. Vadības plūsma

  1. BasicJava_3001: Pareiza izteiksme if komandas nosacījumā ir:

    1. jebkurš no veselo skaitļu tipiem

    2. <tt>boolean</tt>

    3. var būt gan vesels skaitlis, gan <tt>boolean</tt>

    4. neviens no augstākminētajiem

  2. BasicJava_3002: Dots sekojošs koda fragments: {code} char c = 'a'; switch (c) { case 'a': System.out.println("a"); default: System.out.println("default"); } {code} Kas notiks, ja mēģināsies kompilēt un palaist programmu, kas saturēs šo koda daļu?

    1. Kods nekompilējas, jo <tt>switch</tt> komandai ir neatļauta izteiksme

    2. Kodu var palaist, un standartizvadē nekas neparādās

    3. Kods standartizvadē drukā burtu "a"

    4. Kods kompilējas un standartizvadē drukā gan vārdu "a", gan arī  "default"

  3. BasicJava_3003: Dots sekojošs koda fragments: {code} int myInt = 3; if ( myInt < 3 ) if (myInt < 5) System.out.println("AA"); else if (myInt > 2) System.out.println("BB"); else System.out.println("CC"); {code} Ko tas izdrukās?

    1. "AA"

    2. "BB"

    3. "CC"

    4. neko

  4. BasicJava_3004: Kāda veida koda rindiņām var pievienot iezīmi (~label~)?

    1. jebkurai koda rindiņai

    2. tikai rindiņām, kuras saistītas ar kādu ciklu (tieši pirms ieejas ciklā, cikla pirmajai rindiņai, tūlīt pēc cikla)

    3. tikai cikla pirmajai rindiņai

    4. tikai koda rindiņai, kurā sākās pats ārējais cikls

  5. BasicJava_3005: Kas notiks, mēģinot kompilēt un palaist šādu programmu: {code} class A { public static void main(String[] args) { try { System.out.println("hello"); } } } {code}

    1. Kods nekompilēsies - nevar būt tāds <tt>try</tt> bloks, aiz kura neseko ne <tt>catch</tt>, ne <tt>finally</tt> bloks

    2. Kods nekompilēsies, jo vienīgā rindiņa - "System.out.println" nevar izraisīt pārtveramu izņēmumu, tādēļ to nevar rakstīt <tt>try</tt> blokā

    3. Kodu varēs palaist un tas drukās "hello"

    4. Metodei <tt>main()</tt> ir pašai jādeklarē izņēmums, ja tajā
      <tt>try</tt> bloku lieto bez atbilstoša <tt>catch</tt>

  6. BasicJava_3006: Kāds ir rezultāts, mēģinot kompilēt un palaist sekojošu kodu: {code} class A { public static void main(String[] args) { method(); } static void method() throws Exception { try { System.out.println("hello"); return; } finally { System.out.println("good-bye"); } } } {code}

    1. Kods kompilēsies un displejā izdrukās gan "hello", gan "good-bye"

    2. Kods kompilēsies un displejā parādīs gan "hello", gan "good-bye", bet pēc tam Javas interpretators programmu pārtrauks ar paziņojumu, ka tika mests neapstrādāts izņēmums

    3. Kods nekompilēsies

    4. Kods izdrukās vienīgi "hello"

  7. BasicJava_3007: Kas parādās standartizvadē, ja darbina sekojošu programmu: {code} class A { public static void main(String[] args) { method(); } static void method() { try { System.out.println("hello"); return; } finally { System.out.println("good-bye"); } } } {code}

    1. "hello"

    2. "good-bye"

    3. Vispirms "hello", tad "good-bye"

    4. Kodu nevar nokompilēt, jo aiz <tt>try</tt> neseko <tt>catch</tt>

4. Javas API

5. Pavedieni

6. Kolekcijas

7. Pamattipi, masīvi, operatori

  1. BasicJava_7001: Veselo skaitļu datu tipu vērtību intervāls valodā Java ir:

    1. no -2<sup>16</sup> līdz 2<sup>16</sup> - 1

    2. no -2<sup>(B-1)</sup> līdz 2<sup>(B-1)</sup>, kur B ir bitu skaits datu tipā

    3. no -2<sup>31</sup> līdz 2<sup>31</sup>

    4. no -2<sup>(B-1)</sup> līdz 2<sup>(B-1)</sup>-1, kur B ir bitu skaits datu tipā

  2. BasicJava_7002: Kādi ir divi veidi, lai uzstādītu char mainīgajam c vērtību vienādu ar atstarpi jeb tukšumu?

    1. <tt>c = " "</tt> un <tt>c = ' '</tt>

    2. <tt>c = " "</tt> un <tt>c ='\u0000'</tt>

    3. <tt>c = ' '</tt> un <tt>c ='\u0020'</tt>

    4. <tt>c = " "</tt> un <tt>c ='\u0020'</tt>

  3. BasicJava_7003: Kāda ir izteiksmes vērtība: 5 & 2

    1. 0

    2. 2

    3. 5

    4. 7

  4. BasicJava_7004: Kāda ir izteiksmes vērtība: 10 | 2

    1. 0

    2. 2

    3. 10

    4. 14

  5. BasicJava_7005: Kāds būs rezultāts, mēģinot kompilēt un palaist sekojošu kodu? {code} class Tree {} class Pine { public static void main(String[] args) { Pine[] p = new Pine[1]; if (p instanceof Tree[]) System.out.println("p inherits from Tree[]"); } } {code}

    1. Kompilators paziņos, ka <tt>Tree\[\]</tt> nevar mantot no <tt>Pine\[\]</tt>

    2. Kompilators paziņos, ka <tt>Pine\[\]</tt> nevar mantot no <tt>Tree\[\]</tt>

    3. Programma strādā, un standartizvadē nekas neparādās

    4. Programma strādā, un standartizvadē parādās uzraksts "p inherits from Tree\[\]"

  6. BasicJava_7006: Kāds būs rezultāts izteiksmei: 0x800028FF >> 3

    1. 0x900005FF

    2. 0x1000051F

    3. 0x1000011F

    4. 0xF000051F

  7. BasicJava_7007: Kāds būs rezultāts kompilējot un palaižot šādu programmu? {code} class Phone implements Cloneable { public static void main(String[] args) { Phone p = new Phone(); if (p instanceof Object) System.out.println("Object"); if (p instanceof Cloneable) System.out.println("Clonable"); } } {code}

    1. Programmu neizdosies nokompilēt

    2. Programma kompilēsies un, to palaižot, standartizvadē izdrukās "Object"

    3. Programma kompilēsies un, to palaižot, standartizvadē izdrukās "Cloneable"

    4. Programma nokompilēsies un, to palaižot, standartizvadē izdrukās gan "Object", gan "Cloneable"

8. Javas tehnoloģiju pamati

  1. BasicJava_8001: Cik objektu ir drazu savākšanas kandidāti pēc sekojoša koda fragmenta izpildes? {code} String s = "saka"; s = "pa" + "saka"; int[] arr = {1, 4, 9, 16}; arr[3] = 0; arr = new int[4]; s = null; {code}

    1. 2

    2. 3

    3. 4

    4. 5

  2. BasicJava_8002: Kurā variantā dota pareizi definēta finalize() metode?

    1. {code}
      public class Stuff {
          protected void finalize() {
              atbrīvo objekta resursus
              super.finalize();
          }
      }
      {code}

    2. {code}
      public class Stuff {
          private void finalize() throws Throwable {
              atbrīvo resursus
              super.finalize();
          }
      }
      {code}

    3. {code}
      protected class Stuff {
          protected void finalize() throws Throwable {
              atbrīvo resursus
              super.finalize();
          }
      }
      {code}

    4. {code}
      protected class Stuff {
          void finalize() {
              atbrīvo resursus
              super.finalize();
          }
      }
      {code}

Unclassified Questions

Tags:
Created by Kalvis Apsītis on 2007-12-27 19:25
    
This wiki is licensed under a Creative Commons 2.0 license
XWiki Enterprise 6.4 - Documentation