OCPJP 6 Probeprüfung -18

1 . Was wird die Ausgabe sein?

	public class Test1 extends Base{
    Test1(long i){}
    public static void main(String args()){}
}
class Base{
    Base(int i){}
}

Wählen Sie die folgende aus:

  • Base(){}
  • Base(long l){}
  • Basis(float f){}
  • Es wird ordnungsgemäß kompiliert
  • 2 . Was wird die Ausgabe sein?

    	public class Test2 extends Base{
        Test2(long i){
            super(2);
        }
        Test2(){}
        public static void main(String args()){
            new Test2(2);
        }
    }
    class Base{
        Base(int i){
            System.out.println(i);
        }
        Base(byte i){
            System.out.println(i*2);
        }
    }
    

    Wählen Sie die folgende aus:

  • 2
  • 4
  • Compilerfehler
  • Es wird kompiliert, wenn wir in Test2() super(2) hinzufügen
  • 3 . Welches der folgenden Schlüsselwörter kann auf Konstruktoren angewendet werden?

  • Privat
  • öffentlich
  • Leere
  • Alles oben Genannte
  • 4 . Welche der folgenden sind gültige Konstruktoren?

  • Test4(){}
  • void Test4(){}
  • privater Test4(){}
  • Alles oben Genannte
  • 5 . Welche der folgenden Aussagen sind wahr?

  • Konstruktoren können überschrieben werden
  • Konstruktoren können überladen sein
  • Konstruktoren können einen Wert zurückgeben
  • Konstruktoren können statisch sein
  • 6 . Was wird die Ausgabe sein?

    	public class Test6{
        Test6(int i, int j){
            System.out.println("Int");
        }
        Test6(short i, short j){
            System.out.println("Short");
        }
        Test6(byte i, byte j){
            System.out.println("Byte");
        }
        public static void main(String args()){
            Test6 t = new Test6(1,2);
        }
    }
    

    Wählen Sie die folgende aus:

  • Int
  • Byte
  • Kurz
  • Compilerfehler
  • 7 . Was wird die Ausgabe sein?

    	public class Test7{
        Test7(int i, int j){
            System.out.println("Int");
        }
        Test7(short i, short j){
            System.out.println("Short");
        }
        Test7(byte i, byte j){
            System.out.println("Byte");
        }
        public static void main(String args()){
            byte b1 = 1;
            byte b2 = 2;
            Test7 t1 = new Test7(b1,b1);
            Test7 t2 = new Test7(b1*1,b1*2);
            Test7 t3 = new Test7(b1*b1,b1*b2);
        }
    }
    

    Wählen Sie die folgende aus:

  • Byte Int Int
  • Byte Byte Byte
  • Byte Int Byte
  • Int Int Int
  • 8 . Was wird die Ausgabe sein?

    	public class Test8 extends Base{
        Test8(){}
        public static void main(String args()){}
    }
    class Base{
        Base() throws Exception{}
    }
    

    Wählen Sie die folgende aus:

  • Byte Int Int
  • Byte Byte Byte
  • Byte Int Byte
  • Int Int Int
  • 9 . Was wird die Ausgabe sein?

    	public class Test9 extends Base{
       Test9()throws Exception{}
       Test9(int i) {}
       public static void main(String args())throws Exception{
          new Test9();
       }
    }
    class Base{
       Base() throws Exception{
          System.out.println("Base");
       }
    }
    

    Wählen Sie die folgende aus:

  • Base
  • Compilerfehler
  • Laufzeitausnahme
  • Nichts des oben Genannten
  • 10 . Was wird die Ausgabe sein?

    	public class Test10 extends Base{
        Test10(){}
        Test10(int i) {}
        public static void main(String args()){
            new Test10();
        }
    }
    class Base{
        Base() {
            System.out.println("Base");
        }
        Base(int i) throws Exception{
            System.out.println("No argument constructor.");
        }
    }
    

    Wählen Sie die folgende aus:

  • Base
  • Compilerfehler
  • Laufzeitausnahme
  • Nichts des oben Genannten
  • 11 . Was wird die Ausgabe sein?

    	class Test11 extends B {
        private Test11() { super(); }
        public Test11(String msg) { this(); }
        public Test11(int i) {}
    }
    class A {
        public A() {}
        public A(int i) { this(); }
    }
    class B extends A {
        public boolean B(String msg) { return false; }
    }
    

    Wählen Sie die folgende aus:

  • Der Code kann nicht kompiliert werden
  • Der Konstruktor in A, der ein int als Argument akzeptiert, wird niemals als Ergebnis der Konstruktion eines Objekts der Klasse B oder Test11 aufgerufen
  • Die Klasse Test11 hat drei Konstruktoren
  • Als Ergebnis der Konstruktion eines Objekts der Klasse Test11 wird höchstens einer der Konstruktoren jeder Klasse aufgerufen
  • 12 . Welche der folgenden Aussagen sind wahr?

  • Der Standardkonstruktor hat den Rückgabetyp void
  • Der Standardkonstruktor akzeptiert einen Sungle-Parameter
  • Der Standardkonstruktor akzeptiert keine Parameter
  • Der Standardkonstruktor wird nicht erstellt, wenn die Klasse über eigene Konstruktoren verfügt
  • Antworten

    1 : 1 ist richtig. Base(){}.

    2 : 4 ist richtig. Es wird kompiliert, wenn wir super(2) in Test2() hinzufügen.

    3: 1 & 2 ist richtig.

    1 . Privat
    2 . öffentlich

    4: 1 & 3 ist richtig.

    1 . Test4(){}
    3 . privater Test4(){}

    5 : 2 ist richtig. Konstruktoren können überladen sein.

    6 : 1 ist richtig. Int.

    7 : 3 ist richtig. Byte Byte Int.

    8 : 3 ist richtig. Byte Byte Int.

    9 : 2 ist richtig. Compilerfehler.

    10 : 1 ist richtig. Base.

    11: 2 & 3 ist richtig.

    2 . Der Konstruktor in A, der ein int als Argument akzeptiert, wird niemals als Ergebnis der Konstruktion eines Objekts der Klasse B oder Test11 aufgerufen
    3 . Die Klasse Test11 hat drei Konstruktoren

    12: 3 & 4 ist richtig.

    3 . Der Standardkonstruktor akzeptiert keine Parameter
    4 . Der Standardkonstruktor wird nicht erstellt, wenn die Klasse über eigene Konstruktoren verfügt

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen