{"id":2394,"date":"2013-09-28T12:58:37","date_gmt":"2013-09-28T10:58:37","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=2394"},"modified":"2013-10-20T11:58:53","modified_gmt":"2013-10-20T09:58:53","slug":"fragen-zur-java-zertifizierung-grundlegende-spracheigenschaften","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2013\/09\/fragen-zur-java-zertifizierung-grundlegende-spracheigenschaften\/","title":{"rendered":"Fragen zur Java-Zertifizierung, Grundlegende Spracheigenschaften"},"content":{"rendered":"

Frage<\/h3>\n

In welcher Reihenfolge k\u00f6nnen die folgenden Klassen in der Quelldatei gesetzt werden, ohne dass Fehler oder Warnungen zur \u00dcbersetzungszeit auftreten.<\/p>\n

\/\/ A\r\n import java.applet.*;\r\n\/\/ B\r\n class Helper { }\r\n\/\/ C\r\n package myclasses;\r\n\/\/ D\r\n public class MyApplet extends java.applet.Applet { }<\/pre>\n
    \n
  1. A, B, C, D<\/li>\n
  2. A, C, B, D<\/li>\n
  3. C, A, B, D<\/li>\n
  4. C, A, D, B<\/li>\n
  5. C, B, A, D<\/li>\n<\/ol>\n
    Befindet sich eine Klasse in einem Paket, so muss in der ersten Zeile die package Deklaration stehen. So sind Antworten A, B falsch. Anschlie\u00dfend m\u00fcssen die Import Anweisungen folgen. So ist auch E falsch. Antworten C und D sind korrekt. Bei D w\u00fcrde aber ein extends Applet reichen.<\/p>\n
    Frage<\/h3>\n
    Was ist die korrekte Reihenfolge f\u00fcr Importanweisungen, Klassen und Pakete, wenn diese in einer einzigen Datei vorkommen?<\/p>\n
      \n
    1. Paketanweisung, Importanweisung, Klasse<\/li>\n
    2. Klasse, Importanweisung, Paketanweisung<\/li>\n
    3. Importanweisung, Paketanweisung, Klassen<\/li>\n
    4. Paketanweisung, Klassen, Importanweisung<\/li>\n<\/ol>\n
      Die korrekte Antwort ist A.<\/p>\n
      Frage<\/h3>\n
      Was sind g\u00fcltige Schl\u00fcsselw\u00f6rter in Java?<\/p>\n
        \n
      1. sizeof<\/li>\n
      2. abstract<\/li>\n
      3. native<\/li>\n
      4. NULL<\/li>\n
      5. BOOLEAN<\/li>\n
      6. goto<\/li>\n<\/ol>\n
        sizeof ist ein Operator in C(++), der in Java keine Bedeutung hat. Er kann daher ein kein g\u00fcltiges Schl\u00fcsselwort. A ist flasch. abstract und native sind reservierte Schl\u00fcsselw\u00f6rter, daher sind Antwort B und C richtig. NULL ist ein Makro unter C(++), welches in Java nicht existiert. Nur null ist ein eingebautes Schl\u00fcsselwort. Auch BOOLEAN ist kein Schl\u00fcsselwort, da Java Gro\u00df\/Kleinschreibung trennt. So sind D und E keine Schl\u00fcsselw\u00f6rter. Obwohl es in Java kein goto gibt (jedoch Multibreak continue, was im Prinzip das gleiche ist), ist das Schl\u00fcsselwort reserviert und man kann es nicht als Bezeichner w\u00e4hlen. Auch F ist richtig.<\/p>\n
        Frage<\/h3>\n
        Welche der folgenden Bezeichner ist illegal?<\/p>\n
          \n
        1. #_pound<\/li>\n
        2. _underscore<\/li>\n
        3. 4Interface<\/li>\n
        4. Interface5<\/li>\n
        5. _5_<\/li>\n<\/ol>\n
          Bezeichner d\u00fcrfen nur mit einem Unterstrich oder einem Buchstaben beginnen. Demnach sind A und C illegale Bezeichner. Die anderen sind g\u00fcltige Namen, es sind B, D und E korrekt.<\/p>\n
          Frage<\/h3>\n
          Welche der folgenden Deklarationen f\u00fcr die main() Methode in einer Konsole Applikation ist nicht korrekt?<\/p>\n
            \n
          1. public static void main()<\/li>\n
          2. public static void main( String[] string )<\/li>\n
          3. public static void main( String args )<\/li>\n
          4. public static void main( String[] args )<\/li>\n
          5. static void main( String[] args )<\/li>\n<\/ol>\n
            Die korrekte Signatur ist public static void main( String [] ). Also B und D korrekt, da es auf die Namensgebung nicht ankommt. Da die main() Funktion immer als Argument ein String Feld hat, ist A und C falsch. E ist im Prinzip richtig, jedoch wird mit public die main() Funktion auch au\u00dferhalb des Paketes sichtbar. Also ist auch E falsch.<\/p>\n
            Frage<\/h3>\n
            Wie lautet die Spezifikation f\u00fcr den Paramter der pulic static void main Methode?<\/p>\n
              \n
            1. String args []<\/li>\n
            2. String [] args<\/li>\n
            3. Strings args []<\/li>\n
            4. String args<\/li>\n<\/ol>\n
              Als Parameter wird ein Feld von Strings erwartet. Also ist D falsch. Da die Klammern bei der Deklaration eines Feldes vor oder hinter dem Bezeichner stehen k\u00f6nnen und der Name des Feldes unerheblich ist, sind A, B und C richtige Antworten.<\/p>\n
              Frage<\/h3>\n
              Was enth\u00e4lt das erste Erste Element des Stringfeldes, das der public static void main Methode \u00fcbergeben wird.<\/p>\n
                \n
              1. Der Name des Programms.<\/li>\n
              2. Die Anzahl der Argumente.<\/li>\n
              3. Das erste Argument falls verf\u00fcgbar.<\/li>\n<\/ol>\n
                In Java gibt es keine zusammengebunden Programme, sondern nur Klassen. Daher ist A falsch. Die Anzahl der Argumente ergibt sich dem Attribut length der Feldvariablen. Es bleibt C als richtige Antwort.<\/p>\n
                Frage<\/h3>\n
                Was ist das Ergebnis des folgenden Programmes:<\/p>\n
                public class Alter {\r\n public static void main( String args [] ) {\r\n  int age;\r\n  age = age + 1;\r\n  System.out.println( \"Das Alter ist \" + age);\r\n  }\r\n }<\/pre>\n
                  \n
                1. Kompiliert und l\u00e4uft ohne Ausgabe.<\/li>\n
                2. Kompiliert und die Ausgabe ist „Das Alter ist 1“.<\/li>\n
                3. Kompiliert aber erzeugt einen Laufzeitfehler.<\/li>\n
                4. Kompiliert nicht.<\/li>\n<\/ol>\n
                  Das Programm kann nicht kompiliert werden, da auf die lokale Variable age vor dem Lesezugriff kein Schreibzugriff stattfand. Da lokale Variablen aber vor der Benutzung initialisiert werden m\u00fcssen, meldet der Compiler einen Fehler.<\/p>\n
                  Frage<\/h3>\n
                  Was ist das Ergebnis des folgenden Programmcodes?<\/p>\n
                  public class Alter {\r\n static int age;\r\n public static void main( String args [] ) {\r\n  age = age + 1;\r\n  System.out.println( \"Das Alter ist \" + age );\r\n }\r\n}<\/pre>\n
                    \n
                  1. Kompiliert und l\u00e4uft ohne Ausgabe<\/li>\n
                  2. Kompiliert und liefert die Ausgabe „Das Alter ist 1 „<\/li>\n
                  3. Kompiliert aber erzeugt einen Laufzeitfehler.<\/li>\n
                  4. Kompiliert nicht.<\/li>\n<\/ol>\n
                    Das Programm kompiliert und schreibt das Alter 1 auf den Schirm. Die int Objektvariablen wird mit Null initialisiert. Es ist egal, ob sie dabei static ist oder nicht. Nach dem einmaligen Erh\u00f6hen wird sie auf 1 gesetzt. Also ist B die richtige Antwort.<\/p>\n
                    Frage<\/h3>\n
                    Welche der folgenden Anweisungen ist korrekt, um ein Zeichenliteral mit dem Wert a zu erzeugen.<\/p>\n
                      \n
                    1. ‚a‘<\/li>\n
                    2. „a“<\/li>\n
                    3. new Character(a)<\/li>\n
                    4. \\000a<\/li>\n<\/ol>\n
                      Nur Antwort A ist korrekt. Ein Zeichenliteral muss in einfachen Hochkommas stehen. Nur Zeichenkette, also String-Objekte, stehen in doppelten Anf\u00fchrungszeichen. String Objekte sind aber Objekte und keine primitiven Datentypen wie ein char. Antwort C ist falsch, da dort versucht wird ein Character Objekt zu konstruieren. Der new Operator erzeugt allerdings ein Objekt und kein Literal. Au\u00dferdem muss Buchstabe a in Hochkomma stehen. Sonst w\u00fcrde die Zeile auf eine char Variable a zur\u00fcckgreifen. Das Zeichen \\0000a ist die Hexadezimalschreibweise und steht f\u00fcr die Zahl 10. Also ist auch D falsch.<\/p>\n
                      Frage<\/h3>\n
                      Wie ist der Zahlenbereich eines byte?<\/p>\n
                        \n
                      1. 0 bis 65.535<\/li>\n
                      2. \u2013128 bis 127<\/li>\n
                      3. \u201332.768 bis 32.767<\/li>\n
                      4. \u2013256 bis 255<\/li>\n<\/ol>\n
                        Ein byte hat die Datengr\u00f6\u00dfe von 8 Bit. So sind Antwort A und C schon falsch. Mit 8 Bit kann man den Zahlenbereich von 0 bis 255 abdecken. Ein Vorzeichen kostet aber noch ein zus\u00e4tzliches Bit. So ist auch D falsch, da wir hier 9 Bit br\u00e4uchten. Da alle primitiven Datentypen au\u00dfer char mit einem vorzeichenbehaftet sind, bleibt als richtige Antwort B.<\/p>\n
                        Frage<\/h3>\n
                        Welche der Anweisungen ist illegal?<\/p>\n
                          \n
                        1. int i = 32;<\/li>\n
                        2. float f = 45.0;<\/li>\n
                        3. double d = 45.0;<\/li>\n<\/ol>\n
                          Die erste Anweisung ist korrekt, da 32 im Bereich eines int liegt. Auch Anweisung C ist korrekt. Nur bei B ist das Literal ein double. Dies kann nicht ohne m\u00f6glichen Verlust in ein float kopiert werden. Also ist Antwort B korrekt. Um die Zeile zu korrigieren schreiben wie float f = 4.0f.<\/p>\n","protected":false},"excerpt":{"rendered":"
                          Frage In welcher Reihenfolge k\u00f6nnen die folgenden Klassen in der Quelldatei gesetzt werden, ohne dass Fehler oder Warnungen zur \u00dcbersetzungszeit auftreten. \/\/ A import java.applet.*; \/\/ B class Helper { } \/\/ C package myclasses; \/\/ D public class MyApplet extends java.applet.Applet { } A, B, C, D A, C, B, D C, A, B, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[1],"tags":[],"class_list":["post-2394","post","type-post","status-publish","format-standard","hentry","category-allgemein"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2394","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=2394"}],"version-history":[{"count":4,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2394\/revisions"}],"predecessor-version":[{"id":2484,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2394\/revisions\/2484"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=2394"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=2394"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=2394"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}