Nehézségi szint: Közepes Megjósolja a következő Java programok kimenetét. 1. program: Java

   public     class   Calculator   {      int     num     =     100  ;      public     void     calc  (  int     num  )     {     this  .  num     =     num     *     10  ;     }      public     void     printNum  ()     {     System  .  out  .  println  (  num  );     }      public     static     void     main  (  String  []     args  )      {      Calculator     obj     =     new     Calculator  ();      obj  .  calc  (  2  );      obj  .  printNum  ();      }   }   

Opciók: A) 20 B) 100 C) 1000 D) 2 Válasz: A) 20 Magyarázat: Itt az osztálypéldány változó neve(szám) ugyanaz, mint calc() metódus helyi változó neve(szám). Tehát az osztálypéldányváltozó hivatkozására calc() módszer ez kulcsszót használjuk. Tehát nyilatkozatban ez.szám = szám * 10 a a metódus helyi változója, amelynek értéke 2 és ezt.szám osztálypéldány változót képvisel, amelynek kezdeti értéke 100. Most be printNum() metódust, mivel nincs olyan helyi változója, amelynek neve megegyezik az osztálypéldány változójával, így közvetlenül használhatjuk a példányváltozóra hivatkozni bár ezt.szám használható.   2. program: Java

   public     class   MyStuff   {      String     name  ;      MyStuff  (  String     n  )     {     name     =     n  ;     }      public     static     void     main  (  String  []     args  )      {      MyStuff     m1     =     new     MyStuff  (  'guitar'  );      MyStuff     m2     =     new     MyStuff  (  'tv'  );      System  .  out  .  println  (  m2  .  equals  (  m1  ));      }      @Override      public     boolean     equals  (  Object     obj  )      {      MyStuff     m     =     (  MyStuff  )     obj  ;      if     (  m  .  name     !=     null  )     {     return     true  ;     }      return     false  ;      }   }   

Opciók: A) A kimenet igaz, és a MyStuff teljesíti az Object.equals() szerződést. B) A kimenet hamis, és a MyStuff teljesíti az Object.equals() szerződést. C) A kimenet igaz, és a MyStuff NEM teljesíti az Object.equals() szerződést. D) A kimenet hamis, és a MyStuff NEM teljesíti az Object.equals() szerződést. Válasz: C) A kimenet igaz, és a MyStuff NEM teljesíti az Object.equals() szerződést. Magyarázat: Mint egyenlő (Object Obj) metódus az Object osztályban két objektumot hasonlít össze ekvivalencia reláció alapján. De itt csak megerősítjük, hogy az objektum nulla vagy sem. Tehát nem teljesül Object.equals() szerződés. Mint m1 nem null true ki lesz nyomtatva.   3. program: Java

   class   Alpha   {      public     String     type     =     'a '  ;      public     Alpha  ()     {     System  .  out  .  print  (  'alpha '  );     }   }   public     class   Beta     extends     Alpha   {      public     Beta  ()     {     System  .  out  .  print  (  'beta '  );     }      void     go  ()      {      type     =     'b '  ;      System  .  out  .  print  (  this  .  type     +     super  .  type  );      }      public     static     void     main  (  String  []     args  )      {      new     Beta  ().  go  ();      }   }   

Opciók: A) alfa béta b b B) alfa béta a b C) béta alfa b b D) béta alfa a b Válasz: A) alfa béta b b Magyarázat: A nyilatkozat új béta().go() két fázisban valósul meg. Első fázisban Beta osztály konstruktorát hívják. Nincs jelen a példányban Beta osztály. Szóval most Beta osztály konstruktora kerül végrehajtásra. Mint Beta osztály meghosszabbodik Alpha osztály, így a hívás a címre megy Alpha osztály konstruktor, mint az első utasítás alapértelmezés szerint (a fordító által). szuper() a Beta osztályú konstruktőr. Most egy példányváltozóként ( típus ) benne van Alpha osztályba, így lesz memória és most Alpha osztály konstruktor végrehajtódik, majd hívja a return to Beta osztály konstruktor következő utasítása. Így alfa béta ki van nyomtatva. Második fázisban megy() metódus hívódik meg ezen az objektumon. Mivel csak egy változó van ( típus ) abban az objektumban, amelynek értéke a . Tehát erre módosul b és kétszer nyomtatták ki. A szuper kulcsszó itt semmi haszna.   4. program: Java

   public     class   Test   {      public     static     void     main  (  String  []     args  )      {      StringBuilder     s1     =     new     StringBuilder  (  'Java'  );      String     s2     =     'Love'  ;      s1  .  append  (  s2  );      s1  .  substring  (  4  );      int     foundAt     =     s1  .  indexOf  (  s2  );      System  .  out  .  println  (  foundAt  );      }   }   

Opciók: A) -1 B) 3 C) 4 D) A StringIndexOutOfBoundsException futásidőben van dobva. Válasz: C) 4 Magyarázat: hozzáfűzés (String str) metódus kapcsolja össze az str-t s1 . A részkarakterlánc (int index) metódus visszaadja a karakterláncot az adott indexből a végére. De mivel nincs String változó a visszaadott karakterlánc tárolására, ezért az megsemmisül. Most indexOf(karakterlánc s2) metódus az első előfordulásának indexét adja vissza s2 . Tehát a 4 s1='JavaLove'-ként kerül kinyomtatásra.   5. program: Java

   class   Writer   {      public     static     void     write  ()      {      System  .  out  .  println  (  'Writing...'  );      }   }   class   Author     extends     Writer   {      public     static     void     write  ()      {      System  .  out  .  println  (  'Writing book'  );      }   }   public     class   Programmer     extends     Author   {      public     static     void     write  ()      {      System  .  out  .  println  (  'Writing code'  );      }      public     static     void     main  (  String  []     args  )      {      Author     a     =     new     Programmer  ();      a  .  write  ();      }   }   

Opciók: A) Írás... B) Írókönyv C) Kódírás D) A fordítás sikertelen Válasz: B) Írókönyv Magyarázat: Mivel a statikus metódusokat nem lehet felülírni, nem mindegy, hogy melyik osztályobjektum jön létre. Mint a az a Szerző hivatkozott típus tehát mindig Szerző osztály metódust hívják. Ha eltávolítjuk írj () módszertől Szerző osztály akkor Író osztály metódusának nevezzük Szerző osztály meghosszabbodik Író osztály.