Q11

Given:
interface Rideable {

       public String ride() { return "riding "; };

}

class Horse implements Rideable {

       public String ride() {

             return "cantering ";

       }

}

class Icelandic extends Horse implements Rideable {

       public String ride() {

             return "tolting ";

       }

}

class Test {

       public static void main(String[] args) {

             Rideable r1 = new Icelandic();

             Rideable r2 = new Horse();

             Horse h1 = new Icelandic();

             System.out.println(r1.ride() + r2.ride() + h1.ride());

       }

}

What is the result?

A.
riding riding tolting

B.
riding riding cantering

C.
tolting cantering tolting

D.
tolting cantering cantering

E.
Compilation fails.

F.
An exception is thrown at runtime.

La risposta è E perché i metodi di una interfaccia possono essere solo astratti (abstract) e quindi non devono avere un corpo.

Per compilare il metodo dell’interfaccia dovrebbe essere corretto in :
public String ride() { return "riding "; };à public String ride();

Q10

You have been asked to create a ResourceBundle file to localize an application.

Which code example specifies valid keys menu1 and manu2 with values of File Menu and View Menu?

A.
<key name ="menu1">File Menu</key>

<key name ="menu1">View Menu</key>

B.
<key> menu1</key><File Menu>File Menu </value>

<key> menu1</key><File Menu>View Menu </value>

C.
menu1m File menu, menu2, view menu

D.
menu1 = File Menu

menu2 = View Menu

La risposta è D.

Infatti abbiamo bisogno di scrivere un file di properties per inserire le coppie chiave valore e la sintassi è appunto :

chiave = valore

 Un esempio di classe che legge un file di properties è :

import java.util.Enumeration;

import java.util.ResourceBundle;

public class Principale {

       public static void main(String[] args) {

             ResourceBundle rb = ResourceBundle.getBundle("ButtonLabel");

             Enumeration <String> keys = rb.getKeys();

             while (keys.hasMoreElements()) {

                    String key = keys.nextElement();

                    String value = rb.getString(key);

                    System.out.println(key + ": " + value);

             }

       }

}

e il file di properties collegato è :

menu1 = File Menu

menu2 = View Menu

che da luogo all’uscita:

menu2: View Menu

menu1: File Menu

Riferimenti :

http://www.avajava.com/tutorials/lessons/how-do-i-read-a-properties-file-with-a-resource-bundle.html

Q9

Given:
interface Rideable {

       String ride();

}

class Horse implements Rideable {

       String ride() {

             return "cantering ";

       }

}

class Icelandic extends Horse {

       String ride() {

             return "tolting ";

       }

}

class Test {

       public static void main(String[] args) {

             Rideable r1 = new Icelandic();

             Rideable r2 = new Horse();

             Horse h1 = new Icelandic();

             System.out.println(r1.ride() + r2.ride() + h1.ride());

       }

}

What is the result?

A.
tolting cantering cantering

B.
cantering cantering cantering

C.
compilation fails

D.
an exception is thrown at runtime

Risposta C.

Tutti i metodi di una interfaccia sono automaticamente pubblici. I metodi ride() delle classi Horse e Icelandic sono invece dichiarati default , infatti non hanno modificatore.

Perciò i metodi ride() di Horse e Icelandic abbassano la visibilità del metodo ride() di Rideable.

Questo in Java e in generale nella programmazione ad oggetti non è permesso perché viola il principio di Principio di Liskov, che pretende la sostituibilità tra una superclasse (in questo caso un’interfaccia) e una sottoclasse.

Questo è esplicitamente scritto nella documentazione ufficiale del Java :

The access modifier (§6.6) of an overriding or hiding method must provide at least as much access as the overridden or hidden method, or a compile-time error occurs. In more detail:

·         If the overridden or hidden method is public, then the overriding or hiding method must be public; otherwise, a compile-time error occurs.

