Kolejność pytań jest random(), więc nie uczyć się po numerkach...

Jak ktoś się nie domyślił, to prawidłowe są pogrubione oraz mają [X] na początku, w przeciwieństwie do [ ]


Pytanie 1: Program w Javie jest:
[X] zestawem klas
[ ] zestawem funkcji
-----------------------------------------------------------------

Pytanie 2: Klasa to:
[ ] zestaw funkcji
[X] opis wspólnych właściwości podobnych obiektów
-----------------------------------------------------------------

Pytanie 3: Który z poniższych fragmentów jest prawidłowym szablonem zapisu najprostszej aplikacji w Javie:
[X]
class Program {
  public static void main(String[] args) {
    System.out.println("Hello, world");
  }
}

[ ]
class Program {
  System.out.println("Hello, world");
} 

[ ]
 public static void main(String[] args) {
   System.out.println("Hello, world");
 }

[ ]
  System.out.println("Hello, world");

-----------------------------------------------------------------

Pytanie 4: Który z poniższych zapisów oznacza w Javie literał:
[ ] 'ala ma kota'
[ ] x
[X] 'x'
[X] '\n'
[X] "\n"
[X] 1
[X] '1'
[X] "1"
[X] "ala ma kota"
-----------------------------------------------------------------

Pytanie 5: Jaki będzie efekt działania następującego fragmentu programu:
   final int n = 20;
   System.out.println(n);
   n = n + 1;
   System.out.println(n);

[ ] zostanie wyprowadzona liczba 20, a następnie 21
[X] wystąpi błąd w kompilacji
-----------------------------------------------------------------

Pytanie 6: Jaki będzie efekt działania następującego programu:
public class Test1 {
 
  public static void main(String[] args) {
    kraj = "Polska";
    System.out.println(kraj);
  } 
 
}

[ ] zostanie wyprowadzony napis "Polska"
[X] wystąpi błąd w kompilacji
-----------------------------------------------------------------

Pytanie 7: Jaki będzie efekt działania następującego fragmentu programu:
    String kraj = "Polska";
    System.out.println(kraj);
    String kraj = "Czechy";
    System.out.println(kraj);

[X] wystąpi błąd w kompilacji
[ ] wyprowadzi napis Polska, a w następnym wierszu - Czechy
-----------------------------------------------------------------

Pytanie 8: Typ danej:
[X] określa jej możliwe wartości oraz operacje, które można nad nimi wykonywać
[ ] może być nieokreślony w fazie kompilacji
-----------------------------------------------------------------

Pytanie 9: Wyrażenie w Javie:
[X] ma typ i wartość
[ ] ma wartość, ale jej typ może być nieokreślony
[X] może być nazwą zmiennej
[X] może być literałem
[X] może składać się z nazwy zmiennej, operatora i literału
[ ] może zawierać dowolne słowo kluczowe języka
-----------------------------------------------------------------

Pytanie 10: Jeśli a i b są zmiennymi typu int oraz obie mają wartości równe 1, to prawdziwe jest, że:
[X] zapis a = b++; spowoduje, że a ma wartość 1, b ma wartość 2
[X] zapis a = ++b; spowoduje, że a ma wartość 2, b ma wartość 2
[ ] zapis a = ++b; spowoduje, że a ma wartość 1, b ma wartość 2
[ ] zapis a = ++b; spowoduje błąd w kompilacji
[ ] zapis a++ = b++; spowoduje, że a ma wartość 2, b ma wartość 2
[X] zapis a++ = b++; spowoduje błąd w kompilacji
[ ] zapis a = b++; spowoduje, że a ma wartość 2, b ma wartość 2
-----------------------------------------------------------------

Pytanie 11: Konwersja
[X] to zmiana typu wyrażenia
[X] jest dokonywana automatycznie, gdy przypisujemy wartość typu int na zmienną typu long
[X] może być dokonana jawnie za pomocą operatora konwersji
[ ] wymaga jawnego użycia operatora konwersji gdy przypisujemy int na long
[X] wymaga jawnego użycia operatora konwersji gdy przypisujemy long na int
-----------------------------------------------------------------

Pytanie 12: Jaki będzie efekt następującego fragmentu programu:
    double d = 2.1;
    int a = d;
    System.out.println(a);

[ ] wyprowadzenie wartości 2
[ ] wyprowdazenie wartości 2.1
[X] błąd w kompilacji
-----------------------------------------------------------------

Pytanie 13: Jaki będzie efekt następującego fragmentu programu:
    int a = 1;
    System.out.println(a/3);
    System.out.println(a/3.0);
    System.out.println((double) a/3);

