{"id":2406,"date":"2013-09-28T13:34:57","date_gmt":"2013-09-28T11:34:57","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=2406"},"modified":"2013-09-28T13:34:57","modified_gmt":"2013-09-28T11:34:57","slug":"fragen-zur-java-zertifizierung-berladen-berschreiben-typen-zur-laufzeit-und-objektorientierung","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2013\/09\/fragen-zur-java-zertifizierung-berladen-berschreiben-typen-zur-laufzeit-und-objektorientierung\/","title":{"rendered":"Fragen zur Java-Zertifizierung, Überladen, Überschreiben, Typen zur Laufzeit und Objektorientierung"},"content":{"rendered":"

Frage<\/h3>\n

Das Design einer Klasse erfordert, dass eine Instanzvariable von Unterklassen ver\u00e4ndert werden kann. Klassen, die allerdings im gleichen Paket liegen, sollen keinen Zugriff haben. Wie muss der Modifier gew\u00e4hlt werden, so dass dies m\u00f6glich wird? <\/p>\n

    \n
  1. public <\/li>\n
  2. private <\/li>\n
  3. protected <\/li>\n
  4. Kein besonderer Modifier. <\/li>\n
  5. private und die es sollte Zugriffsmethoden geben.<\/li>\n<\/ol>\n

    Public w\u00fcrde die Variable f\u00fcr alle sichtbar machen, daher ist A falsch. Private w\u00fcrde die Variable auch f\u00fcr Unterklassen unsichtbar machen, daher ist auch B falsch. C ist korrekt, da die Variable von erbenden Klassen ge\u00e4ndert werden kann. Gibt man keinen Modifier an, so k\u00f6nnen auch Klassen im gleichen Paket (also Verzeichnis) die Variable ver\u00e4ndern. Dies ist aber in der Aufgabe verboten. So ist auch D falsch. Obwohl Zugriffsmethoden im Design einer Klasse zu einer sch\u00f6ne Modellierung f\u00fchrt, verbieten diese jedoch nicht, dass nur Methoden der Unterklassen auf die Variablen zugreifen k\u00f6nnen. Also ist auch E falsch.<\/p>\n

    Frage<\/h3>\n

    Was passiert, wenn folgende Klasse compiliert und ausgef\u00fchrt wird?<\/p>\n

    class Test\n{\n  static int myArg = 1;\n  public static void main( String args[] )\n  {\n    int myArg;\n    System.out.println( myArg );\n  }\n}<\/pre>\n
      \n
    1. Der Code l\u00e4sst sich kompilieren und bei der Auff\u00fchrung erscheint 0 auf dem Bildschirm. <\/li>\n
    2. Der Code l\u00e4sst sich kompilieren und bei der Auff\u00fchrung erscheint 1 auf dem Bildschirm. <\/li>\n
    3. \n
      Dieses Programmst\u00fcck l\u00e4sst sich nicht kompilieren, da eine lokale Variable nicht den gleichen Namen besitzen darf, wie eine statische Variable.<\/p>\n<\/li>\n
    4. Dieses Programmst\u00fcck l\u00e4sst sich nicht kompilieren, da die lokale Variable vor der Nutzung noch nicht initialisiert ist.<\/li>\n<\/ol>\n
      Der Programmcode wird nicht kompiliert, da myArg nicht initialisiert wurde, Antwort D ist korrekt. A ist falsch, da lokale Variablen nicht automatisch mit 0 initialisiert werden. B ist falsch, da der Zugriff erst auf innere Variablen erfolgt.<\/p>\n
      Frage<\/h3>\n
      Welches der folgenden Code Fragmente ist geeignet, um die Anzahl der Argumente, die einer Java Applikation \u00fcbergeben werden, in count zu speichern. Die Deklaration der main() Funktion ist wie folgt:<\/p>\n
      public static void main( String args[] )\n{\n  \/\/ Hier den Block einsetzen\n}<\/pre>\n
        \n
      1. int count = args.length; <\/li>\n
      2. int count = args.length – 1; <\/li>\n
      3. int count = 0;
        \n    
        while ( args[count] != null )<\/p>\n
          count++; <\/li>\n
      4. int count = 0;
        \n    
        while ( !(args[count].equals("") ) )<\/p>\n
          count++;<\/li>\n<\/ol>\n
        A ist korrekt. B ist falsch, da in Java der Name des Programmes nicht im ersten Argument steht und daher der Z\u00e4hler nicht erniedrigt werden muss. Da alle Argumente g\u00fcltige Strings sind, kann C nicht richtig sein. Leerstring k\u00f6nnen ebenso nicht in der Folge vorkommen, daher ist auch D falsch.<\/p>\n
        Frage<\/h3>\n
        Analysiere die folgenden beiden Klassen:<\/p>\n
        final class First\n{\n  static int a = 3;\n}\nclass Second extends First\n{\n  public void method() {     System.out.println( a );\n  }\n}<\/pre>\n
          \n
        1. Die Klasse First l\u00e4sst sich kompilieren, aber nicht die Klasse Second. <\/li>\n
        2. Die Klasse Second l\u00e4sst sich kompilieren, aber nicht die Klasse First. <\/li>\n
        3. Keine der beiden Klassen l\u00e4sst sich kompilieren. <\/li>\n
        4. Beide Klassen lassen sich kompilieren und wenn method() aufgerufen wird, schreibt es 3 auf die Standardausgabe. <\/li>\n
        5. Beide Klassen lassen sich kompilieren, aber ein Aufruf von method() m\u00fcndet in eine Exception.<\/li>\n<\/ol>\n
          Die Klasse First l\u00e4sst sich problemlos kompilieren. Die Kompilation der Klasse Second scheitert jedoch daran, dass man final Klassen nicht erweitern kann. So ist A, C und D falsch und B die richtige Antwort. C ist falsch, da sich First kompilieren l\u00e4sst.<\/p>\n
          Frage<\/h3>\n
          Was passiert, wenn folgender Programmcode kompiliert und die main() Methode von B aufgerufen wird?<\/p>\n
          class A {\n  int i;\n  A( int i ) {\n    this.i = i*2;\n  }\n}\nclass B extends A {\n  public static void main( String args[] ) {\n    B b = new B(2);\n  }\n  B( int i ) {     System.out.println( i );\n  }\n}<\/pre>\n
            \n
          1. Die Instanzvariable i bekommt den Wert 4. <\/li>\n
          2. Die Instanzvariable i bekommt den Wert 2. <\/li>\n
          3. Die Instanzvariable i bekommt den Wert 0. <\/li>\n
          4. Der Code l\u00e4sst sich nicht kompilieren.<\/li>\n<\/ol>\n
            Da sich der Programmcode nicht kompilieren l\u00e4sst ist A, B und C falsch und D richtig. In der Vererbung ruft der Konstruktor der Klasse B den Standard-Konstruktor von A auf. Dieser existiert aber nicht. Um da Programm zum Laufen zu bringen, muss im Konstruktor B(int) mit super() der parametrisierte Konstruktor in A aufgerufen werden.<\/p>\n
            Frage<\/p>\n
            Was ist an folgendem Programmst\u00fcck falsch?<\/p>\n
            final class First\n{\n  private int a = 1;\n  int b = 2;\n}\nclass Second extends First\n{\n  public void method() {     System.out.println( a + b );\n  }\n}<\/pre>\n
              \n
            1. Die println() Methode kann nicht ohne einen String Parameter benutzt werden. <\/li>\n
            2. Da die Variable a privat ist, hat keine Klasse au\u00dfer First Zugriff auf die Variable. <\/li>\n
            3. Second kann First nicht erweitern. <\/li>\n
            4. final ist kein g\u00fcltiges Schl\u00fcsselwort f\u00fcr eine Klasse.<\/li>\n<\/ol>\n
              Eine Klasse kann eine final Klasse nicht erweitern. Daher ist Antwort C korrekt. println() ist auf verschiedenen Parametern definiert, auch mit int. Lie\u00dfe man final weg, so k\u00e4me dann der Fehler vom privaten Attribut a. final ist nat\u00fcrlich ein g\u00fcltiges Schl\u00fcsselwort f\u00fcr Klassen.<\/p>\n
              Frage<\/h3>\n
              Folgende Klassen sind auf einem Dateisystem, welches Gro\u00df\/Kleinschreibung unterscheidet unter Fred.java gesichert. Welches sind korrekte Klassendeklarationen? (Zwei Antworten.) <\/p>\n
                \n
              1. \n
                public class Fred {\n  public int x = 0;\n  public Fred( int x ) {\n    this.x = x;\n  }\n}<\/pre>\n<\/li>\n
              2. \n
                public class fred {\n  public int x = 0;\n  public fred( int x ) {\n    this.x = x;\n  }\n}<\/pre>\n<\/li>\n
              3. \n
                public class Fred extends MyBaseClass, MyOtherBaseClass {\n  public int x = 0;\n  public Fred( int xval ) {\n    x = xval;\n  }\n}<\/pre>\n<\/li>\n
              4. \n
                protected class Fred {\n  private int x = 0;\n  private Fred( int xval ) {\n    x = xval;\n  }\n}<\/pre>\n<\/li>\n
              5. \n
                import java.awt.*;\npublic class Fred extends Object {\n  int x;\n  private Fred( int xval ) {\n    x = xval;\n  }\n}<\/pre>\n<\/li>\n<\/ol>\n
                Antwort A ist korrekt, da die Klasse die gleiche Gro\u00df\/Kleinschreibung wie der Dateiname besitzt. B ist falsch, die die Schreibweise immer \u00fcbereinstimmen muss. In Java gibt es keine Mehrfachvererbung, daher ist C falsch. Hei\u00dft die Klasse Fred.java, so muss sie auch von au\u00dfen sichtbar sein. Daher muss sie public sein. W\u00e4hre die Klasse zusammen mit einer anderen \u00f6ffentlichen Klasse in einer Datei, so w\u00e4re dies korrekt. Auch E ist korrekt. Das Abstract Window Toolkit geh\u00f6rt zum Kern Paket von Java, ist also immer vorhanden. Obwohl jedes Objekt implizit Object erweitert, kann man dies noch einmal hinschreiben. Wenn der Konstruktor privat ist, l\u00e4sst er sich nicht von au\u00dfen aufrufen. So macht also diese Klasse wenig Sinn, da man sie nicht erzeugen kann. Man macht oft den Standard-Konstruktor private, wenn man den Benutzer zwingen will, einen parametrisieren zu verwenden.<\/p>\n
                Frage<\/p>\n
                Was passiert, wenn versucht wird, den folgenden Programmcode zu kompilieren und auszuf\u00fchren?<\/p>\n
                class Mystery {\n  String s;\n  public static void main( Sting args[] ) {\n    Mystery m = new Mystery();\n    m.go();\n  }\n  void Mystery()\n  {\n    s = "pal\u00fcmpal\u00fcm";\n  }\n  void go()\n  {\n    System.out.println( s );\n  }\n}<\/pre>\n
                  \n
                1. Dieser Code l\u00e4sst sich nicht kompilieren. <\/li>\n
                2. Dieser Code kompiliert, aber wirft eine Exception zur Laufzeit . <\/li>\n
                3. Dieser Code l\u00e4uft aber nichts erscheint in der Standard Ausgabe. <\/li>\n
                4. Dieser Code l\u00e4uft und schreibt "pal\u00fcmpal\u00fcm" in die Standard Ausgabe. <\/li>\n
                5. Dieser Code l\u00e4uft und schreibt "null" in die Standardausgabe.<\/li>\n<\/ol>\n
                  Der Programmcode l\u00e4sst sich nicht kompilieren, da die Methode Mystery() so hei\u00dft wie die Klasse. Da nur Konstruktoren so hei\u00dfen d\u00fcrfen wie die Klasse, Konstruktoren aber keine R\u00fcckgabewerte haben (sie geben explizit den this Zeiger des neuen Objektes zur\u00fcck) muss man void von der Deklaration nehmen, so dass die Kompilation erfolgreich ist. So ist A korrekt. W\u00e4re das void nicht vor dem Konstruktor w\u00fcrde das Programm pal\u00fcmpal\u00fcm ausgeben.<\/p>\n
                  Frage<\/h3>\n
                  Welche der folgenden inneren Klassen sind korrekt f\u00fcr die Klasse A? <\/p>\n
                    \n
                  1. \n
                    class B { }<\/pre>\n<\/li>\n
                  2. \n
                    class B extends A { }<\/pre>\n<\/li>\n
                  3. \n
                    class B {\n  B() {     System.out.println( "i = " + i );\n  }\n}<\/pre>\n<\/li>\n
                  4. \n
                    class B {\n  class A { }\n}<\/pre>\n<\/li>\n
                  5. \n
                    class A {\n}<\/pre>\n<\/li>\n<\/ol>\n
                    Antwort A, B sind richtig. Antwort C ist falsch, da kein i deklariert wurde. D und E f\u00fchren den Jikes Compiler an seine Grenzen.<\/p>\n
                    Frage<\/h3>\n
                    Warum lassen sich die folgenden Klassen nicht kompilieren?<\/p>\n
                    class A\n{   private int x;\n  public static void main( String args[] ) {\n    new B();\n  }<\/pre>\n
                      class B {\n    B() {       System.out.println( x );\n    }   }\n}<\/pre>\n
                      \n
                    1. Die Klasse B versucht, Zugriff zu der privaten Variablen zu bekommen, die in der \u00e4u\u00dferen Klasse definiert ist. <\/li>\n
                    2. Die Klasse A versucht, eine Instanz von B zu erzeugen, obwohl es keine g\u00fcltige Instanz der Klasse A gibt. <\/li>\n
                    3. Der Konstruktor der Klasse B muss \u00f6ffentlich sein.<\/li>\n<\/ol>\n
                      Eine innere Klasse ist immer mit einer \u00e4u\u00dferen Klasse verbunden. Da aber eine static Method nicht an ein Objekt gebunden ist, wurde versucht ein B Objekt ohne Bezug zu einem A Objekt zu erzeugen. Dies ergibt die Fehlermeldung. So ist B korrekt. Folgende Zeilen w\u00fcrde die main() Funktion korrigieren.<\/p>\n
                      public static void main( String args[] ) {
                      \n  
                      A a = new A();<\/p>\n
                      A.B b = a.new B();<\/p>\n
                      }<\/p>\n
                      Frage<\/p>\n
                      Was produziert das folgende Programm:<\/p>\n
                      public class Test {\n  static int total = 10;\n  public static void main (String args []) {\n    new Test();\n  }\n  public Test() {\n    System.out.println( "In Test" );\n    System.out.println( this );\n    int temp = this.total;\n    if ( temp > 5 )\n      System.out.println( temp );\n  }\n}<\/pre>\n
                        \n
                      1. Die Klasse l\u00e4sst sich nicht kompilieren. <\/li>\n
                      2. Der Compiler meldet einen Fehler in Zeile 2. <\/li>\n
                      3. Der Compiler meldet einen Fehler in Zeile 9. <\/li>\n
                      4. Der Wert 10 ist unter der Ausgabe. <\/li>\n
                      5. Die Klasse wird kompiliert, erzeugt jedoch einen Laufzeitfehler.<\/li>\n<\/ol>\n
                        Die Klasse l\u00e4sst sich kompilieren. Daher sind die Antworten A, B und C falsch. Die main() Methode erzeugt ein Test Objekt und dabei wird der Konstruktor aufgerufen. Dieser gibt erst "In Test" aus und anschlie\u00dfend den Hash Wert des Objektes. Da temp gr\u00f6\u00dfer 5 ist, wird die Verzweigung genommen und 10 auf dem Schirm ausgegeben.<\/p>\n
                        Frage<\/p>\n
                        Was erfolgt, wenn man folgenden Progammcode kompiliert und ausf\u00fchrt.<\/p>\n
                        abstract class Base {\n  abstract void method(); \n  static int i;\n}\n\npublic class Mine extends Base\n{\n  public static void main( String args[] ) {\n  int[] a = new int[5];\n  for( i = 0; i < a.length; i++ )\n    System.out.println( a[i] );\n  }\n}<\/pre>\n
                          \n
                        1. Es werden  f\u00fcnf Nullen ausgegeben. <\/li>\n
                        2. Das Feld a wird benutzt, bevor es initialisiert wurde. <\/li>\n
                        3. Kompilierfehler. Mine muss abstakt definiert werden. <\/li>\n
                        4. IndexOutOfBoundes Error i.<\/li>\n<\/ol>\n
                          Abstrakte Klasse k\u00f6nnen Objekt- und Klassenvariablen besitzen sowie ausprogrammierte und wieder abstrakte Methoden. Erweitert eine Funktion eine abstrakte Klasse, so muss sie alle nicht ausprogrammierten Methoden implementieren, sonst ist diese Klasse wieder abstrakt. Mine erweitert zwar Base, \u00fcberschreibt jedoch nicht die abstrakte Methode method(). Daher meldet der Compiler einen Fehler. So ist Antwort C korrekt und die anderen falsch.<\/p>\n
                          Frage<\/p>\n
                          Was passiert, wenn man folgendes Programm kompiliert und laufen l\u00e4sst?<\/p>\n
                          1: class Base {}\n2: class Sub extends Base {}\n3: class Sub2 extends Base {}\n4:\n5: public class Super {\n6:   public static void main( String args[] ) {\n7:     Base b = new Base();\n8:     Sub s = (Sub) b;\n9:   }\nA: }<\/pre>\n
                            \n
                          1. Das Programm kompiliert und l\u00e4uft ohne Fehler. <\/li>\n
                          2. Das Programm kompiliert nicht. <\/li>\n
                          3. Das Programm kompiliert aber liefert einen Fehler zur Laufzeit.<\/li>\n<\/ol>\n
                            Die Definition aller vier Klassen ist korrekt und f\u00fchrt zu keinem Compilerfehler. Sub2 wird nicht ben\u00f6tigt und dient der Verwirrung. Die main() Methode legt eine lokale Variable b an. Diese Variable ist die Basisklasse von Sub. In Zeile 8 versuchen wir aber diese einfache Klasse \u00fcber die explizite Typumwandlung zur Klasse Sub aufzubauen. Dies l\u00e4sst der Compiler durch,  aber da Base einfach kein Sub werden kann, f\u00fchrt die Ausf\u00fchrung zu einem Laufzeitfehler. Ohne die Typumwandlung w\u00fcrde es schon zu einem Compilerfehler kommen. Daher ist Antwort C alleine korrekt.<\/p>\n
                            Frage<\/p>\n
                            Welche Modifier lassen sich im Programmcode f\u00fcr die innere Klasse korrekt einsetzen?<\/p>\n
                            public class Clazz {\n  public static void main( String args[] ) { }\n  \n  \/* Modifier *\/ class MyInner { }\n}<\/pre>\n
                              \n
                            1. public <\/li>\n
                            2. private <\/li>\n
                            3. static <\/li>\n
                            4. friend<\/li>\n<\/ol>\n
                              public, private, static sind m\u00f6gliche Modifier f\u00fcr innere Klassen. Also ist A, B und C korrekt. Es ist Eigenheit der Sprache C++ Freunde zu definieren, friend ist in Java kein eingetragenes Schl\u00fcsselwort.<\/p>\n","protected":false},"excerpt":{"rendered":"
                              Frage Das Design einer Klasse erfordert, dass eine Instanzvariable von Unterklassen ver\u00e4ndert werden kann. Klassen, die allerdings im gleichen Paket liegen, sollen keinen Zugriff haben. Wie muss der Modifier gew\u00e4hlt werden, so dass dies m\u00f6glich wird? public private protected Kein besonderer Modifier. private und die es sollte Zugriffsmethoden geben. Public w\u00fcrde die Variable f\u00fcr alle […]<\/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-2406","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\/2406","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=2406"}],"version-history":[{"count":1,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2406\/revisions"}],"predecessor-version":[{"id":2407,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/2406\/revisions\/2407"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=2406"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=2406"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=2406"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}