·         If the overridden or hidden method is protected, then the overriding or hiding method must be protected or public; otherwise, a compile-time error occurs.

·         If the overridden or hidden method has default (package) access, then the overriding or hiding method must not be private; otherwise, a compile-time error occurs.

Per capire questo concetto si prenda questo esempio :

class A {

public void myMethod() {...}

}

class B extends A {

private void myMethod() {...}

}

//...

A a = new B();

 

Istanziare una variabile di tipo A assegnandole un oggetto di tipo B è sempre possibile in Java, e su questo si basa l’ereditarietà. Ma al momento di usare il metodo myMethod() sorgono i problemi di visibilità perché il metodo è pubblico in A ma in realtà è la variabile è un oggetto di tipo B e B non ha il metodo pubblico.

Riferimenti:

http://www.iet.unipi.it/g.dini/Teaching/tiga/materiale-didattico/java/Java-Interfacce.pdf

http://www.google.it/url?sa=t&rct=j&q=&esrc=s&frm=1&source=web&cd=1&cad=rja&ved=0CDEQFjAA&url=http%3A%2F%2Fwww.html.it%2Fpag%2F15597%2Fla-visibilit%2F&ei=3j1AUrWbJpDZsgaRxoD4CA&usg=AFQjCNEMuqExTFzRWiWRA-h9dX9_tg5HWA&sig2=PGoPoa9eX_v-4CiRFWsvYQ&bvm=bv.52434380,d.ZGU

http://it.wikipedia.org/wiki/Principio_di_sostituzione_di_Liskov

http://www.coderanch.com/t/529407/java/java/reduce-visibility-inherited-method-super

Q8

Given:

public class SleepOtherThread {

       public static void main(String[] args) throws InterruptedException {

             Runnable r = new Runnable() {

                    public void run() {

                      System.out.print(Thread.currentThread().getName()); 

                    }

             };

             Thread t1 = new Thread(r, "One ");

             t1.start();

             t1.sleep(2000);

             Thread t2 = new Thread(r, "Two ");

             t2.start();

             t2.sleep(1000);

             System.out.print("Main ");

       }

}
What is the most likely result?

A.
Main One Two

B.
Main Two One

C.
One Two Main

D.
One Main Two

E.
Two Main One
 

Risposta: C
One Two Main

Per capire cosa succede nel tempo vediamo uno schema. Le frecce vanno nel senso del tempo crescente:

Q7

Which two are valid initialization statements?

 A.

Map<String, String> m = newSortedMap<String, String>();

B.

Collection m = new TreeMap<Object, Object>();

C.

HashMap<Object, Object> m = newSortedMap<Object, Object>();

D.

SortedMap<Object, Object> m = new TreeMap<Object, Object> ();

E.

Hashtablem= new HashMap();

F.

Map<List, ArrayList> m = new Hashtable<List, ArrayList>();

Risposta D e F

A.

SortedMap è un'interfaccia che estende proprio l'interfaccia Map. Infatti :

public interface SortedMap<K, V> extends Map<K, V>

Quindi questo codice non ha senso perchè si sta cercando di instanziare un' interfaccia.

B.

TreeMap viene da Map infatti :

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V> à

public abstract class AbstractMap<K,V> extends Object implements Map

Non possiamo instanziare un oggetto TreeMap e assegnare il reference ad una variabile di tipo Collection.

Dobbiamo fare un cast per arrivare almeno a compilare:

Collection m = (Collection) new TreeMap<Object, Object>();

Invece avrebbe avuto senso partire dall'interfaccia Map, infatti questo codice compila:

Map m = new TreeMap<Object, Object>();

C.

public interface SortedMap<K, V> extends Map

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,

SortedMap è una interfaccia e noi stiamo cercando di instanziarla. Questo non è possibile.

D.