[ ] wyprowadzenie trzech liczb: 0.33333... , 0.33333... , 0.333333...
[ ] wyprowadznie trzech liczb: 0 , 0 , 0
[X] wyprowadznie trzech liczb 0 , 0.33333... , 0.333333...
[ ] błąd w kompilacji
-----------------------------------------------------------------

Pytanie 14: Poniższa deklaracja:
String s;

[X] deklaruje zmienną s, która (ew.) będzie zawierać referencję do obiektu klasy String
[ ] tworzy obiekt klasy String
-----------------------------------------------------------------

Pytanie 15: Poniższa deklaracja:
String s = "Ala";

[ ] nie stworzy obiektu klasy String
[X] powoduje stworzenie obiektu klasy String, zawierającego łańcuch znakowy Ala
-----------------------------------------------------------------

Pytanie 16: Na referencjach możemy wykonywać:
[ ] dodawanie
[ ] odejmowanie
[X] operacje porównania na równość-nierówność z innymi referencjami do obiektów tej samej klasy
[X] operacje porównania z wartością null
[ ] operacje porównania "czy mniejsze"
-----------------------------------------------------------------

Pytanie 17: Obiekty klas tworzymy:
[X] za pomocą wyrażenia new
[ ] poprzez przypisanie referencjom wartości innych referencji
-----------------------------------------------------------------

Pytanie 18: W kontekście:
    String s = "Ala";
    s = s + 1;
    String s1 = "Ala1";

[ ] s == s1 będzie miało wartość true
[X] !s.equals(s1) będzie mialo wartość false
[X] s.equals(s1) będzie mialo wartość true
-----------------------------------------------------------------

Pytanie 19: W kontekście:

  String s = "Liczby";
  int i = 1, j = 2;
  String w;


[X] w = s + i + j; --> w wskazuje na napis Liczby12
[ ] w = i + j + s; --> w wskazuje na napis 12Liczby
[X] w = i + 2 + s; --> w wskazuje na napis 3Liczby
[ ] w = i + j; --> w wskazuje na napis 3
-----------------------------------------------------------------

Pytanie 20: Jeżeli String s = "3"; to:
[ ] int n = s; spowoduje, że zmienna n będzie miala wartość 3
[ ] int n = (int) s; spowoduje, że zmienna n będzie miala wartość 3
[X] int n = Integer.parseInt(s); spowoduje, że zmienna n będzie miala wartość 3
-----------------------------------------------------------------

Pytanie 21: Konstruktor
[ ] może mieć dowolną nazwę
[X] może mieć parametry
[X] może być przeciążony
[ ] jego typ wyniku jest void
-----------------------------------------------------------------

Pytanie 22: W kontekście:
  class A {
    private int a;
    int b;
    int getA() { return a; }
    int getB() { return b; }
  }

[ ] odwołanie new A() - jest niepoprawne, bo nie zdefiniowaliśmy konstruktora bezparametrowego
[ ] jeśli w innej klasie w tym samym pliku źródłowym mamy odnośnik oa do obiektu klasy A, to oa.a = 1 ustali wartość elementu a na 1
[ ] w innej klasie w tym samym pliku źródłowym nie możemy użyć na rzecz obiektu klasy A metody getA(), bo pole a jest prywatne
[X] jeśli w innej klasie w tym samym pliku źródłowym mamy odnośnik oa do obiektu klasy A, to oa.b = 1 ustali wartość elementu b na 1
-----------------------------------------------------------------

Pytanie 23: Czy poniższy fragment programu wypisze na konsoli napis "Ok"?
class Q3 {

   public static void main(String[] args) {
     say("Ok");
   }

   void say(String s) { System.out.println(s); }
}

[ ] tak
[X] nie
-----------------------------------------------------------------

Pytanie 24: Czy poniższy program wyprowadzi napis "Ala ma kota" ?
class A {

  public static void main(String[] args) {
    String txt = "Ala";
    new A().change(txt);
    System.out.println(txt);
    }

void change(String s) { s = s + " ma kota "; }

}

[X] nie
[ ] tak
-----------------------------------------------------------------

Pytanie 25: Zmienne this
[X] w metodzie niestatycznej oznacza obiekt na rzecz którego wywołano tę metodę
[X] w konstruktorze oznacza obiekt inicjowany przez konstruktor
[ ] w metodzie statycznej oznacza obiekt na rzecz którego wywołano tę metodę
-----------------------------------------------------------------

Pytanie 26: Czy poniższy fragment programu wypisze na konsoli napis "Ok"?
class Q3 {

   public static void main(String[] args) {
     say("Ok");
   }

   static void say(String s) { System.out.println(s); }
}

[X] tak
[ ] nie
-----------------------------------------------------------------

Pytanie 27: Czy w poniższym fragmencie programu metoda public boolean isOk() z klasy Test będzie wywołana na rzecz obiektu tej klasy, oznaczanego przez zmienną t:
int a = 1, b = 2;
if (a > b && t.isOk()) ...

[X] nie
[ ] tak
-----------------------------------------------------------------

Pytanie 28: Jako etykietę case w instrukcji break możemy zapisać:
[ ] case "a" : //...tu dowolna instrukcja
[X] case 'a' : //...tu dowolna instrukcja
[ ] case a > b : //...tu dowolna instrukcja
[X] case NUM + 1 : // (NUM jest nazwą stałej typu int)
[X] case 1 : //...tu dowolna instrukcja
-----------------------------------------------------------------

Pytanie 29: Zaznacz prawdziwe zdania:
[ ] pętla while wykona się co najmniej jeden raz
[X] pętla while może nie wykonać się ani razu
[X] pętla do..while wykona się co najmniej jeden raz
-----------------------------------------------------------------

Pytanie 30: Która z poniższych instrukcji przerywa działanie pętli:
[X] break
[X] return
[ ] continue
-----------------------------------------------------------------

Pytanie 31: Które z poniższych zapisów w programie spowodują utworzenie tablicy liczb całkowitych:
[ ] int[] a;
[ ] int a[10];
[ ] int[10] a;
[X] int[] a = new int[10];
[ ] int[] a = new int(10);
[X] int[] a = { 1, 2, 3 };
-----------------------------------------------------------------

Pytanie 32: Które z poniższych instrukcji iteracyjnych ustalają wartości wszystkich elementów tablicy tab na 1:
[ ] for (int i=1; i <= tab.length; i++) tab[i] = 1;
[ ] for (int i=1; i < tab.length; i++) tab[i] = 1;
[ ] for (int i=0; i <= tab.length; i++) tab[i] = 1;
[X] for (int i=0; i < tab.length; i++) tab[i] = 1;
[ ] for (int i=0; i < tab.length(); i++) tab[i] = 1;
-----------------------------------------------------------------

Pytanie 33: Czy poniższy program wyprowadzi napis "Ala ma kota" ?
class A {

  public static void main(String[] args) {
    String[] txt = { "Ala" };
    new A().change(txt);
    System.out.println(txt[0]);
    }

void change(String[] s) { s[0] = s[0] + " ma kota "; }

}

[X] tak
[ ] nie
-----------------------------------------------------------------

Pytanie 34: Jezeli int[] x = { 1, 2 }, y = { 1, 2, 3 }; to:
[ ] po wykonaniu instrukcji x = y; y[0] = 2; x[0] będzie równe 1
[X] po wykonaniu instrukcji x = y; y[0] = 2; x[0] będzie równe 2
[ ] y = x spowoduje skopiowanie tablicy x do tablicy y
-----------------------------------------------------------------

Pytanie 35: Jeżeli w klasie Para reprezentującej pary liczb całkowitych zdefiniowano konstruktor bezparametrowy, który nadaje składnikom pary wartości (1, 1), to:
[ ] new Para[10]; utworzy tablicę dziesięciu par o wartościach (0, 0)
[X] Para[] p = { new Para(), new Para() }; utworzy tablicę dwóch par o wartościach (1, 1)
[ ] new Para[10]; utworzy tablicę dziesięciu par o wartościach (1, 1)
-----------------------------------------------------------------

Pytanie 36: Aby porównać dwa napisy i określić, który z nich występuje wcześniej w porządku leksykograficznym stosujemy:
[ ] operator <
[X] metodę compareTo z klasy String
[ ] metodę equals z klasy String
-----------------------------------------------------------------

Pytanie 37: Klasy opakowujące typy pierwotne (np. klasy Integer i Double) służą m.in. do:
[ ] wykonywania operacji arytmetycznych na danych typów pierwotnych
[X] przedstawianiu danych typów pierwotnych w postaci obiektów
-----------------------------------------------------------------

Pytanie 38: Operator instanceof służy do:
[ ] stwierdzenia czy treść napisu jest zgodna z argumentem operatora
[X] stwierdzenia czy zmienna wskazuje na obiekt podanej klasy
-----------------------------------------------------------------