Questo è corretto perchè stiamo instanziando un oggetto di tipo TreeMap (public class TreeMap<K,V> extends AbstractMap<K,V>) assegnando il reference ad una variabile di tipo SortedMap (public interface SortedMap<K, V> extends Map).

E.

Questo codice non ha senso perchè Hashtablem non può essere risolto in una variabile non essendo mai stato creato.

F.

Questo è corretto perchè stiamo instanziando un oggetto di tipo Hashtable (public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>,) assegnando il reference ad una variabile di tipo Map (public interface Map<K,V>).

Riferimenti :
http://docs.oracle.com/javase/tutorial/collections/interfaces/index.html

Q6

Which four are syntactically correct?

 

A.

package abc;

package def;

import java.util . * ;

public class Test { }

B.

package abc;

import java.util.*;

import java.util.regex.* ;

public class Test { }

C.

package abc;

public class Test {}

import Java.util.* ;

D.

import java.util.*;

package abc;

public class Test {}

E.

package abc;

import java.util.*;

public class Test{}

F.

public class Test{}

package abc;

importjava.util.*{}

G.

import java.util.*;

public class Test{}

 

H.

package abc;

public class test

La risposta è BEGH
A.

E' errata perchè la classe è dichiarata appartenere a due package

B.

E' corretta

C.

E' errata perchè l'ordine è sbagliato. L'import precede sempre la dichiarazione della classe

D.

E' errata perchè l'ordine è sbagliato. il package precede sempre gli import

E.

E' corretta

F.

E' errata perché la classe deve seguire sempre package e import.

G.

La classe Test è correttamente inserita nel package di default, che non va quindi dichiarato.

H.

E' corretta.

Q5

Given the code fragment:

public class Test {

       public static void main(String[] args) {

             Path dir = Paths.get("D:\\company");

             //insert code here. Line ***

                    for (Path entry : stream) {

                           System.out.println(entry.getFileName());

                    }

             } catch (IOException e) {

                    System.err.println("Caught IOException: " + e.getMessage());

             }

       }

Which two try statements, when inserted at line ***, enable you to print files with the extensions.java,

.htm, and .jar.

A.
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,”*.{java, htm,jar}”)){

B.
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,”*. [java, htm, jar]“)) {

C.
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,”*.{java*, htm*, jar*}”)) {

D.
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,”**.{java, htm, jar}”)) {

La risposta è A e D.
Infatti sia A che D indicano di prendere tutti i file che terminano in java oppure htm oppure jar.

La B non funziona perchè oltre allo spazio tra l'asterisco e le parentesi (probabilmente un errore nella domanda) le parentesi sono quadre. Le parentesi quadre indicano una collezione di caratteri.
[java, htm, jar] significa : Prendi tutti i file che contengano almeno una j oppure a oppure  v oppure  a oppure uno spazio oppure h ecc fino alla r di jar.

La C invece prende tutti anche i file la cui estensione inizia con il termina specificato. Ad esempio .java ma anche .javadoc , a causa dell'asterisco finale.

Riferimenti
http://docs.oracle.com/javase/tutorial/essential/io/dirs.html
  Listing a Directory's Contents
  Filtering a Directory Listing By Using Globbing
http://docs.oracle.com/javase/tutorial/essential/io/fileOps.html#glob

Argomento glob
Files.newDirectoryStream accetta un argomento glob. La sintassi glob serve a specificare un comportamento dei percorsi.

Nei nostri casi:
Un asterisco * significa tutto, dal lato dell'asterisco.
Due asterischi ** significa tutto, dal lato degli asterischi ma penetra anche dentro le sottocartelle.
Ad esempio :
*.html prende tutti i file che finiscono in .html

Le parentesi graffe indicano una collezione, e quindi una sorta di OR.
Ad esempio :
◦{sun,moon,stars} significa : sun oppure moon oppure star.

Le parentesi quadre indicano una collezione di singoli caratteri:
[aeiou] significa : prendi tutti file che abbiamo almeno una vocale minuscola.